blob: 8aa8b90f96b9bde427b4eeb5faef2247e2e4666b [file] [log] [blame]
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00001//===---- TargetInfo.cpp - Encapsulate target details -----------*- C++ -*-===//
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002//
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// These classes wrap the information about a call or function
11// definition used to handle ABI compliancy.
12//
13//===----------------------------------------------------------------------===//
14
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000015#include "TargetInfo.h"
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000016#include "ABIInfo.h"
17#include "CodeGenFunction.h"
Anders Carlsson19cc4ab2009-07-18 19:43:29 +000018#include "clang/AST/RecordLayout.h"
Sandeep Patel34c1af82011-04-05 00:23:47 +000019#include "clang/Frontend/CodeGenOptions.h"
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000020#include "llvm/Type.h"
Micah Villmow25a6a842012-10-08 16:25:52 +000021#include "llvm/DataLayout.h"
Daniel Dunbar2c0843f2009-08-24 08:52:16 +000022#include "llvm/ADT/Triple.h"
Daniel Dunbar28df7a52009-12-03 09:13:49 +000023#include "llvm/Support/raw_ostream.h"
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000024using namespace clang;
25using namespace CodeGen;
26
John McCallaeeb7012010-05-27 06:19:26 +000027static void AssignToArrayRange(CodeGen::CGBuilderTy &Builder,
28 llvm::Value *Array,
29 llvm::Value *Value,
30 unsigned FirstIndex,
31 unsigned LastIndex) {
32 // Alternatively, we could emit this as a loop in the source.
33 for (unsigned I = FirstIndex; I <= LastIndex; ++I) {
34 llvm::Value *Cell = Builder.CreateConstInBoundsGEP1_32(Array, I);
35 Builder.CreateStore(Value, Cell);
36 }
37}
38
John McCalld608cdb2010-08-22 10:59:02 +000039static bool isAggregateTypeForABI(QualType T) {
40 return CodeGenFunction::hasAggregateLLVMType(T) ||
41 T->isMemberFunctionPointerType();
42}
43
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000044ABIInfo::~ABIInfo() {}
45
Chris Lattnerea044322010-07-29 02:01:43 +000046ASTContext &ABIInfo::getContext() const {
47 return CGT.getContext();
48}
49
50llvm::LLVMContext &ABIInfo::getVMContext() const {
51 return CGT.getLLVMContext();
52}
53
Micah Villmow25a6a842012-10-08 16:25:52 +000054const llvm::DataLayout &ABIInfo::getDataLayout() const {
55 return CGT.getDataLayout();
Chris Lattnerea044322010-07-29 02:01:43 +000056}
57
58
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000059void ABIArgInfo::dump() const {
Chris Lattner5f9e2722011-07-23 10:55:15 +000060 raw_ostream &OS = llvm::errs();
Daniel Dunbar28df7a52009-12-03 09:13:49 +000061 OS << "(ABIArgInfo Kind=";
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000062 switch (TheKind) {
63 case Direct:
Chris Lattner800588f2010-07-29 06:26:06 +000064 OS << "Direct Type=";
Chris Lattner2acc6e32011-07-18 04:24:23 +000065 if (llvm::Type *Ty = getCoerceToType())
Chris Lattner800588f2010-07-29 06:26:06 +000066 Ty->print(OS);
67 else
68 OS << "null";
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000069 break;
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +000070 case Extend:
Daniel Dunbar28df7a52009-12-03 09:13:49 +000071 OS << "Extend";
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +000072 break;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000073 case Ignore:
Daniel Dunbar28df7a52009-12-03 09:13:49 +000074 OS << "Ignore";
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000075 break;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000076 case Indirect:
Daniel Dunbardc6d5742010-04-21 19:10:51 +000077 OS << "Indirect Align=" << getIndirectAlign()
Joerg Sonnenbergere9b5d772011-07-15 18:23:44 +000078 << " ByVal=" << getIndirectByVal()
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +000079 << " Realign=" << getIndirectRealign();
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000080 break;
81 case Expand:
Daniel Dunbar28df7a52009-12-03 09:13:49 +000082 OS << "Expand";
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000083 break;
84 }
Daniel Dunbar28df7a52009-12-03 09:13:49 +000085 OS << ")\n";
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +000086}
87
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000088TargetCodeGenInfo::~TargetCodeGenInfo() { delete Info; }
89
John McCall49e34be2011-08-30 01:42:09 +000090// If someone can figure out a general rule for this, that would be great.
91// It's probably just doomed to be platform-dependent, though.
92unsigned TargetCodeGenInfo::getSizeOfUnwindException() const {
93 // Verified for:
94 // x86-64 FreeBSD, Linux, Darwin
95 // x86-32 FreeBSD, Linux, Darwin
96 // PowerPC Linux, Darwin
97 // ARM Darwin (*not* EABI)
98 return 32;
99}
100
John McCallde5d3c72012-02-17 03:33:10 +0000101bool TargetCodeGenInfo::isNoProtoCallVariadic(const CallArgList &args,
102 const FunctionNoProtoType *fnType) const {
John McCall01f151e2011-09-21 08:08:30 +0000103 // The following conventions are known to require this to be false:
104 // x86_stdcall
105 // MIPS
106 // For everything else, we just prefer false unless we opt out.
107 return false;
108}
109
Daniel Dunbar98303b92009-09-13 08:03:58 +0000110static bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000111
Sylvestre Ledruf3477c12012-09-27 10:16:10 +0000112/// isEmptyField - Return true iff a the field is "empty", that is it
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000113/// is an unnamed bit-field or an (array of) empty record(s).
Daniel Dunbar98303b92009-09-13 08:03:58 +0000114static bool isEmptyField(ASTContext &Context, const FieldDecl *FD,
115 bool AllowArrays) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000116 if (FD->isUnnamedBitfield())
117 return true;
118
119 QualType FT = FD->getType();
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000120
Eli Friedman7e7ad3f2011-11-18 03:47:20 +0000121 // Constant arrays of empty records count as empty, strip them off.
122 // Constant arrays of zero length always count as empty.
Daniel Dunbar98303b92009-09-13 08:03:58 +0000123 if (AllowArrays)
Eli Friedman7e7ad3f2011-11-18 03:47:20 +0000124 while (const ConstantArrayType *AT = Context.getAsConstantArrayType(FT)) {
125 if (AT->getSize() == 0)
126 return true;
Daniel Dunbar98303b92009-09-13 08:03:58 +0000127 FT = AT->getElementType();
Eli Friedman7e7ad3f2011-11-18 03:47:20 +0000128 }
Daniel Dunbar98303b92009-09-13 08:03:58 +0000129
Daniel Dunbar5ea68612010-05-17 16:46:00 +0000130 const RecordType *RT = FT->getAs<RecordType>();
131 if (!RT)
132 return false;
133
134 // C++ record fields are never empty, at least in the Itanium ABI.
135 //
136 // FIXME: We should use a predicate for whether this behavior is true in the
137 // current ABI.
138 if (isa<CXXRecordDecl>(RT->getDecl()))
139 return false;
140
Daniel Dunbar98303b92009-09-13 08:03:58 +0000141 return isEmptyRecord(Context, FT, AllowArrays);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000142}
143
Sylvestre Ledruf3477c12012-09-27 10:16:10 +0000144/// isEmptyRecord - Return true iff a structure contains only empty
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000145/// fields. Note that a structure with a flexible array member is not
146/// considered empty.
Daniel Dunbar98303b92009-09-13 08:03:58 +0000147static bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays) {
Ted Kremenek6217b802009-07-29 21:53:49 +0000148 const RecordType *RT = T->getAs<RecordType>();
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000149 if (!RT)
150 return 0;
151 const RecordDecl *RD = RT->getDecl();
152 if (RD->hasFlexibleArrayMember())
153 return false;
Daniel Dunbar5ea68612010-05-17 16:46:00 +0000154
Argyrios Kyrtzidisc5f18f32011-05-17 02:17:52 +0000155 // If this is a C++ record, check the bases first.
Daniel Dunbar5ea68612010-05-17 16:46:00 +0000156 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
Argyrios Kyrtzidisc5f18f32011-05-17 02:17:52 +0000157 for (CXXRecordDecl::base_class_const_iterator i = CXXRD->bases_begin(),
158 e = CXXRD->bases_end(); i != e; ++i)
159 if (!isEmptyRecord(Context, i->getType(), true))
160 return false;
Daniel Dunbar5ea68612010-05-17 16:46:00 +0000161
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000162 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
163 i != e; ++i)
David Blaikie581deb32012-06-06 20:45:41 +0000164 if (!isEmptyField(Context, *i, AllowArrays))
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000165 return false;
166 return true;
167}
168
Anders Carlsson0a8f8472009-09-16 15:53:40 +0000169/// hasNonTrivialDestructorOrCopyConstructor - Determine if a type has either
170/// a non-trivial destructor or a non-trivial copy constructor.
171static bool hasNonTrivialDestructorOrCopyConstructor(const RecordType *RT) {
172 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
173 if (!RD)
174 return false;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000175
Anders Carlsson0a8f8472009-09-16 15:53:40 +0000176 return !RD->hasTrivialDestructor() || !RD->hasTrivialCopyConstructor();
177}
178
179/// isRecordWithNonTrivialDestructorOrCopyConstructor - Determine if a type is
180/// a record type with either a non-trivial destructor or a non-trivial copy
181/// constructor.
182static bool isRecordWithNonTrivialDestructorOrCopyConstructor(QualType T) {
183 const RecordType *RT = T->getAs<RecordType>();
184 if (!RT)
185 return false;
186
187 return hasNonTrivialDestructorOrCopyConstructor(RT);
188}
189
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000190/// isSingleElementStruct - Determine if a structure is a "single
191/// element struct", i.e. it has exactly one non-empty field or
192/// exactly one field which is itself a single element
193/// struct. Structures with flexible array members are never
194/// considered single element structs.
195///
196/// \return The field declaration for the single non-empty field, if
197/// it exists.
198static const Type *isSingleElementStruct(QualType T, ASTContext &Context) {
199 const RecordType *RT = T->getAsStructureType();
200 if (!RT)
201 return 0;
202
203 const RecordDecl *RD = RT->getDecl();
204 if (RD->hasFlexibleArrayMember())
205 return 0;
206
207 const Type *Found = 0;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000208
Daniel Dunbar9430d5a2010-05-11 21:15:36 +0000209 // If this is a C++ record, check the bases first.
210 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
211 for (CXXRecordDecl::base_class_const_iterator i = CXXRD->bases_begin(),
212 e = CXXRD->bases_end(); i != e; ++i) {
Daniel Dunbar9430d5a2010-05-11 21:15:36 +0000213 // Ignore empty records.
Daniel Dunbar5ea68612010-05-17 16:46:00 +0000214 if (isEmptyRecord(Context, i->getType(), true))
Daniel Dunbar9430d5a2010-05-11 21:15:36 +0000215 continue;
216
217 // If we already found an element then this isn't a single-element struct.
218 if (Found)
219 return 0;
220
221 // If this is non-empty and not a single element struct, the composite
222 // cannot be a single element struct.
223 Found = isSingleElementStruct(i->getType(), Context);
224 if (!Found)
225 return 0;
226 }
227 }
228
229 // Check for single element.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000230 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
231 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000232 const FieldDecl *FD = *i;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000233 QualType FT = FD->getType();
234
235 // Ignore empty fields.
Daniel Dunbar98303b92009-09-13 08:03:58 +0000236 if (isEmptyField(Context, FD, true))
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000237 continue;
238
239 // If we already found an element then this isn't a single-element
240 // struct.
241 if (Found)
242 return 0;
243
244 // Treat single element arrays as the element.
245 while (const ConstantArrayType *AT = Context.getAsConstantArrayType(FT)) {
246 if (AT->getSize().getZExtValue() != 1)
247 break;
248 FT = AT->getElementType();
249 }
250
John McCalld608cdb2010-08-22 10:59:02 +0000251 if (!isAggregateTypeForABI(FT)) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000252 Found = FT.getTypePtr();
253 } else {
254 Found = isSingleElementStruct(FT, Context);
255 if (!Found)
256 return 0;
257 }
258 }
259
Eli Friedmanbd4d3bc2011-11-18 01:25:50 +0000260 // We don't consider a struct a single-element struct if it has
261 // padding beyond the element type.
262 if (Found && Context.getTypeSize(Found) != Context.getTypeSize(T))
263 return 0;
264
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000265 return Found;
266}
267
268static bool is32Or64BitBasicType(QualType Ty, ASTContext &Context) {
Daniel Dunbara1842d32010-05-14 03:40:53 +0000269 if (!Ty->getAs<BuiltinType>() && !Ty->hasPointerRepresentation() &&
Daniel Dunbar55e59e12009-09-24 05:12:36 +0000270 !Ty->isAnyComplexType() && !Ty->isEnumeralType() &&
271 !Ty->isBlockPointerType())
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000272 return false;
273
274 uint64_t Size = Context.getTypeSize(Ty);
275 return Size == 32 || Size == 64;
276}
277
Daniel Dunbar53012f42009-11-09 01:33:53 +0000278/// canExpandIndirectArgument - Test whether an argument type which is to be
279/// passed indirectly (on the stack) would have the equivalent layout if it was
280/// expanded into separate arguments. If so, we prefer to do the latter to avoid
281/// inhibiting optimizations.
282///
283// FIXME: This predicate is missing many cases, currently it just follows
284// llvm-gcc (checks that all fields are 32-bit or 64-bit primitive types). We
285// should probably make this smarter, or better yet make the LLVM backend
286// capable of handling it.
287static bool canExpandIndirectArgument(QualType Ty, ASTContext &Context) {
288 // We can only expand structure types.
289 const RecordType *RT = Ty->getAs<RecordType>();
290 if (!RT)
291 return false;
292
293 // We can only expand (C) structures.
294 //
295 // FIXME: This needs to be generalized to handle classes as well.
296 const RecordDecl *RD = RT->getDecl();
297 if (!RD->isStruct() || isa<CXXRecordDecl>(RD))
298 return false;
299
Eli Friedman506d4e32011-11-18 01:32:26 +0000300 uint64_t Size = 0;
301
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000302 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
303 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000304 const FieldDecl *FD = *i;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000305
306 if (!is32Or64BitBasicType(FD->getType(), Context))
307 return false;
308
309 // FIXME: Reject bit-fields wholesale; there are two problems, we don't know
310 // how to expand them yet, and the predicate for telling if a bitfield still
311 // counts as "basic" is more complicated than what we were doing previously.
312 if (FD->isBitField())
313 return false;
Eli Friedman506d4e32011-11-18 01:32:26 +0000314
315 Size += Context.getTypeSize(FD->getType());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000316 }
317
Eli Friedman506d4e32011-11-18 01:32:26 +0000318 // Make sure there are not any holes in the struct.
319 if (Size != Context.getTypeSize(Ty))
320 return false;
321
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000322 return true;
323}
324
325namespace {
326/// DefaultABIInfo - The default implementation for ABI specific
327/// details. This implementation provides information which results in
328/// self-consistent and sensible LLVM IR generation, but does not
329/// conform to any particular ABI.
330class DefaultABIInfo : public ABIInfo {
Chris Lattnerea044322010-07-29 02:01:43 +0000331public:
332 DefaultABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000333
Chris Lattnera3c109b2010-07-29 02:16:43 +0000334 ABIArgInfo classifyReturnType(QualType RetTy) const;
335 ABIArgInfo classifyArgumentType(QualType RetTy) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000336
Chris Lattneree5dcd02010-07-29 02:31:05 +0000337 virtual void computeInfo(CGFunctionInfo &FI) const {
Chris Lattnera3c109b2010-07-29 02:16:43 +0000338 FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000339 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
340 it != ie; ++it)
Chris Lattnera3c109b2010-07-29 02:16:43 +0000341 it->info = classifyArgumentType(it->type);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000342 }
343
344 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
345 CodeGenFunction &CGF) const;
346};
347
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000348class DefaultTargetCodeGenInfo : public TargetCodeGenInfo {
349public:
Chris Lattnerea044322010-07-29 02:01:43 +0000350 DefaultTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
351 : TargetCodeGenInfo(new DefaultABIInfo(CGT)) {}
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000352};
353
354llvm::Value *DefaultABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
355 CodeGenFunction &CGF) const {
356 return 0;
357}
358
Chris Lattnera3c109b2010-07-29 02:16:43 +0000359ABIArgInfo DefaultABIInfo::classifyArgumentType(QualType Ty) const {
Jan Wen Voung90306932011-11-03 00:59:44 +0000360 if (isAggregateTypeForABI(Ty)) {
361 // Records with non trivial destructors/constructors should not be passed
362 // by value.
363 if (isRecordWithNonTrivialDestructorOrCopyConstructor(Ty))
364 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
365
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000366 return ABIArgInfo::getIndirect(0);
Jan Wen Voung90306932011-11-03 00:59:44 +0000367 }
Daniel Dunbardc6d5742010-04-21 19:10:51 +0000368
Chris Lattnera14db752010-03-11 18:19:55 +0000369 // Treat an enum type as its underlying type.
370 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
371 Ty = EnumTy->getDecl()->getIntegerType();
Douglas Gregoraa74a1e2010-02-02 20:10:50 +0000372
Chris Lattnera14db752010-03-11 18:19:55 +0000373 return (Ty->isPromotableIntegerType() ?
374 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000375}
376
Bob Wilson0024f942011-01-10 23:54:17 +0000377ABIArgInfo DefaultABIInfo::classifyReturnType(QualType RetTy) const {
378 if (RetTy->isVoidType())
379 return ABIArgInfo::getIgnore();
380
381 if (isAggregateTypeForABI(RetTy))
382 return ABIArgInfo::getIndirect(0);
383
384 // Treat an enum type as its underlying type.
385 if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
386 RetTy = EnumTy->getDecl()->getIntegerType();
387
388 return (RetTy->isPromotableIntegerType() ?
389 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
390}
391
Derek Schuff9ed63f82012-09-06 17:37:28 +0000392//===----------------------------------------------------------------------===//
393// le32/PNaCl bitcode ABI Implementation
394//===----------------------------------------------------------------------===//
395
396class PNaClABIInfo : public ABIInfo {
397 public:
398 PNaClABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}
399
400 ABIArgInfo classifyReturnType(QualType RetTy) const;
401 ABIArgInfo classifyArgumentType(QualType RetTy, unsigned &FreeRegs) const;
402
403 virtual void computeInfo(CGFunctionInfo &FI) const;
404 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
405 CodeGenFunction &CGF) const;
406};
407
408class PNaClTargetCodeGenInfo : public TargetCodeGenInfo {
409 public:
410 PNaClTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
411 : TargetCodeGenInfo(new PNaClABIInfo(CGT)) {}
412};
413
414void PNaClABIInfo::computeInfo(CGFunctionInfo &FI) const {
415 FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
416
417 unsigned FreeRegs = FI.getHasRegParm() ? FI.getRegParm() : 0;
418
419 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
420 it != ie; ++it)
421 it->info = classifyArgumentType(it->type, FreeRegs);
422 }
423
424llvm::Value *PNaClABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
425 CodeGenFunction &CGF) const {
426 return 0;
427}
428
429ABIArgInfo PNaClABIInfo::classifyArgumentType(QualType Ty,
430 unsigned &FreeRegs) const {
431 if (isAggregateTypeForABI(Ty)) {
432 // Records with non trivial destructors/constructors should not be passed
433 // by value.
434 FreeRegs = 0;
435 if (isRecordWithNonTrivialDestructorOrCopyConstructor(Ty))
436 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
437
438 return ABIArgInfo::getIndirect(0);
439 }
440
441 // Treat an enum type as its underlying type.
442 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
443 Ty = EnumTy->getDecl()->getIntegerType();
444
445 ABIArgInfo BaseInfo = (Ty->isPromotableIntegerType() ?
446 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
447
448 // Regparm regs hold 32 bits.
449 unsigned SizeInRegs = (getContext().getTypeSize(Ty) + 31) / 32;
450 if (SizeInRegs == 0) return BaseInfo;
451 if (SizeInRegs > FreeRegs) {
452 FreeRegs = 0;
453 return BaseInfo;
454 }
455 FreeRegs -= SizeInRegs;
456 return BaseInfo.isDirect() ?
457 ABIArgInfo::getDirectInReg(BaseInfo.getCoerceToType()) :
458 ABIArgInfo::getExtendInReg(BaseInfo.getCoerceToType());
459}
460
461ABIArgInfo PNaClABIInfo::classifyReturnType(QualType RetTy) const {
462 if (RetTy->isVoidType())
463 return ABIArgInfo::getIgnore();
464
465 if (isAggregateTypeForABI(RetTy))
466 return ABIArgInfo::getIndirect(0);
467
468 // Treat an enum type as its underlying type.
469 if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
470 RetTy = EnumTy->getDecl()->getIntegerType();
471
472 return (RetTy->isPromotableIntegerType() ?
473 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
474}
475
Eli Friedman55fc7e22012-01-25 22:46:34 +0000476/// UseX86_MMXType - Return true if this is an MMX type that should use the
477/// special x86_mmx type.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000478bool UseX86_MMXType(llvm::Type *IRType) {
Bill Wendlingbb465d72010-10-18 03:41:31 +0000479 // If the type is an MMX type <2 x i32>, <4 x i16>, or <8 x i8>, use the
480 // special x86_mmx type.
481 return IRType->isVectorTy() && IRType->getPrimitiveSizeInBits() == 64 &&
482 cast<llvm::VectorType>(IRType)->getElementType()->isIntegerTy() &&
483 IRType->getScalarSizeInBits() != 64;
484}
485
Jay Foadef6de3d2011-07-11 09:56:20 +0000486static llvm::Type* X86AdjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000487 StringRef Constraint,
Jay Foadef6de3d2011-07-11 09:56:20 +0000488 llvm::Type* Ty) {
Bill Wendling0507be62011-03-07 22:47:14 +0000489 if ((Constraint == "y" || Constraint == "&y") && Ty->isVectorTy())
Peter Collingbourne4b93d662011-02-19 23:03:58 +0000490 return llvm::Type::getX86_MMXTy(CGF.getLLVMContext());
491 return Ty;
492}
493
Chris Lattnerdce5ad02010-06-28 20:05:43 +0000494//===----------------------------------------------------------------------===//
495// X86-32 ABI Implementation
496//===----------------------------------------------------------------------===//
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000497
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000498/// X86_32ABIInfo - The X86-32 ABI information.
499class X86_32ABIInfo : public ABIInfo {
Rafael Espindolab48280b2012-07-31 02:44:24 +0000500 enum Class {
501 Integer,
502 Float
503 };
504
Daniel Dunbarfb67d6c2010-09-16 20:41:56 +0000505 static const unsigned MinABIStackAlignInBytes = 4;
506
David Chisnall1e4249c2009-08-17 23:08:21 +0000507 bool IsDarwinVectorABI;
508 bool IsSmallStructInRegABI;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +0000509 bool IsMMXDisabled;
Eli Friedman55fc7e22012-01-25 22:46:34 +0000510 bool IsWin32FloatStructABI;
Rafael Espindolab48280b2012-07-31 02:44:24 +0000511 unsigned DefaultNumRegisterParameters;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000512
513 static bool isRegisterSize(unsigned Size) {
514 return (Size == 8 || Size == 16 || Size == 32 || Size == 64);
515 }
516
Aaron Ballman6c60c8d2012-02-22 03:04:13 +0000517 static bool shouldReturnTypeInRegister(QualType Ty, ASTContext &Context,
518 unsigned callingConvention);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000519
Daniel Dunbardc6d5742010-04-21 19:10:51 +0000520 /// getIndirectResult - Give a source type \arg Ty, return a suitable result
521 /// such that the argument will be passed in memory.
Chris Lattnera3c109b2010-07-29 02:16:43 +0000522 ABIArgInfo getIndirectResult(QualType Ty, bool ByVal = true) const;
Daniel Dunbardc6d5742010-04-21 19:10:51 +0000523
Daniel Dunbarfb67d6c2010-09-16 20:41:56 +0000524 /// \brief Return the alignment to use for the given type on the stack.
Daniel Dunbare59d8582010-09-16 20:42:06 +0000525 unsigned getTypeStackAlignInBytes(QualType Ty, unsigned Align) const;
Daniel Dunbarfb67d6c2010-09-16 20:41:56 +0000526
Rafael Espindolab48280b2012-07-31 02:44:24 +0000527 Class classify(QualType Ty) const;
Rafael Espindolab33a3c42012-07-23 23:30:29 +0000528 ABIArgInfo classifyReturnType(QualType RetTy,
Aaron Ballman6c60c8d2012-02-22 03:04:13 +0000529 unsigned callingConvention) const;
Rafael Espindolab48280b2012-07-31 02:44:24 +0000530 ABIArgInfo classifyArgumentTypeWithReg(QualType RetTy,
531 unsigned &FreeRegs) const;
Chris Lattnera3c109b2010-07-29 02:16:43 +0000532 ABIArgInfo classifyArgumentType(QualType RetTy) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000533
Rafael Espindolab33a3c42012-07-23 23:30:29 +0000534public:
535
Rafael Espindolaaa9cf8d2012-07-24 00:01:07 +0000536 virtual void computeInfo(CGFunctionInfo &FI) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000537 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
538 CodeGenFunction &CGF) const;
539
Rafael Espindolab48280b2012-07-31 02:44:24 +0000540 X86_32ABIInfo(CodeGen::CodeGenTypes &CGT, bool d, bool p, bool m, bool w,
541 unsigned r)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +0000542 : ABIInfo(CGT), IsDarwinVectorABI(d), IsSmallStructInRegABI(p),
Rafael Espindolab48280b2012-07-31 02:44:24 +0000543 IsMMXDisabled(m), IsWin32FloatStructABI(w),
544 DefaultNumRegisterParameters(r) {}
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000545};
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000546
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000547class X86_32TargetCodeGenInfo : public TargetCodeGenInfo {
548public:
Eli Friedman55fc7e22012-01-25 22:46:34 +0000549 X86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,
Rafael Espindolab48280b2012-07-31 02:44:24 +0000550 bool d, bool p, bool m, bool w, unsigned r)
551 :TargetCodeGenInfo(new X86_32ABIInfo(CGT, d, p, m, w, r)) {}
Charles Davis74f72932010-02-13 15:54:06 +0000552
553 void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
554 CodeGen::CodeGenModule &CGM) const;
John McCall6374c332010-03-06 00:35:14 +0000555
556 int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const {
557 // Darwin uses different dwarf register numbers for EH.
558 if (CGM.isTargetDarwin()) return 5;
559
560 return 4;
561 }
562
563 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
564 llvm::Value *Address) const;
Peter Collingbourne4b93d662011-02-19 23:03:58 +0000565
Jay Foadef6de3d2011-07-11 09:56:20 +0000566 llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000567 StringRef Constraint,
Jay Foadef6de3d2011-07-11 09:56:20 +0000568 llvm::Type* Ty) const {
Peter Collingbourne4b93d662011-02-19 23:03:58 +0000569 return X86AdjustInlineAsmType(CGF, Constraint, Ty);
570 }
571
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000572};
573
574}
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000575
576/// shouldReturnTypeInRegister - Determine if the given type should be
577/// passed in a register (for the Darwin ABI).
578bool X86_32ABIInfo::shouldReturnTypeInRegister(QualType Ty,
Aaron Ballman6c60c8d2012-02-22 03:04:13 +0000579 ASTContext &Context,
580 unsigned callingConvention) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000581 uint64_t Size = Context.getTypeSize(Ty);
582
583 // Type must be register sized.
584 if (!isRegisterSize(Size))
585 return false;
586
587 if (Ty->isVectorType()) {
588 // 64- and 128- bit vectors inside structures are not returned in
589 // registers.
590 if (Size == 64 || Size == 128)
591 return false;
592
593 return true;
594 }
595
Daniel Dunbar77115232010-05-15 00:00:30 +0000596 // If this is a builtin, pointer, enum, complex type, member pointer, or
597 // member function pointer it is ok.
Daniel Dunbara1842d32010-05-14 03:40:53 +0000598 if (Ty->getAs<BuiltinType>() || Ty->hasPointerRepresentation() ||
Daniel Dunbar55e59e12009-09-24 05:12:36 +0000599 Ty->isAnyComplexType() || Ty->isEnumeralType() ||
Daniel Dunbar77115232010-05-15 00:00:30 +0000600 Ty->isBlockPointerType() || Ty->isMemberPointerType())
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000601 return true;
602
603 // Arrays are treated like records.
604 if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty))
Aaron Ballman6c60c8d2012-02-22 03:04:13 +0000605 return shouldReturnTypeInRegister(AT->getElementType(), Context,
606 callingConvention);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000607
608 // Otherwise, it must be a record type.
Ted Kremenek6217b802009-07-29 21:53:49 +0000609 const RecordType *RT = Ty->getAs<RecordType>();
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000610 if (!RT) return false;
611
Anders Carlssona8874232010-01-27 03:25:19 +0000612 // FIXME: Traverse bases here too.
613
Aaron Ballman6c60c8d2012-02-22 03:04:13 +0000614 // For thiscall conventions, structures will never be returned in
615 // a register. This is for compatibility with the MSVC ABI
616 if (callingConvention == llvm::CallingConv::X86_ThisCall &&
617 RT->isStructureType()) {
618 return false;
619 }
620
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000621 // Structure types are passed in register if all fields would be
622 // passed in a register.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000623 for (RecordDecl::field_iterator i = RT->getDecl()->field_begin(),
624 e = RT->getDecl()->field_end(); i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000625 const FieldDecl *FD = *i;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000626
627 // Empty fields are ignored.
Daniel Dunbar98303b92009-09-13 08:03:58 +0000628 if (isEmptyField(Context, FD, true))
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000629 continue;
630
631 // Check fields recursively.
Aaron Ballman6c60c8d2012-02-22 03:04:13 +0000632 if (!shouldReturnTypeInRegister(FD->getType(), Context,
633 callingConvention))
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000634 return false;
635 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000636 return true;
637}
638
Aaron Ballman6c60c8d2012-02-22 03:04:13 +0000639ABIArgInfo X86_32ABIInfo::classifyReturnType(QualType RetTy,
640 unsigned callingConvention) const {
Chris Lattnera3c109b2010-07-29 02:16:43 +0000641 if (RetTy->isVoidType())
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000642 return ABIArgInfo::getIgnore();
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000643
Chris Lattnera3c109b2010-07-29 02:16:43 +0000644 if (const VectorType *VT = RetTy->getAs<VectorType>()) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000645 // On Darwin, some vectors are returned in registers.
David Chisnall1e4249c2009-08-17 23:08:21 +0000646 if (IsDarwinVectorABI) {
Chris Lattnera3c109b2010-07-29 02:16:43 +0000647 uint64_t Size = getContext().getTypeSize(RetTy);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000648
649 // 128-bit vectors are a special case; they are returned in
650 // registers and we need to make sure to pick a type the LLVM
651 // backend will like.
652 if (Size == 128)
Chris Lattner800588f2010-07-29 06:26:06 +0000653 return ABIArgInfo::getDirect(llvm::VectorType::get(
Chris Lattnera3c109b2010-07-29 02:16:43 +0000654 llvm::Type::getInt64Ty(getVMContext()), 2));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000655
656 // Always return in register if it fits in a general purpose
657 // register, or if it is 64 bits and has a single element.
658 if ((Size == 8 || Size == 16 || Size == 32) ||
659 (Size == 64 && VT->getNumElements() == 1))
Chris Lattner800588f2010-07-29 06:26:06 +0000660 return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
Chris Lattnera3c109b2010-07-29 02:16:43 +0000661 Size));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000662
663 return ABIArgInfo::getIndirect(0);
664 }
665
666 return ABIArgInfo::getDirect();
Chris Lattnera3c109b2010-07-29 02:16:43 +0000667 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000668
John McCalld608cdb2010-08-22 10:59:02 +0000669 if (isAggregateTypeForABI(RetTy)) {
Anders Carlssona8874232010-01-27 03:25:19 +0000670 if (const RecordType *RT = RetTy->getAs<RecordType>()) {
Anders Carlsson40092972009-10-20 22:07:59 +0000671 // Structures with either a non-trivial destructor or a non-trivial
672 // copy constructor are always indirect.
673 if (hasNonTrivialDestructorOrCopyConstructor(RT))
674 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000675
Anders Carlsson40092972009-10-20 22:07:59 +0000676 // Structures with flexible arrays are always indirect.
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000677 if (RT->getDecl()->hasFlexibleArrayMember())
678 return ABIArgInfo::getIndirect(0);
Anders Carlsson40092972009-10-20 22:07:59 +0000679 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000680
David Chisnall1e4249c2009-08-17 23:08:21 +0000681 // If specified, structs and unions are always indirect.
682 if (!IsSmallStructInRegABI && !RetTy->isAnyComplexType())
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000683 return ABIArgInfo::getIndirect(0);
684
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000685 // Small structures which are register sized are generally returned
686 // in a register.
Aaron Ballman6c60c8d2012-02-22 03:04:13 +0000687 if (X86_32ABIInfo::shouldReturnTypeInRegister(RetTy, getContext(),
688 callingConvention)) {
Chris Lattnera3c109b2010-07-29 02:16:43 +0000689 uint64_t Size = getContext().getTypeSize(RetTy);
Eli Friedmanbd4d3bc2011-11-18 01:25:50 +0000690
691 // As a special-case, if the struct is a "single-element" struct, and
692 // the field is of type "float" or "double", return it in a
Eli Friedman55fc7e22012-01-25 22:46:34 +0000693 // floating-point register. (MSVC does not apply this special case.)
694 // We apply a similar transformation for pointer types to improve the
695 // quality of the generated IR.
Eli Friedmanbd4d3bc2011-11-18 01:25:50 +0000696 if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
Eli Friedman55fc7e22012-01-25 22:46:34 +0000697 if ((!IsWin32FloatStructABI && SeltTy->isRealFloatingType())
698 || SeltTy->hasPointerRepresentation())
Eli Friedmanbd4d3bc2011-11-18 01:25:50 +0000699 return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
700
701 // FIXME: We should be able to narrow this integer in cases with dead
702 // padding.
Chris Lattner800588f2010-07-29 06:26:06 +0000703 return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),Size));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000704 }
705
706 return ABIArgInfo::getIndirect(0);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000707 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000708
Chris Lattnera3c109b2010-07-29 02:16:43 +0000709 // Treat an enum type as its underlying type.
710 if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
711 RetTy = EnumTy->getDecl()->getIntegerType();
712
713 return (RetTy->isPromotableIntegerType() ?
714 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000715}
716
Eli Friedmanf4bd4d82012-06-05 19:40:46 +0000717static bool isSSEVectorType(ASTContext &Context, QualType Ty) {
718 return Ty->getAs<VectorType>() && Context.getTypeSize(Ty) == 128;
719}
720
Daniel Dunbar93ae9472010-09-16 20:42:00 +0000721static bool isRecordWithSSEVectorType(ASTContext &Context, QualType Ty) {
722 const RecordType *RT = Ty->getAs<RecordType>();
723 if (!RT)
724 return 0;
725 const RecordDecl *RD = RT->getDecl();
726
727 // If this is a C++ record, check the bases first.
728 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
729 for (CXXRecordDecl::base_class_const_iterator i = CXXRD->bases_begin(),
730 e = CXXRD->bases_end(); i != e; ++i)
731 if (!isRecordWithSSEVectorType(Context, i->getType()))
732 return false;
733
734 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
735 i != e; ++i) {
736 QualType FT = i->getType();
737
Eli Friedmanf4bd4d82012-06-05 19:40:46 +0000738 if (isSSEVectorType(Context, FT))
Daniel Dunbar93ae9472010-09-16 20:42:00 +0000739 return true;
740
741 if (isRecordWithSSEVectorType(Context, FT))
742 return true;
743 }
744
745 return false;
746}
747
Daniel Dunbare59d8582010-09-16 20:42:06 +0000748unsigned X86_32ABIInfo::getTypeStackAlignInBytes(QualType Ty,
749 unsigned Align) const {
750 // Otherwise, if the alignment is less than or equal to the minimum ABI
751 // alignment, just use the default; the backend will handle this.
Daniel Dunbarfb67d6c2010-09-16 20:41:56 +0000752 if (Align <= MinABIStackAlignInBytes)
Daniel Dunbare59d8582010-09-16 20:42:06 +0000753 return 0; // Use default alignment.
754
755 // On non-Darwin, the stack type alignment is always 4.
756 if (!IsDarwinVectorABI) {
757 // Set explicit alignment, since we may need to realign the top.
Daniel Dunbarfb67d6c2010-09-16 20:41:56 +0000758 return MinABIStackAlignInBytes;
Daniel Dunbare59d8582010-09-16 20:42:06 +0000759 }
Daniel Dunbarfb67d6c2010-09-16 20:41:56 +0000760
Daniel Dunbar93ae9472010-09-16 20:42:00 +0000761 // Otherwise, if the type contains an SSE vector type, the alignment is 16.
Eli Friedmanf4bd4d82012-06-05 19:40:46 +0000762 if (Align >= 16 && (isSSEVectorType(getContext(), Ty) ||
763 isRecordWithSSEVectorType(getContext(), Ty)))
Daniel Dunbar93ae9472010-09-16 20:42:00 +0000764 return 16;
765
766 return MinABIStackAlignInBytes;
Daniel Dunbarfb67d6c2010-09-16 20:41:56 +0000767}
768
Chris Lattnera3c109b2010-07-29 02:16:43 +0000769ABIArgInfo X86_32ABIInfo::getIndirectResult(QualType Ty, bool ByVal) const {
Daniel Dunbar46c54fb2010-04-21 19:49:55 +0000770 if (!ByVal)
771 return ABIArgInfo::getIndirect(0, false);
772
Daniel Dunbare59d8582010-09-16 20:42:06 +0000773 // Compute the byval alignment.
774 unsigned TypeAlign = getContext().getTypeAlign(Ty) / 8;
775 unsigned StackAlign = getTypeStackAlignInBytes(Ty, TypeAlign);
776 if (StackAlign == 0)
Chris Lattnerde92d732011-05-22 23:35:00 +0000777 return ABIArgInfo::getIndirect(4);
Daniel Dunbare59d8582010-09-16 20:42:06 +0000778
779 // If the stack alignment is less than the type alignment, realign the
780 // argument.
781 if (StackAlign < TypeAlign)
782 return ABIArgInfo::getIndirect(StackAlign, /*ByVal=*/true,
783 /*Realign=*/true);
784
785 return ABIArgInfo::getIndirect(StackAlign);
Daniel Dunbardc6d5742010-04-21 19:10:51 +0000786}
787
Rafael Espindolab48280b2012-07-31 02:44:24 +0000788X86_32ABIInfo::Class X86_32ABIInfo::classify(QualType Ty) const {
789 const Type *T = isSingleElementStruct(Ty, getContext());
790 if (!T)
791 T = Ty.getTypePtr();
792
793 if (const BuiltinType *BT = T->getAs<BuiltinType>()) {
794 BuiltinType::Kind K = BT->getKind();
795 if (K == BuiltinType::Float || K == BuiltinType::Double)
796 return Float;
797 }
798 return Integer;
799}
800
801ABIArgInfo
802X86_32ABIInfo::classifyArgumentTypeWithReg(QualType Ty,
803 unsigned &FreeRegs) const {
804 // Common case first.
805 if (FreeRegs == 0)
806 return classifyArgumentType(Ty);
807
808 Class C = classify(Ty);
809 if (C == Float)
810 return classifyArgumentType(Ty);
811
812 unsigned SizeInRegs = (getContext().getTypeSize(Ty) + 31) / 32;
813 if (SizeInRegs == 0)
814 return classifyArgumentType(Ty);
815
816 if (SizeInRegs > FreeRegs) {
817 FreeRegs = 0;
818 return classifyArgumentType(Ty);
819 }
820 assert(SizeInRegs >= 1 && SizeInRegs <= 3);
821 FreeRegs -= SizeInRegs;
822
823 // If it is a simple scalar, keep the type so that we produce a cleaner IR.
824 ABIArgInfo Foo = classifyArgumentType(Ty);
825 if (Foo.isDirect() && !Foo.getDirectOffset() && !Foo.getPaddingType())
826 return ABIArgInfo::getDirectInReg(Foo.getCoerceToType());
827 if (Foo.isExtend())
828 return ABIArgInfo::getExtendInReg(Foo.getCoerceToType());
829
830 llvm::LLVMContext &LLVMContext = getVMContext();
831 llvm::Type *Int32 = llvm::Type::getInt32Ty(LLVMContext);
832 SmallVector<llvm::Type*, 3> Elements;
833 for (unsigned I = 0; I < SizeInRegs; ++I)
834 Elements.push_back(Int32);
835 llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements);
836 return ABIArgInfo::getDirectInReg(Result);
837}
838
Chris Lattnera3c109b2010-07-29 02:16:43 +0000839ABIArgInfo X86_32ABIInfo::classifyArgumentType(QualType Ty) const {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000840 // FIXME: Set alignment on indirect arguments.
John McCalld608cdb2010-08-22 10:59:02 +0000841 if (isAggregateTypeForABI(Ty)) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000842 // Structures with flexible arrays are always indirect.
Anders Carlssona8874232010-01-27 03:25:19 +0000843 if (const RecordType *RT = Ty->getAs<RecordType>()) {
844 // Structures with either a non-trivial destructor or a non-trivial
845 // copy constructor are always indirect.
846 if (hasNonTrivialDestructorOrCopyConstructor(RT))
Chris Lattnera3c109b2010-07-29 02:16:43 +0000847 return getIndirectResult(Ty, /*ByVal=*/false);
Daniel Dunbardc6d5742010-04-21 19:10:51 +0000848
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000849 if (RT->getDecl()->hasFlexibleArrayMember())
Chris Lattnera3c109b2010-07-29 02:16:43 +0000850 return getIndirectResult(Ty);
Anders Carlssona8874232010-01-27 03:25:19 +0000851 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000852
Eli Friedman5a4d3522011-11-18 00:28:11 +0000853 // Ignore empty structs/unions.
Eli Friedman5a1ac892011-11-18 04:01:36 +0000854 if (isEmptyRecord(getContext(), Ty, true))
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000855 return ABIArgInfo::getIgnore();
856
Daniel Dunbar53012f42009-11-09 01:33:53 +0000857 // Expand small (<= 128-bit) record types when we know that the stack layout
858 // of those arguments will match the struct. This is important because the
859 // LLVM backend isn't smart enough to remove byval, which inhibits many
860 // optimizations.
Chris Lattnera3c109b2010-07-29 02:16:43 +0000861 if (getContext().getTypeSize(Ty) <= 4*32 &&
862 canExpandIndirectArgument(Ty, getContext()))
Daniel Dunbar53012f42009-11-09 01:33:53 +0000863 return ABIArgInfo::getExpand();
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000864
Chris Lattnera3c109b2010-07-29 02:16:43 +0000865 return getIndirectResult(Ty);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000866 }
867
Chris Lattnerbbae8b42010-08-26 20:05:13 +0000868 if (const VectorType *VT = Ty->getAs<VectorType>()) {
Chris Lattner7b733502010-08-26 20:08:43 +0000869 // On Darwin, some vectors are passed in memory, we handle this by passing
870 // it as an i8/i16/i32/i64.
Chris Lattnerbbae8b42010-08-26 20:05:13 +0000871 if (IsDarwinVectorABI) {
872 uint64_t Size = getContext().getTypeSize(Ty);
Chris Lattnerbbae8b42010-08-26 20:05:13 +0000873 if ((Size == 8 || Size == 16 || Size == 32) ||
874 (Size == 64 && VT->getNumElements() == 1))
875 return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
876 Size));
Chris Lattnerbbae8b42010-08-26 20:05:13 +0000877 }
Bill Wendlingbb465d72010-10-18 03:41:31 +0000878
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000879 llvm::Type *IRType = CGT.ConvertType(Ty);
Bill Wendlingbb465d72010-10-18 03:41:31 +0000880 if (UseX86_MMXType(IRType)) {
Eli Friedmanc3e0fb42011-07-08 23:31:17 +0000881 if (IsMMXDisabled)
882 return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
883 64));
Bill Wendlingbb465d72010-10-18 03:41:31 +0000884 ABIArgInfo AAI = ABIArgInfo::getDirect(IRType);
885 AAI.setCoerceToType(llvm::Type::getX86_MMXTy(getVMContext()));
886 return AAI;
887 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000888
Chris Lattnerbbae8b42010-08-26 20:05:13 +0000889 return ABIArgInfo::getDirect();
890 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000891
892
Chris Lattnera3c109b2010-07-29 02:16:43 +0000893 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
894 Ty = EnumTy->getDecl()->getIntegerType();
Douglas Gregoraa74a1e2010-02-02 20:10:50 +0000895
Chris Lattnera3c109b2010-07-29 02:16:43 +0000896 return (Ty->isPromotableIntegerType() ?
897 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000898}
899
Rafael Espindolaaa9cf8d2012-07-24 00:01:07 +0000900void X86_32ABIInfo::computeInfo(CGFunctionInfo &FI) const {
901 FI.getReturnInfo() = classifyReturnType(FI.getReturnType(),
902 FI.getCallingConvention());
Rafael Espindolab48280b2012-07-31 02:44:24 +0000903
904 unsigned FreeRegs = FI.getHasRegParm() ? FI.getRegParm() :
905 DefaultNumRegisterParameters;
906
907 // If the return value is indirect, then the hidden argument is consuming one
908 // integer register.
909 if (FI.getReturnInfo().isIndirect() && FreeRegs) {
910 --FreeRegs;
911 ABIArgInfo &Old = FI.getReturnInfo();
912 Old = ABIArgInfo::getIndirectInReg(Old.getIndirectAlign(),
913 Old.getIndirectByVal(),
914 Old.getIndirectRealign());
915 }
916
Rafael Espindolaaa9cf8d2012-07-24 00:01:07 +0000917 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
918 it != ie; ++it)
Rafael Espindolab48280b2012-07-31 02:44:24 +0000919 it->info = classifyArgumentTypeWithReg(it->type, FreeRegs);
Rafael Espindolaaa9cf8d2012-07-24 00:01:07 +0000920}
921
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000922llvm::Value *X86_32ABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
923 CodeGenFunction &CGF) const {
Chris Lattner8b418682012-02-07 00:39:47 +0000924 llvm::Type *BPP = CGF.Int8PtrPtrTy;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000925
926 CGBuilderTy &Builder = CGF.Builder;
927 llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP,
928 "ap");
929 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
Eli Friedman7b1fb812011-11-18 02:12:09 +0000930
931 // Compute if the address needs to be aligned
932 unsigned Align = CGF.getContext().getTypeAlignInChars(Ty).getQuantity();
933 Align = getTypeStackAlignInBytes(Ty, Align);
934 Align = std::max(Align, 4U);
935 if (Align > 4) {
936 // addr = (addr + align - 1) & -align;
937 llvm::Value *Offset =
938 llvm::ConstantInt::get(CGF.Int32Ty, Align - 1);
939 Addr = CGF.Builder.CreateGEP(Addr, Offset);
940 llvm::Value *AsInt = CGF.Builder.CreatePtrToInt(Addr,
941 CGF.Int32Ty);
942 llvm::Value *Mask = llvm::ConstantInt::get(CGF.Int32Ty, -Align);
943 Addr = CGF.Builder.CreateIntToPtr(CGF.Builder.CreateAnd(AsInt, Mask),
944 Addr->getType(),
945 "ap.cur.aligned");
946 }
947
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000948 llvm::Type *PTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000949 llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000950 llvm::Value *AddrTyped = Builder.CreateBitCast(Addr, PTy);
951
952 uint64_t Offset =
Eli Friedman7b1fb812011-11-18 02:12:09 +0000953 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, Align);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000954 llvm::Value *NextAddr =
Chris Lattner77b89b82010-06-27 07:15:29 +0000955 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +0000956 "ap.next");
957 Builder.CreateStore(NextAddr, VAListAddrAsBPP);
958
959 return AddrTyped;
960}
961
Charles Davis74f72932010-02-13 15:54:06 +0000962void X86_32TargetCodeGenInfo::SetTargetAttributes(const Decl *D,
963 llvm::GlobalValue *GV,
964 CodeGen::CodeGenModule &CGM) const {
965 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
966 if (FD->hasAttr<X86ForceAlignArgPointerAttr>()) {
967 // Get the LLVM function.
968 llvm::Function *Fn = cast<llvm::Function>(GV);
969
970 // Now add the 'alignstack' attribute with a value of 16.
Bill Wendlingfac63102012-10-10 03:13:20 +0000971 Fn->addAttribute(~0U,
972 llvm::Attributes::constructStackAlignmentFromInt(16));
Charles Davis74f72932010-02-13 15:54:06 +0000973 }
974 }
975}
976
John McCall6374c332010-03-06 00:35:14 +0000977bool X86_32TargetCodeGenInfo::initDwarfEHRegSizeTable(
978 CodeGen::CodeGenFunction &CGF,
979 llvm::Value *Address) const {
980 CodeGen::CGBuilderTy &Builder = CGF.Builder;
John McCall6374c332010-03-06 00:35:14 +0000981
Chris Lattner8b418682012-02-07 00:39:47 +0000982 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000983
John McCall6374c332010-03-06 00:35:14 +0000984 // 0-7 are the eight integer registers; the order is different
985 // on Darwin (for EH), but the range is the same.
986 // 8 is %eip.
John McCallaeeb7012010-05-27 06:19:26 +0000987 AssignToArrayRange(Builder, Address, Four8, 0, 8);
John McCall6374c332010-03-06 00:35:14 +0000988
989 if (CGF.CGM.isTargetDarwin()) {
990 // 12-16 are st(0..4). Not sure why we stop at 4.
991 // These have size 16, which is sizeof(long double) on
992 // platforms with 8-byte alignment for that type.
Chris Lattner8b418682012-02-07 00:39:47 +0000993 llvm::Value *Sixteen8 = llvm::ConstantInt::get(CGF.Int8Ty, 16);
John McCallaeeb7012010-05-27 06:19:26 +0000994 AssignToArrayRange(Builder, Address, Sixteen8, 12, 16);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +0000995
John McCall6374c332010-03-06 00:35:14 +0000996 } else {
997 // 9 is %eflags, which doesn't get a size on Darwin for some
998 // reason.
999 Builder.CreateStore(Four8, Builder.CreateConstInBoundsGEP1_32(Address, 9));
1000
1001 // 11-16 are st(0..5). Not sure why we stop at 5.
1002 // These have size 12, which is sizeof(long double) on
1003 // platforms with 4-byte alignment for that type.
Chris Lattner8b418682012-02-07 00:39:47 +00001004 llvm::Value *Twelve8 = llvm::ConstantInt::get(CGF.Int8Ty, 12);
John McCallaeeb7012010-05-27 06:19:26 +00001005 AssignToArrayRange(Builder, Address, Twelve8, 11, 16);
1006 }
John McCall6374c332010-03-06 00:35:14 +00001007
1008 return false;
1009}
1010
Chris Lattnerdce5ad02010-06-28 20:05:43 +00001011//===----------------------------------------------------------------------===//
1012// X86-64 ABI Implementation
1013//===----------------------------------------------------------------------===//
1014
1015
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001016namespace {
1017/// X86_64ABIInfo - The X86_64 ABI information.
1018class X86_64ABIInfo : public ABIInfo {
1019 enum Class {
1020 Integer = 0,
1021 SSE,
1022 SSEUp,
1023 X87,
1024 X87Up,
1025 ComplexX87,
1026 NoClass,
1027 Memory
1028 };
1029
1030 /// merge - Implement the X86_64 ABI merging algorithm.
1031 ///
1032 /// Merge an accumulating classification \arg Accum with a field
1033 /// classification \arg Field.
1034 ///
1035 /// \param Accum - The accumulating classification. This should
1036 /// always be either NoClass or the result of a previous merge
1037 /// call. In addition, this should never be Memory (the caller
1038 /// should just return Memory for the aggregate).
Chris Lattner1090a9b2010-06-28 21:43:59 +00001039 static Class merge(Class Accum, Class Field);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001040
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001041 /// postMerge - Implement the X86_64 ABI post merging algorithm.
1042 ///
1043 /// Post merger cleanup, reduces a malformed Hi and Lo pair to
1044 /// final MEMORY or SSE classes when necessary.
1045 ///
1046 /// \param AggregateSize - The size of the current aggregate in
1047 /// the classification process.
1048 ///
1049 /// \param Lo - The classification for the parts of the type
1050 /// residing in the low word of the containing object.
1051 ///
1052 /// \param Hi - The classification for the parts of the type
1053 /// residing in the higher words of the containing object.
1054 ///
1055 void postMerge(unsigned AggregateSize, Class &Lo, Class &Hi) const;
1056
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001057 /// classify - Determine the x86_64 register classes in which the
1058 /// given type T should be passed.
1059 ///
1060 /// \param Lo - The classification for the parts of the type
1061 /// residing in the low word of the containing object.
1062 ///
1063 /// \param Hi - The classification for the parts of the type
1064 /// residing in the high word of the containing object.
1065 ///
1066 /// \param OffsetBase - The bit offset of this type in the
1067 /// containing object. Some parameters are classified different
1068 /// depending on whether they straddle an eightbyte boundary.
1069 ///
1070 /// If a word is unused its result will be NoClass; if a type should
1071 /// be passed in Memory then at least the classification of \arg Lo
1072 /// will be Memory.
1073 ///
Sylvestre Ledruf3477c12012-09-27 10:16:10 +00001074 /// The \arg Lo class will be NoClass iff the argument is ignored.
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001075 ///
1076 /// If the \arg Lo class is ComplexX87, then the \arg Hi class will
1077 /// also be ComplexX87.
Chris Lattner9c254f02010-06-29 06:01:59 +00001078 void classify(QualType T, uint64_t OffsetBase, Class &Lo, Class &Hi) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001079
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001080 llvm::Type *GetByteVectorType(QualType Ty) const;
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001081 llvm::Type *GetSSETypeAtOffset(llvm::Type *IRType,
1082 unsigned IROffset, QualType SourceTy,
1083 unsigned SourceOffset) const;
1084 llvm::Type *GetINTEGERTypeAtOffset(llvm::Type *IRType,
1085 unsigned IROffset, QualType SourceTy,
1086 unsigned SourceOffset) const;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001087
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001088 /// getIndirectResult - Give a source type \arg Ty, return a suitable result
Daniel Dunbar46c54fb2010-04-21 19:49:55 +00001089 /// such that the argument will be returned in memory.
Chris Lattner9c254f02010-06-29 06:01:59 +00001090 ABIArgInfo getIndirectReturnResult(QualType Ty) const;
Daniel Dunbar46c54fb2010-04-21 19:49:55 +00001091
1092 /// getIndirectResult - Give a source type \arg Ty, return a suitable result
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001093 /// such that the argument will be passed in memory.
Daniel Dunbaredfac032012-03-10 01:03:58 +00001094 ///
1095 /// \param freeIntRegs - The number of free integer registers remaining
1096 /// available.
1097 ABIArgInfo getIndirectResult(QualType Ty, unsigned freeIntRegs) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001098
Chris Lattnera3c109b2010-07-29 02:16:43 +00001099 ABIArgInfo classifyReturnType(QualType RetTy) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001100
Bill Wendlingbb465d72010-10-18 03:41:31 +00001101 ABIArgInfo classifyArgumentType(QualType Ty,
Daniel Dunbaredfac032012-03-10 01:03:58 +00001102 unsigned freeIntRegs,
Bill Wendlingbb465d72010-10-18 03:41:31 +00001103 unsigned &neededInt,
Bill Wendling99aaae82010-10-18 23:51:38 +00001104 unsigned &neededSSE) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001105
Eli Friedmanee1ad992011-12-02 00:11:43 +00001106 bool IsIllegalVectorType(QualType Ty) const;
1107
John McCall67a57732011-04-21 01:20:55 +00001108 /// The 0.98 ABI revision clarified a lot of ambiguities,
1109 /// unfortunately in ways that were not always consistent with
1110 /// certain previous compilers. In particular, platforms which
1111 /// required strict binary compatibility with older versions of GCC
1112 /// may need to exempt themselves.
1113 bool honorsRevision0_98() const {
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00001114 return !getContext().getTargetInfo().getTriple().isOSDarwin();
John McCall67a57732011-04-21 01:20:55 +00001115 }
1116
Eli Friedmanee1ad992011-12-02 00:11:43 +00001117 bool HasAVX;
1118
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001119public:
Eli Friedmanee1ad992011-12-02 00:11:43 +00001120 X86_64ABIInfo(CodeGen::CodeGenTypes &CGT, bool hasavx) :
1121 ABIInfo(CGT), HasAVX(hasavx) {}
Chris Lattner9c254f02010-06-29 06:01:59 +00001122
John McCallde5d3c72012-02-17 03:33:10 +00001123 bool isPassedUsingAVXType(QualType type) const {
1124 unsigned neededInt, neededSSE;
Daniel Dunbaredfac032012-03-10 01:03:58 +00001125 // The freeIntRegs argument doesn't matter here.
1126 ABIArgInfo info = classifyArgumentType(type, 0, neededInt, neededSSE);
John McCallde5d3c72012-02-17 03:33:10 +00001127 if (info.isDirect()) {
1128 llvm::Type *ty = info.getCoerceToType();
1129 if (llvm::VectorType *vectorTy = dyn_cast_or_null<llvm::VectorType>(ty))
1130 return (vectorTy->getBitWidth() > 128);
1131 }
1132 return false;
1133 }
1134
Chris Lattneree5dcd02010-07-29 02:31:05 +00001135 virtual void computeInfo(CGFunctionInfo &FI) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001136
1137 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
1138 CodeGenFunction &CGF) const;
1139};
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00001140
Chris Lattnerf13721d2010-08-31 16:44:54 +00001141/// WinX86_64ABIInfo - The Windows X86_64 ABI information.
NAKAMURA Takumia7573222011-01-17 22:56:31 +00001142class WinX86_64ABIInfo : public ABIInfo {
1143
1144 ABIArgInfo classify(QualType Ty) const;
1145
Chris Lattnerf13721d2010-08-31 16:44:54 +00001146public:
NAKAMURA Takumia7573222011-01-17 22:56:31 +00001147 WinX86_64ABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}
1148
1149 virtual void computeInfo(CGFunctionInfo &FI) const;
Chris Lattnerf13721d2010-08-31 16:44:54 +00001150
1151 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
1152 CodeGenFunction &CGF) const;
1153};
1154
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00001155class X86_64TargetCodeGenInfo : public TargetCodeGenInfo {
1156public:
Eli Friedmanee1ad992011-12-02 00:11:43 +00001157 X86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool HasAVX)
1158 : TargetCodeGenInfo(new X86_64ABIInfo(CGT, HasAVX)) {}
John McCall6374c332010-03-06 00:35:14 +00001159
John McCallde5d3c72012-02-17 03:33:10 +00001160 const X86_64ABIInfo &getABIInfo() const {
1161 return static_cast<const X86_64ABIInfo&>(TargetCodeGenInfo::getABIInfo());
1162 }
1163
John McCall6374c332010-03-06 00:35:14 +00001164 int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const {
1165 return 7;
1166 }
1167
1168 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
1169 llvm::Value *Address) const {
Chris Lattner8b418682012-02-07 00:39:47 +00001170 llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001171
John McCallaeeb7012010-05-27 06:19:26 +00001172 // 0-15 are the 16 integer registers.
1173 // 16 is %rip.
Chris Lattner8b418682012-02-07 00:39:47 +00001174 AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
John McCall6374c332010-03-06 00:35:14 +00001175 return false;
1176 }
Peter Collingbourne4b93d662011-02-19 23:03:58 +00001177
Jay Foadef6de3d2011-07-11 09:56:20 +00001178 llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001179 StringRef Constraint,
Jay Foadef6de3d2011-07-11 09:56:20 +00001180 llvm::Type* Ty) const {
Peter Collingbourne4b93d662011-02-19 23:03:58 +00001181 return X86AdjustInlineAsmType(CGF, Constraint, Ty);
1182 }
1183
John McCallde5d3c72012-02-17 03:33:10 +00001184 bool isNoProtoCallVariadic(const CallArgList &args,
1185 const FunctionNoProtoType *fnType) const {
John McCall01f151e2011-09-21 08:08:30 +00001186 // The default CC on x86-64 sets %al to the number of SSA
1187 // registers used, and GCC sets this when calling an unprototyped
Eli Friedman3ed79032011-12-01 04:53:19 +00001188 // function, so we override the default behavior. However, don't do
Eli Friedman68805fe2011-12-06 03:08:26 +00001189 // that when AVX types are involved: the ABI explicitly states it is
1190 // undefined, and it doesn't work in practice because of how the ABI
1191 // defines varargs anyway.
John McCallde5d3c72012-02-17 03:33:10 +00001192 if (fnType->getCallConv() == CC_Default || fnType->getCallConv() == CC_C) {
Eli Friedman3ed79032011-12-01 04:53:19 +00001193 bool HasAVXType = false;
John McCallde5d3c72012-02-17 03:33:10 +00001194 for (CallArgList::const_iterator
1195 it = args.begin(), ie = args.end(); it != ie; ++it) {
1196 if (getABIInfo().isPassedUsingAVXType(it->Ty)) {
1197 HasAVXType = true;
1198 break;
Eli Friedman3ed79032011-12-01 04:53:19 +00001199 }
1200 }
John McCallde5d3c72012-02-17 03:33:10 +00001201
Eli Friedman3ed79032011-12-01 04:53:19 +00001202 if (!HasAVXType)
1203 return true;
1204 }
John McCall01f151e2011-09-21 08:08:30 +00001205
John McCallde5d3c72012-02-17 03:33:10 +00001206 return TargetCodeGenInfo::isNoProtoCallVariadic(args, fnType);
John McCall01f151e2011-09-21 08:08:30 +00001207 }
1208
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00001209};
1210
Chris Lattnerf13721d2010-08-31 16:44:54 +00001211class WinX86_64TargetCodeGenInfo : public TargetCodeGenInfo {
1212public:
1213 WinX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
1214 : TargetCodeGenInfo(new WinX86_64ABIInfo(CGT)) {}
1215
1216 int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const {
1217 return 7;
1218 }
1219
1220 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
1221 llvm::Value *Address) const {
Chris Lattner8b418682012-02-07 00:39:47 +00001222 llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001223
Chris Lattnerf13721d2010-08-31 16:44:54 +00001224 // 0-15 are the 16 integer registers.
1225 // 16 is %rip.
Chris Lattner8b418682012-02-07 00:39:47 +00001226 AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
Chris Lattnerf13721d2010-08-31 16:44:54 +00001227 return false;
1228 }
1229};
1230
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001231}
1232
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001233void X86_64ABIInfo::postMerge(unsigned AggregateSize, Class &Lo,
1234 Class &Hi) const {
1235 // AMD64-ABI 3.2.3p2: Rule 5. Then a post merger cleanup is done:
1236 //
1237 // (a) If one of the classes is Memory, the whole argument is passed in
1238 // memory.
1239 //
1240 // (b) If X87UP is not preceded by X87, the whole argument is passed in
1241 // memory.
1242 //
1243 // (c) If the size of the aggregate exceeds two eightbytes and the first
1244 // eightbyte isn't SSE or any other eightbyte isn't SSEUP, the whole
1245 // argument is passed in memory. NOTE: This is necessary to keep the
1246 // ABI working for processors that don't support the __m256 type.
1247 //
1248 // (d) If SSEUP is not preceded by SSE or SSEUP, it is converted to SSE.
1249 //
1250 // Some of these are enforced by the merging logic. Others can arise
1251 // only with unions; for example:
1252 // union { _Complex double; unsigned; }
1253 //
1254 // Note that clauses (b) and (c) were added in 0.98.
1255 //
1256 if (Hi == Memory)
1257 Lo = Memory;
1258 if (Hi == X87Up && Lo != X87 && honorsRevision0_98())
1259 Lo = Memory;
1260 if (AggregateSize > 128 && (Lo != SSE || Hi != SSEUp))
1261 Lo = Memory;
1262 if (Hi == SSEUp && Lo != SSE)
1263 Hi = SSE;
1264}
1265
Chris Lattner1090a9b2010-06-28 21:43:59 +00001266X86_64ABIInfo::Class X86_64ABIInfo::merge(Class Accum, Class Field) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001267 // AMD64-ABI 3.2.3p2: Rule 4. Each field of an object is
1268 // classified recursively so that always two fields are
1269 // considered. The resulting class is calculated according to
1270 // the classes of the fields in the eightbyte:
1271 //
1272 // (a) If both classes are equal, this is the resulting class.
1273 //
1274 // (b) If one of the classes is NO_CLASS, the resulting class is
1275 // the other class.
1276 //
1277 // (c) If one of the classes is MEMORY, the result is the MEMORY
1278 // class.
1279 //
1280 // (d) If one of the classes is INTEGER, the result is the
1281 // INTEGER.
1282 //
1283 // (e) If one of the classes is X87, X87UP, COMPLEX_X87 class,
1284 // MEMORY is used as class.
1285 //
1286 // (f) Otherwise class SSE is used.
1287
1288 // Accum should never be memory (we should have returned) or
1289 // ComplexX87 (because this cannot be passed in a structure).
1290 assert((Accum != Memory && Accum != ComplexX87) &&
1291 "Invalid accumulated classification during merge.");
1292 if (Accum == Field || Field == NoClass)
1293 return Accum;
Chris Lattner1090a9b2010-06-28 21:43:59 +00001294 if (Field == Memory)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001295 return Memory;
Chris Lattner1090a9b2010-06-28 21:43:59 +00001296 if (Accum == NoClass)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001297 return Field;
Chris Lattner1090a9b2010-06-28 21:43:59 +00001298 if (Accum == Integer || Field == Integer)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001299 return Integer;
Chris Lattner1090a9b2010-06-28 21:43:59 +00001300 if (Field == X87 || Field == X87Up || Field == ComplexX87 ||
1301 Accum == X87 || Accum == X87Up)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001302 return Memory;
Chris Lattner1090a9b2010-06-28 21:43:59 +00001303 return SSE;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001304}
1305
Chris Lattnerbcaedae2010-06-30 19:14:05 +00001306void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase,
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001307 Class &Lo, Class &Hi) const {
1308 // FIXME: This code can be simplified by introducing a simple value class for
1309 // Class pairs with appropriate constructor methods for the various
1310 // situations.
1311
1312 // FIXME: Some of the split computations are wrong; unaligned vectors
1313 // shouldn't be passed in registers for example, so there is no chance they
1314 // can straddle an eightbyte. Verify & simplify.
1315
1316 Lo = Hi = NoClass;
1317
1318 Class &Current = OffsetBase < 64 ? Lo : Hi;
1319 Current = Memory;
1320
John McCall183700f2009-09-21 23:43:11 +00001321 if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001322 BuiltinType::Kind k = BT->getKind();
1323
1324 if (k == BuiltinType::Void) {
1325 Current = NoClass;
1326 } else if (k == BuiltinType::Int128 || k == BuiltinType::UInt128) {
1327 Lo = Integer;
1328 Hi = Integer;
1329 } else if (k >= BuiltinType::Bool && k <= BuiltinType::LongLong) {
1330 Current = Integer;
1331 } else if (k == BuiltinType::Float || k == BuiltinType::Double) {
1332 Current = SSE;
1333 } else if (k == BuiltinType::LongDouble) {
1334 Lo = X87;
1335 Hi = X87Up;
1336 }
1337 // FIXME: _Decimal32 and _Decimal64 are SSE.
1338 // FIXME: _float128 and _Decimal128 are (SSE, SSEUp).
Chris Lattner1090a9b2010-06-28 21:43:59 +00001339 return;
1340 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001341
Chris Lattner1090a9b2010-06-28 21:43:59 +00001342 if (const EnumType *ET = Ty->getAs<EnumType>()) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001343 // Classify the underlying integer type.
Chris Lattner9c254f02010-06-29 06:01:59 +00001344 classify(ET->getDecl()->getIntegerType(), OffsetBase, Lo, Hi);
Chris Lattner1090a9b2010-06-28 21:43:59 +00001345 return;
1346 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001347
Chris Lattner1090a9b2010-06-28 21:43:59 +00001348 if (Ty->hasPointerRepresentation()) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001349 Current = Integer;
Chris Lattner1090a9b2010-06-28 21:43:59 +00001350 return;
1351 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001352
Chris Lattner1090a9b2010-06-28 21:43:59 +00001353 if (Ty->isMemberPointerType()) {
Daniel Dunbar67d438d2010-05-15 00:00:37 +00001354 if (Ty->isMemberFunctionPointerType())
1355 Lo = Hi = Integer;
1356 else
1357 Current = Integer;
Chris Lattner1090a9b2010-06-28 21:43:59 +00001358 return;
1359 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001360
Chris Lattner1090a9b2010-06-28 21:43:59 +00001361 if (const VectorType *VT = Ty->getAs<VectorType>()) {
Chris Lattnerea044322010-07-29 02:01:43 +00001362 uint64_t Size = getContext().getTypeSize(VT);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001363 if (Size == 32) {
1364 // gcc passes all <4 x char>, <2 x short>, <1 x int>, <1 x
1365 // float> as integer.
1366 Current = Integer;
1367
1368 // If this type crosses an eightbyte boundary, it should be
1369 // split.
1370 uint64_t EB_Real = (OffsetBase) / 64;
1371 uint64_t EB_Imag = (OffsetBase + Size - 1) / 64;
1372 if (EB_Real != EB_Imag)
1373 Hi = Lo;
1374 } else if (Size == 64) {
1375 // gcc passes <1 x double> in memory. :(
1376 if (VT->getElementType()->isSpecificBuiltinType(BuiltinType::Double))
1377 return;
1378
1379 // gcc passes <1 x long long> as INTEGER.
Chris Lattner473f8e72010-08-26 18:03:20 +00001380 if (VT->getElementType()->isSpecificBuiltinType(BuiltinType::LongLong) ||
Chris Lattner0fefa412010-08-26 18:13:50 +00001381 VT->getElementType()->isSpecificBuiltinType(BuiltinType::ULongLong) ||
1382 VT->getElementType()->isSpecificBuiltinType(BuiltinType::Long) ||
1383 VT->getElementType()->isSpecificBuiltinType(BuiltinType::ULong))
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001384 Current = Integer;
1385 else
1386 Current = SSE;
1387
1388 // If this type crosses an eightbyte boundary, it should be
1389 // split.
1390 if (OffsetBase && OffsetBase != 64)
1391 Hi = Lo;
Eli Friedmanee1ad992011-12-02 00:11:43 +00001392 } else if (Size == 128 || (HasAVX && Size == 256)) {
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001393 // Arguments of 256-bits are split into four eightbyte chunks. The
1394 // least significant one belongs to class SSE and all the others to class
1395 // SSEUP. The original Lo and Hi design considers that types can't be
1396 // greater than 128-bits, so a 64-bit split in Hi and Lo makes sense.
1397 // This design isn't correct for 256-bits, but since there're no cases
1398 // where the upper parts would need to be inspected, avoid adding
1399 // complexity and just consider Hi to match the 64-256 part.
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001400 Lo = SSE;
1401 Hi = SSEUp;
1402 }
Chris Lattner1090a9b2010-06-28 21:43:59 +00001403 return;
1404 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001405
Chris Lattner1090a9b2010-06-28 21:43:59 +00001406 if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
Chris Lattnerea044322010-07-29 02:01:43 +00001407 QualType ET = getContext().getCanonicalType(CT->getElementType());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001408
Chris Lattnerea044322010-07-29 02:01:43 +00001409 uint64_t Size = getContext().getTypeSize(Ty);
Douglas Gregor2ade35e2010-06-16 00:17:44 +00001410 if (ET->isIntegralOrEnumerationType()) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001411 if (Size <= 64)
1412 Current = Integer;
1413 else if (Size <= 128)
1414 Lo = Hi = Integer;
Chris Lattnerea044322010-07-29 02:01:43 +00001415 } else if (ET == getContext().FloatTy)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001416 Current = SSE;
Chris Lattnerea044322010-07-29 02:01:43 +00001417 else if (ET == getContext().DoubleTy)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001418 Lo = Hi = SSE;
Chris Lattnerea044322010-07-29 02:01:43 +00001419 else if (ET == getContext().LongDoubleTy)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001420 Current = ComplexX87;
1421
1422 // If this complex type crosses an eightbyte boundary then it
1423 // should be split.
1424 uint64_t EB_Real = (OffsetBase) / 64;
Chris Lattnerea044322010-07-29 02:01:43 +00001425 uint64_t EB_Imag = (OffsetBase + getContext().getTypeSize(ET)) / 64;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001426 if (Hi == NoClass && EB_Real != EB_Imag)
1427 Hi = Lo;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001428
Chris Lattner1090a9b2010-06-28 21:43:59 +00001429 return;
1430 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001431
Chris Lattnerea044322010-07-29 02:01:43 +00001432 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001433 // Arrays are treated like structures.
1434
Chris Lattnerea044322010-07-29 02:01:43 +00001435 uint64_t Size = getContext().getTypeSize(Ty);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001436
1437 // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001438 // than four eightbytes, ..., it has class MEMORY.
1439 if (Size > 256)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001440 return;
1441
1442 // AMD64-ABI 3.2.3p2: Rule 1. If ..., or it contains unaligned
1443 // fields, it has class MEMORY.
1444 //
1445 // Only need to check alignment of array base.
Chris Lattnerea044322010-07-29 02:01:43 +00001446 if (OffsetBase % getContext().getTypeAlign(AT->getElementType()))
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001447 return;
1448
1449 // Otherwise implement simplified merge. We could be smarter about
1450 // this, but it isn't worth it and would be harder to verify.
1451 Current = NoClass;
Chris Lattnerea044322010-07-29 02:01:43 +00001452 uint64_t EltSize = getContext().getTypeSize(AT->getElementType());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001453 uint64_t ArraySize = AT->getSize().getZExtValue();
Bruno Cardoso Lopes089d8922011-07-12 01:27:38 +00001454
1455 // The only case a 256-bit wide vector could be used is when the array
1456 // contains a single 256-bit element. Since Lo and Hi logic isn't extended
1457 // to work for sizes wider than 128, early check and fallback to memory.
1458 if (Size > 128 && EltSize != 256)
1459 return;
1460
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001461 for (uint64_t i=0, Offset=OffsetBase; i<ArraySize; ++i, Offset += EltSize) {
1462 Class FieldLo, FieldHi;
Chris Lattner9c254f02010-06-29 06:01:59 +00001463 classify(AT->getElementType(), Offset, FieldLo, FieldHi);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001464 Lo = merge(Lo, FieldLo);
1465 Hi = merge(Hi, FieldHi);
1466 if (Lo == Memory || Hi == Memory)
1467 break;
1468 }
1469
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001470 postMerge(Size, Lo, Hi);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001471 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp array classification.");
Chris Lattner1090a9b2010-06-28 21:43:59 +00001472 return;
1473 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001474
Chris Lattner1090a9b2010-06-28 21:43:59 +00001475 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Chris Lattnerea044322010-07-29 02:01:43 +00001476 uint64_t Size = getContext().getTypeSize(Ty);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001477
1478 // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001479 // than four eightbytes, ..., it has class MEMORY.
1480 if (Size > 256)
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001481 return;
1482
Anders Carlsson0a8f8472009-09-16 15:53:40 +00001483 // AMD64-ABI 3.2.3p2: Rule 2. If a C++ object has either a non-trivial
1484 // copy constructor or a non-trivial destructor, it is passed by invisible
1485 // reference.
1486 if (hasNonTrivialDestructorOrCopyConstructor(RT))
1487 return;
Daniel Dunbarce9f4232009-11-22 23:01:23 +00001488
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001489 const RecordDecl *RD = RT->getDecl();
1490
1491 // Assume variable sized types are passed in memory.
1492 if (RD->hasFlexibleArrayMember())
1493 return;
1494
Chris Lattnerea044322010-07-29 02:01:43 +00001495 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001496
1497 // Reset Lo class, this will be recomputed.
1498 Current = NoClass;
Daniel Dunbarce9f4232009-11-22 23:01:23 +00001499
1500 // If this is a C++ record, classify the bases first.
1501 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
1502 for (CXXRecordDecl::base_class_const_iterator i = CXXRD->bases_begin(),
1503 e = CXXRD->bases_end(); i != e; ++i) {
1504 assert(!i->isVirtual() && !i->getType()->isDependentType() &&
1505 "Unexpected base class!");
1506 const CXXRecordDecl *Base =
1507 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1508
1509 // Classify this field.
1510 //
1511 // AMD64-ABI 3.2.3p2: Rule 3. If the size of the aggregate exceeds a
1512 // single eightbyte, each is classified separately. Each eightbyte gets
1513 // initialized to class NO_CLASS.
1514 Class FieldLo, FieldHi;
Benjamin Kramerd4f51982012-07-04 18:45:14 +00001515 uint64_t Offset =
1516 OffsetBase + getContext().toBits(Layout.getBaseClassOffset(Base));
Chris Lattner9c254f02010-06-29 06:01:59 +00001517 classify(i->getType(), Offset, FieldLo, FieldHi);
Daniel Dunbarce9f4232009-11-22 23:01:23 +00001518 Lo = merge(Lo, FieldLo);
1519 Hi = merge(Hi, FieldHi);
1520 if (Lo == Memory || Hi == Memory)
1521 break;
1522 }
1523 }
1524
1525 // Classify the fields one at a time, merging the results.
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001526 unsigned idx = 0;
Bruno Cardoso Lopes548e4782011-07-12 22:30:58 +00001527 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001528 i != e; ++i, ++idx) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001529 uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx);
1530 bool BitField = i->isBitField();
1531
Bruno Cardoso Lopesb8981df2011-07-13 21:58:55 +00001532 // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger than
1533 // four eightbytes, or it contains unaligned fields, it has class MEMORY.
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001534 //
Bruno Cardoso Lopesb8981df2011-07-13 21:58:55 +00001535 // The only case a 256-bit wide vector could be used is when the struct
1536 // contains a single 256-bit element. Since Lo and Hi logic isn't extended
1537 // to work for sizes wider than 128, early check and fallback to memory.
1538 //
1539 if (Size > 128 && getContext().getTypeSize(i->getType()) != 256) {
1540 Lo = Memory;
1541 return;
1542 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001543 // Note, skip this test for bit-fields, see below.
Chris Lattnerea044322010-07-29 02:01:43 +00001544 if (!BitField && Offset % getContext().getTypeAlign(i->getType())) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001545 Lo = Memory;
1546 return;
1547 }
1548
1549 // Classify this field.
1550 //
1551 // AMD64-ABI 3.2.3p2: Rule 3. If the size of the aggregate
1552 // exceeds a single eightbyte, each is classified
1553 // separately. Each eightbyte gets initialized to class
1554 // NO_CLASS.
1555 Class FieldLo, FieldHi;
1556
1557 // Bit-fields require special handling, they do not force the
1558 // structure to be passed in memory even if unaligned, and
1559 // therefore they can straddle an eightbyte.
1560 if (BitField) {
1561 // Ignore padding bit-fields.
1562 if (i->isUnnamedBitfield())
1563 continue;
1564
1565 uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx);
Richard Smitha6b8b2c2011-10-10 18:28:20 +00001566 uint64_t Size = i->getBitWidthValue(getContext());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001567
1568 uint64_t EB_Lo = Offset / 64;
1569 uint64_t EB_Hi = (Offset + Size - 1) / 64;
1570 FieldLo = FieldHi = NoClass;
1571 if (EB_Lo) {
1572 assert(EB_Hi == EB_Lo && "Invalid classification, type > 16 bytes.");
1573 FieldLo = NoClass;
1574 FieldHi = Integer;
1575 } else {
1576 FieldLo = Integer;
1577 FieldHi = EB_Hi ? Integer : NoClass;
1578 }
1579 } else
Chris Lattner9c254f02010-06-29 06:01:59 +00001580 classify(i->getType(), Offset, FieldLo, FieldHi);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001581 Lo = merge(Lo, FieldLo);
1582 Hi = merge(Hi, FieldHi);
1583 if (Lo == Memory || Hi == Memory)
1584 break;
1585 }
1586
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001587 postMerge(Size, Lo, Hi);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001588 }
1589}
1590
Chris Lattner9c254f02010-06-29 06:01:59 +00001591ABIArgInfo X86_64ABIInfo::getIndirectReturnResult(QualType Ty) const {
Daniel Dunbar46c54fb2010-04-21 19:49:55 +00001592 // If this is a scalar LLVM value then assume LLVM will pass it in the right
1593 // place naturally.
John McCalld608cdb2010-08-22 10:59:02 +00001594 if (!isAggregateTypeForABI(Ty)) {
Daniel Dunbar46c54fb2010-04-21 19:49:55 +00001595 // Treat an enum type as its underlying type.
1596 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
1597 Ty = EnumTy->getDecl()->getIntegerType();
1598
1599 return (Ty->isPromotableIntegerType() ?
1600 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
1601 }
1602
1603 return ABIArgInfo::getIndirect(0);
1604}
1605
Eli Friedmanee1ad992011-12-02 00:11:43 +00001606bool X86_64ABIInfo::IsIllegalVectorType(QualType Ty) const {
1607 if (const VectorType *VecTy = Ty->getAs<VectorType>()) {
1608 uint64_t Size = getContext().getTypeSize(VecTy);
1609 unsigned LargestVector = HasAVX ? 256 : 128;
1610 if (Size <= 64 || Size > LargestVector)
1611 return true;
1612 }
1613
1614 return false;
1615}
1616
Daniel Dunbaredfac032012-03-10 01:03:58 +00001617ABIArgInfo X86_64ABIInfo::getIndirectResult(QualType Ty,
1618 unsigned freeIntRegs) const {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001619 // If this is a scalar LLVM value then assume LLVM will pass it in the right
1620 // place naturally.
Daniel Dunbaredfac032012-03-10 01:03:58 +00001621 //
1622 // This assumption is optimistic, as there could be free registers available
1623 // when we need to pass this argument in memory, and LLVM could try to pass
1624 // the argument in the free register. This does not seem to happen currently,
1625 // but this code would be much safer if we could mark the argument with
1626 // 'onstack'. See PR12193.
Eli Friedmanee1ad992011-12-02 00:11:43 +00001627 if (!isAggregateTypeForABI(Ty) && !IsIllegalVectorType(Ty)) {
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00001628 // Treat an enum type as its underlying type.
1629 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
1630 Ty = EnumTy->getDecl()->getIntegerType();
1631
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001632 return (Ty->isPromotableIntegerType() ?
1633 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00001634 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001635
Daniel Dunbar46c54fb2010-04-21 19:49:55 +00001636 if (isRecordWithNonTrivialDestructorOrCopyConstructor(Ty))
1637 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
Anders Carlsson0a8f8472009-09-16 15:53:40 +00001638
Chris Lattner855d2272011-05-22 23:21:23 +00001639 // Compute the byval alignment. We specify the alignment of the byval in all
1640 // cases so that the mid-level optimizer knows the alignment of the byval.
1641 unsigned Align = std::max(getContext().getTypeAlign(Ty) / 8, 8U);
Daniel Dunbaredfac032012-03-10 01:03:58 +00001642
1643 // Attempt to avoid passing indirect results using byval when possible. This
1644 // is important for good codegen.
1645 //
1646 // We do this by coercing the value into a scalar type which the backend can
1647 // handle naturally (i.e., without using byval).
1648 //
1649 // For simplicity, we currently only do this when we have exhausted all of the
1650 // free integer registers. Doing this when there are free integer registers
1651 // would require more care, as we would have to ensure that the coerced value
1652 // did not claim the unused register. That would require either reording the
1653 // arguments to the function (so that any subsequent inreg values came first),
1654 // or only doing this optimization when there were no following arguments that
1655 // might be inreg.
1656 //
1657 // We currently expect it to be rare (particularly in well written code) for
1658 // arguments to be passed on the stack when there are still free integer
1659 // registers available (this would typically imply large structs being passed
1660 // by value), so this seems like a fair tradeoff for now.
1661 //
1662 // We can revisit this if the backend grows support for 'onstack' parameter
1663 // attributes. See PR12193.
1664 if (freeIntRegs == 0) {
1665 uint64_t Size = getContext().getTypeSize(Ty);
1666
1667 // If this type fits in an eightbyte, coerce it into the matching integral
1668 // type, which will end up on the stack (with alignment 8).
1669 if (Align == 8 && Size <= 64)
1670 return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
1671 Size));
1672 }
1673
Chris Lattner855d2272011-05-22 23:21:23 +00001674 return ABIArgInfo::getIndirect(Align);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00001675}
1676
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001677/// GetByteVectorType - The ABI specifies that a value should be passed in an
1678/// full vector XMM/YMM register. Pick an LLVM IR type that will be passed as a
Chris Lattner0f408f52010-07-29 04:56:46 +00001679/// vector register.
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001680llvm::Type *X86_64ABIInfo::GetByteVectorType(QualType Ty) const {
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001681 llvm::Type *IRType = CGT.ConvertType(Ty);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001682
Chris Lattner15842bd2010-07-29 05:02:29 +00001683 // Wrapper structs that just contain vectors are passed just like vectors,
1684 // strip them off if present.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001685 llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType);
Chris Lattner15842bd2010-07-29 05:02:29 +00001686 while (STy && STy->getNumElements() == 1) {
1687 IRType = STy->getElementType(0);
1688 STy = dyn_cast<llvm::StructType>(IRType);
1689 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001690
Bruno Cardoso Lopes528a8c72011-07-08 22:57:35 +00001691 // If the preferred type is a 16-byte vector, prefer to pass it.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001692 if (llvm::VectorType *VT = dyn_cast<llvm::VectorType>(IRType)){
1693 llvm::Type *EltTy = VT->getElementType();
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00001694 unsigned BitWidth = VT->getBitWidth();
Tanya Lattnerce275672011-11-28 23:18:11 +00001695 if ((BitWidth >= 128 && BitWidth <= 256) &&
Chris Lattner0f408f52010-07-29 04:56:46 +00001696 (EltTy->isFloatTy() || EltTy->isDoubleTy() ||
1697 EltTy->isIntegerTy(8) || EltTy->isIntegerTy(16) ||
1698 EltTy->isIntegerTy(32) || EltTy->isIntegerTy(64) ||
1699 EltTy->isIntegerTy(128)))
1700 return VT;
1701 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001702
Chris Lattner0f408f52010-07-29 04:56:46 +00001703 return llvm::VectorType::get(llvm::Type::getDoubleTy(getVMContext()), 2);
1704}
1705
Chris Lattnere2962be2010-07-29 07:30:00 +00001706/// BitsContainNoUserData - Return true if the specified [start,end) bit range
1707/// is known to either be off the end of the specified type or being in
1708/// alignment padding. The user type specified is known to be at most 128 bits
1709/// in size, and have passed through X86_64ABIInfo::classify with a successful
1710/// classification that put one of the two halves in the INTEGER class.
1711///
1712/// It is conservatively correct to return false.
1713static bool BitsContainNoUserData(QualType Ty, unsigned StartBit,
1714 unsigned EndBit, ASTContext &Context) {
1715 // If the bytes being queried are off the end of the type, there is no user
1716 // data hiding here. This handles analysis of builtins, vectors and other
1717 // types that don't contain interesting padding.
1718 unsigned TySize = (unsigned)Context.getTypeSize(Ty);
1719 if (TySize <= StartBit)
1720 return true;
1721
Chris Lattner021c3a32010-07-29 07:43:55 +00001722 if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) {
1723 unsigned EltSize = (unsigned)Context.getTypeSize(AT->getElementType());
1724 unsigned NumElts = (unsigned)AT->getSize().getZExtValue();
1725
1726 // Check each element to see if the element overlaps with the queried range.
1727 for (unsigned i = 0; i != NumElts; ++i) {
1728 // If the element is after the span we care about, then we're done..
1729 unsigned EltOffset = i*EltSize;
1730 if (EltOffset >= EndBit) break;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001731
Chris Lattner021c3a32010-07-29 07:43:55 +00001732 unsigned EltStart = EltOffset < StartBit ? StartBit-EltOffset :0;
1733 if (!BitsContainNoUserData(AT->getElementType(), EltStart,
1734 EndBit-EltOffset, Context))
1735 return false;
1736 }
1737 // If it overlaps no elements, then it is safe to process as padding.
1738 return true;
1739 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001740
Chris Lattnere2962be2010-07-29 07:30:00 +00001741 if (const RecordType *RT = Ty->getAs<RecordType>()) {
1742 const RecordDecl *RD = RT->getDecl();
1743 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001744
Chris Lattnere2962be2010-07-29 07:30:00 +00001745 // If this is a C++ record, check the bases first.
1746 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
1747 for (CXXRecordDecl::base_class_const_iterator i = CXXRD->bases_begin(),
1748 e = CXXRD->bases_end(); i != e; ++i) {
1749 assert(!i->isVirtual() && !i->getType()->isDependentType() &&
1750 "Unexpected base class!");
1751 const CXXRecordDecl *Base =
1752 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001753
Chris Lattnere2962be2010-07-29 07:30:00 +00001754 // If the base is after the span we care about, ignore it.
Benjamin Kramerd4f51982012-07-04 18:45:14 +00001755 unsigned BaseOffset = Context.toBits(Layout.getBaseClassOffset(Base));
Chris Lattnere2962be2010-07-29 07:30:00 +00001756 if (BaseOffset >= EndBit) continue;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001757
Chris Lattnere2962be2010-07-29 07:30:00 +00001758 unsigned BaseStart = BaseOffset < StartBit ? StartBit-BaseOffset :0;
1759 if (!BitsContainNoUserData(i->getType(), BaseStart,
1760 EndBit-BaseOffset, Context))
1761 return false;
1762 }
1763 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001764
Chris Lattnere2962be2010-07-29 07:30:00 +00001765 // Verify that no field has data that overlaps the region of interest. Yes
1766 // this could be sped up a lot by being smarter about queried fields,
1767 // however we're only looking at structs up to 16 bytes, so we don't care
1768 // much.
1769 unsigned idx = 0;
1770 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
1771 i != e; ++i, ++idx) {
1772 unsigned FieldOffset = (unsigned)Layout.getFieldOffset(idx);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001773
Chris Lattnere2962be2010-07-29 07:30:00 +00001774 // If we found a field after the region we care about, then we're done.
1775 if (FieldOffset >= EndBit) break;
1776
1777 unsigned FieldStart = FieldOffset < StartBit ? StartBit-FieldOffset :0;
1778 if (!BitsContainNoUserData(i->getType(), FieldStart, EndBit-FieldOffset,
1779 Context))
1780 return false;
1781 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001782
Chris Lattnere2962be2010-07-29 07:30:00 +00001783 // If nothing in this record overlapped the area of interest, then we're
1784 // clean.
1785 return true;
1786 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001787
Chris Lattnere2962be2010-07-29 07:30:00 +00001788 return false;
1789}
1790
Chris Lattner0b362002010-07-29 18:39:32 +00001791/// ContainsFloatAtOffset - Return true if the specified LLVM IR type has a
1792/// float member at the specified offset. For example, {int,{float}} has a
1793/// float at offset 4. It is conservatively correct for this routine to return
1794/// false.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001795static bool ContainsFloatAtOffset(llvm::Type *IRType, unsigned IROffset,
Micah Villmow25a6a842012-10-08 16:25:52 +00001796 const llvm::DataLayout &TD) {
Chris Lattner0b362002010-07-29 18:39:32 +00001797 // Base case if we find a float.
1798 if (IROffset == 0 && IRType->isFloatTy())
1799 return true;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001800
Chris Lattner0b362002010-07-29 18:39:32 +00001801 // If this is a struct, recurse into the field at the specified offset.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001802 if (llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType)) {
Chris Lattner0b362002010-07-29 18:39:32 +00001803 const llvm::StructLayout *SL = TD.getStructLayout(STy);
1804 unsigned Elt = SL->getElementContainingOffset(IROffset);
1805 IROffset -= SL->getElementOffset(Elt);
1806 return ContainsFloatAtOffset(STy->getElementType(Elt), IROffset, TD);
1807 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001808
Chris Lattner0b362002010-07-29 18:39:32 +00001809 // If this is an array, recurse into the field at the specified offset.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001810 if (llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(IRType)) {
1811 llvm::Type *EltTy = ATy->getElementType();
Chris Lattner0b362002010-07-29 18:39:32 +00001812 unsigned EltSize = TD.getTypeAllocSize(EltTy);
1813 IROffset -= IROffset/EltSize*EltSize;
1814 return ContainsFloatAtOffset(EltTy, IROffset, TD);
1815 }
1816
1817 return false;
1818}
1819
Chris Lattnerf47c9442010-07-29 18:13:09 +00001820
1821/// GetSSETypeAtOffset - Return a type that will be passed by the backend in the
1822/// low 8 bytes of an XMM register, corresponding to the SSE class.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001823llvm::Type *X86_64ABIInfo::
1824GetSSETypeAtOffset(llvm::Type *IRType, unsigned IROffset,
Chris Lattnerf47c9442010-07-29 18:13:09 +00001825 QualType SourceTy, unsigned SourceOffset) const {
Chris Lattnercba8d312010-07-29 18:19:50 +00001826 // The only three choices we have are either double, <2 x float>, or float. We
Chris Lattnerf47c9442010-07-29 18:13:09 +00001827 // pass as float if the last 4 bytes is just padding. This happens for
1828 // structs that contain 3 floats.
1829 if (BitsContainNoUserData(SourceTy, SourceOffset*8+32,
1830 SourceOffset*8+64, getContext()))
1831 return llvm::Type::getFloatTy(getVMContext());
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001832
Chris Lattner0b362002010-07-29 18:39:32 +00001833 // We want to pass as <2 x float> if the LLVM IR type contains a float at
1834 // offset+0 and offset+4. Walk the LLVM IR type to find out if this is the
1835 // case.
Micah Villmow25a6a842012-10-08 16:25:52 +00001836 if (ContainsFloatAtOffset(IRType, IROffset, getDataLayout()) &&
1837 ContainsFloatAtOffset(IRType, IROffset+4, getDataLayout()))
Chris Lattner22fd4ba2010-08-25 23:39:14 +00001838 return llvm::VectorType::get(llvm::Type::getFloatTy(getVMContext()), 2);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001839
Chris Lattnerf47c9442010-07-29 18:13:09 +00001840 return llvm::Type::getDoubleTy(getVMContext());
1841}
1842
1843
Chris Lattner0d2656d2010-07-29 17:40:35 +00001844/// GetINTEGERTypeAtOffset - The ABI specifies that a value should be passed in
1845/// an 8-byte GPR. This means that we either have a scalar or we are talking
1846/// about the high or low part of an up-to-16-byte struct. This routine picks
1847/// the best LLVM IR type to represent this, which may be i64 or may be anything
Chris Lattner49382de2010-07-28 22:44:07 +00001848/// else that the backend will pass in a GPR that works better (e.g. i8, %foo*,
1849/// etc).
1850///
1851/// PrefType is an LLVM IR type that corresponds to (part of) the IR type for
1852/// the source type. IROffset is an offset in bytes into the LLVM IR type that
1853/// the 8-byte value references. PrefType may be null.
1854///
1855/// SourceTy is the source level type for the entire argument. SourceOffset is
1856/// an offset into this that we're processing (which is always either 0 or 8).
1857///
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001858llvm::Type *X86_64ABIInfo::
1859GetINTEGERTypeAtOffset(llvm::Type *IRType, unsigned IROffset,
Chris Lattner0d2656d2010-07-29 17:40:35 +00001860 QualType SourceTy, unsigned SourceOffset) const {
Chris Lattnere2962be2010-07-29 07:30:00 +00001861 // If we're dealing with an un-offset LLVM IR type, then it means that we're
1862 // returning an 8-byte unit starting with it. See if we can safely use it.
1863 if (IROffset == 0) {
1864 // Pointers and int64's always fill the 8-byte unit.
1865 if (isa<llvm::PointerType>(IRType) || IRType->isIntegerTy(64))
1866 return IRType;
Chris Lattner49382de2010-07-28 22:44:07 +00001867
Chris Lattnere2962be2010-07-29 07:30:00 +00001868 // If we have a 1/2/4-byte integer, we can use it only if the rest of the
1869 // goodness in the source type is just tail padding. This is allowed to
1870 // kick in for struct {double,int} on the int, but not on
1871 // struct{double,int,int} because we wouldn't return the second int. We
1872 // have to do this analysis on the source type because we can't depend on
1873 // unions being lowered a specific way etc.
1874 if (IRType->isIntegerTy(8) || IRType->isIntegerTy(16) ||
1875 IRType->isIntegerTy(32)) {
1876 unsigned BitWidth = cast<llvm::IntegerType>(IRType)->getBitWidth();
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001877
Chris Lattnere2962be2010-07-29 07:30:00 +00001878 if (BitsContainNoUserData(SourceTy, SourceOffset*8+BitWidth,
1879 SourceOffset*8+64, getContext()))
1880 return IRType;
1881 }
1882 }
Chris Lattner49382de2010-07-28 22:44:07 +00001883
Chris Lattner2acc6e32011-07-18 04:24:23 +00001884 if (llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType)) {
Chris Lattner49382de2010-07-28 22:44:07 +00001885 // If this is a struct, recurse into the field at the specified offset.
Micah Villmow25a6a842012-10-08 16:25:52 +00001886 const llvm::StructLayout *SL = getDataLayout().getStructLayout(STy);
Chris Lattner49382de2010-07-28 22:44:07 +00001887 if (IROffset < SL->getSizeInBytes()) {
1888 unsigned FieldIdx = SL->getElementContainingOffset(IROffset);
1889 IROffset -= SL->getElementOffset(FieldIdx);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001890
Chris Lattner0d2656d2010-07-29 17:40:35 +00001891 return GetINTEGERTypeAtOffset(STy->getElementType(FieldIdx), IROffset,
1892 SourceTy, SourceOffset);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001893 }
Chris Lattner49382de2010-07-28 22:44:07 +00001894 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001895
Chris Lattner2acc6e32011-07-18 04:24:23 +00001896 if (llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(IRType)) {
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001897 llvm::Type *EltTy = ATy->getElementType();
Micah Villmow25a6a842012-10-08 16:25:52 +00001898 unsigned EltSize = getDataLayout().getTypeAllocSize(EltTy);
Chris Lattner021c3a32010-07-29 07:43:55 +00001899 unsigned EltOffset = IROffset/EltSize*EltSize;
Chris Lattner0d2656d2010-07-29 17:40:35 +00001900 return GetINTEGERTypeAtOffset(EltTy, IROffset-EltOffset, SourceTy,
1901 SourceOffset);
Chris Lattner021c3a32010-07-29 07:43:55 +00001902 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001903
Chris Lattner49382de2010-07-28 22:44:07 +00001904 // Okay, we don't have any better idea of what to pass, so we pass this in an
1905 // integer register that isn't too big to fit the rest of the struct.
Chris Lattner9e45a3d2010-07-29 17:34:39 +00001906 unsigned TySizeInBytes =
1907 (unsigned)getContext().getTypeSizeInChars(SourceTy).getQuantity();
Chris Lattner49382de2010-07-28 22:44:07 +00001908
Chris Lattner9e45a3d2010-07-29 17:34:39 +00001909 assert(TySizeInBytes != SourceOffset && "Empty field?");
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001910
Chris Lattner49382de2010-07-28 22:44:07 +00001911 // It is always safe to classify this as an integer type up to i64 that
1912 // isn't larger than the structure.
Chris Lattner9e45a3d2010-07-29 17:34:39 +00001913 return llvm::IntegerType::get(getVMContext(),
1914 std::min(TySizeInBytes-SourceOffset, 8U)*8);
Chris Lattner9c254f02010-06-29 06:01:59 +00001915}
1916
Chris Lattner66e7b682010-09-01 00:50:20 +00001917
1918/// GetX86_64ByValArgumentPair - Given a high and low type that can ideally
1919/// be used as elements of a two register pair to pass or return, return a
1920/// first class aggregate to represent them. For example, if the low part of
1921/// a by-value argument should be passed as i32* and the high part as float,
1922/// return {i32*, float}.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001923static llvm::Type *
Jay Foadef6de3d2011-07-11 09:56:20 +00001924GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi,
Micah Villmow25a6a842012-10-08 16:25:52 +00001925 const llvm::DataLayout &TD) {
Chris Lattner66e7b682010-09-01 00:50:20 +00001926 // In order to correctly satisfy the ABI, we need to the high part to start
1927 // at offset 8. If the high and low parts we inferred are both 4-byte types
1928 // (e.g. i32 and i32) then the resultant struct type ({i32,i32}) won't have
1929 // the second element at offset 8. Check for this:
1930 unsigned LoSize = (unsigned)TD.getTypeAllocSize(Lo);
1931 unsigned HiAlign = TD.getABITypeAlignment(Hi);
Micah Villmow25a6a842012-10-08 16:25:52 +00001932 unsigned HiStart = llvm::DataLayout::RoundUpAlignment(LoSize, HiAlign);
Chris Lattner66e7b682010-09-01 00:50:20 +00001933 assert(HiStart != 0 && HiStart <= 8 && "Invalid x86-64 argument pair!");
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001934
Chris Lattner66e7b682010-09-01 00:50:20 +00001935 // To handle this, we have to increase the size of the low part so that the
1936 // second element will start at an 8 byte offset. We can't increase the size
1937 // of the second element because it might make us access off the end of the
1938 // struct.
1939 if (HiStart != 8) {
1940 // There are only two sorts of types the ABI generation code can produce for
1941 // the low part of a pair that aren't 8 bytes in size: float or i8/i16/i32.
1942 // Promote these to a larger type.
1943 if (Lo->isFloatTy())
1944 Lo = llvm::Type::getDoubleTy(Lo->getContext());
1945 else {
1946 assert(Lo->isIntegerTy() && "Invalid/unknown lo type");
1947 Lo = llvm::Type::getInt64Ty(Lo->getContext());
1948 }
1949 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001950
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001951 llvm::StructType *Result = llvm::StructType::get(Lo, Hi, NULL);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001952
1953
Chris Lattner66e7b682010-09-01 00:50:20 +00001954 // Verify that the second element is at an 8-byte offset.
1955 assert(TD.getStructLayout(Result)->getElementOffset(1) == 8 &&
1956 "Invalid x86-64 argument pair!");
1957 return Result;
1958}
1959
Chris Lattner519f68c2010-07-28 23:06:14 +00001960ABIArgInfo X86_64ABIInfo::
Chris Lattnera3c109b2010-07-29 02:16:43 +00001961classifyReturnType(QualType RetTy) const {
Chris Lattner519f68c2010-07-28 23:06:14 +00001962 // AMD64-ABI 3.2.3p4: Rule 1. Classify the return type with the
1963 // classification algorithm.
1964 X86_64ABIInfo::Class Lo, Hi;
1965 classify(RetTy, 0, Lo, Hi);
1966
1967 // Check some invariants.
1968 assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
Chris Lattner519f68c2010-07-28 23:06:14 +00001969 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
1970
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001971 llvm::Type *ResType = 0;
Chris Lattner519f68c2010-07-28 23:06:14 +00001972 switch (Lo) {
1973 case NoClass:
Chris Lattner117e3f42010-07-30 04:02:24 +00001974 if (Hi == NoClass)
1975 return ABIArgInfo::getIgnore();
1976 // If the low part is just padding, it takes no register, leave ResType
1977 // null.
1978 assert((Hi == SSE || Hi == Integer || Hi == X87Up) &&
1979 "Unknown missing lo part");
1980 break;
Chris Lattner519f68c2010-07-28 23:06:14 +00001981
1982 case SSEUp:
1983 case X87Up:
David Blaikieb219cfc2011-09-23 05:06:16 +00001984 llvm_unreachable("Invalid classification for lo word.");
Chris Lattner519f68c2010-07-28 23:06:14 +00001985
1986 // AMD64-ABI 3.2.3p4: Rule 2. Types of class memory are returned via
1987 // hidden argument.
1988 case Memory:
1989 return getIndirectReturnResult(RetTy);
1990
1991 // AMD64-ABI 3.2.3p4: Rule 3. If the class is INTEGER, the next
1992 // available register of the sequence %rax, %rdx is used.
1993 case Integer:
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001994 ResType = GetINTEGERTypeAtOffset(CGT.ConvertType(RetTy), 0, RetTy, 0);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00001995
Chris Lattnereb518b42010-07-29 21:42:50 +00001996 // If we have a sign or zero extended integer, make sure to return Extend
1997 // so that the parameter gets the right LLVM IR attributes.
1998 if (Hi == NoClass && isa<llvm::IntegerType>(ResType)) {
1999 // Treat an enum type as its underlying type.
2000 if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
2001 RetTy = EnumTy->getDecl()->getIntegerType();
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002002
Chris Lattnereb518b42010-07-29 21:42:50 +00002003 if (RetTy->isIntegralOrEnumerationType() &&
2004 RetTy->isPromotableIntegerType())
2005 return ABIArgInfo::getExtend();
2006 }
Chris Lattner519f68c2010-07-28 23:06:14 +00002007 break;
2008
2009 // AMD64-ABI 3.2.3p4: Rule 4. If the class is SSE, the next
2010 // available SSE register of the sequence %xmm0, %xmm1 is used.
2011 case SSE:
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002012 ResType = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 0, RetTy, 0);
Chris Lattner0b30c672010-07-28 23:12:33 +00002013 break;
Chris Lattner519f68c2010-07-28 23:06:14 +00002014
2015 // AMD64-ABI 3.2.3p4: Rule 6. If the class is X87, the value is
2016 // returned on the X87 stack in %st0 as 80-bit x87 number.
2017 case X87:
Chris Lattnerea044322010-07-29 02:01:43 +00002018 ResType = llvm::Type::getX86_FP80Ty(getVMContext());
Chris Lattner0b30c672010-07-28 23:12:33 +00002019 break;
Chris Lattner519f68c2010-07-28 23:06:14 +00002020
2021 // AMD64-ABI 3.2.3p4: Rule 8. If the class is COMPLEX_X87, the real
2022 // part of the value is returned in %st0 and the imaginary part in
2023 // %st1.
2024 case ComplexX87:
2025 assert(Hi == ComplexX87 && "Unexpected ComplexX87 classification.");
Chris Lattner7650d952011-06-18 22:49:11 +00002026 ResType = llvm::StructType::get(llvm::Type::getX86_FP80Ty(getVMContext()),
Chris Lattnerea044322010-07-29 02:01:43 +00002027 llvm::Type::getX86_FP80Ty(getVMContext()),
Chris Lattner519f68c2010-07-28 23:06:14 +00002028 NULL);
2029 break;
2030 }
2031
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002032 llvm::Type *HighPart = 0;
Chris Lattner519f68c2010-07-28 23:06:14 +00002033 switch (Hi) {
2034 // Memory was handled previously and X87 should
2035 // never occur as a hi class.
2036 case Memory:
2037 case X87:
David Blaikieb219cfc2011-09-23 05:06:16 +00002038 llvm_unreachable("Invalid classification for hi word.");
Chris Lattner519f68c2010-07-28 23:06:14 +00002039
2040 case ComplexX87: // Previously handled.
Chris Lattner0b30c672010-07-28 23:12:33 +00002041 case NoClass:
2042 break;
Chris Lattner519f68c2010-07-28 23:06:14 +00002043
Chris Lattner3db4dde2010-09-01 00:20:33 +00002044 case Integer:
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002045 HighPart = GetINTEGERTypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);
Chris Lattner3db4dde2010-09-01 00:20:33 +00002046 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
2047 return ABIArgInfo::getDirect(HighPart, 8);
Chris Lattner519f68c2010-07-28 23:06:14 +00002048 break;
Chris Lattner3db4dde2010-09-01 00:20:33 +00002049 case SSE:
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002050 HighPart = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);
Chris Lattner3db4dde2010-09-01 00:20:33 +00002051 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
2052 return ABIArgInfo::getDirect(HighPart, 8);
Chris Lattner519f68c2010-07-28 23:06:14 +00002053 break;
2054
2055 // AMD64-ABI 3.2.3p4: Rule 5. If the class is SSEUP, the eightbyte
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00002056 // is passed in the next available eightbyte chunk if the last used
2057 // vector register.
Chris Lattner519f68c2010-07-28 23:06:14 +00002058 //
Chris Lattnerfc8f0e12011-04-15 05:22:18 +00002059 // SSEUP should always be preceded by SSE, just widen.
Chris Lattner519f68c2010-07-28 23:06:14 +00002060 case SSEUp:
2061 assert(Lo == SSE && "Unexpected SSEUp classification.");
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00002062 ResType = GetByteVectorType(RetTy);
Chris Lattner519f68c2010-07-28 23:06:14 +00002063 break;
2064
2065 // AMD64-ABI 3.2.3p4: Rule 7. If the class is X87UP, the value is
2066 // returned together with the previous X87 value in %st0.
2067 case X87Up:
Chris Lattnerfc8f0e12011-04-15 05:22:18 +00002068 // If X87Up is preceded by X87, we don't need to do
Chris Lattner519f68c2010-07-28 23:06:14 +00002069 // anything. However, in some cases with unions it may not be
Chris Lattnerfc8f0e12011-04-15 05:22:18 +00002070 // preceded by X87. In such situations we follow gcc and pass the
Chris Lattner519f68c2010-07-28 23:06:14 +00002071 // extra bits in an SSE reg.
Chris Lattner603519d2010-07-29 17:49:08 +00002072 if (Lo != X87) {
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002073 HighPart = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);
Chris Lattner3db4dde2010-09-01 00:20:33 +00002074 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
2075 return ABIArgInfo::getDirect(HighPart, 8);
Chris Lattner603519d2010-07-29 17:49:08 +00002076 }
Chris Lattner519f68c2010-07-28 23:06:14 +00002077 break;
2078 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002079
Chris Lattner3db4dde2010-09-01 00:20:33 +00002080 // If a high part was specified, merge it together with the low part. It is
Chris Lattner645406a2010-09-01 00:24:35 +00002081 // known to pass in the high eightbyte of the result. We do this by forming a
2082 // first class struct aggregate with the high and low part: {low, high}
Chris Lattner66e7b682010-09-01 00:50:20 +00002083 if (HighPart)
Micah Villmow25a6a842012-10-08 16:25:52 +00002084 ResType = GetX86_64ByValArgumentPair(ResType, HighPart, getDataLayout());
Chris Lattner519f68c2010-07-28 23:06:14 +00002085
Chris Lattnereb518b42010-07-29 21:42:50 +00002086 return ABIArgInfo::getDirect(ResType);
Chris Lattner519f68c2010-07-28 23:06:14 +00002087}
2088
Daniel Dunbaredfac032012-03-10 01:03:58 +00002089ABIArgInfo X86_64ABIInfo::classifyArgumentType(
2090 QualType Ty, unsigned freeIntRegs, unsigned &neededInt, unsigned &neededSSE)
2091 const
2092{
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002093 X86_64ABIInfo::Class Lo, Hi;
Chris Lattner9c254f02010-06-29 06:01:59 +00002094 classify(Ty, 0, Lo, Hi);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002095
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002096 // Check some invariants.
2097 // FIXME: Enforce these by construction.
2098 assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002099 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
2100
2101 neededInt = 0;
2102 neededSSE = 0;
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002103 llvm::Type *ResType = 0;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002104 switch (Lo) {
2105 case NoClass:
Chris Lattner117e3f42010-07-30 04:02:24 +00002106 if (Hi == NoClass)
2107 return ABIArgInfo::getIgnore();
2108 // If the low part is just padding, it takes no register, leave ResType
2109 // null.
2110 assert((Hi == SSE || Hi == Integer || Hi == X87Up) &&
2111 "Unknown missing lo part");
2112 break;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002113
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002114 // AMD64-ABI 3.2.3p3: Rule 1. If the class is MEMORY, pass the argument
2115 // on the stack.
2116 case Memory:
2117
2118 // AMD64-ABI 3.2.3p3: Rule 5. If the class is X87, X87UP or
2119 // COMPLEX_X87, it is passed in memory.
2120 case X87:
2121 case ComplexX87:
Eli Friedmanded137f2011-06-29 07:04:55 +00002122 if (isRecordWithNonTrivialDestructorOrCopyConstructor(Ty))
2123 ++neededInt;
Daniel Dunbaredfac032012-03-10 01:03:58 +00002124 return getIndirectResult(Ty, freeIntRegs);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002125
2126 case SSEUp:
2127 case X87Up:
David Blaikieb219cfc2011-09-23 05:06:16 +00002128 llvm_unreachable("Invalid classification for lo word.");
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002129
2130 // AMD64-ABI 3.2.3p3: Rule 2. If the class is INTEGER, the next
2131 // available register of the sequence %rdi, %rsi, %rdx, %rcx, %r8
2132 // and %r9 is used.
2133 case Integer:
Chris Lattner9c254f02010-06-29 06:01:59 +00002134 ++neededInt;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002135
Chris Lattner49382de2010-07-28 22:44:07 +00002136 // Pick an 8-byte type based on the preferred type.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002137 ResType = GetINTEGERTypeAtOffset(CGT.ConvertType(Ty), 0, Ty, 0);
Chris Lattnereb518b42010-07-29 21:42:50 +00002138
2139 // If we have a sign or zero extended integer, make sure to return Extend
2140 // so that the parameter gets the right LLVM IR attributes.
2141 if (Hi == NoClass && isa<llvm::IntegerType>(ResType)) {
2142 // Treat an enum type as its underlying type.
2143 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
2144 Ty = EnumTy->getDecl()->getIntegerType();
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002145
Chris Lattnereb518b42010-07-29 21:42:50 +00002146 if (Ty->isIntegralOrEnumerationType() &&
2147 Ty->isPromotableIntegerType())
2148 return ABIArgInfo::getExtend();
2149 }
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002150
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002151 break;
2152
2153 // AMD64-ABI 3.2.3p3: Rule 3. If the class is SSE, the next
2154 // available SSE register is used, the registers are taken in the
2155 // order from %xmm0 to %xmm7.
Bill Wendlingbb465d72010-10-18 03:41:31 +00002156 case SSE: {
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002157 llvm::Type *IRType = CGT.ConvertType(Ty);
Eli Friedman14508ff2011-07-02 00:57:27 +00002158 ResType = GetSSETypeAtOffset(IRType, 0, Ty, 0);
Bill Wendling99aaae82010-10-18 23:51:38 +00002159 ++neededSSE;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002160 break;
2161 }
Bill Wendlingbb465d72010-10-18 03:41:31 +00002162 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002163
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002164 llvm::Type *HighPart = 0;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002165 switch (Hi) {
2166 // Memory was handled previously, ComplexX87 and X87 should
Chris Lattnerfc8f0e12011-04-15 05:22:18 +00002167 // never occur as hi classes, and X87Up must be preceded by X87,
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002168 // which is passed in memory.
2169 case Memory:
2170 case X87:
2171 case ComplexX87:
David Blaikieb219cfc2011-09-23 05:06:16 +00002172 llvm_unreachable("Invalid classification for hi word.");
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002173
2174 case NoClass: break;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002175
Chris Lattner645406a2010-09-01 00:24:35 +00002176 case Integer:
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002177 ++neededInt;
Chris Lattner49382de2010-07-28 22:44:07 +00002178 // Pick an 8-byte type based on the preferred type.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002179 HighPart = GetINTEGERTypeAtOffset(CGT.ConvertType(Ty), 8, Ty, 8);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002180
Chris Lattner645406a2010-09-01 00:24:35 +00002181 if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
2182 return ABIArgInfo::getDirect(HighPart, 8);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002183 break;
2184
2185 // X87Up generally doesn't occur here (long double is passed in
2186 // memory), except in situations involving unions.
2187 case X87Up:
Chris Lattner645406a2010-09-01 00:24:35 +00002188 case SSE:
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002189 HighPart = GetSSETypeAtOffset(CGT.ConvertType(Ty), 8, Ty, 8);
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002190
Chris Lattner645406a2010-09-01 00:24:35 +00002191 if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
2192 return ABIArgInfo::getDirect(HighPart, 8);
Chris Lattner117e3f42010-07-30 04:02:24 +00002193
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002194 ++neededSSE;
2195 break;
2196
2197 // AMD64-ABI 3.2.3p3: Rule 4. If the class is SSEUP, the
2198 // eightbyte is passed in the upper half of the last used SSE
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002199 // register. This only happens when 128-bit vectors are passed.
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002200 case SSEUp:
Chris Lattnerab5722e2010-07-28 23:47:21 +00002201 assert(Lo == SSE && "Unexpected SSEUp classification");
Bruno Cardoso Lopes4943c152011-07-11 22:41:29 +00002202 ResType = GetByteVectorType(Ty);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002203 break;
2204 }
2205
Chris Lattner645406a2010-09-01 00:24:35 +00002206 // If a high part was specified, merge it together with the low part. It is
2207 // known to pass in the high eightbyte of the result. We do this by forming a
2208 // first class struct aggregate with the high and low part: {low, high}
2209 if (HighPart)
Micah Villmow25a6a842012-10-08 16:25:52 +00002210 ResType = GetX86_64ByValArgumentPair(ResType, HighPart, getDataLayout());
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002211
Chris Lattnereb518b42010-07-29 21:42:50 +00002212 return ABIArgInfo::getDirect(ResType);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002213}
2214
Chris Lattneree5dcd02010-07-29 02:31:05 +00002215void X86_64ABIInfo::computeInfo(CGFunctionInfo &FI) const {
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002216
Chris Lattnera3c109b2010-07-29 02:16:43 +00002217 FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002218
2219 // Keep track of the number of assigned registers.
Bill Wendling99aaae82010-10-18 23:51:38 +00002220 unsigned freeIntRegs = 6, freeSSERegs = 8;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002221
2222 // If the return value is indirect, then the hidden argument is consuming one
2223 // integer register.
2224 if (FI.getReturnInfo().isIndirect())
2225 --freeIntRegs;
2226
2227 // AMD64-ABI 3.2.3p3: Once arguments are classified, the registers
2228 // get assigned (in left-to-right order) for passing as follows...
2229 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
2230 it != ie; ++it) {
Bill Wendling99aaae82010-10-18 23:51:38 +00002231 unsigned neededInt, neededSSE;
Daniel Dunbaredfac032012-03-10 01:03:58 +00002232 it->info = classifyArgumentType(it->type, freeIntRegs, neededInt,
2233 neededSSE);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002234
2235 // AMD64-ABI 3.2.3p3: If there are no registers available for any
2236 // eightbyte of an argument, the whole argument is passed on the
2237 // stack. If registers have already been assigned for some
2238 // eightbytes of such an argument, the assignments get reverted.
Bill Wendling99aaae82010-10-18 23:51:38 +00002239 if (freeIntRegs >= neededInt && freeSSERegs >= neededSSE) {
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002240 freeIntRegs -= neededInt;
2241 freeSSERegs -= neededSSE;
2242 } else {
Daniel Dunbaredfac032012-03-10 01:03:58 +00002243 it->info = getIndirectResult(it->type, freeIntRegs);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002244 }
2245 }
2246}
2247
2248static llvm::Value *EmitVAArgFromMemory(llvm::Value *VAListAddr,
2249 QualType Ty,
2250 CodeGenFunction &CGF) {
2251 llvm::Value *overflow_arg_area_p =
2252 CGF.Builder.CreateStructGEP(VAListAddr, 2, "overflow_arg_area_p");
2253 llvm::Value *overflow_arg_area =
2254 CGF.Builder.CreateLoad(overflow_arg_area_p, "overflow_arg_area");
2255
2256 // AMD64-ABI 3.5.7p5: Step 7. Align l->overflow_arg_area upwards to a 16
2257 // byte boundary if alignment needed by type exceeds 8 byte boundary.
Eli Friedman8d2fe422011-11-18 02:44:19 +00002258 // It isn't stated explicitly in the standard, but in practice we use
2259 // alignment greater than 16 where necessary.
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002260 uint64_t Align = CGF.getContext().getTypeAlign(Ty) / 8;
2261 if (Align > 8) {
Eli Friedman8d2fe422011-11-18 02:44:19 +00002262 // overflow_arg_area = (overflow_arg_area + align - 1) & -align;
Owen Anderson0032b272009-08-13 21:57:51 +00002263 llvm::Value *Offset =
Eli Friedman8d2fe422011-11-18 02:44:19 +00002264 llvm::ConstantInt::get(CGF.Int64Ty, Align - 1);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002265 overflow_arg_area = CGF.Builder.CreateGEP(overflow_arg_area, Offset);
2266 llvm::Value *AsInt = CGF.Builder.CreatePtrToInt(overflow_arg_area,
Chris Lattner77b89b82010-06-27 07:15:29 +00002267 CGF.Int64Ty);
Eli Friedman8d2fe422011-11-18 02:44:19 +00002268 llvm::Value *Mask = llvm::ConstantInt::get(CGF.Int64Ty, -(uint64_t)Align);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002269 overflow_arg_area =
2270 CGF.Builder.CreateIntToPtr(CGF.Builder.CreateAnd(AsInt, Mask),
2271 overflow_arg_area->getType(),
2272 "overflow_arg_area.align");
2273 }
2274
2275 // AMD64-ABI 3.5.7p5: Step 8. Fetch type from l->overflow_arg_area.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002276 llvm::Type *LTy = CGF.ConvertTypeForMem(Ty);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002277 llvm::Value *Res =
2278 CGF.Builder.CreateBitCast(overflow_arg_area,
Owen Anderson96e0fc72009-07-29 22:16:19 +00002279 llvm::PointerType::getUnqual(LTy));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002280
2281 // AMD64-ABI 3.5.7p5: Step 9. Set l->overflow_arg_area to:
2282 // l->overflow_arg_area + sizeof(type).
2283 // AMD64-ABI 3.5.7p5: Step 10. Align l->overflow_arg_area upwards to
2284 // an 8 byte boundary.
2285
2286 uint64_t SizeInBytes = (CGF.getContext().getTypeSize(Ty) + 7) / 8;
Owen Anderson0032b272009-08-13 21:57:51 +00002287 llvm::Value *Offset =
Chris Lattner77b89b82010-06-27 07:15:29 +00002288 llvm::ConstantInt::get(CGF.Int32Ty, (SizeInBytes + 7) & ~7);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002289 overflow_arg_area = CGF.Builder.CreateGEP(overflow_arg_area, Offset,
2290 "overflow_arg_area.next");
2291 CGF.Builder.CreateStore(overflow_arg_area, overflow_arg_area_p);
2292
2293 // AMD64-ABI 3.5.7p5: Step 11. Return the fetched type.
2294 return Res;
2295}
2296
2297llvm::Value *X86_64ABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
2298 CodeGenFunction &CGF) const {
2299 // Assume that va_list type is correct; should be pointer to LLVM type:
2300 // struct {
2301 // i32 gp_offset;
2302 // i32 fp_offset;
2303 // i8* overflow_arg_area;
2304 // i8* reg_save_area;
2305 // };
Bill Wendling99aaae82010-10-18 23:51:38 +00002306 unsigned neededInt, neededSSE;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002307
Chris Lattnera14db752010-03-11 18:19:55 +00002308 Ty = CGF.getContext().getCanonicalType(Ty);
Daniel Dunbaredfac032012-03-10 01:03:58 +00002309 ABIArgInfo AI = classifyArgumentType(Ty, 0, neededInt, neededSSE);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002310
2311 // AMD64-ABI 3.5.7p5: Step 1. Determine whether type may be passed
2312 // in the registers. If not go to step 7.
2313 if (!neededInt && !neededSSE)
2314 return EmitVAArgFromMemory(VAListAddr, Ty, CGF);
2315
2316 // AMD64-ABI 3.5.7p5: Step 2. Compute num_gp to hold the number of
2317 // general purpose registers needed to pass type and num_fp to hold
2318 // the number of floating point registers needed.
2319
2320 // AMD64-ABI 3.5.7p5: Step 3. Verify whether arguments fit into
2321 // registers. In the case: l->gp_offset > 48 - num_gp * 8 or
2322 // l->fp_offset > 304 - num_fp * 16 go to step 7.
2323 //
2324 // NOTE: 304 is a typo, there are (6 * 8 + 8 * 16) = 176 bytes of
2325 // register save space).
2326
2327 llvm::Value *InRegs = 0;
2328 llvm::Value *gp_offset_p = 0, *gp_offset = 0;
2329 llvm::Value *fp_offset_p = 0, *fp_offset = 0;
2330 if (neededInt) {
2331 gp_offset_p = CGF.Builder.CreateStructGEP(VAListAddr, 0, "gp_offset_p");
2332 gp_offset = CGF.Builder.CreateLoad(gp_offset_p, "gp_offset");
Chris Lattner1090a9b2010-06-28 21:43:59 +00002333 InRegs = llvm::ConstantInt::get(CGF.Int32Ty, 48 - neededInt * 8);
2334 InRegs = CGF.Builder.CreateICmpULE(gp_offset, InRegs, "fits_in_gp");
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002335 }
2336
2337 if (neededSSE) {
2338 fp_offset_p = CGF.Builder.CreateStructGEP(VAListAddr, 1, "fp_offset_p");
2339 fp_offset = CGF.Builder.CreateLoad(fp_offset_p, "fp_offset");
2340 llvm::Value *FitsInFP =
Chris Lattner1090a9b2010-06-28 21:43:59 +00002341 llvm::ConstantInt::get(CGF.Int32Ty, 176 - neededSSE * 16);
2342 FitsInFP = CGF.Builder.CreateICmpULE(fp_offset, FitsInFP, "fits_in_fp");
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002343 InRegs = InRegs ? CGF.Builder.CreateAnd(InRegs, FitsInFP) : FitsInFP;
2344 }
2345
2346 llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg");
2347 llvm::BasicBlock *InMemBlock = CGF.createBasicBlock("vaarg.in_mem");
2348 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end");
2349 CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);
2350
2351 // Emit code to load the value if it was passed in registers.
2352
2353 CGF.EmitBlock(InRegBlock);
2354
2355 // AMD64-ABI 3.5.7p5: Step 4. Fetch type from l->reg_save_area with
2356 // an offset of l->gp_offset and/or l->fp_offset. This may require
2357 // copying to a temporary location in case the parameter is passed
2358 // in different register classes or requires an alignment greater
2359 // than 8 for general purpose registers and 16 for XMM registers.
2360 //
2361 // FIXME: This really results in shameful code when we end up needing to
2362 // collect arguments from different places; often what should result in a
2363 // simple assembling of a structure from scattered addresses has many more
2364 // loads than necessary. Can we clean this up?
Chris Lattner2acc6e32011-07-18 04:24:23 +00002365 llvm::Type *LTy = CGF.ConvertTypeForMem(Ty);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002366 llvm::Value *RegAddr =
2367 CGF.Builder.CreateLoad(CGF.Builder.CreateStructGEP(VAListAddr, 3),
2368 "reg_save_area");
2369 if (neededInt && neededSSE) {
2370 // FIXME: Cleanup.
Chris Lattner800588f2010-07-29 06:26:06 +00002371 assert(AI.isDirect() && "Unexpected ABI info for mixed regs");
Chris Lattner2acc6e32011-07-18 04:24:23 +00002372 llvm::StructType *ST = cast<llvm::StructType>(AI.getCoerceToType());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002373 llvm::Value *Tmp = CGF.CreateTempAlloca(ST);
2374 assert(ST->getNumElements() == 2 && "Unexpected ABI info for mixed regs");
Chris Lattner2acc6e32011-07-18 04:24:23 +00002375 llvm::Type *TyLo = ST->getElementType(0);
2376 llvm::Type *TyHi = ST->getElementType(1);
Chris Lattnera8b7a7d2010-08-26 06:28:35 +00002377 assert((TyLo->isFPOrFPVectorTy() ^ TyHi->isFPOrFPVectorTy()) &&
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002378 "Unexpected ABI info for mixed regs");
Chris Lattner2acc6e32011-07-18 04:24:23 +00002379 llvm::Type *PTyLo = llvm::PointerType::getUnqual(TyLo);
2380 llvm::Type *PTyHi = llvm::PointerType::getUnqual(TyHi);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002381 llvm::Value *GPAddr = CGF.Builder.CreateGEP(RegAddr, gp_offset);
2382 llvm::Value *FPAddr = CGF.Builder.CreateGEP(RegAddr, fp_offset);
Duncan Sandsf177d9d2010-02-15 16:14:01 +00002383 llvm::Value *RegLoAddr = TyLo->isFloatingPointTy() ? FPAddr : GPAddr;
2384 llvm::Value *RegHiAddr = TyLo->isFloatingPointTy() ? GPAddr : FPAddr;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002385 llvm::Value *V =
2386 CGF.Builder.CreateLoad(CGF.Builder.CreateBitCast(RegLoAddr, PTyLo));
2387 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
2388 V = CGF.Builder.CreateLoad(CGF.Builder.CreateBitCast(RegHiAddr, PTyHi));
2389 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
2390
Owen Andersona1cf15f2009-07-14 23:10:40 +00002391 RegAddr = CGF.Builder.CreateBitCast(Tmp,
Owen Anderson96e0fc72009-07-29 22:16:19 +00002392 llvm::PointerType::getUnqual(LTy));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002393 } else if (neededInt) {
2394 RegAddr = CGF.Builder.CreateGEP(RegAddr, gp_offset);
2395 RegAddr = CGF.Builder.CreateBitCast(RegAddr,
Owen Anderson96e0fc72009-07-29 22:16:19 +00002396 llvm::PointerType::getUnqual(LTy));
Chris Lattnerdce5ad02010-06-28 20:05:43 +00002397 } else if (neededSSE == 1) {
2398 RegAddr = CGF.Builder.CreateGEP(RegAddr, fp_offset);
2399 RegAddr = CGF.Builder.CreateBitCast(RegAddr,
2400 llvm::PointerType::getUnqual(LTy));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002401 } else {
Chris Lattnerdce5ad02010-06-28 20:05:43 +00002402 assert(neededSSE == 2 && "Invalid number of needed registers!");
2403 // SSE registers are spaced 16 bytes apart in the register save
2404 // area, we need to collect the two eightbytes together.
2405 llvm::Value *RegAddrLo = CGF.Builder.CreateGEP(RegAddr, fp_offset);
Chris Lattner1090a9b2010-06-28 21:43:59 +00002406 llvm::Value *RegAddrHi = CGF.Builder.CreateConstGEP1_32(RegAddrLo, 16);
Chris Lattner8b418682012-02-07 00:39:47 +00002407 llvm::Type *DoubleTy = CGF.DoubleTy;
Chris Lattner2acc6e32011-07-18 04:24:23 +00002408 llvm::Type *DblPtrTy =
Chris Lattnerdce5ad02010-06-28 20:05:43 +00002409 llvm::PointerType::getUnqual(DoubleTy);
Chris Lattner2acc6e32011-07-18 04:24:23 +00002410 llvm::StructType *ST = llvm::StructType::get(DoubleTy,
Chris Lattnerdce5ad02010-06-28 20:05:43 +00002411 DoubleTy, NULL);
2412 llvm::Value *V, *Tmp = CGF.CreateTempAlloca(ST);
2413 V = CGF.Builder.CreateLoad(CGF.Builder.CreateBitCast(RegAddrLo,
2414 DblPtrTy));
2415 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
2416 V = CGF.Builder.CreateLoad(CGF.Builder.CreateBitCast(RegAddrHi,
2417 DblPtrTy));
2418 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
2419 RegAddr = CGF.Builder.CreateBitCast(Tmp,
2420 llvm::PointerType::getUnqual(LTy));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002421 }
2422
2423 // AMD64-ABI 3.5.7p5: Step 5. Set:
2424 // l->gp_offset = l->gp_offset + num_gp * 8
2425 // l->fp_offset = l->fp_offset + num_fp * 16.
2426 if (neededInt) {
Chris Lattner77b89b82010-06-27 07:15:29 +00002427 llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, neededInt * 8);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002428 CGF.Builder.CreateStore(CGF.Builder.CreateAdd(gp_offset, Offset),
2429 gp_offset_p);
2430 }
2431 if (neededSSE) {
Chris Lattner77b89b82010-06-27 07:15:29 +00002432 llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, neededSSE * 16);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002433 CGF.Builder.CreateStore(CGF.Builder.CreateAdd(fp_offset, Offset),
2434 fp_offset_p);
2435 }
2436 CGF.EmitBranch(ContBlock);
2437
2438 // Emit code to load the value if it was passed in memory.
2439
2440 CGF.EmitBlock(InMemBlock);
2441 llvm::Value *MemAddr = EmitVAArgFromMemory(VAListAddr, Ty, CGF);
2442
2443 // Return the appropriate result.
2444
2445 CGF.EmitBlock(ContBlock);
Jay Foadbbf3bac2011-03-30 11:28:58 +00002446 llvm::PHINode *ResAddr = CGF.Builder.CreatePHI(RegAddr->getType(), 2,
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002447 "vaarg.addr");
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002448 ResAddr->addIncoming(RegAddr, InRegBlock);
2449 ResAddr->addIncoming(MemAddr, InMemBlock);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002450 return ResAddr;
2451}
2452
NAKAMURA Takumia7573222011-01-17 22:56:31 +00002453ABIArgInfo WinX86_64ABIInfo::classify(QualType Ty) const {
2454
2455 if (Ty->isVoidType())
2456 return ABIArgInfo::getIgnore();
2457
2458 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
2459 Ty = EnumTy->getDecl()->getIntegerType();
2460
2461 uint64_t Size = getContext().getTypeSize(Ty);
2462
2463 if (const RecordType *RT = Ty->getAs<RecordType>()) {
NAKAMURA Takumiff8be0e2011-01-19 00:11:33 +00002464 if (hasNonTrivialDestructorOrCopyConstructor(RT) ||
2465 RT->getDecl()->hasFlexibleArrayMember())
NAKAMURA Takumia7573222011-01-17 22:56:31 +00002466 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
2467
NAKAMURA Takumi6f174332011-02-22 03:56:57 +00002468 // FIXME: mingw-w64-gcc emits 128-bit struct as i128
2469 if (Size == 128 &&
Eli Friedman55fc7e22012-01-25 22:46:34 +00002470 getContext().getTargetInfo().getTriple().getOS()
2471 == llvm::Triple::MinGW32)
NAKAMURA Takumi6f174332011-02-22 03:56:57 +00002472 return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
2473 Size));
2474
2475 // MS x64 ABI requirement: "Any argument that doesn't fit in 8 bytes, or is
2476 // not 1, 2, 4, or 8 bytes, must be passed by reference."
2477 if (Size <= 64 &&
NAKAMURA Takumiff8be0e2011-01-19 00:11:33 +00002478 (Size & (Size - 1)) == 0)
NAKAMURA Takumia7573222011-01-17 22:56:31 +00002479 return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
2480 Size));
2481
2482 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
2483 }
2484
2485 if (Ty->isPromotableIntegerType())
2486 return ABIArgInfo::getExtend();
2487
2488 return ABIArgInfo::getDirect();
2489}
2490
2491void WinX86_64ABIInfo::computeInfo(CGFunctionInfo &FI) const {
2492
2493 QualType RetTy = FI.getReturnType();
2494 FI.getReturnInfo() = classify(RetTy);
2495
NAKAMURA Takumia7573222011-01-17 22:56:31 +00002496 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
2497 it != ie; ++it)
2498 it->info = classify(it->type);
2499}
2500
Chris Lattnerf13721d2010-08-31 16:44:54 +00002501llvm::Value *WinX86_64ABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
2502 CodeGenFunction &CGF) const {
Chris Lattner8b418682012-02-07 00:39:47 +00002503 llvm::Type *BPP = CGF.Int8PtrPtrTy;
Chris Lattnerdce5ad02010-06-28 20:05:43 +00002504
Chris Lattnerf13721d2010-08-31 16:44:54 +00002505 CGBuilderTy &Builder = CGF.Builder;
2506 llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP,
2507 "ap");
2508 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
2509 llvm::Type *PTy =
2510 llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
2511 llvm::Value *AddrTyped = Builder.CreateBitCast(Addr, PTy);
2512
2513 uint64_t Offset =
2514 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, 8);
2515 llvm::Value *NextAddr =
2516 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
2517 "ap.next");
2518 Builder.CreateStore(NextAddr, VAListAddrAsBPP);
2519
2520 return AddrTyped;
2521}
Chris Lattnerdce5ad02010-06-28 20:05:43 +00002522
John McCallec853ba2010-03-11 00:10:12 +00002523// PowerPC-32
2524
2525namespace {
2526class PPC32TargetCodeGenInfo : public DefaultTargetCodeGenInfo {
2527public:
Chris Lattnerea044322010-07-29 02:01:43 +00002528 PPC32TargetCodeGenInfo(CodeGenTypes &CGT) : DefaultTargetCodeGenInfo(CGT) {}
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002529
John McCallec853ba2010-03-11 00:10:12 +00002530 int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const {
2531 // This is recovered from gcc output.
2532 return 1; // r1 is the dedicated stack pointer
2533 }
2534
2535 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002536 llvm::Value *Address) const;
John McCallec853ba2010-03-11 00:10:12 +00002537};
2538
2539}
2540
2541bool
2542PPC32TargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2543 llvm::Value *Address) const {
2544 // This is calculated from the LLVM and GCC tables and verified
2545 // against gcc output. AFAIK all ABIs use the same encoding.
2546
2547 CodeGen::CGBuilderTy &Builder = CGF.Builder;
John McCallec853ba2010-03-11 00:10:12 +00002548
Chris Lattner8b418682012-02-07 00:39:47 +00002549 llvm::IntegerType *i8 = CGF.Int8Ty;
John McCallec853ba2010-03-11 00:10:12 +00002550 llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
2551 llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
2552 llvm::Value *Sixteen8 = llvm::ConstantInt::get(i8, 16);
2553
2554 // 0-31: r0-31, the 4-byte general-purpose registers
John McCallaeeb7012010-05-27 06:19:26 +00002555 AssignToArrayRange(Builder, Address, Four8, 0, 31);
John McCallec853ba2010-03-11 00:10:12 +00002556
2557 // 32-63: fp0-31, the 8-byte floating-point registers
John McCallaeeb7012010-05-27 06:19:26 +00002558 AssignToArrayRange(Builder, Address, Eight8, 32, 63);
John McCallec853ba2010-03-11 00:10:12 +00002559
2560 // 64-76 are various 4-byte special-purpose registers:
2561 // 64: mq
2562 // 65: lr
2563 // 66: ctr
2564 // 67: ap
2565 // 68-75 cr0-7
2566 // 76: xer
John McCallaeeb7012010-05-27 06:19:26 +00002567 AssignToArrayRange(Builder, Address, Four8, 64, 76);
John McCallec853ba2010-03-11 00:10:12 +00002568
2569 // 77-108: v0-31, the 16-byte vector registers
John McCallaeeb7012010-05-27 06:19:26 +00002570 AssignToArrayRange(Builder, Address, Sixteen8, 77, 108);
John McCallec853ba2010-03-11 00:10:12 +00002571
2572 // 109: vrsave
2573 // 110: vscr
2574 // 111: spe_acc
2575 // 112: spefscr
2576 // 113: sfp
John McCallaeeb7012010-05-27 06:19:26 +00002577 AssignToArrayRange(Builder, Address, Four8, 109, 113);
John McCallec853ba2010-03-11 00:10:12 +00002578
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00002579 return false;
John McCallec853ba2010-03-11 00:10:12 +00002580}
2581
Roman Divacky0fbc4b92012-05-09 18:22:46 +00002582// PowerPC-64
2583
2584namespace {
Bill Schmidt2fc107f2012-10-03 19:18:57 +00002585/// PPC64_SVR4_ABIInfo - The 64-bit PowerPC ELF (SVR4) ABI information.
2586class PPC64_SVR4_ABIInfo : public DefaultABIInfo {
2587
2588public:
2589 PPC64_SVR4_ABIInfo(CodeGen::CodeGenTypes &CGT) : DefaultABIInfo(CGT) {}
2590
2591 // TODO: Could override computeInfo to model the ABI more completely if
2592 // it would be helpful. Example: We might remove the byVal flag from
2593 // aggregate arguments that fit in a register to avoid pushing them to
2594 // memory on function entry. Note that this is a performance optimization,
2595 // not a compliance issue. In general we prefer to keep ABI details in
2596 // the back end where possible, but modifying an argument flag seems like
2597 // a good thing to do before invoking the back end.
2598
2599 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr,
2600 QualType Ty,
2601 CodeGenFunction &CGF) const;
2602};
2603
2604class PPC64_SVR4_TargetCodeGenInfo : public TargetCodeGenInfo {
2605public:
2606 PPC64_SVR4_TargetCodeGenInfo(CodeGenTypes &CGT)
2607 : TargetCodeGenInfo(new PPC64_SVR4_ABIInfo(CGT)) {}
2608
2609 int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const {
2610 // This is recovered from gcc output.
2611 return 1; // r1 is the dedicated stack pointer
2612 }
2613
2614 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2615 llvm::Value *Address) const;
2616};
2617
Roman Divacky0fbc4b92012-05-09 18:22:46 +00002618class PPC64TargetCodeGenInfo : public DefaultTargetCodeGenInfo {
2619public:
2620 PPC64TargetCodeGenInfo(CodeGenTypes &CGT) : DefaultTargetCodeGenInfo(CGT) {}
2621
2622 int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const {
2623 // This is recovered from gcc output.
2624 return 1; // r1 is the dedicated stack pointer
2625 }
2626
2627 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2628 llvm::Value *Address) const;
2629};
2630
2631}
2632
Bill Schmidt2fc107f2012-10-03 19:18:57 +00002633// Based on ARMABIInfo::EmitVAArg, adjusted for 64-bit machine.
2634llvm::Value *PPC64_SVR4_ABIInfo::EmitVAArg(llvm::Value *VAListAddr,
2635 QualType Ty,
2636 CodeGenFunction &CGF) const {
2637 llvm::Type *BP = CGF.Int8PtrTy;
2638 llvm::Type *BPP = CGF.Int8PtrPtrTy;
2639
2640 CGBuilderTy &Builder = CGF.Builder;
2641 llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP, "ap");
2642 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
2643
2644 // Handle address alignment for type alignment > 64 bits. Although
2645 // long double normally requires 16-byte alignment, this is not the
2646 // case when it is passed as an argument; so handle that special case.
2647 const BuiltinType *BT = Ty->getAs<BuiltinType>();
2648 unsigned TyAlign = CGF.getContext().getTypeAlign(Ty) / 8;
2649
2650 if (TyAlign > 8 && (!BT || !BT->isFloatingPoint())) {
2651 assert((TyAlign & (TyAlign - 1)) == 0 &&
2652 "Alignment is not power of 2!");
2653 llvm::Value *AddrAsInt = Builder.CreatePtrToInt(Addr, CGF.Int64Ty);
2654 AddrAsInt = Builder.CreateAdd(AddrAsInt, Builder.getInt64(TyAlign - 1));
2655 AddrAsInt = Builder.CreateAnd(AddrAsInt, Builder.getInt64(~(TyAlign - 1)));
2656 Addr = Builder.CreateIntToPtr(AddrAsInt, BP);
2657 }
2658
2659 // Update the va_list pointer.
2660 unsigned SizeInBytes = CGF.getContext().getTypeSize(Ty) / 8;
2661 unsigned Offset = llvm::RoundUpToAlignment(SizeInBytes, 8);
2662 llvm::Value *NextAddr =
2663 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int64Ty, Offset),
2664 "ap.next");
2665 Builder.CreateStore(NextAddr, VAListAddrAsBPP);
2666
2667 // If the argument is smaller than 8 bytes, it is right-adjusted in
2668 // its doubleword slot. Adjust the pointer to pick it up from the
2669 // correct offset.
2670 if (SizeInBytes < 8) {
2671 llvm::Value *AddrAsInt = Builder.CreatePtrToInt(Addr, CGF.Int64Ty);
2672 AddrAsInt = Builder.CreateAdd(AddrAsInt, Builder.getInt64(8 - SizeInBytes));
2673 Addr = Builder.CreateIntToPtr(AddrAsInt, BP);
2674 }
2675
2676 llvm::Type *PTy = llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
2677 return Builder.CreateBitCast(Addr, PTy);
2678}
2679
2680static bool
2681PPC64_initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2682 llvm::Value *Address) {
Roman Divacky0fbc4b92012-05-09 18:22:46 +00002683 // This is calculated from the LLVM and GCC tables and verified
2684 // against gcc output. AFAIK all ABIs use the same encoding.
2685
2686 CodeGen::CGBuilderTy &Builder = CGF.Builder;
2687
2688 llvm::IntegerType *i8 = CGF.Int8Ty;
2689 llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
2690 llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
2691 llvm::Value *Sixteen8 = llvm::ConstantInt::get(i8, 16);
2692
2693 // 0-31: r0-31, the 8-byte general-purpose registers
2694 AssignToArrayRange(Builder, Address, Eight8, 0, 31);
2695
2696 // 32-63: fp0-31, the 8-byte floating-point registers
2697 AssignToArrayRange(Builder, Address, Eight8, 32, 63);
2698
2699 // 64-76 are various 4-byte special-purpose registers:
2700 // 64: mq
2701 // 65: lr
2702 // 66: ctr
2703 // 67: ap
2704 // 68-75 cr0-7
2705 // 76: xer
2706 AssignToArrayRange(Builder, Address, Four8, 64, 76);
2707
2708 // 77-108: v0-31, the 16-byte vector registers
2709 AssignToArrayRange(Builder, Address, Sixteen8, 77, 108);
2710
2711 // 109: vrsave
2712 // 110: vscr
2713 // 111: spe_acc
2714 // 112: spefscr
2715 // 113: sfp
2716 AssignToArrayRange(Builder, Address, Four8, 109, 113);
2717
2718 return false;
2719}
John McCallec853ba2010-03-11 00:10:12 +00002720
Bill Schmidt2fc107f2012-10-03 19:18:57 +00002721bool
2722PPC64_SVR4_TargetCodeGenInfo::initDwarfEHRegSizeTable(
2723 CodeGen::CodeGenFunction &CGF,
2724 llvm::Value *Address) const {
2725
2726 return PPC64_initDwarfEHRegSizeTable(CGF, Address);
2727}
2728
2729bool
2730PPC64TargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2731 llvm::Value *Address) const {
2732
2733 return PPC64_initDwarfEHRegSizeTable(CGF, Address);
2734}
2735
Chris Lattnerdce5ad02010-06-28 20:05:43 +00002736//===----------------------------------------------------------------------===//
Daniel Dunbar34d91fd2009-09-12 00:59:49 +00002737// ARM ABI Implementation
Chris Lattnerdce5ad02010-06-28 20:05:43 +00002738//===----------------------------------------------------------------------===//
Daniel Dunbar34d91fd2009-09-12 00:59:49 +00002739
2740namespace {
2741
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002742class ARMABIInfo : public ABIInfo {
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002743public:
2744 enum ABIKind {
2745 APCS = 0,
2746 AAPCS = 1,
2747 AAPCS_VFP
2748 };
2749
2750private:
2751 ABIKind Kind;
2752
2753public:
Chris Lattnerea044322010-07-29 02:01:43 +00002754 ARMABIInfo(CodeGenTypes &CGT, ABIKind _Kind) : ABIInfo(CGT), Kind(_Kind) {}
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002755
John McCall49e34be2011-08-30 01:42:09 +00002756 bool isEABI() const {
Eli Friedman55fc7e22012-01-25 22:46:34 +00002757 StringRef Env =
2758 getContext().getTargetInfo().getTriple().getEnvironmentName();
Logan Chien94a71422012-09-02 09:30:11 +00002759 return (Env == "gnueabi" || Env == "eabi" ||
2760 Env == "android" || Env == "androideabi");
John McCall49e34be2011-08-30 01:42:09 +00002761 }
2762
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002763private:
2764 ABIKind getABIKind() const { return Kind; }
2765
Chris Lattnera3c109b2010-07-29 02:16:43 +00002766 ABIArgInfo classifyReturnType(QualType RetTy) const;
2767 ABIArgInfo classifyArgumentType(QualType RetTy) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002768
Chris Lattneree5dcd02010-07-29 02:31:05 +00002769 virtual void computeInfo(CGFunctionInfo &FI) const;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002770
2771 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
2772 CodeGenFunction &CGF) const;
2773};
2774
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00002775class ARMTargetCodeGenInfo : public TargetCodeGenInfo {
2776public:
Chris Lattnerea044322010-07-29 02:01:43 +00002777 ARMTargetCodeGenInfo(CodeGenTypes &CGT, ARMABIInfo::ABIKind K)
2778 :TargetCodeGenInfo(new ARMABIInfo(CGT, K)) {}
John McCall6374c332010-03-06 00:35:14 +00002779
John McCall49e34be2011-08-30 01:42:09 +00002780 const ARMABIInfo &getABIInfo() const {
2781 return static_cast<const ARMABIInfo&>(TargetCodeGenInfo::getABIInfo());
2782 }
2783
John McCall6374c332010-03-06 00:35:14 +00002784 int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const {
2785 return 13;
2786 }
Roman Divacky09345d12011-05-18 19:36:54 +00002787
Chris Lattner5f9e2722011-07-23 10:55:15 +00002788 StringRef getARCRetainAutoreleasedReturnValueMarker() const {
John McCallf85e1932011-06-15 23:02:42 +00002789 return "mov\tr7, r7\t\t@ marker for objc_retainAutoreleaseReturnValue";
2790 }
2791
Roman Divacky09345d12011-05-18 19:36:54 +00002792 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2793 llvm::Value *Address) const {
Chris Lattner8b418682012-02-07 00:39:47 +00002794 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
Roman Divacky09345d12011-05-18 19:36:54 +00002795
2796 // 0-15 are the 16 integer registers.
Chris Lattner8b418682012-02-07 00:39:47 +00002797 AssignToArrayRange(CGF.Builder, Address, Four8, 0, 15);
Roman Divacky09345d12011-05-18 19:36:54 +00002798 return false;
2799 }
John McCall49e34be2011-08-30 01:42:09 +00002800
2801 unsigned getSizeOfUnwindException() const {
2802 if (getABIInfo().isEABI()) return 88;
2803 return TargetCodeGenInfo::getSizeOfUnwindException();
2804 }
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00002805};
2806
Daniel Dunbar34d91fd2009-09-12 00:59:49 +00002807}
2808
Chris Lattneree5dcd02010-07-29 02:31:05 +00002809void ARMABIInfo::computeInfo(CGFunctionInfo &FI) const {
Chris Lattnera3c109b2010-07-29 02:16:43 +00002810 FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002811 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
Chris Lattnera3c109b2010-07-29 02:16:43 +00002812 it != ie; ++it)
2813 it->info = classifyArgumentType(it->type);
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002814
Anton Korobeynikov414d8962011-04-14 20:06:49 +00002815 // Always honor user-specified calling convention.
2816 if (FI.getCallingConvention() != llvm::CallingConv::C)
2817 return;
2818
2819 // Calling convention as default by an ABI.
Rafael Espindola25117ab2010-06-16 16:13:39 +00002820 llvm::CallingConv::ID DefaultCC;
John McCall49e34be2011-08-30 01:42:09 +00002821 if (isEABI())
Rafael Espindola25117ab2010-06-16 16:13:39 +00002822 DefaultCC = llvm::CallingConv::ARM_AAPCS;
Rafael Espindola1ed1a592010-06-16 19:01:17 +00002823 else
2824 DefaultCC = llvm::CallingConv::ARM_APCS;
Rafael Espindola25117ab2010-06-16 16:13:39 +00002825
Anton Korobeynikov414d8962011-04-14 20:06:49 +00002826 // If user did not ask for specific calling convention explicitly (e.g. via
2827 // pcs attribute), set effective calling convention if it's different than ABI
2828 // default.
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002829 switch (getABIKind()) {
2830 case APCS:
Rafael Espindola25117ab2010-06-16 16:13:39 +00002831 if (DefaultCC != llvm::CallingConv::ARM_APCS)
2832 FI.setEffectiveCallingConvention(llvm::CallingConv::ARM_APCS);
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002833 break;
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002834 case AAPCS:
Rafael Espindola25117ab2010-06-16 16:13:39 +00002835 if (DefaultCC != llvm::CallingConv::ARM_AAPCS)
2836 FI.setEffectiveCallingConvention(llvm::CallingConv::ARM_AAPCS);
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002837 break;
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002838 case AAPCS_VFP:
Anton Korobeynikov414d8962011-04-14 20:06:49 +00002839 if (DefaultCC != llvm::CallingConv::ARM_AAPCS_VFP)
2840 FI.setEffectiveCallingConvention(llvm::CallingConv::ARM_AAPCS_VFP);
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00002841 break;
2842 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002843}
2844
Bob Wilson194f06a2011-08-03 05:58:22 +00002845/// isHomogeneousAggregate - Return true if a type is an AAPCS-VFP homogeneous
2846/// aggregate. If HAMembers is non-null, the number of base elements
2847/// contained in the type is returned through it; this is used for the
2848/// recursive calls that check aggregate component types.
2849static bool isHomogeneousAggregate(QualType Ty, const Type *&Base,
2850 ASTContext &Context,
2851 uint64_t *HAMembers = 0) {
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002852 uint64_t Members = 0;
Bob Wilson194f06a2011-08-03 05:58:22 +00002853 if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) {
2854 if (!isHomogeneousAggregate(AT->getElementType(), Base, Context, &Members))
2855 return false;
2856 Members *= AT->getSize().getZExtValue();
2857 } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
2858 const RecordDecl *RD = RT->getDecl();
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002859 if (RD->hasFlexibleArrayMember())
Bob Wilson194f06a2011-08-03 05:58:22 +00002860 return false;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002861
Bob Wilson194f06a2011-08-03 05:58:22 +00002862 Members = 0;
2863 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
2864 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00002865 const FieldDecl *FD = *i;
Bob Wilson194f06a2011-08-03 05:58:22 +00002866 uint64_t FldMembers;
2867 if (!isHomogeneousAggregate(FD->getType(), Base, Context, &FldMembers))
2868 return false;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002869
2870 Members = (RD->isUnion() ?
2871 std::max(Members, FldMembers) : Members + FldMembers);
Bob Wilson194f06a2011-08-03 05:58:22 +00002872 }
2873 } else {
2874 Members = 1;
2875 if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
2876 Members = 2;
2877 Ty = CT->getElementType();
2878 }
2879
2880 // Homogeneous aggregates for AAPCS-VFP must have base types of float,
2881 // double, or 64-bit or 128-bit vectors.
2882 if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
2883 if (BT->getKind() != BuiltinType::Float &&
Tim Northoveradfa45f2012-07-20 22:29:29 +00002884 BT->getKind() != BuiltinType::Double &&
2885 BT->getKind() != BuiltinType::LongDouble)
Bob Wilson194f06a2011-08-03 05:58:22 +00002886 return false;
2887 } else if (const VectorType *VT = Ty->getAs<VectorType>()) {
2888 unsigned VecSize = Context.getTypeSize(VT);
2889 if (VecSize != 64 && VecSize != 128)
2890 return false;
2891 } else {
2892 return false;
2893 }
2894
2895 // The base type must be the same for all members. Vector types of the
2896 // same total size are treated as being equivalent here.
2897 const Type *TyPtr = Ty.getTypePtr();
2898 if (!Base)
2899 Base = TyPtr;
2900 if (Base != TyPtr &&
2901 (!Base->isVectorType() || !TyPtr->isVectorType() ||
2902 Context.getTypeSize(Base) != Context.getTypeSize(TyPtr)))
2903 return false;
2904 }
2905
2906 // Homogeneous Aggregates can have at most 4 members of the base type.
2907 if (HAMembers)
2908 *HAMembers = Members;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002909
2910 return (Members > 0 && Members <= 4);
Bob Wilson194f06a2011-08-03 05:58:22 +00002911}
2912
Chris Lattnera3c109b2010-07-29 02:16:43 +00002913ABIArgInfo ARMABIInfo::classifyArgumentType(QualType Ty) const {
John McCalld608cdb2010-08-22 10:59:02 +00002914 if (!isAggregateTypeForABI(Ty)) {
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00002915 // Treat an enum type as its underlying type.
2916 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
2917 Ty = EnumTy->getDecl()->getIntegerType();
2918
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00002919 return (Ty->isPromotableIntegerType() ?
2920 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00002921 }
Daniel Dunbar98303b92009-09-13 08:03:58 +00002922
Daniel Dunbar42025572009-09-14 21:54:03 +00002923 // Ignore empty records.
Chris Lattnera3c109b2010-07-29 02:16:43 +00002924 if (isEmptyRecord(getContext(), Ty, true))
Daniel Dunbar42025572009-09-14 21:54:03 +00002925 return ABIArgInfo::getIgnore();
2926
Rafael Espindola0eb1d972010-06-08 02:42:08 +00002927 // Structures with either a non-trivial destructor or a non-trivial
2928 // copy constructor are always indirect.
2929 if (isRecordWithNonTrivialDestructorOrCopyConstructor(Ty))
2930 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
2931
Bob Wilson194f06a2011-08-03 05:58:22 +00002932 if (getABIKind() == ARMABIInfo::AAPCS_VFP) {
2933 // Homogeneous Aggregates need to be expanded.
2934 const Type *Base = 0;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002935 if (isHomogeneousAggregate(Ty, Base, getContext())) {
2936 assert(Base && "Base class should be set for homogeneous aggregate");
Bob Wilson194f06a2011-08-03 05:58:22 +00002937 return ABIArgInfo::getExpand();
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002938 }
Bob Wilson194f06a2011-08-03 05:58:22 +00002939 }
2940
Manman Ren634b3d22012-08-13 21:23:55 +00002941 // Support byval for ARM.
2942 if (getContext().getTypeSizeInChars(Ty) > CharUnits::fromQuantity(64) ||
2943 getContext().getTypeAlign(Ty) > 64) {
2944 return ABIArgInfo::getIndirect(0, /*ByVal=*/true);
Eli Friedman79f30982012-08-09 00:31:40 +00002945 }
2946
Daniel Dunbar8aa87c72010-09-23 01:54:28 +00002947 // Otherwise, pass by coercing to a structure of the appropriate size.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002948 llvm::Type* ElemTy;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002949 unsigned SizeRegs;
Eli Friedman79f30982012-08-09 00:31:40 +00002950 // FIXME: Try to match the types of the arguments more accurately where
2951 // we can.
2952 if (getContext().getTypeAlign(Ty) <= 32) {
Bob Wilson53fc1a62011-08-01 23:39:04 +00002953 ElemTy = llvm::Type::getInt32Ty(getVMContext());
2954 SizeRegs = (getContext().getTypeSize(Ty) + 31) / 32;
Manman Ren78eb76e2012-06-25 22:04:00 +00002955 } else {
Manman Ren78eb76e2012-06-25 22:04:00 +00002956 ElemTy = llvm::Type::getInt64Ty(getVMContext());
2957 SizeRegs = (getContext().getTypeSize(Ty) + 63) / 64;
Stuart Hastings67d097e2011-04-27 17:24:02 +00002958 }
Stuart Hastingsb7f62d02011-04-28 18:16:06 +00002959
Chris Lattner9cbe4f02011-07-09 17:41:47 +00002960 llvm::Type *STy =
Chris Lattner7650d952011-06-18 22:49:11 +00002961 llvm::StructType::get(llvm::ArrayType::get(ElemTy, SizeRegs), NULL);
Stuart Hastingsb7f62d02011-04-28 18:16:06 +00002962 return ABIArgInfo::getDirect(STy);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00002963}
2964
Chris Lattnera3c109b2010-07-29 02:16:43 +00002965static bool isIntegerLikeType(QualType Ty, ASTContext &Context,
Daniel Dunbar98303b92009-09-13 08:03:58 +00002966 llvm::LLVMContext &VMContext) {
2967 // APCS, C Language Calling Conventions, Non-Simple Return Values: A structure
2968 // is called integer-like if its size is less than or equal to one word, and
2969 // the offset of each of its addressable sub-fields is zero.
2970
2971 uint64_t Size = Context.getTypeSize(Ty);
2972
2973 // Check that the type fits in a word.
2974 if (Size > 32)
2975 return false;
2976
2977 // FIXME: Handle vector types!
2978 if (Ty->isVectorType())
2979 return false;
2980
Daniel Dunbarb0d58192009-09-14 02:20:34 +00002981 // Float types are never treated as "integer like".
2982 if (Ty->isRealFloatingType())
2983 return false;
2984
Daniel Dunbar98303b92009-09-13 08:03:58 +00002985 // If this is a builtin or pointer type then it is ok.
John McCall183700f2009-09-21 23:43:11 +00002986 if (Ty->getAs<BuiltinType>() || Ty->isPointerType())
Daniel Dunbar98303b92009-09-13 08:03:58 +00002987 return true;
2988
Daniel Dunbar45815812010-02-01 23:31:26 +00002989 // Small complex integer types are "integer like".
2990 if (const ComplexType *CT = Ty->getAs<ComplexType>())
2991 return isIntegerLikeType(CT->getElementType(), Context, VMContext);
Daniel Dunbar98303b92009-09-13 08:03:58 +00002992
2993 // Single element and zero sized arrays should be allowed, by the definition
2994 // above, but they are not.
2995
2996 // Otherwise, it must be a record type.
2997 const RecordType *RT = Ty->getAs<RecordType>();
2998 if (!RT) return false;
2999
3000 // Ignore records with flexible arrays.
3001 const RecordDecl *RD = RT->getDecl();
3002 if (RD->hasFlexibleArrayMember())
3003 return false;
3004
3005 // Check that all sub-fields are at offset 0, and are themselves "integer
3006 // like".
3007 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
3008
3009 bool HadField = false;
3010 unsigned idx = 0;
3011 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
3012 i != e; ++i, ++idx) {
David Blaikie581deb32012-06-06 20:45:41 +00003013 const FieldDecl *FD = *i;
Daniel Dunbar98303b92009-09-13 08:03:58 +00003014
Daniel Dunbar679855a2010-01-29 03:22:29 +00003015 // Bit-fields are not addressable, we only need to verify they are "integer
3016 // like". We still have to disallow a subsequent non-bitfield, for example:
3017 // struct { int : 0; int x }
3018 // is non-integer like according to gcc.
3019 if (FD->isBitField()) {
3020 if (!RD->isUnion())
3021 HadField = true;
Daniel Dunbar98303b92009-09-13 08:03:58 +00003022
Daniel Dunbar679855a2010-01-29 03:22:29 +00003023 if (!isIntegerLikeType(FD->getType(), Context, VMContext))
3024 return false;
Daniel Dunbar98303b92009-09-13 08:03:58 +00003025
Daniel Dunbar679855a2010-01-29 03:22:29 +00003026 continue;
Daniel Dunbar98303b92009-09-13 08:03:58 +00003027 }
3028
Daniel Dunbar679855a2010-01-29 03:22:29 +00003029 // Check if this field is at offset 0.
3030 if (Layout.getFieldOffset(idx) != 0)
3031 return false;
3032
Daniel Dunbar98303b92009-09-13 08:03:58 +00003033 if (!isIntegerLikeType(FD->getType(), Context, VMContext))
3034 return false;
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00003035
Daniel Dunbar679855a2010-01-29 03:22:29 +00003036 // Only allow at most one field in a structure. This doesn't match the
3037 // wording above, but follows gcc in situations with a field following an
3038 // empty structure.
Daniel Dunbar98303b92009-09-13 08:03:58 +00003039 if (!RD->isUnion()) {
3040 if (HadField)
3041 return false;
3042
3043 HadField = true;
3044 }
3045 }
3046
3047 return true;
3048}
3049
Chris Lattnera3c109b2010-07-29 02:16:43 +00003050ABIArgInfo ARMABIInfo::classifyReturnType(QualType RetTy) const {
Daniel Dunbar98303b92009-09-13 08:03:58 +00003051 if (RetTy->isVoidType())
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003052 return ABIArgInfo::getIgnore();
Daniel Dunbar98303b92009-09-13 08:03:58 +00003053
Daniel Dunbarf554b1c2010-09-23 01:54:32 +00003054 // Large vector types should be returned via memory.
3055 if (RetTy->isVectorType() && getContext().getTypeSize(RetTy) > 128)
3056 return ABIArgInfo::getIndirect(0);
3057
John McCalld608cdb2010-08-22 10:59:02 +00003058 if (!isAggregateTypeForABI(RetTy)) {
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00003059 // Treat an enum type as its underlying type.
3060 if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
3061 RetTy = EnumTy->getDecl()->getIntegerType();
3062
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00003063 return (RetTy->isPromotableIntegerType() ?
3064 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00003065 }
Daniel Dunbar98303b92009-09-13 08:03:58 +00003066
Rafael Espindola0eb1d972010-06-08 02:42:08 +00003067 // Structures with either a non-trivial destructor or a non-trivial
3068 // copy constructor are always indirect.
3069 if (isRecordWithNonTrivialDestructorOrCopyConstructor(RetTy))
3070 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
3071
Daniel Dunbar98303b92009-09-13 08:03:58 +00003072 // Are we following APCS?
3073 if (getABIKind() == APCS) {
Chris Lattnera3c109b2010-07-29 02:16:43 +00003074 if (isEmptyRecord(getContext(), RetTy, false))
Daniel Dunbar98303b92009-09-13 08:03:58 +00003075 return ABIArgInfo::getIgnore();
3076
Daniel Dunbar4cc753f2010-02-01 23:31:19 +00003077 // Complex types are all returned as packed integers.
3078 //
3079 // FIXME: Consider using 2 x vector types if the back end handles them
3080 // correctly.
3081 if (RetTy->isAnyComplexType())
Chris Lattner800588f2010-07-29 06:26:06 +00003082 return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
Chris Lattnera3c109b2010-07-29 02:16:43 +00003083 getContext().getTypeSize(RetTy)));
Daniel Dunbar4cc753f2010-02-01 23:31:19 +00003084
Daniel Dunbar98303b92009-09-13 08:03:58 +00003085 // Integer like structures are returned in r0.
Chris Lattnera3c109b2010-07-29 02:16:43 +00003086 if (isIntegerLikeType(RetTy, getContext(), getVMContext())) {
Daniel Dunbar98303b92009-09-13 08:03:58 +00003087 // Return in the smallest viable integer type.
Chris Lattnera3c109b2010-07-29 02:16:43 +00003088 uint64_t Size = getContext().getTypeSize(RetTy);
Daniel Dunbar98303b92009-09-13 08:03:58 +00003089 if (Size <= 8)
Chris Lattner800588f2010-07-29 06:26:06 +00003090 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
Daniel Dunbar98303b92009-09-13 08:03:58 +00003091 if (Size <= 16)
Chris Lattner800588f2010-07-29 06:26:06 +00003092 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
3093 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
Daniel Dunbar98303b92009-09-13 08:03:58 +00003094 }
3095
3096 // Otherwise return in memory.
3097 return ABIArgInfo::getIndirect(0);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003098 }
Daniel Dunbar98303b92009-09-13 08:03:58 +00003099
3100 // Otherwise this is an AAPCS variant.
3101
Chris Lattnera3c109b2010-07-29 02:16:43 +00003102 if (isEmptyRecord(getContext(), RetTy, true))
Daniel Dunbar16a08082009-09-14 00:56:55 +00003103 return ABIArgInfo::getIgnore();
3104
Bob Wilson3b694fa2011-11-02 04:51:36 +00003105 // Check for homogeneous aggregates with AAPCS-VFP.
3106 if (getABIKind() == AAPCS_VFP) {
3107 const Type *Base = 0;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00003108 if (isHomogeneousAggregate(RetTy, Base, getContext())) {
3109 assert(Base && "Base class should be set for homogeneous aggregate");
Bob Wilson3b694fa2011-11-02 04:51:36 +00003110 // Homogeneous Aggregates are returned directly.
3111 return ABIArgInfo::getDirect();
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00003112 }
Bob Wilson3b694fa2011-11-02 04:51:36 +00003113 }
3114
Daniel Dunbar98303b92009-09-13 08:03:58 +00003115 // Aggregates <= 4 bytes are returned in r0; other aggregates
3116 // are returned indirectly.
Chris Lattnera3c109b2010-07-29 02:16:43 +00003117 uint64_t Size = getContext().getTypeSize(RetTy);
Daniel Dunbar16a08082009-09-14 00:56:55 +00003118 if (Size <= 32) {
3119 // Return in the smallest viable integer type.
3120 if (Size <= 8)
Chris Lattner800588f2010-07-29 06:26:06 +00003121 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
Daniel Dunbar16a08082009-09-14 00:56:55 +00003122 if (Size <= 16)
Chris Lattner800588f2010-07-29 06:26:06 +00003123 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
3124 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
Daniel Dunbar16a08082009-09-14 00:56:55 +00003125 }
3126
Daniel Dunbar98303b92009-09-13 08:03:58 +00003127 return ABIArgInfo::getIndirect(0);
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003128}
3129
3130llvm::Value *ARMABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
Chris Lattner77b89b82010-06-27 07:15:29 +00003131 CodeGenFunction &CGF) const {
Chris Lattner8b418682012-02-07 00:39:47 +00003132 llvm::Type *BP = CGF.Int8PtrTy;
3133 llvm::Type *BPP = CGF.Int8PtrPtrTy;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003134
3135 CGBuilderTy &Builder = CGF.Builder;
Chris Lattner8b418682012-02-07 00:39:47 +00003136 llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP, "ap");
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003137 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
Rafael Espindolae164c182011-08-02 22:33:37 +00003138 // Handle address alignment for type alignment > 32 bits
3139 uint64_t TyAlign = CGF.getContext().getTypeAlign(Ty) / 8;
3140 if (TyAlign > 4) {
3141 assert((TyAlign & (TyAlign - 1)) == 0 &&
3142 "Alignment is not power of 2!");
3143 llvm::Value *AddrAsInt = Builder.CreatePtrToInt(Addr, CGF.Int32Ty);
3144 AddrAsInt = Builder.CreateAdd(AddrAsInt, Builder.getInt32(TyAlign - 1));
3145 AddrAsInt = Builder.CreateAnd(AddrAsInt, Builder.getInt32(~(TyAlign - 1)));
3146 Addr = Builder.CreateIntToPtr(AddrAsInt, BP);
3147 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003148 llvm::Type *PTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +00003149 llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003150 llvm::Value *AddrTyped = Builder.CreateBitCast(Addr, PTy);
3151
3152 uint64_t Offset =
3153 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, 4);
3154 llvm::Value *NextAddr =
Chris Lattner77b89b82010-06-27 07:15:29 +00003155 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003156 "ap.next");
3157 Builder.CreateStore(NextAddr, VAListAddrAsBPP);
3158
3159 return AddrTyped;
3160}
3161
Chris Lattnerdce5ad02010-06-28 20:05:43 +00003162//===----------------------------------------------------------------------===//
Justin Holewinski2c585b92012-05-24 17:43:12 +00003163// NVPTX ABI Implementation
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003164//===----------------------------------------------------------------------===//
3165
3166namespace {
3167
Justin Holewinski2c585b92012-05-24 17:43:12 +00003168class NVPTXABIInfo : public ABIInfo {
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003169public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00003170 NVPTXABIInfo(CodeGenTypes &CGT) : ABIInfo(CGT) {}
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003171
3172 ABIArgInfo classifyReturnType(QualType RetTy) const;
3173 ABIArgInfo classifyArgumentType(QualType Ty) const;
3174
3175 virtual void computeInfo(CGFunctionInfo &FI) const;
3176 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
3177 CodeGenFunction &CFG) const;
3178};
3179
Justin Holewinski2c585b92012-05-24 17:43:12 +00003180class NVPTXTargetCodeGenInfo : public TargetCodeGenInfo {
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003181public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00003182 NVPTXTargetCodeGenInfo(CodeGenTypes &CGT)
3183 : TargetCodeGenInfo(new NVPTXABIInfo(CGT)) {}
Justin Holewinski818eafb2011-10-05 17:58:44 +00003184
Peter Collingbourne2f7aa992011-10-13 16:24:41 +00003185 virtual void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
3186 CodeGen::CodeGenModule &M) const;
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003187};
3188
Justin Holewinski2c585b92012-05-24 17:43:12 +00003189ABIArgInfo NVPTXABIInfo::classifyReturnType(QualType RetTy) const {
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003190 if (RetTy->isVoidType())
3191 return ABIArgInfo::getIgnore();
3192 if (isAggregateTypeForABI(RetTy))
3193 return ABIArgInfo::getIndirect(0);
3194 return ABIArgInfo::getDirect();
3195}
3196
Justin Holewinski2c585b92012-05-24 17:43:12 +00003197ABIArgInfo NVPTXABIInfo::classifyArgumentType(QualType Ty) const {
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003198 if (isAggregateTypeForABI(Ty))
3199 return ABIArgInfo::getIndirect(0);
3200
3201 return ABIArgInfo::getDirect();
3202}
3203
Justin Holewinski2c585b92012-05-24 17:43:12 +00003204void NVPTXABIInfo::computeInfo(CGFunctionInfo &FI) const {
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003205 FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
3206 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
3207 it != ie; ++it)
3208 it->info = classifyArgumentType(it->type);
3209
3210 // Always honor user-specified calling convention.
3211 if (FI.getCallingConvention() != llvm::CallingConv::C)
3212 return;
3213
3214 // Calling convention as default by an ABI.
Justin Holewinski2c585b92012-05-24 17:43:12 +00003215 // We're still using the PTX_Kernel/PTX_Device calling conventions here,
3216 // but we should switch to NVVM metadata later on.
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003217 llvm::CallingConv::ID DefaultCC;
David Blaikie4e4d0842012-03-11 07:00:24 +00003218 const LangOptions &LangOpts = getContext().getLangOpts();
Peter Collingbourne744d90b2011-10-06 16:49:54 +00003219 if (LangOpts.OpenCL || LangOpts.CUDA) {
3220 // If we are in OpenCL or CUDA mode, then default to device functions
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003221 DefaultCC = llvm::CallingConv::PTX_Device;
Justin Holewinski818eafb2011-10-05 17:58:44 +00003222 } else {
3223 // If we are in standard C/C++ mode, use the triple to decide on the default
3224 StringRef Env =
3225 getContext().getTargetInfo().getTriple().getEnvironmentName();
3226 if (Env == "device")
3227 DefaultCC = llvm::CallingConv::PTX_Device;
3228 else
3229 DefaultCC = llvm::CallingConv::PTX_Kernel;
3230 }
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003231 FI.setEffectiveCallingConvention(DefaultCC);
Justin Holewinski818eafb2011-10-05 17:58:44 +00003232
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003233}
3234
Justin Holewinski2c585b92012-05-24 17:43:12 +00003235llvm::Value *NVPTXABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
3236 CodeGenFunction &CFG) const {
3237 llvm_unreachable("NVPTX does not support varargs");
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003238}
3239
Justin Holewinski2c585b92012-05-24 17:43:12 +00003240void NVPTXTargetCodeGenInfo::
3241SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
3242 CodeGen::CodeGenModule &M) const{
Justin Holewinski818eafb2011-10-05 17:58:44 +00003243 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
3244 if (!FD) return;
3245
3246 llvm::Function *F = cast<llvm::Function>(GV);
3247
3248 // Perform special handling in OpenCL mode
David Blaikie4e4d0842012-03-11 07:00:24 +00003249 if (M.getLangOpts().OpenCL) {
Justin Holewinski818eafb2011-10-05 17:58:44 +00003250 // Use OpenCL function attributes to set proper calling conventions
3251 // By default, all functions are device functions
Justin Holewinski818eafb2011-10-05 17:58:44 +00003252 if (FD->hasAttr<OpenCLKernelAttr>()) {
3253 // OpenCL __kernel functions get a kernel calling convention
Peter Collingbourne744d90b2011-10-06 16:49:54 +00003254 F->setCallingConv(llvm::CallingConv::PTX_Kernel);
Justin Holewinski818eafb2011-10-05 17:58:44 +00003255 // And kernel functions are not subject to inlining
Bill Wendlingfac63102012-10-10 03:13:20 +00003256 F->addFnAttr(llvm::Attributes::NoInline);
Justin Holewinski818eafb2011-10-05 17:58:44 +00003257 }
Peter Collingbourne744d90b2011-10-06 16:49:54 +00003258 }
Justin Holewinski818eafb2011-10-05 17:58:44 +00003259
Peter Collingbourne744d90b2011-10-06 16:49:54 +00003260 // Perform special handling in CUDA mode.
David Blaikie4e4d0842012-03-11 07:00:24 +00003261 if (M.getLangOpts().CUDA) {
Peter Collingbourne744d90b2011-10-06 16:49:54 +00003262 // CUDA __global__ functions get a kernel calling convention. Since
3263 // __global__ functions cannot be called from the device, we do not
3264 // need to set the noinline attribute.
3265 if (FD->getAttr<CUDAGlobalAttr>())
3266 F->setCallingConv(llvm::CallingConv::PTX_Kernel);
Justin Holewinski818eafb2011-10-05 17:58:44 +00003267 }
3268}
3269
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003270}
3271
3272//===----------------------------------------------------------------------===//
Wesley Peck276fdf42010-12-19 19:57:51 +00003273// MBlaze ABI Implementation
3274//===----------------------------------------------------------------------===//
3275
3276namespace {
3277
3278class MBlazeABIInfo : public ABIInfo {
3279public:
3280 MBlazeABIInfo(CodeGenTypes &CGT) : ABIInfo(CGT) {}
3281
3282 bool isPromotableIntegerType(QualType Ty) const;
3283
3284 ABIArgInfo classifyReturnType(QualType RetTy) const;
3285 ABIArgInfo classifyArgumentType(QualType RetTy) const;
3286
3287 virtual void computeInfo(CGFunctionInfo &FI) const {
3288 FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
3289 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
3290 it != ie; ++it)
3291 it->info = classifyArgumentType(it->type);
3292 }
3293
3294 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
3295 CodeGenFunction &CGF) const;
3296};
3297
3298class MBlazeTargetCodeGenInfo : public TargetCodeGenInfo {
3299public:
3300 MBlazeTargetCodeGenInfo(CodeGenTypes &CGT)
3301 : TargetCodeGenInfo(new MBlazeABIInfo(CGT)) {}
3302 void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
3303 CodeGen::CodeGenModule &M) const;
3304};
3305
3306}
3307
3308bool MBlazeABIInfo::isPromotableIntegerType(QualType Ty) const {
3309 // MBlaze ABI requires all 8 and 16 bit quantities to be extended.
3310 if (const BuiltinType *BT = Ty->getAs<BuiltinType>())
3311 switch (BT->getKind()) {
3312 case BuiltinType::Bool:
3313 case BuiltinType::Char_S:
3314 case BuiltinType::Char_U:
3315 case BuiltinType::SChar:
3316 case BuiltinType::UChar:
3317 case BuiltinType::Short:
3318 case BuiltinType::UShort:
3319 return true;
3320 default:
3321 return false;
3322 }
3323 return false;
3324}
3325
3326llvm::Value *MBlazeABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
3327 CodeGenFunction &CGF) const {
3328 // FIXME: Implement
3329 return 0;
3330}
3331
3332
3333ABIArgInfo MBlazeABIInfo::classifyReturnType(QualType RetTy) const {
3334 if (RetTy->isVoidType())
3335 return ABIArgInfo::getIgnore();
3336 if (isAggregateTypeForABI(RetTy))
3337 return ABIArgInfo::getIndirect(0);
3338
3339 return (isPromotableIntegerType(RetTy) ?
3340 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
3341}
3342
3343ABIArgInfo MBlazeABIInfo::classifyArgumentType(QualType Ty) const {
3344 if (isAggregateTypeForABI(Ty))
3345 return ABIArgInfo::getIndirect(0);
3346
3347 return (isPromotableIntegerType(Ty) ?
3348 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
3349}
3350
3351void MBlazeTargetCodeGenInfo::SetTargetAttributes(const Decl *D,
3352 llvm::GlobalValue *GV,
3353 CodeGen::CodeGenModule &M)
3354 const {
3355 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
3356 if (!FD) return;
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00003357
Wesley Peck276fdf42010-12-19 19:57:51 +00003358 llvm::CallingConv::ID CC = llvm::CallingConv::C;
3359 if (FD->hasAttr<MBlazeInterruptHandlerAttr>())
3360 CC = llvm::CallingConv::MBLAZE_INTR;
3361 else if (FD->hasAttr<MBlazeSaveVolatilesAttr>())
3362 CC = llvm::CallingConv::MBLAZE_SVOL;
3363
3364 if (CC != llvm::CallingConv::C) {
3365 // Handle 'interrupt_handler' attribute:
3366 llvm::Function *F = cast<llvm::Function>(GV);
3367
3368 // Step 1: Set ISR calling convention.
3369 F->setCallingConv(CC);
3370
3371 // Step 2: Add attributes goodness.
Bill Wendlingfac63102012-10-10 03:13:20 +00003372 F->addFnAttr(llvm::Attributes::NoInline);
Wesley Peck276fdf42010-12-19 19:57:51 +00003373 }
3374
3375 // Step 3: Emit _interrupt_handler alias.
3376 if (CC == llvm::CallingConv::MBLAZE_INTR)
3377 new llvm::GlobalAlias(GV->getType(), llvm::Function::ExternalLinkage,
3378 "_interrupt_handler", GV, &M.getModule());
3379}
3380
3381
3382//===----------------------------------------------------------------------===//
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00003383// MSP430 ABI Implementation
Chris Lattnerdce5ad02010-06-28 20:05:43 +00003384//===----------------------------------------------------------------------===//
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00003385
3386namespace {
3387
3388class MSP430TargetCodeGenInfo : public TargetCodeGenInfo {
3389public:
Chris Lattnerea044322010-07-29 02:01:43 +00003390 MSP430TargetCodeGenInfo(CodeGenTypes &CGT)
3391 : TargetCodeGenInfo(new DefaultABIInfo(CGT)) {}
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00003392 void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
3393 CodeGen::CodeGenModule &M) const;
3394};
3395
3396}
3397
3398void MSP430TargetCodeGenInfo::SetTargetAttributes(const Decl *D,
3399 llvm::GlobalValue *GV,
3400 CodeGen::CodeGenModule &M) const {
3401 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
3402 if (const MSP430InterruptAttr *attr = FD->getAttr<MSP430InterruptAttr>()) {
3403 // Handle 'interrupt' attribute:
3404 llvm::Function *F = cast<llvm::Function>(GV);
3405
3406 // Step 1: Set ISR calling convention.
3407 F->setCallingConv(llvm::CallingConv::MSP430_INTR);
3408
3409 // Step 2: Add attributes goodness.
Bill Wendlingfac63102012-10-10 03:13:20 +00003410 F->addFnAttr(llvm::Attributes::NoInline);
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00003411
3412 // Step 3: Emit ISR vector alias.
3413 unsigned Num = attr->getNumber() + 0xffe0;
3414 new llvm::GlobalAlias(GV->getType(), llvm::Function::ExternalLinkage,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003415 "vector_" + Twine::utohexstr(Num),
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00003416 GV, &M.getModule());
3417 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003418 }
3419}
3420
Chris Lattnerdce5ad02010-06-28 20:05:43 +00003421//===----------------------------------------------------------------------===//
John McCallaeeb7012010-05-27 06:19:26 +00003422// MIPS ABI Implementation. This works for both little-endian and
3423// big-endian variants.
Chris Lattnerdce5ad02010-06-28 20:05:43 +00003424//===----------------------------------------------------------------------===//
3425
John McCallaeeb7012010-05-27 06:19:26 +00003426namespace {
Akira Hatanaka619e8872011-06-02 00:09:17 +00003427class MipsABIInfo : public ABIInfo {
Akira Hatanakac0e3b662011-11-02 23:14:57 +00003428 bool IsO32;
Akira Hatanakac359f202012-07-03 19:24:06 +00003429 unsigned MinABIStackAlignInBytes, StackAlignInBytes;
3430 void CoerceToIntArgs(uint64_t TySize,
3431 SmallVector<llvm::Type*, 8> &ArgList) const;
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003432 llvm::Type* HandleAggregates(QualType Ty, uint64_t TySize) const;
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003433 llvm::Type* returnAggregateInRegs(QualType RetTy, uint64_t Size) const;
Akira Hatanakaa33fd392012-01-09 19:31:25 +00003434 llvm::Type* getPaddingType(uint64_t Align, uint64_t Offset) const;
Akira Hatanaka619e8872011-06-02 00:09:17 +00003435public:
Akira Hatanakab551dd32011-11-03 00:05:50 +00003436 MipsABIInfo(CodeGenTypes &CGT, bool _IsO32) :
Akira Hatanakac359f202012-07-03 19:24:06 +00003437 ABIInfo(CGT), IsO32(_IsO32), MinABIStackAlignInBytes(IsO32 ? 4 : 8),
3438 StackAlignInBytes(IsO32 ? 8 : 16) {}
Akira Hatanaka619e8872011-06-02 00:09:17 +00003439
3440 ABIArgInfo classifyReturnType(QualType RetTy) const;
Akira Hatanakaf0cc2082012-01-07 00:25:33 +00003441 ABIArgInfo classifyArgumentType(QualType RetTy, uint64_t &Offset) const;
Akira Hatanaka619e8872011-06-02 00:09:17 +00003442 virtual void computeInfo(CGFunctionInfo &FI) const;
3443 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
3444 CodeGenFunction &CGF) const;
3445};
3446
John McCallaeeb7012010-05-27 06:19:26 +00003447class MIPSTargetCodeGenInfo : public TargetCodeGenInfo {
Akira Hatanakae624fa02011-09-20 18:23:28 +00003448 unsigned SizeOfUnwindException;
John McCallaeeb7012010-05-27 06:19:26 +00003449public:
Akira Hatanakac0e3b662011-11-02 23:14:57 +00003450 MIPSTargetCodeGenInfo(CodeGenTypes &CGT, bool IsO32)
3451 : TargetCodeGenInfo(new MipsABIInfo(CGT, IsO32)),
3452 SizeOfUnwindException(IsO32 ? 24 : 32) {}
John McCallaeeb7012010-05-27 06:19:26 +00003453
3454 int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const {
3455 return 29;
3456 }
3457
3458 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
Michael J. Spencer8bea82f2010-08-25 18:17:27 +00003459 llvm::Value *Address) const;
John McCall49e34be2011-08-30 01:42:09 +00003460
3461 unsigned getSizeOfUnwindException() const {
Akira Hatanakae624fa02011-09-20 18:23:28 +00003462 return SizeOfUnwindException;
John McCall49e34be2011-08-30 01:42:09 +00003463 }
John McCallaeeb7012010-05-27 06:19:26 +00003464};
3465}
3466
Akira Hatanakac359f202012-07-03 19:24:06 +00003467void MipsABIInfo::CoerceToIntArgs(uint64_t TySize,
3468 SmallVector<llvm::Type*, 8> &ArgList) const {
3469 llvm::IntegerType *IntTy =
3470 llvm::IntegerType::get(getVMContext(), MinABIStackAlignInBytes * 8);
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003471
3472 // Add (TySize / MinABIStackAlignInBytes) args of IntTy.
3473 for (unsigned N = TySize / (MinABIStackAlignInBytes * 8); N; --N)
3474 ArgList.push_back(IntTy);
3475
3476 // If necessary, add one more integer type to ArgList.
3477 unsigned R = TySize % (MinABIStackAlignInBytes * 8);
3478
3479 if (R)
3480 ArgList.push_back(llvm::IntegerType::get(getVMContext(), R));
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003481}
3482
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003483// In N32/64, an aligned double precision floating point field is passed in
3484// a register.
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003485llvm::Type* MipsABIInfo::HandleAggregates(QualType Ty, uint64_t TySize) const {
Akira Hatanakac359f202012-07-03 19:24:06 +00003486 SmallVector<llvm::Type*, 8> ArgList, IntArgList;
3487
3488 if (IsO32) {
3489 CoerceToIntArgs(TySize, ArgList);
3490 return llvm::StructType::get(getVMContext(), ArgList);
3491 }
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003492
Akira Hatanaka2afd23d2012-01-12 00:52:17 +00003493 if (Ty->isComplexType())
3494 return CGT.ConvertType(Ty);
Akira Hatanaka6d1080f2012-01-10 23:12:19 +00003495
Akira Hatanakaa34e9212012-02-09 19:54:16 +00003496 const RecordType *RT = Ty->getAs<RecordType>();
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003497
Akira Hatanakac359f202012-07-03 19:24:06 +00003498 // Unions/vectors are passed in integer registers.
3499 if (!RT || !RT->isStructureOrClassType()) {
3500 CoerceToIntArgs(TySize, ArgList);
3501 return llvm::StructType::get(getVMContext(), ArgList);
3502 }
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003503
3504 const RecordDecl *RD = RT->getDecl();
3505 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003506 assert(!(TySize % 8) && "Size of structure must be multiple of 8.");
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003507
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003508 uint64_t LastOffset = 0;
3509 unsigned idx = 0;
3510 llvm::IntegerType *I64 = llvm::IntegerType::get(getVMContext(), 64);
3511
Akira Hatanakaa34e9212012-02-09 19:54:16 +00003512 // Iterate over fields in the struct/class and check if there are any aligned
3513 // double fields.
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003514 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
3515 i != e; ++i, ++idx) {
David Blaikie262bc182012-04-30 02:36:29 +00003516 const QualType Ty = i->getType();
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003517 const BuiltinType *BT = Ty->getAs<BuiltinType>();
3518
3519 if (!BT || BT->getKind() != BuiltinType::Double)
3520 continue;
3521
3522 uint64_t Offset = Layout.getFieldOffset(idx);
3523 if (Offset % 64) // Ignore doubles that are not aligned.
3524 continue;
3525
3526 // Add ((Offset - LastOffset) / 64) args of type i64.
3527 for (unsigned j = (Offset - LastOffset) / 64; j > 0; --j)
3528 ArgList.push_back(I64);
3529
3530 // Add double type.
3531 ArgList.push_back(llvm::Type::getDoubleTy(getVMContext()));
3532 LastOffset = Offset + 64;
3533 }
3534
Akira Hatanakac359f202012-07-03 19:24:06 +00003535 CoerceToIntArgs(TySize - LastOffset, IntArgList);
3536 ArgList.append(IntArgList.begin(), IntArgList.end());
Akira Hatanakad5a257f2011-11-02 23:54:49 +00003537
3538 return llvm::StructType::get(getVMContext(), ArgList);
3539}
3540
Akira Hatanakaa33fd392012-01-09 19:31:25 +00003541llvm::Type *MipsABIInfo::getPaddingType(uint64_t Align, uint64_t Offset) const {
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003542 assert((Offset % MinABIStackAlignInBytes) == 0);
Akira Hatanakaa33fd392012-01-09 19:31:25 +00003543
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003544 if ((Align - 1) & Offset)
3545 return llvm::IntegerType::get(getVMContext(), MinABIStackAlignInBytes * 8);
3546
3547 return 0;
Akira Hatanakaa33fd392012-01-09 19:31:25 +00003548}
Akira Hatanaka9659d592012-01-10 22:44:52 +00003549
Akira Hatanakaf0cc2082012-01-07 00:25:33 +00003550ABIArgInfo
3551MipsABIInfo::classifyArgumentType(QualType Ty, uint64_t &Offset) const {
Akira Hatanakaa33fd392012-01-09 19:31:25 +00003552 uint64_t OrigOffset = Offset;
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003553 uint64_t TySize = getContext().getTypeSize(Ty);
Akira Hatanakaa33fd392012-01-09 19:31:25 +00003554 uint64_t Align = getContext().getTypeAlign(Ty) / 8;
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003555
Akira Hatanakac359f202012-07-03 19:24:06 +00003556 Align = std::min(std::max(Align, (uint64_t)MinABIStackAlignInBytes),
3557 (uint64_t)StackAlignInBytes);
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003558 Offset = llvm::RoundUpToAlignment(Offset, Align);
3559 Offset += llvm::RoundUpToAlignment(TySize, Align * 8) / 8;
Akira Hatanakaa33fd392012-01-09 19:31:25 +00003560
Akira Hatanakac359f202012-07-03 19:24:06 +00003561 if (isAggregateTypeForABI(Ty) || Ty->isVectorType()) {
Akira Hatanaka619e8872011-06-02 00:09:17 +00003562 // Ignore empty aggregates.
Akira Hatanakaf0cc2082012-01-07 00:25:33 +00003563 if (TySize == 0)
Akira Hatanaka619e8872011-06-02 00:09:17 +00003564 return ABIArgInfo::getIgnore();
3565
Akira Hatanaka511949b2011-08-01 18:09:58 +00003566 // Records with non trivial destructors/constructors should not be passed
3567 // by value.
Akira Hatanakaf0cc2082012-01-07 00:25:33 +00003568 if (isRecordWithNonTrivialDestructorOrCopyConstructor(Ty)) {
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003569 Offset = OrigOffset + MinABIStackAlignInBytes;
Akira Hatanaka511949b2011-08-01 18:09:58 +00003570 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
Akira Hatanakaf0cc2082012-01-07 00:25:33 +00003571 }
Akira Hatanaka511949b2011-08-01 18:09:58 +00003572
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003573 // If we have reached here, aggregates are passed directly by coercing to
3574 // another structure type. Padding is inserted if the offset of the
3575 // aggregate is unaligned.
3576 return ABIArgInfo::getDirect(HandleAggregates(Ty, TySize), 0,
3577 getPaddingType(Align, OrigOffset));
Akira Hatanaka619e8872011-06-02 00:09:17 +00003578 }
3579
3580 // Treat an enum type as its underlying type.
3581 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
3582 Ty = EnumTy->getDecl()->getIntegerType();
3583
Akira Hatanakaa33fd392012-01-09 19:31:25 +00003584 if (Ty->isPromotableIntegerType())
3585 return ABIArgInfo::getExtend();
3586
3587 return ABIArgInfo::getDirect(0, 0, getPaddingType(Align, OrigOffset));
Akira Hatanaka619e8872011-06-02 00:09:17 +00003588}
3589
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003590llvm::Type*
3591MipsABIInfo::returnAggregateInRegs(QualType RetTy, uint64_t Size) const {
Akira Hatanakada54ff32012-02-09 18:49:26 +00003592 const RecordType *RT = RetTy->getAs<RecordType>();
Akira Hatanakac359f202012-07-03 19:24:06 +00003593 SmallVector<llvm::Type*, 8> RTList;
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003594
Akira Hatanakada54ff32012-02-09 18:49:26 +00003595 if (RT && RT->isStructureOrClassType()) {
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003596 const RecordDecl *RD = RT->getDecl();
Akira Hatanakada54ff32012-02-09 18:49:26 +00003597 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
3598 unsigned FieldCnt = Layout.getFieldCount();
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003599
Akira Hatanakada54ff32012-02-09 18:49:26 +00003600 // N32/64 returns struct/classes in floating point registers if the
3601 // following conditions are met:
3602 // 1. The size of the struct/class is no larger than 128-bit.
3603 // 2. The struct/class has one or two fields all of which are floating
3604 // point types.
3605 // 3. The offset of the first field is zero (this follows what gcc does).
3606 //
3607 // Any other composite results are returned in integer registers.
3608 //
3609 if (FieldCnt && (FieldCnt <= 2) && !Layout.getFieldOffset(0)) {
3610 RecordDecl::field_iterator b = RD->field_begin(), e = RD->field_end();
3611 for (; b != e; ++b) {
David Blaikie262bc182012-04-30 02:36:29 +00003612 const BuiltinType *BT = b->getType()->getAs<BuiltinType>();
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003613
Akira Hatanakada54ff32012-02-09 18:49:26 +00003614 if (!BT || !BT->isFloatingPoint())
3615 break;
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003616
David Blaikie262bc182012-04-30 02:36:29 +00003617 RTList.push_back(CGT.ConvertType(b->getType()));
Akira Hatanakada54ff32012-02-09 18:49:26 +00003618 }
3619
3620 if (b == e)
3621 return llvm::StructType::get(getVMContext(), RTList,
3622 RD->hasAttr<PackedAttr>());
3623
3624 RTList.clear();
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003625 }
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003626 }
3627
Akira Hatanakac359f202012-07-03 19:24:06 +00003628 CoerceToIntArgs(Size, RTList);
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003629 return llvm::StructType::get(getVMContext(), RTList);
3630}
3631
Akira Hatanaka619e8872011-06-02 00:09:17 +00003632ABIArgInfo MipsABIInfo::classifyReturnType(QualType RetTy) const {
Akira Hatanakaa8536c02012-01-23 23:18:57 +00003633 uint64_t Size = getContext().getTypeSize(RetTy);
3634
3635 if (RetTy->isVoidType() || Size == 0)
Akira Hatanaka619e8872011-06-02 00:09:17 +00003636 return ABIArgInfo::getIgnore();
3637
Akira Hatanaka8aeb1472012-05-11 21:01:17 +00003638 if (isAggregateTypeForABI(RetTy) || RetTy->isVectorType()) {
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003639 if (Size <= 128) {
3640 if (RetTy->isAnyComplexType())
3641 return ABIArgInfo::getDirect();
3642
Akira Hatanakac359f202012-07-03 19:24:06 +00003643 // O32 returns integer vectors in registers.
3644 if (IsO32 && RetTy->isVectorType() && !RetTy->hasFloatingRepresentation())
3645 return ABIArgInfo::getDirect(returnAggregateInRegs(RetTy, Size));
3646
Akira Hatanaka526cdfb2012-02-08 01:31:22 +00003647 if (!IsO32 && !isRecordWithNonTrivialDestructorOrCopyConstructor(RetTy))
Akira Hatanakac7ecc2e2012-01-04 03:34:42 +00003648 return ABIArgInfo::getDirect(returnAggregateInRegs(RetTy, Size));
3649 }
Akira Hatanaka619e8872011-06-02 00:09:17 +00003650
3651 return ABIArgInfo::getIndirect(0);
3652 }
3653
3654 // Treat an enum type as its underlying type.
3655 if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
3656 RetTy = EnumTy->getDecl()->getIntegerType();
3657
3658 return (RetTy->isPromotableIntegerType() ?
3659 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
3660}
3661
3662void MipsABIInfo::computeInfo(CGFunctionInfo &FI) const {
Akira Hatanakacc662542012-01-12 01:10:09 +00003663 ABIArgInfo &RetInfo = FI.getReturnInfo();
3664 RetInfo = classifyReturnType(FI.getReturnType());
3665
3666 // Check if a pointer to an aggregate is passed as a hidden argument.
Akira Hatanaka91338cf2012-05-11 21:56:58 +00003667 uint64_t Offset = RetInfo.isIndirect() ? MinABIStackAlignInBytes : 0;
Akira Hatanakacc662542012-01-12 01:10:09 +00003668
Akira Hatanaka619e8872011-06-02 00:09:17 +00003669 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
3670 it != ie; ++it)
Akira Hatanakaf0cc2082012-01-07 00:25:33 +00003671 it->info = classifyArgumentType(it->type, Offset);
Akira Hatanaka619e8872011-06-02 00:09:17 +00003672}
3673
3674llvm::Value* MipsABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
3675 CodeGenFunction &CGF) const {
Chris Lattner8b418682012-02-07 00:39:47 +00003676 llvm::Type *BP = CGF.Int8PtrTy;
3677 llvm::Type *BPP = CGF.Int8PtrPtrTy;
Akira Hatanakac35e69d2011-08-01 20:48:01 +00003678
3679 CGBuilderTy &Builder = CGF.Builder;
3680 llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP, "ap");
3681 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
Akira Hatanaka8f675e42012-01-23 23:59:52 +00003682 int64_t TypeAlign = getContext().getTypeAlign(Ty) / 8;
Akira Hatanakac35e69d2011-08-01 20:48:01 +00003683 llvm::Type *PTy = llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
3684 llvm::Value *AddrTyped;
Akira Hatanaka8f675e42012-01-23 23:59:52 +00003685 unsigned PtrWidth = getContext().getTargetInfo().getPointerWidth(0);
3686 llvm::IntegerType *IntTy = (PtrWidth == 32) ? CGF.Int32Ty : CGF.Int64Ty;
Akira Hatanakac35e69d2011-08-01 20:48:01 +00003687
3688 if (TypeAlign > MinABIStackAlignInBytes) {
Akira Hatanaka8f675e42012-01-23 23:59:52 +00003689 llvm::Value *AddrAsInt = CGF.Builder.CreatePtrToInt(Addr, IntTy);
3690 llvm::Value *Inc = llvm::ConstantInt::get(IntTy, TypeAlign - 1);
3691 llvm::Value *Mask = llvm::ConstantInt::get(IntTy, -TypeAlign);
3692 llvm::Value *Add = CGF.Builder.CreateAdd(AddrAsInt, Inc);
Akira Hatanakac35e69d2011-08-01 20:48:01 +00003693 llvm::Value *And = CGF.Builder.CreateAnd(Add, Mask);
3694 AddrTyped = CGF.Builder.CreateIntToPtr(And, PTy);
3695 }
3696 else
3697 AddrTyped = Builder.CreateBitCast(Addr, PTy);
3698
3699 llvm::Value *AlignedAddr = Builder.CreateBitCast(AddrTyped, BP);
Akira Hatanaka8f675e42012-01-23 23:59:52 +00003700 TypeAlign = std::max((unsigned)TypeAlign, MinABIStackAlignInBytes);
Akira Hatanakac35e69d2011-08-01 20:48:01 +00003701 uint64_t Offset =
3702 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, TypeAlign);
3703 llvm::Value *NextAddr =
Akira Hatanaka8f675e42012-01-23 23:59:52 +00003704 Builder.CreateGEP(AlignedAddr, llvm::ConstantInt::get(IntTy, Offset),
Akira Hatanakac35e69d2011-08-01 20:48:01 +00003705 "ap.next");
3706 Builder.CreateStore(NextAddr, VAListAddrAsBPP);
3707
3708 return AddrTyped;
Akira Hatanaka619e8872011-06-02 00:09:17 +00003709}
3710
John McCallaeeb7012010-05-27 06:19:26 +00003711bool
3712MIPSTargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
3713 llvm::Value *Address) const {
3714 // This information comes from gcc's implementation, which seems to
3715 // as canonical as it gets.
3716
John McCallaeeb7012010-05-27 06:19:26 +00003717 // Everything on MIPS is 4 bytes. Double-precision FP registers
3718 // are aliased to pairs of single-precision FP registers.
Chris Lattner8b418682012-02-07 00:39:47 +00003719 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
John McCallaeeb7012010-05-27 06:19:26 +00003720
3721 // 0-31 are the general purpose registers, $0 - $31.
3722 // 32-63 are the floating-point registers, $f0 - $f31.
3723 // 64 and 65 are the multiply/divide registers, $hi and $lo.
3724 // 66 is the (notional, I think) register for signal-handler return.
Chris Lattner8b418682012-02-07 00:39:47 +00003725 AssignToArrayRange(CGF.Builder, Address, Four8, 0, 65);
John McCallaeeb7012010-05-27 06:19:26 +00003726
3727 // 67-74 are the floating-point status registers, $fcc0 - $fcc7.
3728 // They are one bit wide and ignored here.
3729
3730 // 80-111 are the coprocessor 0 registers, $c0r0 - $c0r31.
3731 // (coprocessor 1 is the FP unit)
3732 // 112-143 are the coprocessor 2 registers, $c2r0 - $c2r31.
3733 // 144-175 are the coprocessor 3 registers, $c3r0 - $c3r31.
3734 // 176-181 are the DSP accumulator registers.
Chris Lattner8b418682012-02-07 00:39:47 +00003735 AssignToArrayRange(CGF.Builder, Address, Four8, 80, 181);
John McCallaeeb7012010-05-27 06:19:26 +00003736 return false;
3737}
3738
Peter Collingbourne2f7aa992011-10-13 16:24:41 +00003739//===----------------------------------------------------------------------===//
3740// TCE ABI Implementation (see http://tce.cs.tut.fi). Uses mostly the defaults.
3741// Currently subclassed only to implement custom OpenCL C function attribute
3742// handling.
3743//===----------------------------------------------------------------------===//
3744
3745namespace {
3746
3747class TCETargetCodeGenInfo : public DefaultTargetCodeGenInfo {
3748public:
3749 TCETargetCodeGenInfo(CodeGenTypes &CGT)
3750 : DefaultTargetCodeGenInfo(CGT) {}
3751
3752 virtual void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
3753 CodeGen::CodeGenModule &M) const;
3754};
3755
3756void TCETargetCodeGenInfo::SetTargetAttributes(const Decl *D,
3757 llvm::GlobalValue *GV,
3758 CodeGen::CodeGenModule &M) const {
3759 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
3760 if (!FD) return;
3761
3762 llvm::Function *F = cast<llvm::Function>(GV);
3763
David Blaikie4e4d0842012-03-11 07:00:24 +00003764 if (M.getLangOpts().OpenCL) {
Peter Collingbourne2f7aa992011-10-13 16:24:41 +00003765 if (FD->hasAttr<OpenCLKernelAttr>()) {
3766 // OpenCL C Kernel functions are not subject to inlining
Bill Wendlingfac63102012-10-10 03:13:20 +00003767 F->addFnAttr(llvm::Attributes::NoInline);
Peter Collingbourne2f7aa992011-10-13 16:24:41 +00003768
3769 if (FD->hasAttr<ReqdWorkGroupSizeAttr>()) {
3770
3771 // Convert the reqd_work_group_size() attributes to metadata.
3772 llvm::LLVMContext &Context = F->getContext();
3773 llvm::NamedMDNode *OpenCLMetadata =
3774 M.getModule().getOrInsertNamedMetadata("opencl.kernel_wg_size_info");
3775
3776 SmallVector<llvm::Value*, 5> Operands;
3777 Operands.push_back(F);
3778
Chris Lattner8b418682012-02-07 00:39:47 +00003779 Operands.push_back(llvm::Constant::getIntegerValue(M.Int32Ty,
3780 llvm::APInt(32,
3781 FD->getAttr<ReqdWorkGroupSizeAttr>()->getXDim())));
3782 Operands.push_back(llvm::Constant::getIntegerValue(M.Int32Ty,
3783 llvm::APInt(32,
Peter Collingbourne2f7aa992011-10-13 16:24:41 +00003784 FD->getAttr<ReqdWorkGroupSizeAttr>()->getYDim())));
Chris Lattner8b418682012-02-07 00:39:47 +00003785 Operands.push_back(llvm::Constant::getIntegerValue(M.Int32Ty,
3786 llvm::APInt(32,
Peter Collingbourne2f7aa992011-10-13 16:24:41 +00003787 FD->getAttr<ReqdWorkGroupSizeAttr>()->getZDim())));
3788
3789 // Add a boolean constant operand for "required" (true) or "hint" (false)
3790 // for implementing the work_group_size_hint attr later. Currently
3791 // always true as the hint is not yet implemented.
Chris Lattner8b418682012-02-07 00:39:47 +00003792 Operands.push_back(llvm::ConstantInt::getTrue(Context));
Peter Collingbourne2f7aa992011-10-13 16:24:41 +00003793 OpenCLMetadata->addOperand(llvm::MDNode::get(Context, Operands));
3794 }
3795 }
3796 }
3797}
3798
3799}
John McCallaeeb7012010-05-27 06:19:26 +00003800
Tony Linthicum96319392011-12-12 21:14:55 +00003801//===----------------------------------------------------------------------===//
3802// Hexagon ABI Implementation
3803//===----------------------------------------------------------------------===//
3804
3805namespace {
3806
3807class HexagonABIInfo : public ABIInfo {
3808
3809
3810public:
3811 HexagonABIInfo(CodeGenTypes &CGT) : ABIInfo(CGT) {}
3812
3813private:
3814
3815 ABIArgInfo classifyReturnType(QualType RetTy) const;
3816 ABIArgInfo classifyArgumentType(QualType RetTy) const;
3817
3818 virtual void computeInfo(CGFunctionInfo &FI) const;
3819
3820 virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
3821 CodeGenFunction &CGF) const;
3822};
3823
3824class HexagonTargetCodeGenInfo : public TargetCodeGenInfo {
3825public:
3826 HexagonTargetCodeGenInfo(CodeGenTypes &CGT)
3827 :TargetCodeGenInfo(new HexagonABIInfo(CGT)) {}
3828
3829 int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const {
3830 return 29;
3831 }
3832};
3833
3834}
3835
3836void HexagonABIInfo::computeInfo(CGFunctionInfo &FI) const {
3837 FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
3838 for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
3839 it != ie; ++it)
3840 it->info = classifyArgumentType(it->type);
3841}
3842
3843ABIArgInfo HexagonABIInfo::classifyArgumentType(QualType Ty) const {
3844 if (!isAggregateTypeForABI(Ty)) {
3845 // Treat an enum type as its underlying type.
3846 if (const EnumType *EnumTy = Ty->getAs<EnumType>())
3847 Ty = EnumTy->getDecl()->getIntegerType();
3848
3849 return (Ty->isPromotableIntegerType() ?
3850 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
3851 }
3852
3853 // Ignore empty records.
3854 if (isEmptyRecord(getContext(), Ty, true))
3855 return ABIArgInfo::getIgnore();
3856
3857 // Structures with either a non-trivial destructor or a non-trivial
3858 // copy constructor are always indirect.
3859 if (isRecordWithNonTrivialDestructorOrCopyConstructor(Ty))
3860 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
3861
3862 uint64_t Size = getContext().getTypeSize(Ty);
3863 if (Size > 64)
3864 return ABIArgInfo::getIndirect(0, /*ByVal=*/true);
3865 // Pass in the smallest viable integer type.
3866 else if (Size > 32)
3867 return ABIArgInfo::getDirect(llvm::Type::getInt64Ty(getVMContext()));
3868 else if (Size > 16)
3869 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
3870 else if (Size > 8)
3871 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
3872 else
3873 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
3874}
3875
3876ABIArgInfo HexagonABIInfo::classifyReturnType(QualType RetTy) const {
3877 if (RetTy->isVoidType())
3878 return ABIArgInfo::getIgnore();
3879
3880 // Large vector types should be returned via memory.
3881 if (RetTy->isVectorType() && getContext().getTypeSize(RetTy) > 64)
3882 return ABIArgInfo::getIndirect(0);
3883
3884 if (!isAggregateTypeForABI(RetTy)) {
3885 // Treat an enum type as its underlying type.
3886 if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
3887 RetTy = EnumTy->getDecl()->getIntegerType();
3888
3889 return (RetTy->isPromotableIntegerType() ?
3890 ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
3891 }
3892
3893 // Structures with either a non-trivial destructor or a non-trivial
3894 // copy constructor are always indirect.
3895 if (isRecordWithNonTrivialDestructorOrCopyConstructor(RetTy))
3896 return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
3897
3898 if (isEmptyRecord(getContext(), RetTy, true))
3899 return ABIArgInfo::getIgnore();
3900
3901 // Aggregates <= 8 bytes are returned in r0; other aggregates
3902 // are returned indirectly.
3903 uint64_t Size = getContext().getTypeSize(RetTy);
3904 if (Size <= 64) {
3905 // Return in the smallest viable integer type.
3906 if (Size <= 8)
3907 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
3908 if (Size <= 16)
3909 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
3910 if (Size <= 32)
3911 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
3912 return ABIArgInfo::getDirect(llvm::Type::getInt64Ty(getVMContext()));
3913 }
3914
3915 return ABIArgInfo::getIndirect(0, /*ByVal=*/true);
3916}
3917
3918llvm::Value *HexagonABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
Chris Lattner8b418682012-02-07 00:39:47 +00003919 CodeGenFunction &CGF) const {
Tony Linthicum96319392011-12-12 21:14:55 +00003920 // FIXME: Need to handle alignment
Chris Lattner8b418682012-02-07 00:39:47 +00003921 llvm::Type *BPP = CGF.Int8PtrPtrTy;
Tony Linthicum96319392011-12-12 21:14:55 +00003922
3923 CGBuilderTy &Builder = CGF.Builder;
3924 llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP,
3925 "ap");
3926 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
3927 llvm::Type *PTy =
3928 llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
3929 llvm::Value *AddrTyped = Builder.CreateBitCast(Addr, PTy);
3930
3931 uint64_t Offset =
3932 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, 4);
3933 llvm::Value *NextAddr =
3934 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
3935 "ap.next");
3936 Builder.CreateStore(NextAddr, VAListAddrAsBPP);
3937
3938 return AddrTyped;
3939}
3940
3941
Chris Lattnerea044322010-07-29 02:01:43 +00003942const TargetCodeGenInfo &CodeGenModule::getTargetCodeGenInfo() {
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00003943 if (TheTargetCodeGenInfo)
3944 return *TheTargetCodeGenInfo;
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00003945
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003946 const llvm::Triple &Triple = getContext().getTargetInfo().getTriple();
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003947 switch (Triple.getArch()) {
Daniel Dunbar2c0843f2009-08-24 08:52:16 +00003948 default:
Chris Lattnerea044322010-07-29 02:01:43 +00003949 return *(TheTargetCodeGenInfo = new DefaultTargetCodeGenInfo(Types));
Daniel Dunbar2c0843f2009-08-24 08:52:16 +00003950
Derek Schuff9ed63f82012-09-06 17:37:28 +00003951 case llvm::Triple::le32:
3952 return *(TheTargetCodeGenInfo = new PNaClTargetCodeGenInfo(Types));
John McCallaeeb7012010-05-27 06:19:26 +00003953 case llvm::Triple::mips:
3954 case llvm::Triple::mipsel:
Akira Hatanakac0e3b662011-11-02 23:14:57 +00003955 return *(TheTargetCodeGenInfo = new MIPSTargetCodeGenInfo(Types, true));
John McCallaeeb7012010-05-27 06:19:26 +00003956
Akira Hatanaka8c6dfbe2011-09-20 18:30:57 +00003957 case llvm::Triple::mips64:
3958 case llvm::Triple::mips64el:
Akira Hatanakac0e3b662011-11-02 23:14:57 +00003959 return *(TheTargetCodeGenInfo = new MIPSTargetCodeGenInfo(Types, false));
Akira Hatanaka8c6dfbe2011-09-20 18:30:57 +00003960
Daniel Dunbar34d91fd2009-09-12 00:59:49 +00003961 case llvm::Triple::arm:
3962 case llvm::Triple::thumb:
Sandeep Patel34c1af82011-04-05 00:23:47 +00003963 {
3964 ARMABIInfo::ABIKind Kind = ARMABIInfo::AAPCS;
Daniel Dunbar5e7bace2009-09-12 01:00:39 +00003965
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003966 if (strcmp(getContext().getTargetInfo().getABI(), "apcs-gnu") == 0)
Sandeep Patel34c1af82011-04-05 00:23:47 +00003967 Kind = ARMABIInfo::APCS;
3968 else if (CodeGenOpts.FloatABI == "hard")
3969 Kind = ARMABIInfo::AAPCS_VFP;
3970
3971 return *(TheTargetCodeGenInfo = new ARMTargetCodeGenInfo(Types, Kind));
3972 }
Daniel Dunbar34d91fd2009-09-12 00:59:49 +00003973
John McCallec853ba2010-03-11 00:10:12 +00003974 case llvm::Triple::ppc:
Chris Lattnerea044322010-07-29 02:01:43 +00003975 return *(TheTargetCodeGenInfo = new PPC32TargetCodeGenInfo(Types));
Roman Divacky0fbc4b92012-05-09 18:22:46 +00003976 case llvm::Triple::ppc64:
Bill Schmidt2fc107f2012-10-03 19:18:57 +00003977 if (Triple.isOSBinFormatELF())
3978 return *(TheTargetCodeGenInfo = new PPC64_SVR4_TargetCodeGenInfo(Types));
3979 else
3980 return *(TheTargetCodeGenInfo = new PPC64TargetCodeGenInfo(Types));
John McCallec853ba2010-03-11 00:10:12 +00003981
Peter Collingbourneedb66f32012-05-20 23:28:41 +00003982 case llvm::Triple::nvptx:
3983 case llvm::Triple::nvptx64:
Justin Holewinski2c585b92012-05-24 17:43:12 +00003984 return *(TheTargetCodeGenInfo = new NVPTXTargetCodeGenInfo(Types));
Justin Holewinski0259c3a2011-04-22 11:10:38 +00003985
Wesley Peck276fdf42010-12-19 19:57:51 +00003986 case llvm::Triple::mblaze:
3987 return *(TheTargetCodeGenInfo = new MBlazeTargetCodeGenInfo(Types));
3988
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00003989 case llvm::Triple::msp430:
Chris Lattnerea044322010-07-29 02:01:43 +00003990 return *(TheTargetCodeGenInfo = new MSP430TargetCodeGenInfo(Types));
Daniel Dunbar34d91fd2009-09-12 00:59:49 +00003991
Peter Collingbourne2f7aa992011-10-13 16:24:41 +00003992 case llvm::Triple::tce:
3993 return *(TheTargetCodeGenInfo = new TCETargetCodeGenInfo(Types));
3994
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00003995 case llvm::Triple::x86: {
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003996 bool DisableMMX = strcmp(getContext().getTargetInfo().getABI(), "no-mmx") == 0;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00003997
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003998 if (Triple.isOSDarwin())
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00003999 return *(TheTargetCodeGenInfo =
Rafael Espindolab48280b2012-07-31 02:44:24 +00004000 new X86_32TargetCodeGenInfo(Types, true, true, DisableMMX, false,
4001 CodeGenOpts.NumRegisterParameters));
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004002
4003 switch (Triple.getOS()) {
Daniel Dunbar2c0843f2009-08-24 08:52:16 +00004004 case llvm::Triple::Cygwin:
Daniel Dunbar2c0843f2009-08-24 08:52:16 +00004005 case llvm::Triple::MinGW32:
Edward O'Callaghan727e2682009-10-21 11:58:24 +00004006 case llvm::Triple::AuroraUX:
4007 case llvm::Triple::DragonFly:
David Chisnall75c135a2009-09-03 01:48:05 +00004008 case llvm::Triple::FreeBSD:
Daniel Dunbar2c0843f2009-08-24 08:52:16 +00004009 case llvm::Triple::OpenBSD:
Eli Friedman42f74f22012-08-08 23:57:20 +00004010 case llvm::Triple::Bitrig:
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00004011 return *(TheTargetCodeGenInfo =
Rafael Espindolab48280b2012-07-31 02:44:24 +00004012 new X86_32TargetCodeGenInfo(Types, false, true, DisableMMX,
4013 false,
4014 CodeGenOpts.NumRegisterParameters));
Eli Friedman55fc7e22012-01-25 22:46:34 +00004015
4016 case llvm::Triple::Win32:
4017 return *(TheTargetCodeGenInfo =
Rafael Espindolab48280b2012-07-31 02:44:24 +00004018 new X86_32TargetCodeGenInfo(Types, false, true, DisableMMX, true,
4019 CodeGenOpts.NumRegisterParameters));
Daniel Dunbar2c0843f2009-08-24 08:52:16 +00004020
4021 default:
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00004022 return *(TheTargetCodeGenInfo =
Rafael Espindolab48280b2012-07-31 02:44:24 +00004023 new X86_32TargetCodeGenInfo(Types, false, false, DisableMMX,
4024 false,
4025 CodeGenOpts.NumRegisterParameters));
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00004026 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00004027 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00004028
Eli Friedmanee1ad992011-12-02 00:11:43 +00004029 case llvm::Triple::x86_64: {
4030 bool HasAVX = strcmp(getContext().getTargetInfo().getABI(), "avx") == 0;
4031
Chris Lattnerf13721d2010-08-31 16:44:54 +00004032 switch (Triple.getOS()) {
4033 case llvm::Triple::Win32:
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00004034 case llvm::Triple::MinGW32:
Chris Lattnerf13721d2010-08-31 16:44:54 +00004035 case llvm::Triple::Cygwin:
4036 return *(TheTargetCodeGenInfo = new WinX86_64TargetCodeGenInfo(Types));
4037 default:
Eli Friedmanee1ad992011-12-02 00:11:43 +00004038 return *(TheTargetCodeGenInfo = new X86_64TargetCodeGenInfo(Types,
4039 HasAVX));
Chris Lattnerf13721d2010-08-31 16:44:54 +00004040 }
Daniel Dunbar2c0843f2009-08-24 08:52:16 +00004041 }
Tony Linthicum96319392011-12-12 21:14:55 +00004042 case llvm::Triple::hexagon:
4043 return *(TheTargetCodeGenInfo = new HexagonTargetCodeGenInfo(Types));
Eli Friedmanee1ad992011-12-02 00:11:43 +00004044 }
Anton Korobeynikovc4a59eb2009-06-05 22:08:42 +00004045}