Simplify vectorcall argument classification of HVAs, NFC
[lldb.git] / clang / lib / CodeGen / TargetInfo.cpp
1 //===---- TargetInfo.cpp - Encapsulate target details -----------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // These classes wrap the information about a call or function
10 // definition used to handle ABI compliancy.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "TargetInfo.h"
15 #include "ABIInfo.h"
16 #include "CGBlocks.h"
17 #include "CGCXXABI.h"
18 #include "CGValue.h"
19 #include "CodeGenFunction.h"
20 #include "clang/AST/Attr.h"
21 #include "clang/AST/RecordLayout.h"
22 #include "clang/Basic/CodeGenOptions.h"
23 #include "clang/Basic/DiagnosticFrontend.h"
24 #include "clang/CodeGen/CGFunctionInfo.h"
25 #include "clang/CodeGen/SwiftCallingConv.h"
26 #include "llvm/ADT/SmallBitVector.h"
27 #include "llvm/ADT/StringExtras.h"
28 #include "llvm/ADT/StringSwitch.h"
29 #include "llvm/ADT/Triple.h"
30 #include "llvm/ADT/Twine.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/IntrinsicsNVPTX.h"
33 #include "llvm/IR/Type.h"
34 #include "llvm/Support/raw_ostream.h"
35 #include <algorithm> // std::sort
36
37 using namespace clang;
38 using namespace CodeGen;
39
40 // Helper for coercing an aggregate argument or return value into an integer
41 // array of the same size (including padding) and alignment.  This alternate
42 // coercion happens only for the RenderScript ABI and can be removed after
43 // runtimes that rely on it are no longer supported.
44 //
45 // RenderScript assumes that the size of the argument / return value in the IR
46 // is the same as the size of the corresponding qualified type. This helper
47 // coerces the aggregate type into an array of the same size (including
48 // padding).  This coercion is used in lieu of expansion of struct members or
49 // other canonical coercions that return a coerced-type of larger size.
50 //
51 // Ty          - The argument / return value type
52 // Context     - The associated ASTContext
53 // LLVMContext - The associated LLVMContext
54 static ABIArgInfo coerceToIntArray(QualType Ty,
55                                    ASTContext &Context,
56                                    llvm::LLVMContext &LLVMContext) {
57   // Alignment and Size are measured in bits.
58   const uint64_t Size = Context.getTypeSize(Ty);
59   const uint64_t Alignment = Context.getTypeAlign(Ty);
60   llvm::Type *IntType = llvm::Type::getIntNTy(LLVMContext, Alignment);
61   const uint64_t NumElements = (Size + Alignment - 1) / Alignment;
62   return ABIArgInfo::getDirect(llvm::ArrayType::get(IntType, NumElements));
63 }
64
65 static void AssignToArrayRange(CodeGen::CGBuilderTy &Builder,
66                                llvm::Value *Array,
67                                llvm::Value *Value,
68                                unsigned FirstIndex,
69                                unsigned LastIndex) {
70   // Alternatively, we could emit this as a loop in the source.
71   for (unsigned I = FirstIndex; I <= LastIndex; ++I) {
72     llvm::Value *Cell =
73         Builder.CreateConstInBoundsGEP1_32(Builder.getInt8Ty(), Array, I);
74     Builder.CreateAlignedStore(Value, Cell, CharUnits::One());
75   }
76 }
77
78 static bool isAggregateTypeForABI(QualType T) {
79   return !CodeGenFunction::hasScalarEvaluationKind(T) ||
80          T->isMemberFunctionPointerType();
81 }
82
83 ABIArgInfo ABIInfo::getNaturalAlignIndirect(QualType Ty, bool ByVal,
84                                             bool Realign,
85                                             llvm::Type *Padding) const {
86   return ABIArgInfo::getIndirect(getContext().getTypeAlignInChars(Ty), ByVal,
87                                  Realign, Padding);
88 }
89
90 ABIArgInfo
91 ABIInfo::getNaturalAlignIndirectInReg(QualType Ty, bool Realign) const {
92   return ABIArgInfo::getIndirectInReg(getContext().getTypeAlignInChars(Ty),
93                                       /*ByVal*/ false, Realign);
94 }
95
96 Address ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
97                              QualType Ty) const {
98   return Address::invalid();
99 }
100
101 bool ABIInfo::isPromotableIntegerTypeForABI(QualType Ty) const {
102   if (Ty->isPromotableIntegerType())
103     return true;
104
105   if (const auto *EIT = Ty->getAs<ExtIntType>())
106     if (EIT->getNumBits() < getContext().getTypeSize(getContext().IntTy))
107       return true;
108
109   return false;
110 }
111
112 ABIInfo::~ABIInfo() {}
113
114 /// Does the given lowering require more than the given number of
115 /// registers when expanded?
116 ///
117 /// This is intended to be the basis of a reasonable basic implementation
118 /// of should{Pass,Return}IndirectlyForSwift.
119 ///
120 /// For most targets, a limit of four total registers is reasonable; this
121 /// limits the amount of code required in order to move around the value
122 /// in case it wasn't produced immediately prior to the call by the caller
123 /// (or wasn't produced in exactly the right registers) or isn't used
124 /// immediately within the callee.  But some targets may need to further
125 /// limit the register count due to an inability to support that many
126 /// return registers.
127 static bool occupiesMoreThan(CodeGenTypes &cgt,
128                              ArrayRef<llvm::Type*> scalarTypes,
129                              unsigned maxAllRegisters) {
130   unsigned intCount = 0, fpCount = 0;
131   for (llvm::Type *type : scalarTypes) {
132     if (type->isPointerTy()) {
133       intCount++;
134     } else if (auto intTy = dyn_cast<llvm::IntegerType>(type)) {
135       auto ptrWidth = cgt.getTarget().getPointerWidth(0);
136       intCount += (intTy->getBitWidth() + ptrWidth - 1) / ptrWidth;
137     } else {
138       assert(type->isVectorTy() || type->isFloatingPointTy());
139       fpCount++;
140     }
141   }
142
143   return (intCount + fpCount > maxAllRegisters);
144 }
145
146 bool SwiftABIInfo::isLegalVectorTypeForSwift(CharUnits vectorSize,
147                                              llvm::Type *eltTy,
148                                              unsigned numElts) const {
149   // The default implementation of this assumes that the target guarantees
150   // 128-bit SIMD support but nothing more.
151   return (vectorSize.getQuantity() > 8 && vectorSize.getQuantity() <= 16);
152 }
153
154 static CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT,
155                                               CGCXXABI &CXXABI) {
156   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
157   if (!RD) {
158     if (!RT->getDecl()->canPassInRegisters())
159       return CGCXXABI::RAA_Indirect;
160     return CGCXXABI::RAA_Default;
161   }
162   return CXXABI.getRecordArgABI(RD);
163 }
164
165 static CGCXXABI::RecordArgABI getRecordArgABI(QualType T,
166                                               CGCXXABI &CXXABI) {
167   const RecordType *RT = T->getAs<RecordType>();
168   if (!RT)
169     return CGCXXABI::RAA_Default;
170   return getRecordArgABI(RT, CXXABI);
171 }
172
173 static bool classifyReturnType(const CGCXXABI &CXXABI, CGFunctionInfo &FI,
174                                const ABIInfo &Info) {
175   QualType Ty = FI.getReturnType();
176
177   if (const auto *RT = Ty->getAs<RecordType>())
178     if (!isa<CXXRecordDecl>(RT->getDecl()) &&
179         !RT->getDecl()->canPassInRegisters()) {
180       FI.getReturnInfo() = Info.getNaturalAlignIndirect(Ty);
181       return true;
182     }
183
184   return CXXABI.classifyReturnType(FI);
185 }
186
187 /// Pass transparent unions as if they were the type of the first element. Sema
188 /// should ensure that all elements of the union have the same "machine type".
189 static QualType useFirstFieldIfTransparentUnion(QualType Ty) {
190   if (const RecordType *UT = Ty->getAsUnionType()) {
191     const RecordDecl *UD = UT->getDecl();
192     if (UD->hasAttr<TransparentUnionAttr>()) {
193       assert(!UD->field_empty() && "sema created an empty transparent union");
194       return UD->field_begin()->getType();
195     }
196   }
197   return Ty;
198 }
199
200 CGCXXABI &ABIInfo::getCXXABI() const {
201   return CGT.getCXXABI();
202 }
203
204 ASTContext &ABIInfo::getContext() const {
205   return CGT.getContext();
206 }
207
208 llvm::LLVMContext &ABIInfo::getVMContext() const {
209   return CGT.getLLVMContext();
210 }
211
212 const llvm::DataLayout &ABIInfo::getDataLayout() const {
213   return CGT.getDataLayout();
214 }
215
216 const TargetInfo &ABIInfo::getTarget() const {
217   return CGT.getTarget();
218 }
219
220 const CodeGenOptions &ABIInfo::getCodeGenOpts() const {
221   return CGT.getCodeGenOpts();
222 }
223
224 bool ABIInfo::isAndroid() const { return getTarget().getTriple().isAndroid(); }
225
226 bool ABIInfo::isHomogeneousAggregateBaseType(QualType Ty) const {
227   return false;
228 }
229
230 bool ABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
231                                                 uint64_t Members) const {
232   return false;
233 }
234
235 LLVM_DUMP_METHOD void ABIArgInfo::dump() const {
236   raw_ostream &OS = llvm::errs();
237   OS << "(ABIArgInfo Kind=";
238   switch (TheKind) {
239   case Direct:
240     OS << "Direct Type=";
241     if (llvm::Type *Ty = getCoerceToType())
242       Ty->print(OS);
243     else
244       OS << "null";
245     break;
246   case Extend:
247     OS << "Extend";
248     break;
249   case Ignore:
250     OS << "Ignore";
251     break;
252   case InAlloca:
253     OS << "InAlloca Offset=" << getInAllocaFieldIndex();
254     break;
255   case Indirect:
256     OS << "Indirect Align=" << getIndirectAlign().getQuantity()
257        << " ByVal=" << getIndirectByVal()
258        << " Realign=" << getIndirectRealign();
259     break;
260   case IndirectAliased:
261     OS << "Indirect Align=" << getIndirectAlign().getQuantity()
262        << " AadrSpace=" << getIndirectAddrSpace()
263        << " Realign=" << getIndirectRealign();
264     break;
265   case Expand:
266     OS << "Expand";
267     break;
268   case CoerceAndExpand:
269     OS << "CoerceAndExpand Type=";
270     getCoerceAndExpandType()->print(OS);
271     break;
272   }
273   OS << ")\n";
274 }
275
276 // Dynamically round a pointer up to a multiple of the given alignment.
277 static llvm::Value *emitRoundPointerUpToAlignment(CodeGenFunction &CGF,
278                                                   llvm::Value *Ptr,
279                                                   CharUnits Align) {
280   llvm::Value *PtrAsInt = Ptr;
281   // OverflowArgArea = (OverflowArgArea + Align - 1) & -Align;
282   PtrAsInt = CGF.Builder.CreatePtrToInt(PtrAsInt, CGF.IntPtrTy);
283   PtrAsInt = CGF.Builder.CreateAdd(PtrAsInt,
284         llvm::ConstantInt::get(CGF.IntPtrTy, Align.getQuantity() - 1));
285   PtrAsInt = CGF.Builder.CreateAnd(PtrAsInt,
286            llvm::ConstantInt::get(CGF.IntPtrTy, -Align.getQuantity()));
287   PtrAsInt = CGF.Builder.CreateIntToPtr(PtrAsInt,
288                                         Ptr->getType(),
289                                         Ptr->getName() + ".aligned");
290   return PtrAsInt;
291 }
292
293 /// Emit va_arg for a platform using the common void* representation,
294 /// where arguments are simply emitted in an array of slots on the stack.
295 ///
296 /// This version implements the core direct-value passing rules.
297 ///
298 /// \param SlotSize - The size and alignment of a stack slot.
299 ///   Each argument will be allocated to a multiple of this number of
300 ///   slots, and all the slots will be aligned to this value.
301 /// \param AllowHigherAlign - The slot alignment is not a cap;
302 ///   an argument type with an alignment greater than the slot size
303 ///   will be emitted on a higher-alignment address, potentially
304 ///   leaving one or more empty slots behind as padding.  If this
305 ///   is false, the returned address might be less-aligned than
306 ///   DirectAlign.
307 static Address emitVoidPtrDirectVAArg(CodeGenFunction &CGF,
308                                       Address VAListAddr,
309                                       llvm::Type *DirectTy,
310                                       CharUnits DirectSize,
311                                       CharUnits DirectAlign,
312                                       CharUnits SlotSize,
313                                       bool AllowHigherAlign) {
314   // Cast the element type to i8* if necessary.  Some platforms define
315   // va_list as a struct containing an i8* instead of just an i8*.
316   if (VAListAddr.getElementType() != CGF.Int8PtrTy)
317     VAListAddr = CGF.Builder.CreateElementBitCast(VAListAddr, CGF.Int8PtrTy);
318
319   llvm::Value *Ptr = CGF.Builder.CreateLoad(VAListAddr, "argp.cur");
320
321   // If the CC aligns values higher than the slot size, do so if needed.
322   Address Addr = Address::invalid();
323   if (AllowHigherAlign && DirectAlign > SlotSize) {
324     Addr = Address(emitRoundPointerUpToAlignment(CGF, Ptr, DirectAlign),
325                                                  DirectAlign);
326   } else {
327     Addr = Address(Ptr, SlotSize);
328   }
329
330   // Advance the pointer past the argument, then store that back.
331   CharUnits FullDirectSize = DirectSize.alignTo(SlotSize);
332   Address NextPtr =
333       CGF.Builder.CreateConstInBoundsByteGEP(Addr, FullDirectSize, "argp.next");
334   CGF.Builder.CreateStore(NextPtr.getPointer(), VAListAddr);
335
336   // If the argument is smaller than a slot, and this is a big-endian
337   // target, the argument will be right-adjusted in its slot.
338   if (DirectSize < SlotSize && CGF.CGM.getDataLayout().isBigEndian() &&
339       !DirectTy->isStructTy()) {
340     Addr = CGF.Builder.CreateConstInBoundsByteGEP(Addr, SlotSize - DirectSize);
341   }
342
343   Addr = CGF.Builder.CreateElementBitCast(Addr, DirectTy);
344   return Addr;
345 }
346
347 /// Emit va_arg for a platform using the common void* representation,
348 /// where arguments are simply emitted in an array of slots on the stack.
349 ///
350 /// \param IsIndirect - Values of this type are passed indirectly.
351 /// \param ValueInfo - The size and alignment of this type, generally
352 ///   computed with getContext().getTypeInfoInChars(ValueTy).
353 /// \param SlotSizeAndAlign - The size and alignment of a stack slot.
354 ///   Each argument will be allocated to a multiple of this number of
355 ///   slots, and all the slots will be aligned to this value.
356 /// \param AllowHigherAlign - The slot alignment is not a cap;
357 ///   an argument type with an alignment greater than the slot size
358 ///   will be emitted on a higher-alignment address, potentially
359 ///   leaving one or more empty slots behind as padding.
360 static Address emitVoidPtrVAArg(CodeGenFunction &CGF, Address VAListAddr,
361                                 QualType ValueTy, bool IsIndirect,
362                                 TypeInfoChars ValueInfo,
363                                 CharUnits SlotSizeAndAlign,
364                                 bool AllowHigherAlign) {
365   // The size and alignment of the value that was passed directly.
366   CharUnits DirectSize, DirectAlign;
367   if (IsIndirect) {
368     DirectSize = CGF.getPointerSize();
369     DirectAlign = CGF.getPointerAlign();
370   } else {
371     DirectSize = ValueInfo.Width;
372     DirectAlign = ValueInfo.Align;
373   }
374
375   // Cast the address we've calculated to the right type.
376   llvm::Type *DirectTy = CGF.ConvertTypeForMem(ValueTy);
377   if (IsIndirect)
378     DirectTy = DirectTy->getPointerTo(0);
379
380   Address Addr = emitVoidPtrDirectVAArg(CGF, VAListAddr, DirectTy,
381                                         DirectSize, DirectAlign,
382                                         SlotSizeAndAlign,
383                                         AllowHigherAlign);
384
385   if (IsIndirect) {
386     Addr = Address(CGF.Builder.CreateLoad(Addr), ValueInfo.Align);
387   }
388
389   return Addr;
390
391 }
392
393 static Address emitMergePHI(CodeGenFunction &CGF,
394                             Address Addr1, llvm::BasicBlock *Block1,
395                             Address Addr2, llvm::BasicBlock *Block2,
396                             const llvm::Twine &Name = "") {
397   assert(Addr1.getType() == Addr2.getType());
398   llvm::PHINode *PHI = CGF.Builder.CreatePHI(Addr1.getType(), 2, Name);
399   PHI->addIncoming(Addr1.getPointer(), Block1);
400   PHI->addIncoming(Addr2.getPointer(), Block2);
401   CharUnits Align = std::min(Addr1.getAlignment(), Addr2.getAlignment());
402   return Address(PHI, Align);
403 }
404
405 TargetCodeGenInfo::~TargetCodeGenInfo() = default;
406
407 // If someone can figure out a general rule for this, that would be great.
408 // It's probably just doomed to be platform-dependent, though.
409 unsigned TargetCodeGenInfo::getSizeOfUnwindException() const {
410   // Verified for:
411   //   x86-64     FreeBSD, Linux, Darwin
412   //   x86-32     FreeBSD, Linux, Darwin
413   //   PowerPC    Linux, Darwin
414   //   ARM        Darwin (*not* EABI)
415   //   AArch64    Linux
416   return 32;
417 }
418
419 bool TargetCodeGenInfo::isNoProtoCallVariadic(const CallArgList &args,
420                                      const FunctionNoProtoType *fnType) const {
421   // The following conventions are known to require this to be false:
422   //   x86_stdcall
423   //   MIPS
424   // For everything else, we just prefer false unless we opt out.
425   return false;
426 }
427
428 void
429 TargetCodeGenInfo::getDependentLibraryOption(llvm::StringRef Lib,
430                                              llvm::SmallString<24> &Opt) const {
431   // This assumes the user is passing a library name like "rt" instead of a
432   // filename like "librt.a/so", and that they don't care whether it's static or
433   // dynamic.
434   Opt = "-l";
435   Opt += Lib;
436 }
437
438 unsigned TargetCodeGenInfo::getOpenCLKernelCallingConv() const {
439   // OpenCL kernels are called via an explicit runtime API with arguments
440   // set with clSetKernelArg(), not as normal sub-functions.
441   // Return SPIR_KERNEL by default as the kernel calling convention to
442   // ensure the fingerprint is fixed such way that each OpenCL argument
443   // gets one matching argument in the produced kernel function argument
444   // list to enable feasible implementation of clSetKernelArg() with
445   // aggregates etc. In case we would use the default C calling conv here,
446   // clSetKernelArg() might break depending on the target-specific
447   // conventions; different targets might split structs passed as values
448   // to multiple function arguments etc.
449   return llvm::CallingConv::SPIR_KERNEL;
450 }
451
452 llvm::Constant *TargetCodeGenInfo::getNullPointer(const CodeGen::CodeGenModule &CGM,
453     llvm::PointerType *T, QualType QT) const {
454   return llvm::ConstantPointerNull::get(T);
455 }
456
457 LangAS TargetCodeGenInfo::getGlobalVarAddressSpace(CodeGenModule &CGM,
458                                                    const VarDecl *D) const {
459   assert(!CGM.getLangOpts().OpenCL &&
460          !(CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) &&
461          "Address space agnostic languages only");
462   return D ? D->getType().getAddressSpace() : LangAS::Default;
463 }
464
465 llvm::Value *TargetCodeGenInfo::performAddrSpaceCast(
466     CodeGen::CodeGenFunction &CGF, llvm::Value *Src, LangAS SrcAddr,
467     LangAS DestAddr, llvm::Type *DestTy, bool isNonNull) const {
468   // Since target may map different address spaces in AST to the same address
469   // space, an address space conversion may end up as a bitcast.
470   if (auto *C = dyn_cast<llvm::Constant>(Src))
471     return performAddrSpaceCast(CGF.CGM, C, SrcAddr, DestAddr, DestTy);
472   // Try to preserve the source's name to make IR more readable.
473   return CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
474       Src, DestTy, Src->hasName() ? Src->getName() + ".ascast" : "");
475 }
476
477 llvm::Constant *
478 TargetCodeGenInfo::performAddrSpaceCast(CodeGenModule &CGM, llvm::Constant *Src,
479                                         LangAS SrcAddr, LangAS DestAddr,
480                                         llvm::Type *DestTy) const {
481   // Since target may map different address spaces in AST to the same address
482   // space, an address space conversion may end up as a bitcast.
483   return llvm::ConstantExpr::getPointerCast(Src, DestTy);
484 }
485
486 llvm::SyncScope::ID
487 TargetCodeGenInfo::getLLVMSyncScopeID(const LangOptions &LangOpts,
488                                       SyncScope Scope,
489                                       llvm::AtomicOrdering Ordering,
490                                       llvm::LLVMContext &Ctx) const {
491   return Ctx.getOrInsertSyncScopeID(""); /* default sync scope */
492 }
493
494 static bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays);
495
496 /// isEmptyField - Return true iff a the field is "empty", that is it
497 /// is an unnamed bit-field or an (array of) empty record(s).
498 static bool isEmptyField(ASTContext &Context, const FieldDecl *FD,
499                          bool AllowArrays) {
500   if (FD->isUnnamedBitfield())
501     return true;
502
503   QualType FT = FD->getType();
504
505   // Constant arrays of empty records count as empty, strip them off.
506   // Constant arrays of zero length always count as empty.
507   bool WasArray = false;
508   if (AllowArrays)
509     while (const ConstantArrayType *AT = Context.getAsConstantArrayType(FT)) {
510       if (AT->getSize() == 0)
511         return true;
512       FT = AT->getElementType();
513       // The [[no_unique_address]] special case below does not apply to
514       // arrays of C++ empty records, so we need to remember this fact.
515       WasArray = true;
516     }
517
518   const RecordType *RT = FT->getAs<RecordType>();
519   if (!RT)
520     return false;
521
522   // C++ record fields are never empty, at least in the Itanium ABI.
523   //
524   // FIXME: We should use a predicate for whether this behavior is true in the
525   // current ABI.
526   //
527   // The exception to the above rule are fields marked with the
528   // [[no_unique_address]] attribute (since C++20).  Those do count as empty
529   // according to the Itanium ABI.  The exception applies only to records,
530   // not arrays of records, so we must also check whether we stripped off an
531   // array type above.
532   if (isa<CXXRecordDecl>(RT->getDecl()) &&
533       (WasArray || !FD->hasAttr<NoUniqueAddressAttr>()))
534     return false;
535
536   return isEmptyRecord(Context, FT, AllowArrays);
537 }
538
539 /// isEmptyRecord - Return true iff a structure contains only empty
540 /// fields. Note that a structure with a flexible array member is not
541 /// considered empty.
542 static bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays) {
543   const RecordType *RT = T->getAs<RecordType>();
544   if (!RT)
545     return false;
546   const RecordDecl *RD = RT->getDecl();
547   if (RD->hasFlexibleArrayMember())
548     return false;
549
550   // If this is a C++ record, check the bases first.
551   if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
552     for (const auto &I : CXXRD->bases())
553       if (!isEmptyRecord(Context, I.getType(), true))
554         return false;
555
556   for (const auto *I : RD->fields())
557     if (!isEmptyField(Context, I, AllowArrays))
558       return false;
559   return true;
560 }
561
562 /// isSingleElementStruct - Determine if a structure is a "single
563 /// element struct", i.e. it has exactly one non-empty field or
564 /// exactly one field which is itself a single element
565 /// struct. Structures with flexible array members are never
566 /// considered single element structs.
567 ///
568 /// \return The field declaration for the single non-empty field, if
569 /// it exists.
570 static const Type *isSingleElementStruct(QualType T, ASTContext &Context) {
571   const RecordType *RT = T->getAs<RecordType>();
572   if (!RT)
573     return nullptr;
574
575   const RecordDecl *RD = RT->getDecl();
576   if (RD->hasFlexibleArrayMember())
577     return nullptr;
578
579   const Type *Found = nullptr;
580
581   // If this is a C++ record, check the bases first.
582   if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
583     for (const auto &I : CXXRD->bases()) {
584       // Ignore empty records.
585       if (isEmptyRecord(Context, I.getType(), true))
586         continue;
587
588       // If we already found an element then this isn't a single-element struct.
589       if (Found)
590         return nullptr;
591
592       // If this is non-empty and not a single element struct, the composite
593       // cannot be a single element struct.
594       Found = isSingleElementStruct(I.getType(), Context);
595       if (!Found)
596         return nullptr;
597     }
598   }
599
600   // Check for single element.
601   for (const auto *FD : RD->fields()) {
602     QualType FT = FD->getType();
603
604     // Ignore empty fields.
605     if (isEmptyField(Context, FD, true))
606       continue;
607
608     // If we already found an element then this isn't a single-element
609     // struct.
610     if (Found)
611       return nullptr;
612
613     // Treat single element arrays as the element.
614     while (const ConstantArrayType *AT = Context.getAsConstantArrayType(FT)) {
615       if (AT->getSize().getZExtValue() != 1)
616         break;
617       FT = AT->getElementType();
618     }
619
620     if (!isAggregateTypeForABI(FT)) {
621       Found = FT.getTypePtr();
622     } else {
623       Found = isSingleElementStruct(FT, Context);
624       if (!Found)
625         return nullptr;
626     }
627   }
628
629   // We don't consider a struct a single-element struct if it has
630   // padding beyond the element type.
631   if (Found && Context.getTypeSize(Found) != Context.getTypeSize(T))
632     return nullptr;
633
634   return Found;
635 }
636
637 namespace {
638 Address EmitVAArgInstr(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
639                        const ABIArgInfo &AI) {
640   // This default implementation defers to the llvm backend's va_arg
641   // instruction. It can handle only passing arguments directly
642   // (typically only handled in the backend for primitive types), or
643   // aggregates passed indirectly by pointer (NOTE: if the "byval"
644   // flag has ABI impact in the callee, this implementation cannot
645   // work.)
646
647   // Only a few cases are covered here at the moment -- those needed
648   // by the default abi.
649   llvm::Value *Val;
650
651   if (AI.isIndirect()) {
652     assert(!AI.getPaddingType() &&
653            "Unexpected PaddingType seen in arginfo in generic VAArg emitter!");
654     assert(
655         !AI.getIndirectRealign() &&
656         "Unexpected IndirectRealign seen in arginfo in generic VAArg emitter!");
657
658     auto TyInfo = CGF.getContext().getTypeInfoInChars(Ty);
659     CharUnits TyAlignForABI = TyInfo.Align;
660
661     llvm::Type *BaseTy =
662         llvm::PointerType::getUnqual(CGF.ConvertTypeForMem(Ty));
663     llvm::Value *Addr =
664         CGF.Builder.CreateVAArg(VAListAddr.getPointer(), BaseTy);
665     return Address(Addr, TyAlignForABI);
666   } else {
667     assert((AI.isDirect() || AI.isExtend()) &&
668            "Unexpected ArgInfo Kind in generic VAArg emitter!");
669
670     assert(!AI.getInReg() &&
671            "Unexpected InReg seen in arginfo in generic VAArg emitter!");
672     assert(!AI.getPaddingType() &&
673            "Unexpected PaddingType seen in arginfo in generic VAArg emitter!");
674     assert(!AI.getDirectOffset() &&
675            "Unexpected DirectOffset seen in arginfo in generic VAArg emitter!");
676     assert(!AI.getCoerceToType() &&
677            "Unexpected CoerceToType seen in arginfo in generic VAArg emitter!");
678
679     Address Temp = CGF.CreateMemTemp(Ty, "varet");
680     Val = CGF.Builder.CreateVAArg(VAListAddr.getPointer(), CGF.ConvertType(Ty));
681     CGF.Builder.CreateStore(Val, Temp);
682     return Temp;
683   }
684 }
685
686 /// DefaultABIInfo - The default implementation for ABI specific
687 /// details. This implementation provides information which results in
688 /// self-consistent and sensible LLVM IR generation, but does not
689 /// conform to any particular ABI.
690 class DefaultABIInfo : public ABIInfo {
691 public:
692   DefaultABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}
693
694   ABIArgInfo classifyReturnType(QualType RetTy) const;
695   ABIArgInfo classifyArgumentType(QualType RetTy) const;
696
697   void computeInfo(CGFunctionInfo &FI) const override {
698     if (!getCXXABI().classifyReturnType(FI))
699       FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
700     for (auto &I : FI.arguments())
701       I.info = classifyArgumentType(I.type);
702   }
703
704   Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
705                     QualType Ty) const override {
706     return EmitVAArgInstr(CGF, VAListAddr, Ty, classifyArgumentType(Ty));
707   }
708 };
709
710 class DefaultTargetCodeGenInfo : public TargetCodeGenInfo {
711 public:
712   DefaultTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
713       : TargetCodeGenInfo(std::make_unique<DefaultABIInfo>(CGT)) {}
714 };
715
716 ABIArgInfo DefaultABIInfo::classifyArgumentType(QualType Ty) const {
717   Ty = useFirstFieldIfTransparentUnion(Ty);
718
719   if (isAggregateTypeForABI(Ty)) {
720     // Records with non-trivial destructors/copy-constructors should not be
721     // passed by value.
722     if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(Ty, getCXXABI()))
723       return getNaturalAlignIndirect(Ty, RAA == CGCXXABI::RAA_DirectInMemory);
724
725     return getNaturalAlignIndirect(Ty);
726   }
727
728   // Treat an enum type as its underlying type.
729   if (const EnumType *EnumTy = Ty->getAs<EnumType>())
730     Ty = EnumTy->getDecl()->getIntegerType();
731
732   ASTContext &Context = getContext();
733   if (const auto *EIT = Ty->getAs<ExtIntType>())
734     if (EIT->getNumBits() >
735         Context.getTypeSize(Context.getTargetInfo().hasInt128Type()
736                                 ? Context.Int128Ty
737                                 : Context.LongLongTy))
738       return getNaturalAlignIndirect(Ty);
739
740   return (isPromotableIntegerTypeForABI(Ty) ? ABIArgInfo::getExtend(Ty)
741                                             : ABIArgInfo::getDirect());
742 }
743
744 ABIArgInfo DefaultABIInfo::classifyReturnType(QualType RetTy) const {
745   if (RetTy->isVoidType())
746     return ABIArgInfo::getIgnore();
747
748   if (isAggregateTypeForABI(RetTy))
749     return getNaturalAlignIndirect(RetTy);
750
751   // Treat an enum type as its underlying type.
752   if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
753     RetTy = EnumTy->getDecl()->getIntegerType();
754
755   if (const auto *EIT = RetTy->getAs<ExtIntType>())
756     if (EIT->getNumBits() >
757         getContext().getTypeSize(getContext().getTargetInfo().hasInt128Type()
758                                      ? getContext().Int128Ty
759                                      : getContext().LongLongTy))
760       return getNaturalAlignIndirect(RetTy);
761
762   return (isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
763                                                : ABIArgInfo::getDirect());
764 }
765
766 //===----------------------------------------------------------------------===//
767 // WebAssembly ABI Implementation
768 //
769 // This is a very simple ABI that relies a lot on DefaultABIInfo.
770 //===----------------------------------------------------------------------===//
771
772 class WebAssemblyABIInfo final : public SwiftABIInfo {
773 public:
774   enum ABIKind {
775     MVP = 0,
776     ExperimentalMV = 1,
777   };
778
779 private:
780   DefaultABIInfo defaultInfo;
781   ABIKind Kind;
782
783 public:
784   explicit WebAssemblyABIInfo(CodeGen::CodeGenTypes &CGT, ABIKind Kind)
785       : SwiftABIInfo(CGT), defaultInfo(CGT), Kind(Kind) {}
786
787 private:
788   ABIArgInfo classifyReturnType(QualType RetTy) const;
789   ABIArgInfo classifyArgumentType(QualType Ty) const;
790
791   // DefaultABIInfo's classifyReturnType and classifyArgumentType are
792   // non-virtual, but computeInfo and EmitVAArg are virtual, so we
793   // overload them.
794   void computeInfo(CGFunctionInfo &FI) const override {
795     if (!getCXXABI().classifyReturnType(FI))
796       FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
797     for (auto &Arg : FI.arguments())
798       Arg.info = classifyArgumentType(Arg.type);
799   }
800
801   Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
802                     QualType Ty) const override;
803
804   bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
805                                     bool asReturnValue) const override {
806     return occupiesMoreThan(CGT, scalars, /*total*/ 4);
807   }
808
809   bool isSwiftErrorInRegister() const override {
810     return false;
811   }
812 };
813
814 class WebAssemblyTargetCodeGenInfo final : public TargetCodeGenInfo {
815 public:
816   explicit WebAssemblyTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,
817                                         WebAssemblyABIInfo::ABIKind K)
818       : TargetCodeGenInfo(std::make_unique<WebAssemblyABIInfo>(CGT, K)) {}
819
820   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
821                            CodeGen::CodeGenModule &CGM) const override {
822     TargetCodeGenInfo::setTargetAttributes(D, GV, CGM);
823     if (const auto *FD = dyn_cast_or_null<FunctionDecl>(D)) {
824       if (const auto *Attr = FD->getAttr<WebAssemblyImportModuleAttr>()) {
825         llvm::Function *Fn = cast<llvm::Function>(GV);
826         llvm::AttrBuilder B;
827         B.addAttribute("wasm-import-module", Attr->getImportModule());
828         Fn->addAttributes(llvm::AttributeList::FunctionIndex, B);
829       }
830       if (const auto *Attr = FD->getAttr<WebAssemblyImportNameAttr>()) {
831         llvm::Function *Fn = cast<llvm::Function>(GV);
832         llvm::AttrBuilder B;
833         B.addAttribute("wasm-import-name", Attr->getImportName());
834         Fn->addAttributes(llvm::AttributeList::FunctionIndex, B);
835       }
836       if (const auto *Attr = FD->getAttr<WebAssemblyExportNameAttr>()) {
837         llvm::Function *Fn = cast<llvm::Function>(GV);
838         llvm::AttrBuilder B;
839         B.addAttribute("wasm-export-name", Attr->getExportName());
840         Fn->addAttributes(llvm::AttributeList::FunctionIndex, B);
841       }
842     }
843
844     if (auto *FD = dyn_cast_or_null<FunctionDecl>(D)) {
845       llvm::Function *Fn = cast<llvm::Function>(GV);
846       if (!FD->doesThisDeclarationHaveABody() && !FD->hasPrototype())
847         Fn->addFnAttr("no-prototype");
848     }
849   }
850 };
851
852 /// Classify argument of given type \p Ty.
853 ABIArgInfo WebAssemblyABIInfo::classifyArgumentType(QualType Ty) const {
854   Ty = useFirstFieldIfTransparentUnion(Ty);
855
856   if (isAggregateTypeForABI(Ty)) {
857     // Records with non-trivial destructors/copy-constructors should not be
858     // passed by value.
859     if (auto RAA = getRecordArgABI(Ty, getCXXABI()))
860       return getNaturalAlignIndirect(Ty, RAA == CGCXXABI::RAA_DirectInMemory);
861     // Ignore empty structs/unions.
862     if (isEmptyRecord(getContext(), Ty, true))
863       return ABIArgInfo::getIgnore();
864     // Lower single-element structs to just pass a regular value. TODO: We
865     // could do reasonable-size multiple-element structs too, using getExpand(),
866     // though watch out for things like bitfields.
867     if (const Type *SeltTy = isSingleElementStruct(Ty, getContext()))
868       return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
869     // For the experimental multivalue ABI, fully expand all other aggregates
870     if (Kind == ABIKind::ExperimentalMV) {
871       const RecordType *RT = Ty->getAs<RecordType>();
872       assert(RT);
873       bool HasBitField = false;
874       for (auto *Field : RT->getDecl()->fields()) {
875         if (Field->isBitField()) {
876           HasBitField = true;
877           break;
878         }
879       }
880       if (!HasBitField)
881         return ABIArgInfo::getExpand();
882     }
883   }
884
885   // Otherwise just do the default thing.
886   return defaultInfo.classifyArgumentType(Ty);
887 }
888
889 ABIArgInfo WebAssemblyABIInfo::classifyReturnType(QualType RetTy) const {
890   if (isAggregateTypeForABI(RetTy)) {
891     // Records with non-trivial destructors/copy-constructors should not be
892     // returned by value.
893     if (!getRecordArgABI(RetTy, getCXXABI())) {
894       // Ignore empty structs/unions.
895       if (isEmptyRecord(getContext(), RetTy, true))
896         return ABIArgInfo::getIgnore();
897       // Lower single-element structs to just return a regular value. TODO: We
898       // could do reasonable-size multiple-element structs too, using
899       // ABIArgInfo::getDirect().
900       if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
901         return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
902       // For the experimental multivalue ABI, return all other aggregates
903       if (Kind == ABIKind::ExperimentalMV)
904         return ABIArgInfo::getDirect();
905     }
906   }
907
908   // Otherwise just do the default thing.
909   return defaultInfo.classifyReturnType(RetTy);
910 }
911
912 Address WebAssemblyABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
913                                       QualType Ty) const {
914   bool IsIndirect = isAggregateTypeForABI(Ty) &&
915                     !isEmptyRecord(getContext(), Ty, true) &&
916                     !isSingleElementStruct(Ty, getContext());
917   return emitVoidPtrVAArg(CGF, VAListAddr, Ty, IsIndirect,
918                           getContext().getTypeInfoInChars(Ty),
919                           CharUnits::fromQuantity(4),
920                           /*AllowHigherAlign=*/true);
921 }
922
923 //===----------------------------------------------------------------------===//
924 // le32/PNaCl bitcode ABI Implementation
925 //
926 // This is a simplified version of the x86_32 ABI.  Arguments and return values
927 // are always passed on the stack.
928 //===----------------------------------------------------------------------===//
929
930 class PNaClABIInfo : public ABIInfo {
931  public:
932   PNaClABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}
933
934   ABIArgInfo classifyReturnType(QualType RetTy) const;
935   ABIArgInfo classifyArgumentType(QualType RetTy) const;
936
937   void computeInfo(CGFunctionInfo &FI) const override;
938   Address EmitVAArg(CodeGenFunction &CGF,
939                     Address VAListAddr, QualType Ty) const override;
940 };
941
942 class PNaClTargetCodeGenInfo : public TargetCodeGenInfo {
943  public:
944    PNaClTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
945        : TargetCodeGenInfo(std::make_unique<PNaClABIInfo>(CGT)) {}
946 };
947
948 void PNaClABIInfo::computeInfo(CGFunctionInfo &FI) const {
949   if (!getCXXABI().classifyReturnType(FI))
950     FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
951
952   for (auto &I : FI.arguments())
953     I.info = classifyArgumentType(I.type);
954 }
955
956 Address PNaClABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
957                                 QualType Ty) const {
958   // The PNaCL ABI is a bit odd, in that varargs don't use normal
959   // function classification. Structs get passed directly for varargs
960   // functions, through a rewriting transform in
961   // pnacl-llvm/lib/Transforms/NaCl/ExpandVarArgs.cpp, which allows
962   // this target to actually support a va_arg instructions with an
963   // aggregate type, unlike other targets.
964   return EmitVAArgInstr(CGF, VAListAddr, Ty, ABIArgInfo::getDirect());
965 }
966
967 /// Classify argument of given type \p Ty.
968 ABIArgInfo PNaClABIInfo::classifyArgumentType(QualType Ty) const {
969   if (isAggregateTypeForABI(Ty)) {
970     if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(Ty, getCXXABI()))
971       return getNaturalAlignIndirect(Ty, RAA == CGCXXABI::RAA_DirectInMemory);
972     return getNaturalAlignIndirect(Ty);
973   } else if (const EnumType *EnumTy = Ty->getAs<EnumType>()) {
974     // Treat an enum type as its underlying type.
975     Ty = EnumTy->getDecl()->getIntegerType();
976   } else if (Ty->isFloatingType()) {
977     // Floating-point types don't go inreg.
978     return ABIArgInfo::getDirect();
979   } else if (const auto *EIT = Ty->getAs<ExtIntType>()) {
980     // Treat extended integers as integers if <=64, otherwise pass indirectly.
981     if (EIT->getNumBits() > 64)
982       return getNaturalAlignIndirect(Ty);
983     return ABIArgInfo::getDirect();
984   }
985
986   return (isPromotableIntegerTypeForABI(Ty) ? ABIArgInfo::getExtend(Ty)
987                                             : ABIArgInfo::getDirect());
988 }
989
990 ABIArgInfo PNaClABIInfo::classifyReturnType(QualType RetTy) const {
991   if (RetTy->isVoidType())
992     return ABIArgInfo::getIgnore();
993
994   // In the PNaCl ABI we always return records/structures on the stack.
995   if (isAggregateTypeForABI(RetTy))
996     return getNaturalAlignIndirect(RetTy);
997
998   // Treat extended integers as integers if <=64, otherwise pass indirectly.
999   if (const auto *EIT = RetTy->getAs<ExtIntType>()) {
1000     if (EIT->getNumBits() > 64)
1001       return getNaturalAlignIndirect(RetTy);
1002     return ABIArgInfo::getDirect();
1003   }
1004
1005   // Treat an enum type as its underlying type.
1006   if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
1007     RetTy = EnumTy->getDecl()->getIntegerType();
1008
1009   return (isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
1010                                                : ABIArgInfo::getDirect());
1011 }
1012
1013 /// IsX86_MMXType - Return true if this is an MMX type.
1014 bool IsX86_MMXType(llvm::Type *IRType) {
1015   // Return true if the type is an MMX type <2 x i32>, <4 x i16>, or <8 x i8>.
1016   return IRType->isVectorTy() && IRType->getPrimitiveSizeInBits() == 64 &&
1017     cast<llvm::VectorType>(IRType)->getElementType()->isIntegerTy() &&
1018     IRType->getScalarSizeInBits() != 64;
1019 }
1020
1021 static llvm::Type* X86AdjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
1022                                           StringRef Constraint,
1023                                           llvm::Type* Ty) {
1024   bool IsMMXCons = llvm::StringSwitch<bool>(Constraint)
1025                      .Cases("y", "&y", "^Ym", true)
1026                      .Default(false);
1027   if (IsMMXCons && Ty->isVectorTy()) {
1028     if (cast<llvm::VectorType>(Ty)->getPrimitiveSizeInBits().getFixedSize() !=
1029         64) {
1030       // Invalid MMX constraint
1031       return nullptr;
1032     }
1033
1034     return llvm::Type::getX86_MMXTy(CGF.getLLVMContext());
1035   }
1036
1037   // No operation needed
1038   return Ty;
1039 }
1040
1041 /// Returns true if this type can be passed in SSE registers with the
1042 /// X86_VectorCall calling convention. Shared between x86_32 and x86_64.
1043 static bool isX86VectorTypeForVectorCall(ASTContext &Context, QualType Ty) {
1044   if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
1045     if (BT->isFloatingPoint() && BT->getKind() != BuiltinType::Half) {
1046       if (BT->getKind() == BuiltinType::LongDouble) {
1047         if (&Context.getTargetInfo().getLongDoubleFormat() ==
1048             &llvm::APFloat::x87DoubleExtended())
1049           return false;
1050       }
1051       return true;
1052     }
1053   } else if (const VectorType *VT = Ty->getAs<VectorType>()) {
1054     // vectorcall can pass XMM, YMM, and ZMM vectors. We don't pass SSE1 MMX
1055     // registers specially.
1056     unsigned VecSize = Context.getTypeSize(VT);
1057     if (VecSize == 128 || VecSize == 256 || VecSize == 512)
1058       return true;
1059   }
1060   return false;
1061 }
1062
1063 /// Returns true if this aggregate is small enough to be passed in SSE registers
1064 /// in the X86_VectorCall calling convention. Shared between x86_32 and x86_64.
1065 static bool isX86VectorCallAggregateSmallEnough(uint64_t NumMembers) {
1066   return NumMembers <= 4;
1067 }
1068
1069 /// Returns a Homogeneous Vector Aggregate ABIArgInfo, used in X86.
1070 static ABIArgInfo getDirectX86Hva(llvm::Type* T = nullptr) {
1071   auto AI = ABIArgInfo::getDirect(T);
1072   AI.setInReg(true);
1073   AI.setCanBeFlattened(false);
1074   return AI;
1075 }
1076
1077 //===----------------------------------------------------------------------===//
1078 // X86-32 ABI Implementation
1079 //===----------------------------------------------------------------------===//
1080
1081 /// Similar to llvm::CCState, but for Clang.
1082 struct CCState {
1083   CCState(CGFunctionInfo &FI)
1084       : IsPreassigned(FI.arg_size()), CC(FI.getCallingConvention()) {}
1085
1086   llvm::SmallBitVector IsPreassigned;
1087   unsigned CC = CallingConv::CC_C;
1088   unsigned FreeRegs = 0;
1089   unsigned FreeSSERegs = 0;
1090 };
1091
1092 /// X86_32ABIInfo - The X86-32 ABI information.
1093 class X86_32ABIInfo : public SwiftABIInfo {
1094   enum Class {
1095     Integer,
1096     Float
1097   };
1098
1099   static const unsigned MinABIStackAlignInBytes = 4;
1100
1101   bool IsDarwinVectorABI;
1102   bool IsRetSmallStructInRegABI;
1103   bool IsWin32StructABI;
1104   bool IsSoftFloatABI;
1105   bool IsMCUABI;
1106   unsigned DefaultNumRegisterParameters;
1107
1108   static bool isRegisterSize(unsigned Size) {
1109     return (Size == 8 || Size == 16 || Size == 32 || Size == 64);
1110   }
1111
1112   bool isHomogeneousAggregateBaseType(QualType Ty) const override {
1113     // FIXME: Assumes vectorcall is in use.
1114     return isX86VectorTypeForVectorCall(getContext(), Ty);
1115   }
1116
1117   bool isHomogeneousAggregateSmallEnough(const Type *Ty,
1118                                          uint64_t NumMembers) const override {
1119     // FIXME: Assumes vectorcall is in use.
1120     return isX86VectorCallAggregateSmallEnough(NumMembers);
1121   }
1122
1123   bool shouldReturnTypeInRegister(QualType Ty, ASTContext &Context) const;
1124
1125   /// getIndirectResult - Give a source type \arg Ty, return a suitable result
1126   /// such that the argument will be passed in memory.
1127   ABIArgInfo getIndirectResult(QualType Ty, bool ByVal, CCState &State) const;
1128
1129   ABIArgInfo getIndirectReturnResult(QualType Ty, CCState &State) const;
1130
1131   /// Return the alignment to use for the given type on the stack.
1132   unsigned getTypeStackAlignInBytes(QualType Ty, unsigned Align) const;
1133
1134   Class classify(QualType Ty) const;
1135   ABIArgInfo classifyReturnType(QualType RetTy, CCState &State) const;
1136   ABIArgInfo classifyArgumentType(QualType RetTy, CCState &State) const;
1137
1138   /// Updates the number of available free registers, returns
1139   /// true if any registers were allocated.
1140   bool updateFreeRegs(QualType Ty, CCState &State) const;
1141
1142   bool shouldAggregateUseDirect(QualType Ty, CCState &State, bool &InReg,
1143                                 bool &NeedsPadding) const;
1144   bool shouldPrimitiveUseInReg(QualType Ty, CCState &State) const;
1145
1146   bool canExpandIndirectArgument(QualType Ty) const;
1147
1148   /// Rewrite the function info so that all memory arguments use
1149   /// inalloca.
1150   void rewriteWithInAlloca(CGFunctionInfo &FI) const;
1151
1152   void addFieldToArgStruct(SmallVector<llvm::Type *, 6> &FrameFields,
1153                            CharUnits &StackOffset, ABIArgInfo &Info,
1154                            QualType Type) const;
1155   void runVectorCallFirstPass(CGFunctionInfo &FI, CCState &State) const;
1156
1157 public:
1158
1159   void computeInfo(CGFunctionInfo &FI) const override;
1160   Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
1161                     QualType Ty) const override;
1162
1163   X86_32ABIInfo(CodeGen::CodeGenTypes &CGT, bool DarwinVectorABI,
1164                 bool RetSmallStructInRegABI, bool Win32StructABI,
1165                 unsigned NumRegisterParameters, bool SoftFloatABI)
1166     : SwiftABIInfo(CGT), IsDarwinVectorABI(DarwinVectorABI),
1167       IsRetSmallStructInRegABI(RetSmallStructInRegABI),
1168       IsWin32StructABI(Win32StructABI),
1169       IsSoftFloatABI(SoftFloatABI),
1170       IsMCUABI(CGT.getTarget().getTriple().isOSIAMCU()),
1171       DefaultNumRegisterParameters(NumRegisterParameters) {}
1172
1173   bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
1174                                     bool asReturnValue) const override {
1175     // LLVM's x86-32 lowering currently only assigns up to three
1176     // integer registers and three fp registers.  Oddly, it'll use up to
1177     // four vector registers for vectors, but those can overlap with the
1178     // scalar registers.
1179     return occupiesMoreThan(CGT, scalars, /*total*/ 3);
1180   }
1181
1182   bool isSwiftErrorInRegister() const override {
1183     // x86-32 lowering does not support passing swifterror in a register.
1184     return false;
1185   }
1186 };
1187
1188 class X86_32TargetCodeGenInfo : public TargetCodeGenInfo {
1189 public:
1190   X86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool DarwinVectorABI,
1191                           bool RetSmallStructInRegABI, bool Win32StructABI,
1192                           unsigned NumRegisterParameters, bool SoftFloatABI)
1193       : TargetCodeGenInfo(std::make_unique<X86_32ABIInfo>(
1194             CGT, DarwinVectorABI, RetSmallStructInRegABI, Win32StructABI,
1195             NumRegisterParameters, SoftFloatABI)) {}
1196
1197   static bool isStructReturnInRegABI(
1198       const llvm::Triple &Triple, const CodeGenOptions &Opts);
1199
1200   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
1201                            CodeGen::CodeGenModule &CGM) const override;
1202
1203   int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
1204     // Darwin uses different dwarf register numbers for EH.
1205     if (CGM.getTarget().getTriple().isOSDarwin()) return 5;
1206     return 4;
1207   }
1208
1209   bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
1210                                llvm::Value *Address) const override;
1211
1212   llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
1213                                   StringRef Constraint,
1214                                   llvm::Type* Ty) const override {
1215     return X86AdjustInlineAsmType(CGF, Constraint, Ty);
1216   }
1217
1218   void addReturnRegisterOutputs(CodeGenFunction &CGF, LValue ReturnValue,
1219                                 std::string &Constraints,
1220                                 std::vector<llvm::Type *> &ResultRegTypes,
1221                                 std::vector<llvm::Type *> &ResultTruncRegTypes,
1222                                 std::vector<LValue> &ResultRegDests,
1223                                 std::string &AsmString,
1224                                 unsigned NumOutputs) const override;
1225
1226   llvm::Constant *
1227   getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const override {
1228     unsigned Sig = (0xeb << 0) |  // jmp rel8
1229                    (0x06 << 8) |  //           .+0x08
1230                    ('v' << 16) |
1231                    ('2' << 24);
1232     return llvm::ConstantInt::get(CGM.Int32Ty, Sig);
1233   }
1234
1235   StringRef getARCRetainAutoreleasedReturnValueMarker() const override {
1236     return "movl\t%ebp, %ebp"
1237            "\t\t// marker for objc_retainAutoreleaseReturnValue";
1238   }
1239 };
1240
1241 }
1242
1243 /// Rewrite input constraint references after adding some output constraints.
1244 /// In the case where there is one output and one input and we add one output,
1245 /// we need to replace all operand references greater than or equal to 1:
1246 ///     mov $0, $1
1247 ///     mov eax, $1
1248 /// The result will be:
1249 ///     mov $0, $2
1250 ///     mov eax, $2
1251 static void rewriteInputConstraintReferences(unsigned FirstIn,
1252                                              unsigned NumNewOuts,
1253                                              std::string &AsmString) {
1254   std::string Buf;
1255   llvm::raw_string_ostream OS(Buf);
1256   size_t Pos = 0;
1257   while (Pos < AsmString.size()) {
1258     size_t DollarStart = AsmString.find('$', Pos);
1259     if (DollarStart == std::string::npos)
1260       DollarStart = AsmString.size();
1261     size_t DollarEnd = AsmString.find_first_not_of('$', DollarStart);
1262     if (DollarEnd == std::string::npos)
1263       DollarEnd = AsmString.size();
1264     OS << StringRef(&AsmString[Pos], DollarEnd - Pos);
1265     Pos = DollarEnd;
1266     size_t NumDollars = DollarEnd - DollarStart;
1267     if (NumDollars % 2 != 0 && Pos < AsmString.size()) {
1268       // We have an operand reference.
1269       size_t DigitStart = Pos;
1270       if (AsmString[DigitStart] == '{') {
1271         OS << '{';
1272         ++DigitStart;
1273       }
1274       size_t DigitEnd = AsmString.find_first_not_of("0123456789", DigitStart);
1275       if (DigitEnd == std::string::npos)
1276         DigitEnd = AsmString.size();
1277       StringRef OperandStr(&AsmString[DigitStart], DigitEnd - DigitStart);
1278       unsigned OperandIndex;
1279       if (!OperandStr.getAsInteger(10, OperandIndex)) {
1280         if (OperandIndex >= FirstIn)
1281           OperandIndex += NumNewOuts;
1282         OS << OperandIndex;
1283       } else {
1284         OS << OperandStr;
1285       }
1286       Pos = DigitEnd;
1287     }
1288   }
1289   AsmString = std::move(OS.str());
1290 }
1291
1292 /// Add output constraints for EAX:EDX because they are return registers.
1293 void X86_32TargetCodeGenInfo::addReturnRegisterOutputs(
1294     CodeGenFunction &CGF, LValue ReturnSlot, std::string &Constraints,
1295     std::vector<llvm::Type *> &ResultRegTypes,
1296     std::vector<llvm::Type *> &ResultTruncRegTypes,
1297     std::vector<LValue> &ResultRegDests, std::string &AsmString,
1298     unsigned NumOutputs) const {
1299   uint64_t RetWidth = CGF.getContext().getTypeSize(ReturnSlot.getType());
1300
1301   // Use the EAX constraint if the width is 32 or smaller and EAX:EDX if it is
1302   // larger.
1303   if (!Constraints.empty())
1304     Constraints += ',';
1305   if (RetWidth <= 32) {
1306     Constraints += "={eax}";
1307     ResultRegTypes.push_back(CGF.Int32Ty);
1308   } else {
1309     // Use the 'A' constraint for EAX:EDX.
1310     Constraints += "=A";
1311     ResultRegTypes.push_back(CGF.Int64Ty);
1312   }
1313
1314   // Truncate EAX or EAX:EDX to an integer of the appropriate size.
1315   llvm::Type *CoerceTy = llvm::IntegerType::get(CGF.getLLVMContext(), RetWidth);
1316   ResultTruncRegTypes.push_back(CoerceTy);
1317
1318   // Coerce the integer by bitcasting the return slot pointer.
1319   ReturnSlot.setAddress(CGF.Builder.CreateBitCast(ReturnSlot.getAddress(CGF),
1320                                                   CoerceTy->getPointerTo()));
1321   ResultRegDests.push_back(ReturnSlot);
1322
1323   rewriteInputConstraintReferences(NumOutputs, 1, AsmString);
1324 }
1325
1326 /// shouldReturnTypeInRegister - Determine if the given type should be
1327 /// returned in a register (for the Darwin and MCU ABI).
1328 bool X86_32ABIInfo::shouldReturnTypeInRegister(QualType Ty,
1329                                                ASTContext &Context) const {
1330   uint64_t Size = Context.getTypeSize(Ty);
1331
1332   // For i386, type must be register sized.
1333   // For the MCU ABI, it only needs to be <= 8-byte
1334   if ((IsMCUABI && Size > 64) || (!IsMCUABI && !isRegisterSize(Size)))
1335    return false;
1336
1337   if (Ty->isVectorType()) {
1338     // 64- and 128- bit vectors inside structures are not returned in
1339     // registers.
1340     if (Size == 64 || Size == 128)
1341       return false;
1342
1343     return true;
1344   }
1345
1346   // If this is a builtin, pointer, enum, complex type, member pointer, or
1347   // member function pointer it is ok.
1348   if (Ty->getAs<BuiltinType>() || Ty->hasPointerRepresentation() ||
1349       Ty->isAnyComplexType() || Ty->isEnumeralType() ||
1350       Ty->isBlockPointerType() || Ty->isMemberPointerType())
1351     return true;
1352
1353   // Arrays are treated like records.
1354   if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty))
1355     return shouldReturnTypeInRegister(AT->getElementType(), Context);
1356
1357   // Otherwise, it must be a record type.
1358   const RecordType *RT = Ty->getAs<RecordType>();
1359   if (!RT) return false;
1360
1361   // FIXME: Traverse bases here too.
1362
1363   // Structure types are passed in register if all fields would be
1364   // passed in a register.
1365   for (const auto *FD : RT->getDecl()->fields()) {
1366     // Empty fields are ignored.
1367     if (isEmptyField(Context, FD, true))
1368       continue;
1369
1370     // Check fields recursively.
1371     if (!shouldReturnTypeInRegister(FD->getType(), Context))
1372       return false;
1373   }
1374   return true;
1375 }
1376
1377 static bool is32Or64BitBasicType(QualType Ty, ASTContext &Context) {
1378   // Treat complex types as the element type.
1379   if (const ComplexType *CTy = Ty->getAs<ComplexType>())
1380     Ty = CTy->getElementType();
1381
1382   // Check for a type which we know has a simple scalar argument-passing
1383   // convention without any padding.  (We're specifically looking for 32
1384   // and 64-bit integer and integer-equivalents, float, and double.)
1385   if (!Ty->getAs<BuiltinType>() && !Ty->hasPointerRepresentation() &&
1386       !Ty->isEnumeralType() && !Ty->isBlockPointerType())
1387     return false;
1388
1389   uint64_t Size = Context.getTypeSize(Ty);
1390   return Size == 32 || Size == 64;
1391 }
1392
1393 static bool addFieldSizes(ASTContext &Context, const RecordDecl *RD,
1394                           uint64_t &Size) {
1395   for (const auto *FD : RD->fields()) {
1396     // Scalar arguments on the stack get 4 byte alignment on x86. If the
1397     // argument is smaller than 32-bits, expanding the struct will create
1398     // alignment padding.
1399     if (!is32Or64BitBasicType(FD->getType(), Context))
1400       return false;
1401
1402     // FIXME: Reject bit-fields wholesale; there are two problems, we don't know
1403     // how to expand them yet, and the predicate for telling if a bitfield still
1404     // counts as "basic" is more complicated than what we were doing previously.
1405     if (FD->isBitField())
1406       return false;
1407
1408     Size += Context.getTypeSize(FD->getType());
1409   }
1410   return true;
1411 }
1412
1413 static bool addBaseAndFieldSizes(ASTContext &Context, const CXXRecordDecl *RD,
1414                                  uint64_t &Size) {
1415   // Don't do this if there are any non-empty bases.
1416   for (const CXXBaseSpecifier &Base : RD->bases()) {
1417     if (!addBaseAndFieldSizes(Context, Base.getType()->getAsCXXRecordDecl(),
1418                               Size))
1419       return false;
1420   }
1421   if (!addFieldSizes(Context, RD, Size))
1422     return false;
1423   return true;
1424 }
1425
1426 /// Test whether an argument type which is to be passed indirectly (on the
1427 /// stack) would have the equivalent layout if it was expanded into separate
1428 /// arguments. If so, we prefer to do the latter to avoid inhibiting
1429 /// optimizations.
1430 bool X86_32ABIInfo::canExpandIndirectArgument(QualType Ty) const {
1431   // We can only expand structure types.
1432   const RecordType *RT = Ty->getAs<RecordType>();
1433   if (!RT)
1434     return false;
1435   const RecordDecl *RD = RT->getDecl();
1436   uint64_t Size = 0;
1437   if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
1438     if (!IsWin32StructABI) {
1439       // On non-Windows, we have to conservatively match our old bitcode
1440       // prototypes in order to be ABI-compatible at the bitcode level.
1441       if (!CXXRD->isCLike())
1442         return false;
1443     } else {
1444       // Don't do this for dynamic classes.
1445       if (CXXRD->isDynamicClass())
1446         return false;
1447     }
1448     if (!addBaseAndFieldSizes(getContext(), CXXRD, Size))
1449       return false;
1450   } else {
1451     if (!addFieldSizes(getContext(), RD, Size))
1452       return false;
1453   }
1454
1455   // We can do this if there was no alignment padding.
1456   return Size == getContext().getTypeSize(Ty);
1457 }
1458
1459 ABIArgInfo X86_32ABIInfo::getIndirectReturnResult(QualType RetTy, CCState &State) const {
1460   // If the return value is indirect, then the hidden argument is consuming one
1461   // integer register.
1462   if (State.FreeRegs) {
1463     --State.FreeRegs;
1464     if (!IsMCUABI)
1465       return getNaturalAlignIndirectInReg(RetTy);
1466   }
1467   return getNaturalAlignIndirect(RetTy, /*ByVal=*/false);
1468 }
1469
1470 ABIArgInfo X86_32ABIInfo::classifyReturnType(QualType RetTy,
1471                                              CCState &State) const {
1472   if (RetTy->isVoidType())
1473     return ABIArgInfo::getIgnore();
1474
1475   const Type *Base = nullptr;
1476   uint64_t NumElts = 0;
1477   if ((State.CC == llvm::CallingConv::X86_VectorCall ||
1478        State.CC == llvm::CallingConv::X86_RegCall) &&
1479       isHomogeneousAggregate(RetTy, Base, NumElts)) {
1480     // The LLVM struct type for such an aggregate should lower properly.
1481     return ABIArgInfo::getDirect();
1482   }
1483
1484   if (const VectorType *VT = RetTy->getAs<VectorType>()) {
1485     // On Darwin, some vectors are returned in registers.
1486     if (IsDarwinVectorABI) {
1487       uint64_t Size = getContext().getTypeSize(RetTy);
1488
1489       // 128-bit vectors are a special case; they are returned in
1490       // registers and we need to make sure to pick a type the LLVM
1491       // backend will like.
1492       if (Size == 128)
1493         return ABIArgInfo::getDirect(llvm::FixedVectorType::get(
1494             llvm::Type::getInt64Ty(getVMContext()), 2));
1495
1496       // Always return in register if it fits in a general purpose
1497       // register, or if it is 64 bits and has a single element.
1498       if ((Size == 8 || Size == 16 || Size == 32) ||
1499           (Size == 64 && VT->getNumElements() == 1))
1500         return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
1501                                                             Size));
1502
1503       return getIndirectReturnResult(RetTy, State);
1504     }
1505
1506     return ABIArgInfo::getDirect();
1507   }
1508
1509   if (isAggregateTypeForABI(RetTy)) {
1510     if (const RecordType *RT = RetTy->getAs<RecordType>()) {
1511       // Structures with flexible arrays are always indirect.
1512       if (RT->getDecl()->hasFlexibleArrayMember())
1513         return getIndirectReturnResult(RetTy, State);
1514     }
1515
1516     // If specified, structs and unions are always indirect.
1517     if (!IsRetSmallStructInRegABI && !RetTy->isAnyComplexType())
1518       return getIndirectReturnResult(RetTy, State);
1519
1520     // Ignore empty structs/unions.
1521     if (isEmptyRecord(getContext(), RetTy, true))
1522       return ABIArgInfo::getIgnore();
1523
1524     // Small structures which are register sized are generally returned
1525     // in a register.
1526     if (shouldReturnTypeInRegister(RetTy, getContext())) {
1527       uint64_t Size = getContext().getTypeSize(RetTy);
1528
1529       // As a special-case, if the struct is a "single-element" struct, and
1530       // the field is of type "float" or "double", return it in a
1531       // floating-point register. (MSVC does not apply this special case.)
1532       // We apply a similar transformation for pointer types to improve the
1533       // quality of the generated IR.
1534       if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
1535         if ((!IsWin32StructABI && SeltTy->isRealFloatingType())
1536             || SeltTy->hasPointerRepresentation())
1537           return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
1538
1539       // FIXME: We should be able to narrow this integer in cases with dead
1540       // padding.
1541       return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),Size));
1542     }
1543
1544     return getIndirectReturnResult(RetTy, State);
1545   }
1546
1547   // Treat an enum type as its underlying type.
1548   if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
1549     RetTy = EnumTy->getDecl()->getIntegerType();
1550
1551   if (const auto *EIT = RetTy->getAs<ExtIntType>())
1552     if (EIT->getNumBits() > 64)
1553       return getIndirectReturnResult(RetTy, State);
1554
1555   return (isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
1556                                                : ABIArgInfo::getDirect());
1557 }
1558
1559 static bool isSIMDVectorType(ASTContext &Context, QualType Ty) {
1560   return Ty->getAs<VectorType>() && Context.getTypeSize(Ty) == 128;
1561 }
1562
1563 static bool isRecordWithSIMDVectorType(ASTContext &Context, QualType Ty) {
1564   const RecordType *RT = Ty->getAs<RecordType>();
1565   if (!RT)
1566     return 0;
1567   const RecordDecl *RD = RT->getDecl();
1568
1569   // If this is a C++ record, check the bases first.
1570   if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1571     for (const auto &I : CXXRD->bases())
1572       if (!isRecordWithSIMDVectorType(Context, I.getType()))
1573         return false;
1574
1575   for (const auto *i : RD->fields()) {
1576     QualType FT = i->getType();
1577
1578     if (isSIMDVectorType(Context, FT))
1579       return true;
1580
1581     if (isRecordWithSIMDVectorType(Context, FT))
1582       return true;
1583   }
1584
1585   return false;
1586 }
1587
1588 unsigned X86_32ABIInfo::getTypeStackAlignInBytes(QualType Ty,
1589                                                  unsigned Align) const {
1590   // Otherwise, if the alignment is less than or equal to the minimum ABI
1591   // alignment, just use the default; the backend will handle this.
1592   if (Align <= MinABIStackAlignInBytes)
1593     return 0; // Use default alignment.
1594
1595   // On non-Darwin, the stack type alignment is always 4.
1596   if (!IsDarwinVectorABI) {
1597     // Set explicit alignment, since we may need to realign the top.
1598     return MinABIStackAlignInBytes;
1599   }
1600
1601   // Otherwise, if the type contains an SSE vector type, the alignment is 16.
1602   if (Align >= 16 && (isSIMDVectorType(getContext(), Ty) ||
1603                       isRecordWithSIMDVectorType(getContext(), Ty)))
1604     return 16;
1605
1606   return MinABIStackAlignInBytes;
1607 }
1608
1609 ABIArgInfo X86_32ABIInfo::getIndirectResult(QualType Ty, bool ByVal,
1610                                             CCState &State) const {
1611   if (!ByVal) {
1612     if (State.FreeRegs) {
1613       --State.FreeRegs; // Non-byval indirects just use one pointer.
1614       if (!IsMCUABI)
1615         return getNaturalAlignIndirectInReg(Ty);
1616     }
1617     return getNaturalAlignIndirect(Ty, false);
1618   }
1619
1620   // Compute the byval alignment.
1621   unsigned TypeAlign = getContext().getTypeAlign(Ty) / 8;
1622   unsigned StackAlign = getTypeStackAlignInBytes(Ty, TypeAlign);
1623   if (StackAlign == 0)
1624     return ABIArgInfo::getIndirect(CharUnits::fromQuantity(4), /*ByVal=*/true);
1625
1626   // If the stack alignment is less than the type alignment, realign the
1627   // argument.
1628   bool Realign = TypeAlign > StackAlign;
1629   return ABIArgInfo::getIndirect(CharUnits::fromQuantity(StackAlign),
1630                                  /*ByVal=*/true, Realign);
1631 }
1632
1633 X86_32ABIInfo::Class X86_32ABIInfo::classify(QualType Ty) const {
1634   const Type *T = isSingleElementStruct(Ty, getContext());
1635   if (!T)
1636     T = Ty.getTypePtr();
1637
1638   if (const BuiltinType *BT = T->getAs<BuiltinType>()) {
1639     BuiltinType::Kind K = BT->getKind();
1640     if (K == BuiltinType::Float || K == BuiltinType::Double)
1641       return Float;
1642   }
1643   return Integer;
1644 }
1645
1646 bool X86_32ABIInfo::updateFreeRegs(QualType Ty, CCState &State) const {
1647   if (!IsSoftFloatABI) {
1648     Class C = classify(Ty);
1649     if (C == Float)
1650       return false;
1651   }
1652
1653   unsigned Size = getContext().getTypeSize(Ty);
1654   unsigned SizeInRegs = (Size + 31) / 32;
1655
1656   if (SizeInRegs == 0)
1657     return false;
1658
1659   if (!IsMCUABI) {
1660     if (SizeInRegs > State.FreeRegs) {
1661       State.FreeRegs = 0;
1662       return false;
1663     }
1664   } else {
1665     // The MCU psABI allows passing parameters in-reg even if there are
1666     // earlier parameters that are passed on the stack. Also,
1667     // it does not allow passing >8-byte structs in-register,
1668     // even if there are 3 free registers available.
1669     if (SizeInRegs > State.FreeRegs || SizeInRegs > 2)
1670       return false;
1671   }
1672
1673   State.FreeRegs -= SizeInRegs;
1674   return true;
1675 }
1676
1677 bool X86_32ABIInfo::shouldAggregateUseDirect(QualType Ty, CCState &State,
1678                                              bool &InReg,
1679                                              bool &NeedsPadding) const {
1680   // On Windows, aggregates other than HFAs are never passed in registers, and
1681   // they do not consume register slots. Homogenous floating-point aggregates
1682   // (HFAs) have already been dealt with at this point.
1683   if (IsWin32StructABI && isAggregateTypeForABI(Ty))
1684     return false;
1685
1686   NeedsPadding = false;
1687   InReg = !IsMCUABI;
1688
1689   if (!updateFreeRegs(Ty, State))
1690     return false;
1691
1692   if (IsMCUABI)
1693     return true;
1694
1695   if (State.CC == llvm::CallingConv::X86_FastCall ||
1696       State.CC == llvm::CallingConv::X86_VectorCall ||
1697       State.CC == llvm::CallingConv::X86_RegCall) {
1698     if (getContext().getTypeSize(Ty) <= 32 && State.FreeRegs)
1699       NeedsPadding = true;
1700
1701     return false;
1702   }
1703
1704   return true;
1705 }
1706
1707 bool X86_32ABIInfo::shouldPrimitiveUseInReg(QualType Ty, CCState &State) const {
1708   if (!updateFreeRegs(Ty, State))
1709     return false;
1710
1711   if (IsMCUABI)
1712     return false;
1713
1714   if (State.CC == llvm::CallingConv::X86_FastCall ||
1715       State.CC == llvm::CallingConv::X86_VectorCall ||
1716       State.CC == llvm::CallingConv::X86_RegCall) {
1717     if (getContext().getTypeSize(Ty) > 32)
1718       return false;
1719
1720     return (Ty->isIntegralOrEnumerationType() || Ty->isPointerType() ||
1721         Ty->isReferenceType());
1722   }
1723
1724   return true;
1725 }
1726
1727 void X86_32ABIInfo::runVectorCallFirstPass(CGFunctionInfo &FI, CCState &State) const {
1728   // Vectorcall x86 works subtly different than in x64, so the format is
1729   // a bit different than the x64 version.  First, all vector types (not HVAs)
1730   // are assigned, with the first 6 ending up in the [XYZ]MM0-5 registers.
1731   // This differs from the x64 implementation, where the first 6 by INDEX get
1732   // registers.
1733   // In the second pass over the arguments, HVAs are passed in the remaining
1734   // vector registers if possible, or indirectly by address. The address will be
1735   // passed in ECX/EDX if available. Any other arguments are passed according to
1736   // the usual fastcall rules.
1737   MutableArrayRef<CGFunctionInfoArgInfo> Args = FI.arguments();
1738   for (int I = 0, E = Args.size(); I < E; ++I) {
1739     const Type *Base = nullptr;
1740     uint64_t NumElts = 0;
1741     const QualType &Ty = Args[I].type;
1742     if ((Ty->isVectorType() || Ty->isBuiltinType()) &&
1743         isHomogeneousAggregate(Ty, Base, NumElts)) {
1744       if (State.FreeSSERegs >= NumElts) {
1745         State.FreeSSERegs -= NumElts;
1746         Args[I].info = ABIArgInfo::getDirectInReg();
1747         State.IsPreassigned.set(I);
1748       }
1749     }
1750   }
1751 }
1752
1753 ABIArgInfo X86_32ABIInfo::classifyArgumentType(QualType Ty,
1754                                                CCState &State) const {
1755   // FIXME: Set alignment on indirect arguments.
1756   bool IsFastCall = State.CC == llvm::CallingConv::X86_FastCall;
1757   bool IsRegCall = State.CC == llvm::CallingConv::X86_RegCall;
1758   bool IsVectorCall = State.CC == llvm::CallingConv::X86_VectorCall;
1759
1760   Ty = useFirstFieldIfTransparentUnion(Ty);
1761   TypeInfo TI = getContext().getTypeInfo(Ty);
1762
1763   // Check with the C++ ABI first.
1764   const RecordType *RT = Ty->getAs<RecordType>();
1765   if (RT) {
1766     CGCXXABI::RecordArgABI RAA = getRecordArgABI(RT, getCXXABI());
1767     if (RAA == CGCXXABI::RAA_Indirect) {
1768       return getIndirectResult(Ty, false, State);
1769     } else if (RAA == CGCXXABI::RAA_DirectInMemory) {
1770       // The field index doesn't matter, we'll fix it up later.
1771       return ABIArgInfo::getInAlloca(/*FieldIndex=*/0);
1772     }
1773   }
1774
1775   // Regcall uses the concept of a homogenous vector aggregate, similar
1776   // to other targets.
1777   const Type *Base = nullptr;
1778   uint64_t NumElts = 0;
1779   if ((IsRegCall || IsVectorCall) &&
1780       isHomogeneousAggregate(Ty, Base, NumElts)) {
1781     if (State.FreeSSERegs >= NumElts) {
1782       State.FreeSSERegs -= NumElts;
1783
1784       // Vectorcall passes HVAs directly and does not flatten them, but regcall
1785       // does.
1786       if (IsVectorCall)
1787         return getDirectX86Hva();
1788
1789       if (Ty->isBuiltinType() || Ty->isVectorType())
1790         return ABIArgInfo::getDirect();
1791       return ABIArgInfo::getExpand();
1792     }
1793     return getIndirectResult(Ty, /*ByVal=*/false, State);
1794   }
1795
1796   if (isAggregateTypeForABI(Ty)) {
1797     // Structures with flexible arrays are always indirect.
1798     // FIXME: This should not be byval!
1799     if (RT && RT->getDecl()->hasFlexibleArrayMember())
1800       return getIndirectResult(Ty, true, State);
1801
1802     // Ignore empty structs/unions on non-Windows.
1803     if (!IsWin32StructABI && isEmptyRecord(getContext(), Ty, true))
1804       return ABIArgInfo::getIgnore();
1805
1806     llvm::LLVMContext &LLVMContext = getVMContext();
1807     llvm::IntegerType *Int32 = llvm::Type::getInt32Ty(LLVMContext);
1808     bool NeedsPadding = false;
1809     bool InReg;
1810     if (shouldAggregateUseDirect(Ty, State, InReg, NeedsPadding)) {
1811       unsigned SizeInRegs = (TI.Width + 31) / 32;
1812       SmallVector<llvm::Type*, 3> Elements(SizeInRegs, Int32);
1813       llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements);
1814       if (InReg)
1815         return ABIArgInfo::getDirectInReg(Result);
1816       else
1817         return ABIArgInfo::getDirect(Result);
1818     }
1819     llvm::IntegerType *PaddingType = NeedsPadding ? Int32 : nullptr;
1820
1821     // Pass over-aligned aggregates on Windows indirectly. This behavior was
1822     // added in MSVC 2015.
1823     if (IsWin32StructABI && TI.AlignIsRequired && TI.Align > 32)
1824       return getIndirectResult(Ty, /*ByVal=*/false, State);
1825
1826     // Expand small (<= 128-bit) record types when we know that the stack layout
1827     // of those arguments will match the struct. This is important because the
1828     // LLVM backend isn't smart enough to remove byval, which inhibits many
1829     // optimizations.
1830     // Don't do this for the MCU if there are still free integer registers
1831     // (see X86_64 ABI for full explanation).
1832     if (TI.Width <= 4 * 32 && (!IsMCUABI || State.FreeRegs == 0) &&
1833         canExpandIndirectArgument(Ty))
1834       return ABIArgInfo::getExpandWithPadding(
1835           IsFastCall || IsVectorCall || IsRegCall, PaddingType);
1836
1837     return getIndirectResult(Ty, true, State);
1838   }
1839
1840   if (const VectorType *VT = Ty->getAs<VectorType>()) {
1841     // On Windows, vectors are passed directly if registers are available, or
1842     // indirectly if not. This avoids the need to align argument memory. Pass
1843     // user-defined vector types larger than 512 bits indirectly for simplicity.
1844     if (IsWin32StructABI) {
1845       if (TI.Width <= 512 && State.FreeSSERegs > 0) {
1846         --State.FreeSSERegs;
1847         return ABIArgInfo::getDirectInReg();
1848       }
1849       return getIndirectResult(Ty, /*ByVal=*/false, State);
1850     }
1851
1852     // On Darwin, some vectors are passed in memory, we handle this by passing
1853     // it as an i8/i16/i32/i64.
1854     if (IsDarwinVectorABI) {
1855       if ((TI.Width == 8 || TI.Width == 16 || TI.Width == 32) ||
1856           (TI.Width == 64 && VT->getNumElements() == 1))
1857         return ABIArgInfo::getDirect(
1858             llvm::IntegerType::get(getVMContext(), TI.Width));
1859     }
1860
1861     if (IsX86_MMXType(CGT.ConvertType(Ty)))
1862       return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(), 64));
1863
1864     return ABIArgInfo::getDirect();
1865   }
1866
1867
1868   if (const EnumType *EnumTy = Ty->getAs<EnumType>())
1869     Ty = EnumTy->getDecl()->getIntegerType();
1870
1871   bool InReg = shouldPrimitiveUseInReg(Ty, State);
1872
1873   if (isPromotableIntegerTypeForABI(Ty)) {
1874     if (InReg)
1875       return ABIArgInfo::getExtendInReg(Ty);
1876     return ABIArgInfo::getExtend(Ty);
1877   }
1878
1879   if (const auto * EIT = Ty->getAs<ExtIntType>()) {
1880     if (EIT->getNumBits() <= 64) {
1881       if (InReg)
1882         return ABIArgInfo::getDirectInReg();
1883       return ABIArgInfo::getDirect();
1884     }
1885     return getIndirectResult(Ty, /*ByVal=*/false, State);
1886   }
1887
1888   if (InReg)
1889     return ABIArgInfo::getDirectInReg();
1890   return ABIArgInfo::getDirect();
1891 }
1892
1893 void X86_32ABIInfo::computeInfo(CGFunctionInfo &FI) const {
1894   CCState State(FI);
1895   if (IsMCUABI)
1896     State.FreeRegs = 3;
1897   else if (State.CC == llvm::CallingConv::X86_FastCall) {
1898     State.FreeRegs = 2;
1899     State.FreeSSERegs = 3;
1900   } else if (State.CC == llvm::CallingConv::X86_VectorCall) {
1901     State.FreeRegs = 2;
1902     State.FreeSSERegs = 6;
1903   } else if (FI.getHasRegParm())
1904     State.FreeRegs = FI.getRegParm();
1905   else if (State.CC == llvm::CallingConv::X86_RegCall) {
1906     State.FreeRegs = 5;
1907     State.FreeSSERegs = 8;
1908   } else if (IsWin32StructABI) {
1909     // Since MSVC 2015, the first three SSE vectors have been passed in
1910     // registers. The rest are passed indirectly.
1911     State.FreeRegs = DefaultNumRegisterParameters;
1912     State.FreeSSERegs = 3;
1913   } else
1914     State.FreeRegs = DefaultNumRegisterParameters;
1915
1916   if (!::classifyReturnType(getCXXABI(), FI, *this)) {
1917     FI.getReturnInfo() = classifyReturnType(FI.getReturnType(), State);
1918   } else if (FI.getReturnInfo().isIndirect()) {
1919     // The C++ ABI is not aware of register usage, so we have to check if the
1920     // return value was sret and put it in a register ourselves if appropriate.
1921     if (State.FreeRegs) {
1922       --State.FreeRegs;  // The sret parameter consumes a register.
1923       if (!IsMCUABI)
1924         FI.getReturnInfo().setInReg(true);
1925     }
1926   }
1927
1928   // The chain argument effectively gives us another free register.
1929   if (FI.isChainCall())
1930     ++State.FreeRegs;
1931
1932   // For vectorcall, do a first pass over the arguments, assigning FP and vector
1933   // arguments to XMM registers as available.
1934   if (State.CC == llvm::CallingConv::X86_VectorCall)
1935     runVectorCallFirstPass(FI, State);
1936
1937   bool UsedInAlloca = false;
1938   MutableArrayRef<CGFunctionInfoArgInfo> Args = FI.arguments();
1939   for (int I = 0, E = Args.size(); I < E; ++I) {
1940     // Skip arguments that have already been assigned.
1941     if (State.IsPreassigned.test(I))
1942       continue;
1943
1944     Args[I].info = classifyArgumentType(Args[I].type, State);
1945     UsedInAlloca |= (Args[I].info.getKind() == ABIArgInfo::InAlloca);
1946   }
1947
1948   // If we needed to use inalloca for any argument, do a second pass and rewrite
1949   // all the memory arguments to use inalloca.
1950   if (UsedInAlloca)
1951     rewriteWithInAlloca(FI);
1952 }
1953
1954 void
1955 X86_32ABIInfo::addFieldToArgStruct(SmallVector<llvm::Type *, 6> &FrameFields,
1956                                    CharUnits &StackOffset, ABIArgInfo &Info,
1957                                    QualType Type) const {
1958   // Arguments are always 4-byte-aligned.
1959   CharUnits WordSize = CharUnits::fromQuantity(4);
1960   assert(StackOffset.isMultipleOf(WordSize) && "unaligned inalloca struct");
1961
1962   // sret pointers and indirect things will require an extra pointer
1963   // indirection, unless they are byval. Most things are byval, and will not
1964   // require this indirection.
1965   bool IsIndirect = false;
1966   if (Info.isIndirect() && !Info.getIndirectByVal())
1967     IsIndirect = true;
1968   Info = ABIArgInfo::getInAlloca(FrameFields.size(), IsIndirect);
1969   llvm::Type *LLTy = CGT.ConvertTypeForMem(Type);
1970   if (IsIndirect)
1971     LLTy = LLTy->getPointerTo(0);
1972   FrameFields.push_back(LLTy);
1973   StackOffset += IsIndirect ? WordSize : getContext().getTypeSizeInChars(Type);
1974
1975   // Insert padding bytes to respect alignment.
1976   CharUnits FieldEnd = StackOffset;
1977   StackOffset = FieldEnd.alignTo(WordSize);
1978   if (StackOffset != FieldEnd) {
1979     CharUnits NumBytes = StackOffset - FieldEnd;
1980     llvm::Type *Ty = llvm::Type::getInt8Ty(getVMContext());
1981     Ty = llvm::ArrayType::get(Ty, NumBytes.getQuantity());
1982     FrameFields.push_back(Ty);
1983   }
1984 }
1985
1986 static bool isArgInAlloca(const ABIArgInfo &Info) {
1987   // Leave ignored and inreg arguments alone.
1988   switch (Info.getKind()) {
1989   case ABIArgInfo::InAlloca:
1990     return true;
1991   case ABIArgInfo::Ignore:
1992   case ABIArgInfo::IndirectAliased:
1993     return false;
1994   case ABIArgInfo::Indirect:
1995   case ABIArgInfo::Direct:
1996   case ABIArgInfo::Extend:
1997     return !Info.getInReg();
1998   case ABIArgInfo::Expand:
1999   case ABIArgInfo::CoerceAndExpand:
2000     // These are aggregate types which are never passed in registers when
2001     // inalloca is involved.
2002     return true;
2003   }
2004   llvm_unreachable("invalid enum");
2005 }
2006
2007 void X86_32ABIInfo::rewriteWithInAlloca(CGFunctionInfo &FI) const {
2008   assert(IsWin32StructABI && "inalloca only supported on win32");
2009
2010   // Build a packed struct type for all of the arguments in memory.
2011   SmallVector<llvm::Type *, 6> FrameFields;
2012
2013   // The stack alignment is always 4.
2014   CharUnits StackAlign = CharUnits::fromQuantity(4);
2015
2016   CharUnits StackOffset;
2017   CGFunctionInfo::arg_iterator I = FI.arg_begin(), E = FI.arg_end();
2018
2019   // Put 'this' into the struct before 'sret', if necessary.
2020   bool IsThisCall =
2021       FI.getCallingConvention() == llvm::CallingConv::X86_ThisCall;
2022   ABIArgInfo &Ret = FI.getReturnInfo();
2023   if (Ret.isIndirect() && Ret.isSRetAfterThis() && !IsThisCall &&
2024       isArgInAlloca(I->info)) {
2025     addFieldToArgStruct(FrameFields, StackOffset, I->info, I->type);
2026     ++I;
2027   }
2028
2029   // Put the sret parameter into the inalloca struct if it's in memory.
2030   if (Ret.isIndirect() && !Ret.getInReg()) {
2031     addFieldToArgStruct(FrameFields, StackOffset, Ret, FI.getReturnType());
2032     // On Windows, the hidden sret parameter is always returned in eax.
2033     Ret.setInAllocaSRet(IsWin32StructABI);
2034   }
2035
2036   // Skip the 'this' parameter in ecx.
2037   if (IsThisCall)
2038     ++I;
2039
2040   // Put arguments passed in memory into the struct.
2041   for (; I != E; ++I) {
2042     if (isArgInAlloca(I->info))
2043       addFieldToArgStruct(FrameFields, StackOffset, I->info, I->type);
2044   }
2045
2046   FI.setArgStruct(llvm::StructType::get(getVMContext(), FrameFields,
2047                                         /*isPacked=*/true),
2048                   StackAlign);
2049 }
2050
2051 Address X86_32ABIInfo::EmitVAArg(CodeGenFunction &CGF,
2052                                  Address VAListAddr, QualType Ty) const {
2053
2054   auto TypeInfo = getContext().getTypeInfoInChars(Ty);
2055
2056   // x86-32 changes the alignment of certain arguments on the stack.
2057   //
2058   // Just messing with TypeInfo like this works because we never pass
2059   // anything indirectly.
2060   TypeInfo.Align = CharUnits::fromQuantity(
2061                 getTypeStackAlignInBytes(Ty, TypeInfo.Align.getQuantity()));
2062
2063   return emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*Indirect*/ false,
2064                           TypeInfo, CharUnits::fromQuantity(4),
2065                           /*AllowHigherAlign*/ true);
2066 }
2067
2068 bool X86_32TargetCodeGenInfo::isStructReturnInRegABI(
2069     const llvm::Triple &Triple, const CodeGenOptions &Opts) {
2070   assert(Triple.getArch() == llvm::Triple::x86);
2071
2072   switch (Opts.getStructReturnConvention()) {
2073   case CodeGenOptions::SRCK_Default:
2074     break;
2075   case CodeGenOptions::SRCK_OnStack:  // -fpcc-struct-return
2076     return false;
2077   case CodeGenOptions::SRCK_InRegs:  // -freg-struct-return
2078     return true;
2079   }
2080
2081   if (Triple.isOSDarwin() || Triple.isOSIAMCU())
2082     return true;
2083
2084   switch (Triple.getOS()) {
2085   case llvm::Triple::DragonFly:
2086   case llvm::Triple::FreeBSD:
2087   case llvm::Triple::OpenBSD:
2088   case llvm::Triple::Win32:
2089     return true;
2090   default:
2091     return false;
2092   }
2093 }
2094
2095 static void addX86InterruptAttrs(const FunctionDecl *FD, llvm::GlobalValue *GV,
2096                                  CodeGen::CodeGenModule &CGM) {
2097   if (!FD->hasAttr<AnyX86InterruptAttr>())
2098     return;
2099
2100   llvm::Function *Fn = cast<llvm::Function>(GV);
2101   Fn->setCallingConv(llvm::CallingConv::X86_INTR);
2102   if (FD->getNumParams() == 0)
2103     return;
2104
2105   auto PtrTy = cast<PointerType>(FD->getParamDecl(0)->getType());
2106   llvm::Type *ByValTy = CGM.getTypes().ConvertType(PtrTy->getPointeeType());
2107   llvm::Attribute NewAttr = llvm::Attribute::getWithByValType(
2108     Fn->getContext(), ByValTy);
2109   Fn->addParamAttr(0, NewAttr);
2110 }
2111
2112 void X86_32TargetCodeGenInfo::setTargetAttributes(
2113     const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM) const {
2114   if (GV->isDeclaration())
2115     return;
2116   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
2117     if (FD->hasAttr<X86ForceAlignArgPointerAttr>()) {
2118       llvm::Function *Fn = cast<llvm::Function>(GV);
2119       Fn->addFnAttr("stackrealign");
2120     }
2121
2122     addX86InterruptAttrs(FD, GV, CGM);
2123   }
2124 }
2125
2126 bool X86_32TargetCodeGenInfo::initDwarfEHRegSizeTable(
2127                                                CodeGen::CodeGenFunction &CGF,
2128                                                llvm::Value *Address) const {
2129   CodeGen::CGBuilderTy &Builder = CGF.Builder;
2130
2131   llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
2132
2133   // 0-7 are the eight integer registers;  the order is different
2134   //   on Darwin (for EH), but the range is the same.
2135   // 8 is %eip.
2136   AssignToArrayRange(Builder, Address, Four8, 0, 8);
2137
2138   if (CGF.CGM.getTarget().getTriple().isOSDarwin()) {
2139     // 12-16 are st(0..4).  Not sure why we stop at 4.
2140     // These have size 16, which is sizeof(long double) on
2141     // platforms with 8-byte alignment for that type.
2142     llvm::Value *Sixteen8 = llvm::ConstantInt::get(CGF.Int8Ty, 16);
2143     AssignToArrayRange(Builder, Address, Sixteen8, 12, 16);
2144
2145   } else {
2146     // 9 is %eflags, which doesn't get a size on Darwin for some
2147     // reason.
2148     Builder.CreateAlignedStore(
2149         Four8, Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, Address, 9),
2150                                CharUnits::One());
2151
2152     // 11-16 are st(0..5).  Not sure why we stop at 5.
2153     // These have size 12, which is sizeof(long double) on
2154     // platforms with 4-byte alignment for that type.
2155     llvm::Value *Twelve8 = llvm::ConstantInt::get(CGF.Int8Ty, 12);
2156     AssignToArrayRange(Builder, Address, Twelve8, 11, 16);
2157   }
2158
2159   return false;
2160 }
2161
2162 //===----------------------------------------------------------------------===//
2163 // X86-64 ABI Implementation
2164 //===----------------------------------------------------------------------===//
2165
2166
2167 namespace {
2168 /// The AVX ABI level for X86 targets.
2169 enum class X86AVXABILevel {
2170   None,
2171   AVX,
2172   AVX512
2173 };
2174
2175 /// \p returns the size in bits of the largest (native) vector for \p AVXLevel.
2176 static unsigned getNativeVectorSizeForAVXABI(X86AVXABILevel AVXLevel) {
2177   switch (AVXLevel) {
2178   case X86AVXABILevel::AVX512:
2179     return 512;
2180   case X86AVXABILevel::AVX:
2181     return 256;
2182   case X86AVXABILevel::None:
2183     return 128;
2184   }
2185   llvm_unreachable("Unknown AVXLevel");
2186 }
2187
2188 /// X86_64ABIInfo - The X86_64 ABI information.
2189 class X86_64ABIInfo : public SwiftABIInfo {
2190   enum Class {
2191     Integer = 0,
2192     SSE,
2193     SSEUp,
2194     X87,
2195     X87Up,
2196     ComplexX87,
2197     NoClass,
2198     Memory
2199   };
2200
2201   /// merge - Implement the X86_64 ABI merging algorithm.
2202   ///
2203   /// Merge an accumulating classification \arg Accum with a field
2204   /// classification \arg Field.
2205   ///
2206   /// \param Accum - The accumulating classification. This should
2207   /// always be either NoClass or the result of a previous merge
2208   /// call. In addition, this should never be Memory (the caller
2209   /// should just return Memory for the aggregate).
2210   static Class merge(Class Accum, Class Field);
2211
2212   /// postMerge - Implement the X86_64 ABI post merging algorithm.
2213   ///
2214   /// Post merger cleanup, reduces a malformed Hi and Lo pair to
2215   /// final MEMORY or SSE classes when necessary.
2216   ///
2217   /// \param AggregateSize - The size of the current aggregate in
2218   /// the classification process.
2219   ///
2220   /// \param Lo - The classification for the parts of the type
2221   /// residing in the low word of the containing object.
2222   ///
2223   /// \param Hi - The classification for the parts of the type
2224   /// residing in the higher words of the containing object.
2225   ///
2226   void postMerge(unsigned AggregateSize, Class &Lo, Class &Hi) const;
2227
2228   /// classify - Determine the x86_64 register classes in which the
2229   /// given type T should be passed.
2230   ///
2231   /// \param Lo - The classification for the parts of the type
2232   /// residing in the low word of the containing object.
2233   ///
2234   /// \param Hi - The classification for the parts of the type
2235   /// residing in the high word of the containing object.
2236   ///
2237   /// \param OffsetBase - The bit offset of this type in the
2238   /// containing object.  Some parameters are classified different
2239   /// depending on whether they straddle an eightbyte boundary.
2240   ///
2241   /// \param isNamedArg - Whether the argument in question is a "named"
2242   /// argument, as used in AMD64-ABI 3.5.7.
2243   ///
2244   /// If a word is unused its result will be NoClass; if a type should
2245   /// be passed in Memory then at least the classification of \arg Lo
2246   /// will be Memory.
2247   ///
2248   /// The \arg Lo class will be NoClass iff the argument is ignored.
2249   ///
2250   /// If the \arg Lo class is ComplexX87, then the \arg Hi class will
2251   /// also be ComplexX87.
2252   void classify(QualType T, uint64_t OffsetBase, Class &Lo, Class &Hi,
2253                 bool isNamedArg) const;
2254
2255   llvm::Type *GetByteVectorType(QualType Ty) const;
2256   llvm::Type *GetSSETypeAtOffset(llvm::Type *IRType,
2257                                  unsigned IROffset, QualType SourceTy,
2258                                  unsigned SourceOffset) const;
2259   llvm::Type *GetINTEGERTypeAtOffset(llvm::Type *IRType,
2260                                      unsigned IROffset, QualType SourceTy,
2261                                      unsigned SourceOffset) const;
2262
2263   /// getIndirectResult - Give a source type \arg Ty, return a suitable result
2264   /// such that the argument will be returned in memory.
2265   ABIArgInfo getIndirectReturnResult(QualType Ty) const;
2266
2267   /// getIndirectResult - Give a source type \arg Ty, return a suitable result
2268   /// such that the argument will be passed in memory.
2269   ///
2270   /// \param freeIntRegs - The number of free integer registers remaining
2271   /// available.
2272   ABIArgInfo getIndirectResult(QualType Ty, unsigned freeIntRegs) const;
2273
2274   ABIArgInfo classifyReturnType(QualType RetTy) const;
2275
2276   ABIArgInfo classifyArgumentType(QualType Ty, unsigned freeIntRegs,
2277                                   unsigned &neededInt, unsigned &neededSSE,
2278                                   bool isNamedArg) const;
2279
2280   ABIArgInfo classifyRegCallStructType(QualType Ty, unsigned &NeededInt,
2281                                        unsigned &NeededSSE) const;
2282
2283   ABIArgInfo classifyRegCallStructTypeImpl(QualType Ty, unsigned &NeededInt,
2284                                            unsigned &NeededSSE) const;
2285
2286   bool IsIllegalVectorType(QualType Ty) const;
2287
2288   /// The 0.98 ABI revision clarified a lot of ambiguities,
2289   /// unfortunately in ways that were not always consistent with
2290   /// certain previous compilers.  In particular, platforms which
2291   /// required strict binary compatibility with older versions of GCC
2292   /// may need to exempt themselves.
2293   bool honorsRevision0_98() const {
2294     return !getTarget().getTriple().isOSDarwin();
2295   }
2296
2297   /// GCC classifies <1 x long long> as SSE but some platform ABIs choose to
2298   /// classify it as INTEGER (for compatibility with older clang compilers).
2299   bool classifyIntegerMMXAsSSE() const {
2300     // Clang <= 3.8 did not do this.
2301     if (getContext().getLangOpts().getClangABICompat() <=
2302         LangOptions::ClangABI::Ver3_8)
2303       return false;
2304
2305     const llvm::Triple &Triple = getTarget().getTriple();
2306     if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::PS4)
2307       return false;
2308     if (Triple.isOSFreeBSD() && Triple.getOSMajorVersion() >= 10)
2309       return false;
2310     return true;
2311   }
2312
2313   // GCC classifies vectors of __int128 as memory.
2314   bool passInt128VectorsInMem() const {
2315     // Clang <= 9.0 did not do this.
2316     if (getContext().getLangOpts().getClangABICompat() <=
2317         LangOptions::ClangABI::Ver9)
2318       return false;
2319
2320     const llvm::Triple &T = getTarget().getTriple();
2321     return T.isOSLinux() || T.isOSNetBSD();
2322   }
2323
2324   X86AVXABILevel AVXLevel;
2325   // Some ABIs (e.g. X32 ABI and Native Client OS) use 32 bit pointers on
2326   // 64-bit hardware.
2327   bool Has64BitPointers;
2328
2329 public:
2330   X86_64ABIInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel) :
2331       SwiftABIInfo(CGT), AVXLevel(AVXLevel),
2332       Has64BitPointers(CGT.getDataLayout().getPointerSize(0) == 8) {
2333   }
2334
2335   bool isPassedUsingAVXType(QualType type) const {
2336     unsigned neededInt, neededSSE;
2337     // The freeIntRegs argument doesn't matter here.
2338     ABIArgInfo info = classifyArgumentType(type, 0, neededInt, neededSSE,
2339                                            /*isNamedArg*/true);
2340     if (info.isDirect()) {
2341       llvm::Type *ty = info.getCoerceToType();
2342       if (llvm::VectorType *vectorTy = dyn_cast_or_null<llvm::VectorType>(ty))
2343         return vectorTy->getPrimitiveSizeInBits().getFixedSize() > 128;
2344     }
2345     return false;
2346   }
2347
2348   void computeInfo(CGFunctionInfo &FI) const override;
2349
2350   Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
2351                     QualType Ty) const override;
2352   Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
2353                       QualType Ty) const override;
2354
2355   bool has64BitPointers() const {
2356     return Has64BitPointers;
2357   }
2358
2359   bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
2360                                     bool asReturnValue) const override {
2361     return occupiesMoreThan(CGT, scalars, /*total*/ 4);
2362   }
2363   bool isSwiftErrorInRegister() const override {
2364     return true;
2365   }
2366 };
2367
2368 /// WinX86_64ABIInfo - The Windows X86_64 ABI information.
2369 class WinX86_64ABIInfo : public SwiftABIInfo {
2370 public:
2371   WinX86_64ABIInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel)
2372       : SwiftABIInfo(CGT), AVXLevel(AVXLevel),
2373         IsMingw64(getTarget().getTriple().isWindowsGNUEnvironment()) {}
2374
2375   void computeInfo(CGFunctionInfo &FI) const override;
2376
2377   Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
2378                     QualType Ty) const override;
2379
2380   bool isHomogeneousAggregateBaseType(QualType Ty) const override {
2381     // FIXME: Assumes vectorcall is in use.
2382     return isX86VectorTypeForVectorCall(getContext(), Ty);
2383   }
2384
2385   bool isHomogeneousAggregateSmallEnough(const Type *Ty,
2386                                          uint64_t NumMembers) const override {
2387     // FIXME: Assumes vectorcall is in use.
2388     return isX86VectorCallAggregateSmallEnough(NumMembers);
2389   }
2390
2391   bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type *> scalars,
2392                                     bool asReturnValue) const override {
2393     return occupiesMoreThan(CGT, scalars, /*total*/ 4);
2394   }
2395
2396   bool isSwiftErrorInRegister() const override {
2397     return true;
2398   }
2399
2400 private:
2401   ABIArgInfo classify(QualType Ty, unsigned &FreeSSERegs, bool IsReturnType,
2402                       bool IsVectorCall, bool IsRegCall) const;
2403   ABIArgInfo reclassifyHvaArgForVectorCall(QualType Ty, unsigned &FreeSSERegs,
2404                                            const ABIArgInfo &current) const;
2405
2406   X86AVXABILevel AVXLevel;
2407
2408   bool IsMingw64;
2409 };
2410
2411 class X86_64TargetCodeGenInfo : public TargetCodeGenInfo {
2412 public:
2413   X86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel)
2414       : TargetCodeGenInfo(std::make_unique<X86_64ABIInfo>(CGT, AVXLevel)) {}
2415
2416   const X86_64ABIInfo &getABIInfo() const {
2417     return static_cast<const X86_64ABIInfo&>(TargetCodeGenInfo::getABIInfo());
2418   }
2419
2420   /// Disable tail call on x86-64. The epilogue code before the tail jump blocks
2421   /// autoreleaseRV/retainRV and autoreleaseRV/unsafeClaimRV optimizations.
2422   bool markARCOptimizedReturnCallsAsNoTail() const override { return true; }
2423
2424   int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
2425     return 7;
2426   }
2427
2428   bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2429                                llvm::Value *Address) const override {
2430     llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
2431
2432     // 0-15 are the 16 integer registers.
2433     // 16 is %rip.
2434     AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
2435     return false;
2436   }
2437
2438   llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
2439                                   StringRef Constraint,
2440                                   llvm::Type* Ty) const override {
2441     return X86AdjustInlineAsmType(CGF, Constraint, Ty);
2442   }
2443
2444   bool isNoProtoCallVariadic(const CallArgList &args,
2445                              const FunctionNoProtoType *fnType) const override {
2446     // The default CC on x86-64 sets %al to the number of SSA
2447     // registers used, and GCC sets this when calling an unprototyped
2448     // function, so we override the default behavior.  However, don't do
2449     // that when AVX types are involved: the ABI explicitly states it is
2450     // undefined, and it doesn't work in practice because of how the ABI
2451     // defines varargs anyway.
2452     if (fnType->getCallConv() == CC_C) {
2453       bool HasAVXType = false;
2454       for (CallArgList::const_iterator
2455              it = args.begin(), ie = args.end(); it != ie; ++it) {
2456         if (getABIInfo().isPassedUsingAVXType(it->Ty)) {
2457           HasAVXType = true;
2458           break;
2459         }
2460       }
2461
2462       if (!HasAVXType)
2463         return true;
2464     }
2465
2466     return TargetCodeGenInfo::isNoProtoCallVariadic(args, fnType);
2467   }
2468
2469   llvm::Constant *
2470   getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const override {
2471     unsigned Sig = (0xeb << 0) | // jmp rel8
2472                    (0x06 << 8) | //           .+0x08
2473                    ('v' << 16) |
2474                    ('2' << 24);
2475     return llvm::ConstantInt::get(CGM.Int32Ty, Sig);
2476   }
2477
2478   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
2479                            CodeGen::CodeGenModule &CGM) const override {
2480     if (GV->isDeclaration())
2481       return;
2482     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
2483       if (FD->hasAttr<X86ForceAlignArgPointerAttr>()) {
2484         llvm::Function *Fn = cast<llvm::Function>(GV);
2485         Fn->addFnAttr("stackrealign");
2486       }
2487
2488       addX86InterruptAttrs(FD, GV, CGM);
2489     }
2490   }
2491
2492   void checkFunctionCallABI(CodeGenModule &CGM, SourceLocation CallLoc,
2493                             const FunctionDecl *Caller,
2494                             const FunctionDecl *Callee,
2495                             const CallArgList &Args) const override;
2496 };
2497
2498 static void initFeatureMaps(const ASTContext &Ctx,
2499                             llvm::StringMap<bool> &CallerMap,
2500                             const FunctionDecl *Caller,
2501                             llvm::StringMap<bool> &CalleeMap,
2502                             const FunctionDecl *Callee) {
2503   if (CalleeMap.empty() && CallerMap.empty()) {
2504     // The caller is potentially nullptr in the case where the call isn't in a
2505     // function.  In this case, the getFunctionFeatureMap ensures we just get
2506     // the TU level setting (since it cannot be modified by 'target'..
2507     Ctx.getFunctionFeatureMap(CallerMap, Caller);
2508     Ctx.getFunctionFeatureMap(CalleeMap, Callee);
2509   }
2510 }
2511
2512 static bool checkAVXParamFeature(DiagnosticsEngine &Diag,
2513                                  SourceLocation CallLoc,
2514                                  const llvm::StringMap<bool> &CallerMap,
2515                                  const llvm::StringMap<bool> &CalleeMap,
2516                                  QualType Ty, StringRef Feature,
2517                                  bool IsArgument) {
2518   bool CallerHasFeat = CallerMap.lookup(Feature);
2519   bool CalleeHasFeat = CalleeMap.lookup(Feature);
2520   if (!CallerHasFeat && !CalleeHasFeat)
2521     return Diag.Report(CallLoc, diag::warn_avx_calling_convention)
2522            << IsArgument << Ty << Feature;
2523
2524   // Mixing calling conventions here is very clearly an error.
2525   if (!CallerHasFeat || !CalleeHasFeat)
2526     return Diag.Report(CallLoc, diag::err_avx_calling_convention)
2527            << IsArgument << Ty << Feature;
2528
2529   // Else, both caller and callee have the required feature, so there is no need
2530   // to diagnose.
2531   return false;
2532 }
2533
2534 static bool checkAVXParam(DiagnosticsEngine &Diag, ASTContext &Ctx,
2535                           SourceLocation CallLoc,
2536                           const llvm::StringMap<bool> &CallerMap,
2537                           const llvm::StringMap<bool> &CalleeMap, QualType Ty,
2538                           bool IsArgument) {
2539   uint64_t Size = Ctx.getTypeSize(Ty);
2540   if (Size > 256)
2541     return checkAVXParamFeature(Diag, CallLoc, CallerMap, CalleeMap, Ty,
2542                                 "avx512f", IsArgument);
2543
2544   if (Size > 128)
2545     return checkAVXParamFeature(Diag, CallLoc, CallerMap, CalleeMap, Ty, "avx",
2546                                 IsArgument);
2547
2548   return false;
2549 }
2550
2551 void X86_64TargetCodeGenInfo::checkFunctionCallABI(
2552     CodeGenModule &CGM, SourceLocation CallLoc, const FunctionDecl *Caller,
2553     const FunctionDecl *Callee, const CallArgList &Args) const {
2554   llvm::StringMap<bool> CallerMap;
2555   llvm::StringMap<bool> CalleeMap;
2556   unsigned ArgIndex = 0;
2557
2558   // We need to loop through the actual call arguments rather than the the
2559   // function's parameters, in case this variadic.
2560   for (const CallArg &Arg : Args) {
2561     // The "avx" feature changes how vectors >128 in size are passed. "avx512f"
2562     // additionally changes how vectors >256 in size are passed. Like GCC, we
2563     // warn when a function is called with an argument where this will change.
2564     // Unlike GCC, we also error when it is an obvious ABI mismatch, that is,
2565     // the caller and callee features are mismatched.
2566     // Unfortunately, we cannot do this diagnostic in SEMA, since the callee can
2567     // change its ABI with attribute-target after this call.
2568     if (Arg.getType()->isVectorType() &&
2569         CGM.getContext().getTypeSize(Arg.getType()) > 128) {
2570       initFeatureMaps(CGM.getContext(), CallerMap, Caller, CalleeMap, Callee);
2571       QualType Ty = Arg.getType();
2572       // The CallArg seems to have desugared the type already, so for clearer
2573       // diagnostics, replace it with the type in the FunctionDecl if possible.
2574       if (ArgIndex < Callee->getNumParams())
2575         Ty = Callee->getParamDecl(ArgIndex)->getType();
2576
2577       if (checkAVXParam(CGM.getDiags(), CGM.getContext(), CallLoc, CallerMap,
2578                         CalleeMap, Ty, /*IsArgument*/ true))
2579         return;
2580     }
2581     ++ArgIndex;
2582   }
2583
2584   // Check return always, as we don't have a good way of knowing in codegen
2585   // whether this value is used, tail-called, etc.
2586   if (Callee->getReturnType()->isVectorType() &&
2587       CGM.getContext().getTypeSize(Callee->getReturnType()) > 128) {
2588     initFeatureMaps(CGM.getContext(), CallerMap, Caller, CalleeMap, Callee);
2589     checkAVXParam(CGM.getDiags(), CGM.getContext(), CallLoc, CallerMap,
2590                   CalleeMap, Callee->getReturnType(),
2591                   /*IsArgument*/ false);
2592   }
2593 }
2594
2595 static std::string qualifyWindowsLibrary(llvm::StringRef Lib) {
2596   // If the argument does not end in .lib, automatically add the suffix.
2597   // If the argument contains a space, enclose it in quotes.
2598   // This matches the behavior of MSVC.
2599   bool Quote = (Lib.find(' ') != StringRef::npos);
2600   std::string ArgStr = Quote ? "\"" : "";
2601   ArgStr += Lib;
2602   if (!Lib.endswith_lower(".lib") && !Lib.endswith_lower(".a"))
2603     ArgStr += ".lib";
2604   ArgStr += Quote ? "\"" : "";
2605   return ArgStr;
2606 }
2607
2608 class WinX86_32TargetCodeGenInfo : public X86_32TargetCodeGenInfo {
2609 public:
2610   WinX86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,
2611         bool DarwinVectorABI, bool RetSmallStructInRegABI, bool Win32StructABI,
2612         unsigned NumRegisterParameters)
2613     : X86_32TargetCodeGenInfo(CGT, DarwinVectorABI, RetSmallStructInRegABI,
2614         Win32StructABI, NumRegisterParameters, false) {}
2615
2616   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
2617                            CodeGen::CodeGenModule &CGM) const override;
2618
2619   void getDependentLibraryOption(llvm::StringRef Lib,
2620                                  llvm::SmallString<24> &Opt) const override {
2621     Opt = "/DEFAULTLIB:";
2622     Opt += qualifyWindowsLibrary(Lib);
2623   }
2624
2625   void getDetectMismatchOption(llvm::StringRef Name,
2626                                llvm::StringRef Value,
2627                                llvm::SmallString<32> &Opt) const override {
2628     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
2629   }
2630 };
2631
2632 static void addStackProbeTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
2633                                           CodeGen::CodeGenModule &CGM) {
2634   if (llvm::Function *Fn = dyn_cast_or_null<llvm::Function>(GV)) {
2635
2636     if (CGM.getCodeGenOpts().StackProbeSize != 4096)
2637       Fn->addFnAttr("stack-probe-size",
2638                     llvm::utostr(CGM.getCodeGenOpts().StackProbeSize));
2639     if (CGM.getCodeGenOpts().NoStackArgProbe)
2640       Fn->addFnAttr("no-stack-arg-probe");
2641   }
2642 }
2643
2644 void WinX86_32TargetCodeGenInfo::setTargetAttributes(
2645     const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM) const {
2646   X86_32TargetCodeGenInfo::setTargetAttributes(D, GV, CGM);
2647   if (GV->isDeclaration())
2648     return;
2649   addStackProbeTargetAttributes(D, GV, CGM);
2650 }
2651
2652 class WinX86_64TargetCodeGenInfo : public TargetCodeGenInfo {
2653 public:
2654   WinX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,
2655                              X86AVXABILevel AVXLevel)
2656       : TargetCodeGenInfo(std::make_unique<WinX86_64ABIInfo>(CGT, AVXLevel)) {}
2657
2658   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
2659                            CodeGen::CodeGenModule &CGM) const override;
2660
2661   int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
2662     return 7;
2663   }
2664
2665   bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2666                                llvm::Value *Address) const override {
2667     llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
2668
2669     // 0-15 are the 16 integer registers.
2670     // 16 is %rip.
2671     AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
2672     return false;
2673   }
2674
2675   void getDependentLibraryOption(llvm::StringRef Lib,
2676                                  llvm::SmallString<24> &Opt) const override {
2677     Opt = "/DEFAULTLIB:";
2678     Opt += qualifyWindowsLibrary(Lib);
2679   }
2680
2681   void getDetectMismatchOption(llvm::StringRef Name,
2682                                llvm::StringRef Value,
2683                                llvm::SmallString<32> &Opt) const override {
2684     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
2685   }
2686 };
2687
2688 void WinX86_64TargetCodeGenInfo::setTargetAttributes(
2689     const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM) const {
2690   TargetCodeGenInfo::setTargetAttributes(D, GV, CGM);
2691   if (GV->isDeclaration())
2692     return;
2693   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
2694     if (FD->hasAttr<X86ForceAlignArgPointerAttr>()) {
2695       llvm::Function *Fn = cast<llvm::Function>(GV);
2696       Fn->addFnAttr("stackrealign");
2697     }
2698
2699     addX86InterruptAttrs(FD, GV, CGM);
2700   }
2701
2702   addStackProbeTargetAttributes(D, GV, CGM);
2703 }
2704 }
2705
2706 void X86_64ABIInfo::postMerge(unsigned AggregateSize, Class &Lo,
2707                               Class &Hi) const {
2708   // AMD64-ABI 3.2.3p2: Rule 5. Then a post merger cleanup is done:
2709   //
2710   // (a) If one of the classes is Memory, the whole argument is passed in
2711   //     memory.
2712   //
2713   // (b) If X87UP is not preceded by X87, the whole argument is passed in
2714   //     memory.
2715   //
2716   // (c) If the size of the aggregate exceeds two eightbytes and the first
2717   //     eightbyte isn't SSE or any other eightbyte isn't SSEUP, the whole
2718   //     argument is passed in memory. NOTE: This is necessary to keep the
2719   //     ABI working for processors that don't support the __m256 type.
2720   //
2721   // (d) If SSEUP is not preceded by SSE or SSEUP, it is converted to SSE.
2722   //
2723   // Some of these are enforced by the merging logic.  Others can arise
2724   // only with unions; for example:
2725   //   union { _Complex double; unsigned; }
2726   //
2727   // Note that clauses (b) and (c) were added in 0.98.
2728   //
2729   if (Hi == Memory)
2730     Lo = Memory;
2731   if (Hi == X87Up && Lo != X87 && honorsRevision0_98())
2732     Lo = Memory;
2733   if (AggregateSize > 128 && (Lo != SSE || Hi != SSEUp))
2734     Lo = Memory;
2735   if (Hi == SSEUp && Lo != SSE)
2736     Hi = SSE;
2737 }
2738
2739 X86_64ABIInfo::Class X86_64ABIInfo::merge(Class Accum, Class Field) {
2740   // AMD64-ABI 3.2.3p2: Rule 4. Each field of an object is
2741   // classified recursively so that always two fields are
2742   // considered. The resulting class is calculated according to
2743   // the classes of the fields in the eightbyte:
2744   //
2745   // (a) If both classes are equal, this is the resulting class.
2746   //
2747   // (b) If one of the classes is NO_CLASS, the resulting class is
2748   // the other class.
2749   //
2750   // (c) If one of the classes is MEMORY, the result is the MEMORY
2751   // class.
2752   //
2753   // (d) If one of the classes is INTEGER, the result is the
2754   // INTEGER.
2755   //
2756   // (e) If one of the classes is X87, X87UP, COMPLEX_X87 class,
2757   // MEMORY is used as class.
2758   //
2759   // (f) Otherwise class SSE is used.
2760
2761   // Accum should never be memory (we should have returned) or
2762   // ComplexX87 (because this cannot be passed in a structure).
2763   assert((Accum != Memory && Accum != ComplexX87) &&
2764          "Invalid accumulated classification during merge.");
2765   if (Accum == Field || Field == NoClass)
2766     return Accum;
2767   if (Field == Memory)
2768     return Memory;
2769   if (Accum == NoClass)
2770     return Field;
2771   if (Accum == Integer || Field == Integer)
2772     return Integer;
2773   if (Field == X87 || Field == X87Up || Field == ComplexX87 ||
2774       Accum == X87 || Accum == X87Up)
2775     return Memory;
2776   return SSE;
2777 }
2778
2779 void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase,
2780                              Class &Lo, Class &Hi, bool isNamedArg) const {
2781   // FIXME: This code can be simplified by introducing a simple value class for
2782   // Class pairs with appropriate constructor methods for the various
2783   // situations.
2784
2785   // FIXME: Some of the split computations are wrong; unaligned vectors
2786   // shouldn't be passed in registers for example, so there is no chance they
2787   // can straddle an eightbyte. Verify & simplify.
2788
2789   Lo = Hi = NoClass;
2790
2791   Class &Current = OffsetBase < 64 ? Lo : Hi;
2792   Current = Memory;
2793
2794   if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
2795     BuiltinType::Kind k = BT->getKind();
2796
2797     if (k == BuiltinType::Void) {
2798       Current = NoClass;
2799     } else if (k == BuiltinType::Int128 || k == BuiltinType::UInt128) {
2800       Lo = Integer;
2801       Hi = Integer;
2802     } else if (k >= BuiltinType::Bool && k <= BuiltinType::LongLong) {
2803       Current = Integer;
2804     } else if (k == BuiltinType::Float || k == BuiltinType::Double) {
2805       Current = SSE;
2806     } else if (k == BuiltinType::LongDouble) {
2807       const llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();
2808       if (LDF == &llvm::APFloat::IEEEquad()) {
2809         Lo = SSE;
2810         Hi = SSEUp;
2811       } else if (LDF == &llvm::APFloat::x87DoubleExtended()) {
2812         Lo = X87;
2813         Hi = X87Up;
2814       } else if (LDF == &llvm::APFloat::IEEEdouble()) {
2815         Current = SSE;
2816       } else
2817         llvm_unreachable("unexpected long double representation!");
2818     }
2819     // FIXME: _Decimal32 and _Decimal64 are SSE.
2820     // FIXME: _float128 and _Decimal128 are (SSE, SSEUp).
2821     return;
2822   }
2823
2824   if (const EnumType *ET = Ty->getAs<EnumType>()) {
2825     // Classify the underlying integer type.
2826     classify(ET->getDecl()->getIntegerType(), OffsetBase, Lo, Hi, isNamedArg);
2827     return;
2828   }
2829
2830   if (Ty->hasPointerRepresentation()) {
2831     Current = Integer;
2832     return;
2833   }
2834
2835   if (Ty->isMemberPointerType()) {
2836     if (Ty->isMemberFunctionPointerType()) {
2837       if (Has64BitPointers) {
2838         // If Has64BitPointers, this is an {i64, i64}, so classify both
2839         // Lo and Hi now.
2840         Lo = Hi = Integer;
2841       } else {
2842         // Otherwise, with 32-bit pointers, this is an {i32, i32}. If that
2843         // straddles an eightbyte boundary, Hi should be classified as well.
2844         uint64_t EB_FuncPtr = (OffsetBase) / 64;
2845         uint64_t EB_ThisAdj = (OffsetBase + 64 - 1) / 64;
2846         if (EB_FuncPtr != EB_ThisAdj) {
2847           Lo = Hi = Integer;
2848         } else {
2849           Current = Integer;
2850         }
2851       }
2852     } else {
2853       Current = Integer;
2854     }
2855     return;
2856   }
2857
2858   if (const VectorType *VT = Ty->getAs<VectorType>()) {
2859     uint64_t Size = getContext().getTypeSize(VT);
2860     if (Size == 1 || Size == 8 || Size == 16 || Size == 32) {
2861       // gcc passes the following as integer:
2862       // 4 bytes - <4 x char>, <2 x short>, <1 x int>, <1 x float>
2863       // 2 bytes - <2 x char>, <1 x short>
2864       // 1 byte  - <1 x char>
2865       Current = Integer;
2866
2867       // If this type crosses an eightbyte boundary, it should be
2868       // split.
2869       uint64_t EB_Lo = (OffsetBase) / 64;
2870       uint64_t EB_Hi = (OffsetBase + Size - 1) / 64;
2871       if (EB_Lo != EB_Hi)
2872         Hi = Lo;
2873     } else if (Size == 64) {
2874       QualType ElementType = VT->getElementType();
2875
2876       // gcc passes <1 x double> in memory. :(
2877       if (ElementType->isSpecificBuiltinType(BuiltinType::Double))
2878         return;
2879
2880       // gcc passes <1 x long long> as SSE but clang used to unconditionally
2881       // pass them as integer.  For platforms where clang is the de facto
2882       // platform compiler, we must continue to use integer.
2883       if (!classifyIntegerMMXAsSSE() &&
2884           (ElementType->isSpecificBuiltinType(BuiltinType::LongLong) ||
2885            ElementType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
2886            ElementType->isSpecificBuiltinType(BuiltinType::Long) ||
2887            ElementType->isSpecificBuiltinType(BuiltinType::ULong)))
2888         Current = Integer;
2889       else
2890         Current = SSE;
2891
2892       // If this type crosses an eightbyte boundary, it should be
2893       // split.
2894       if (OffsetBase && OffsetBase != 64)
2895         Hi = Lo;
2896     } else if (Size == 128 ||
2897                (isNamedArg && Size <= getNativeVectorSizeForAVXABI(AVXLevel))) {
2898       QualType ElementType = VT->getElementType();
2899
2900       // gcc passes 256 and 512 bit <X x __int128> vectors in memory. :(
2901       if (passInt128VectorsInMem() && Size != 128 &&
2902           (ElementType->isSpecificBuiltinType(BuiltinType::Int128) ||
2903            ElementType->isSpecificBuiltinType(BuiltinType::UInt128)))
2904         return;
2905
2906       // Arguments of 256-bits are split into four eightbyte chunks. The
2907       // least significant one belongs to class SSE and all the others to class
2908       // SSEUP. The original Lo and Hi design considers that types can't be
2909       // greater than 128-bits, so a 64-bit split in Hi and Lo makes sense.
2910       // This design isn't correct for 256-bits, but since there're no cases
2911       // where the upper parts would need to be inspected, avoid adding
2912       // complexity and just consider Hi to match the 64-256 part.
2913       //
2914       // Note that per 3.5.7 of AMD64-ABI, 256-bit args are only passed in
2915       // registers if they are "named", i.e. not part of the "..." of a
2916       // variadic function.
2917       //
2918       // Similarly, per 3.2.3. of the AVX512 draft, 512-bits ("named") args are
2919       // split into eight eightbyte chunks, one SSE and seven SSEUP.
2920       Lo = SSE;
2921       Hi = SSEUp;
2922     }
2923     return;
2924   }
2925
2926   if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
2927     QualType ET = getContext().getCanonicalType(CT->getElementType());
2928
2929     uint64_t Size = getContext().getTypeSize(Ty);
2930     if (ET->isIntegralOrEnumerationType()) {
2931       if (Size <= 64)
2932         Current = Integer;
2933       else if (Size <= 128)
2934         Lo = Hi = Integer;
2935     } else if (ET == getContext().FloatTy) {
2936       Current = SSE;
2937     } else if (ET == getContext().DoubleTy) {
2938       Lo = Hi = SSE;
2939     } else if (ET == getContext().LongDoubleTy) {
2940       const llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();
2941       if (LDF == &llvm::APFloat::IEEEquad())
2942         Current = Memory;
2943       else if (LDF == &llvm::APFloat::x87DoubleExtended())
2944         Current = ComplexX87;
2945       else if (LDF == &llvm::APFloat::IEEEdouble())
2946         Lo = Hi = SSE;
2947       else
2948         llvm_unreachable("unexpected long double representation!");
2949     }
2950
2951     // If this complex type crosses an eightbyte boundary then it
2952     // should be split.
2953     uint64_t EB_Real = (OffsetBase) / 64;
2954     uint64_t EB_Imag = (OffsetBase + getContext().getTypeSize(ET)) / 64;
2955     if (Hi == NoClass && EB_Real != EB_Imag)
2956       Hi = Lo;
2957
2958     return;
2959   }
2960
2961   if (const auto *EITy = Ty->getAs<ExtIntType>()) {
2962     if (EITy->getNumBits() <= 64)
2963       Current = Integer;
2964     else if (EITy->getNumBits() <= 128)
2965       Lo = Hi = Integer;
2966     // Larger values need to get passed in memory.
2967     return;
2968   }
2969
2970   if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
2971     // Arrays are treated like structures.
2972
2973     uint64_t Size = getContext().getTypeSize(Ty);
2974
2975     // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger
2976     // than eight eightbytes, ..., it has class MEMORY.
2977     if (Size > 512)
2978       return;
2979
2980     // AMD64-ABI 3.2.3p2: Rule 1. If ..., or it contains unaligned
2981     // fields, it has class MEMORY.
2982     //
2983     // Only need to check alignment of array base.
2984     if (OffsetBase % getContext().getTypeAlign(AT->getElementType()))
2985       return;
2986
2987     // Otherwise implement simplified merge. We could be smarter about
2988     // this, but it isn't worth it and would be harder to verify.
2989     Current = NoClass;
2990     uint64_t EltSize = getContext().getTypeSize(AT->getElementType());
2991     uint64_t ArraySize = AT->getSize().getZExtValue();
2992
2993     // The only case a 256-bit wide vector could be used is when the array
2994     // contains a single 256-bit element. Since Lo and Hi logic isn't extended
2995     // to work for sizes wider than 128, early check and fallback to memory.
2996     //
2997     if (Size > 128 &&
2998         (Size != EltSize || Size > getNativeVectorSizeForAVXABI(AVXLevel)))
2999       return;
3000
3001     for (uint64_t i=0, Offset=OffsetBase; i<ArraySize; ++i, Offset += EltSize) {
3002       Class FieldLo, FieldHi;
3003       classify(AT->getElementType(), Offset, FieldLo, FieldHi, isNamedArg);
3004       Lo = merge(Lo, FieldLo);
3005       Hi = merge(Hi, FieldHi);
3006       if (Lo == Memory || Hi == Memory)
3007         break;
3008     }
3009
3010     postMerge(Size, Lo, Hi);
3011     assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp array classification.");
3012     return;
3013   }
3014
3015   if (const RecordType *RT = Ty->getAs<RecordType>()) {
3016     uint64_t Size = getContext().getTypeSize(Ty);
3017
3018     // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger
3019     // than eight eightbytes, ..., it has class MEMORY.
3020     if (Size > 512)
3021       return;
3022
3023     // AMD64-ABI 3.2.3p2: Rule 2. If a C++ object has either a non-trivial
3024     // copy constructor or a non-trivial destructor, it is passed by invisible
3025     // reference.
3026     if (getRecordArgABI(RT, getCXXABI()))
3027       return;
3028
3029     const RecordDecl *RD = RT->getDecl();
3030
3031     // Assume variable sized types are passed in memory.
3032     if (RD->hasFlexibleArrayMember())
3033       return;
3034
3035     const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
3036
3037     // Reset Lo class, this will be recomputed.
3038     Current = NoClass;
3039
3040     // If this is a C++ record, classify the bases first.
3041     if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3042       for (const auto &I : CXXRD->bases()) {
3043         assert(!I.isVirtual() && !I.getType()->isDependentType() &&
3044                "Unexpected base class!");
3045         const auto *Base =
3046             cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
3047
3048         // Classify this field.
3049         //
3050         // AMD64-ABI 3.2.3p2: Rule 3. If the size of the aggregate exceeds a
3051         // single eightbyte, each is classified separately. Each eightbyte gets
3052         // initialized to class NO_CLASS.
3053         Class FieldLo, FieldHi;
3054         uint64_t Offset =
3055           OffsetBase + getContext().toBits(Layout.getBaseClassOffset(Base));
3056         classify(I.getType(), Offset, FieldLo, FieldHi, isNamedArg);
3057         Lo = merge(Lo, FieldLo);
3058         Hi = merge(Hi, FieldHi);
3059         if (Lo == Memory || Hi == Memory) {
3060           postMerge(Size, Lo, Hi);
3061           return;
3062         }
3063       }
3064     }
3065
3066     // Classify the fields one at a time, merging the results.
3067     unsigned idx = 0;
3068     bool UseClang11Compat = getContext().getLangOpts().getClangABICompat() <=
3069                                 LangOptions::ClangABI::Ver11 ||
3070                             getContext().getTargetInfo().getTriple().isPS4();
3071     bool IsUnion = RT->isUnionType() && !UseClang11Compat;
3072
3073     for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
3074            i != e; ++i, ++idx) {
3075       uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx);
3076       bool BitField = i->isBitField();
3077
3078       // Ignore padding bit-fields.
3079       if (BitField && i->isUnnamedBitfield())
3080         continue;
3081
3082       // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger than
3083       // eight eightbytes, or it contains unaligned fields, it has class MEMORY.
3084       //
3085       // The only case a 256-bit or a 512-bit wide vector could be used is when
3086       // the struct contains a single 256-bit or 512-bit element. Early check
3087       // and fallback to memory.
3088       //
3089       // FIXME: Extended the Lo and Hi logic properly to work for size wider
3090       // than 128.
3091       if (Size > 128 &&
3092           ((!IsUnion && Size != getContext().getTypeSize(i->getType())) ||
3093            Size > getNativeVectorSizeForAVXABI(AVXLevel))) {
3094         Lo = Memory;
3095         postMerge(Size, Lo, Hi);
3096         return;
3097       }
3098       // Note, skip this test for bit-fields, see below.
3099       if (!BitField && Offset % getContext().getTypeAlign(i->getType())) {
3100         Lo = Memory;
3101         postMerge(Size, Lo, Hi);
3102         return;
3103       }
3104
3105       // Classify this field.
3106       //
3107       // AMD64-ABI 3.2.3p2: Rule 3. If the size of the aggregate
3108       // exceeds a single eightbyte, each is classified
3109       // separately. Each eightbyte gets initialized to class
3110       // NO_CLASS.
3111       Class FieldLo, FieldHi;
3112
3113       // Bit-fields require special handling, they do not force the
3114       // structure to be passed in memory even if unaligned, and
3115       // therefore they can straddle an eightbyte.
3116       if (BitField) {
3117         assert(!i->isUnnamedBitfield());
3118         uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx);
3119         uint64_t Size = i->getBitWidthValue(getContext());
3120
3121         uint64_t EB_Lo = Offset / 64;
3122         uint64_t EB_Hi = (Offset + Size - 1) / 64;
3123
3124         if (EB_Lo) {
3125           assert(EB_Hi == EB_Lo && "Invalid classification, type > 16 bytes.");
3126           FieldLo = NoClass;
3127           FieldHi = Integer;
3128         } else {
3129           FieldLo = Integer;
3130           FieldHi = EB_Hi ? Integer : NoClass;
3131         }
3132       } else
3133         classify(i->getType(), Offset, FieldLo, FieldHi, isNamedArg);
3134       Lo = merge(Lo, FieldLo);
3135       Hi = merge(Hi, FieldHi);
3136       if (Lo == Memory || Hi == Memory)
3137         break;
3138     }
3139
3140     postMerge(Size, Lo, Hi);
3141   }
3142 }
3143
3144 ABIArgInfo X86_64ABIInfo::getIndirectReturnResult(QualType Ty) const {
3145   // If this is a scalar LLVM value then assume LLVM will pass it in the right
3146   // place naturally.
3147   if (!isAggregateTypeForABI(Ty)) {
3148     // Treat an enum type as its underlying type.
3149     if (const EnumType *EnumTy = Ty->getAs<EnumType>())
3150       Ty = EnumTy->getDecl()->getIntegerType();
3151
3152     if (Ty->isExtIntType())
3153       return getNaturalAlignIndirect(Ty);
3154
3155     return (isPromotableIntegerTypeForABI(Ty) ? ABIArgInfo::getExtend(Ty)
3156                                               : ABIArgInfo::getDirect());
3157   }
3158
3159   return getNaturalAlignIndirect(Ty);
3160 }
3161
3162 bool X86_64ABIInfo::IsIllegalVectorType(QualType Ty) const {
3163   if (const VectorType *VecTy = Ty->getAs<VectorType>()) {
3164     uint64_t Size = getContext().getTypeSize(VecTy);
3165     unsigned LargestVector = getNativeVectorSizeForAVXABI(AVXLevel);
3166     if (Size <= 64 || Size > LargestVector)
3167       return true;
3168     QualType EltTy = VecTy->getElementType();
3169     if (passInt128VectorsInMem() &&
3170         (EltTy->isSpecificBuiltinType(BuiltinType::Int128) ||
3171          EltTy->isSpecificBuiltinType(BuiltinType::UInt128)))
3172       return true;
3173   }
3174
3175   return false;
3176 }
3177
3178 ABIArgInfo X86_64ABIInfo::getIndirectResult(QualType Ty,
3179                                             unsigned freeIntRegs) const {
3180   // If this is a scalar LLVM value then assume LLVM will pass it in the right
3181   // place naturally.
3182   //
3183   // This assumption is optimistic, as there could be free registers available
3184   // when we need to pass this argument in memory, and LLVM could try to pass
3185   // the argument in the free register. This does not seem to happen currently,
3186   // but this code would be much safer if we could mark the argument with
3187   // 'onstack'. See PR12193.
3188   if (!isAggregateTypeForABI(Ty) && !IsIllegalVectorType(Ty) &&
3189       !Ty->isExtIntType()) {
3190     // Treat an enum type as its underlying type.
3191     if (const EnumType *EnumTy = Ty->getAs<EnumType>())
3192       Ty = EnumTy->getDecl()->getIntegerType();
3193
3194     return (isPromotableIntegerTypeForABI(Ty) ? ABIArgInfo::getExtend(Ty)
3195                                               : ABIArgInfo::getDirect());
3196   }
3197
3198   if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(Ty, getCXXABI()))
3199     return getNaturalAlignIndirect(Ty, RAA == CGCXXABI::RAA_DirectInMemory);
3200
3201   // Compute the byval alignment. We specify the alignment of the byval in all
3202   // cases so that the mid-level optimizer knows the alignment of the byval.
3203   unsigned Align = std::max(getContext().getTypeAlign(Ty) / 8, 8U);
3204
3205   // Attempt to avoid passing indirect results using byval when possible. This
3206   // is important for good codegen.
3207   //
3208   // We do this by coercing the value into a scalar type which the backend can
3209   // handle naturally (i.e., without using byval).
3210   //
3211   // For simplicity, we currently only do this when we have exhausted all of the
3212   // free integer registers. Doing this when there are free integer registers
3213   // would require more care, as we would have to ensure that the coerced value
3214   // did not claim the unused register. That would require either reording the
3215   // arguments to the function (so that any subsequent inreg values came first),
3216   // or only doing this optimization when there were no following arguments that
3217   // might be inreg.
3218   //
3219   // We currently expect it to be rare (particularly in well written code) for
3220   // arguments to be passed on the stack when there are still free integer
3221   // registers available (this would typically imply large structs being passed
3222   // by value), so this seems like a fair tradeoff for now.
3223   //
3224   // We can revisit this if the backend grows support for 'onstack' parameter
3225   // attributes. See PR12193.
3226   if (freeIntRegs == 0) {
3227     uint64_t Size = getContext().getTypeSize(Ty);
3228
3229     // If this type fits in an eightbyte, coerce it into the matching integral
3230     // type, which will end up on the stack (with alignment 8).
3231     if (Align == 8 && Size <= 64)
3232       return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
3233                                                           Size));
3234   }
3235
3236   return ABIArgInfo::getIndirect(CharUnits::fromQuantity(Align));
3237 }
3238
3239 /// The ABI specifies that a value should be passed in a full vector XMM/YMM
3240 /// register. Pick an LLVM IR type that will be passed as a vector register.
3241 llvm::Type *X86_64ABIInfo::GetByteVectorType(QualType Ty) const {
3242   // Wrapper structs/arrays that only contain vectors are passed just like
3243   // vectors; strip them off if present.
3244   if (const Type *InnerTy = isSingleElementStruct(Ty, getContext()))
3245     Ty = QualType(InnerTy, 0);
3246
3247   llvm::Type *IRType = CGT.ConvertType(Ty);
3248   if (isa<llvm::VectorType>(IRType)) {
3249     // Don't pass vXi128 vectors in their native type, the backend can't
3250     // legalize them.
3251     if (passInt128VectorsInMem() &&
3252         cast<llvm::VectorType>(IRType)->getElementType()->isIntegerTy(128)) {
3253       // Use a vXi64 vector.
3254       uint64_t Size = getContext().getTypeSize(Ty);
3255       return llvm::FixedVectorType::get(llvm::Type::getInt64Ty(getVMContext()),
3256                                         Size / 64);
3257     }
3258
3259     return IRType;
3260   }
3261
3262   if (IRType->getTypeID() == llvm::Type::FP128TyID)
3263     return IRType;
3264
3265   // We couldn't find the preferred IR vector type for 'Ty'.
3266   uint64_t Size = getContext().getTypeSize(Ty);
3267   assert((Size == 128 || Size == 256 || Size == 512) && "Invalid type found!");
3268
3269
3270   // Return a LLVM IR vector type based on the size of 'Ty'.
3271   return llvm::FixedVectorType::get(llvm::Type::getDoubleTy(getVMContext()),
3272                                     Size / 64);
3273 }
3274
3275 /// BitsContainNoUserData - Return true if the specified [start,end) bit range
3276 /// is known to either be off the end of the specified type or being in
3277 /// alignment padding.  The user type specified is known to be at most 128 bits
3278 /// in size, and have passed through X86_64ABIInfo::classify with a successful
3279 /// classification that put one of the two halves in the INTEGER class.
3280 ///
3281 /// It is conservatively correct to return false.
3282 static bool BitsContainNoUserData(QualType Ty, unsigned StartBit,
3283                                   unsigned EndBit, ASTContext &Context) {
3284   // If the bytes being queried are off the end of the type, there is no user
3285   // data hiding here.  This handles analysis of builtins, vectors and other
3286   // types that don't contain interesting padding.
3287   unsigned TySize = (unsigned)Context.getTypeSize(Ty);
3288   if (TySize <= StartBit)
3289     return true;
3290
3291   if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) {
3292     unsigned EltSize = (unsigned)Context.getTypeSize(AT->getElementType());
3293     unsigned NumElts = (unsigned)AT->getSize().getZExtValue();
3294
3295     // Check each element to see if the element overlaps with the queried range.
3296     for (unsigned i = 0; i != NumElts; ++i) {
3297       // If the element is after the span we care about, then we're done..
3298       unsigned EltOffset = i*EltSize;
3299       if (EltOffset >= EndBit) break;
3300
3301       unsigned EltStart = EltOffset < StartBit ? StartBit-EltOffset :0;
3302       if (!BitsContainNoUserData(AT->getElementType(), EltStart,
3303                                  EndBit-EltOffset, Context))
3304         return false;
3305     }
3306     // If it overlaps no elements, then it is safe to process as padding.
3307     return true;
3308   }
3309
3310   if (const RecordType *RT = Ty->getAs<RecordType>()) {
3311     const RecordDecl *RD = RT->getDecl();
3312     const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
3313
3314     // If this is a C++ record, check the bases first.
3315     if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3316       for (const auto &I : CXXRD->bases()) {
3317         assert(!I.isVirtual() && !I.getType()->isDependentType() &&
3318                "Unexpected base class!");
3319         const auto *Base =
3320             cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
3321
3322         // If the base is after the span we care about, ignore it.
3323         unsigned BaseOffset = Context.toBits(Layout.getBaseClassOffset(Base));
3324         if (BaseOffset >= EndBit) continue;
3325
3326         unsigned BaseStart = BaseOffset < StartBit ? StartBit-BaseOffset :0;
3327         if (!BitsContainNoUserData(I.getType(), BaseStart,
3328                                    EndBit-BaseOffset, Context))
3329           return false;
3330       }
3331     }
3332
3333     // Verify that no field has data that overlaps the region of interest.  Yes
3334     // this could be sped up a lot by being smarter about queried fields,
3335     // however we're only looking at structs up to 16 bytes, so we don't care
3336     // much.
3337     unsigned idx = 0;
3338     for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
3339          i != e; ++i, ++idx) {
3340       unsigned FieldOffset = (unsigned)Layout.getFieldOffset(idx);
3341
3342       // If we found a field after the region we care about, then we're done.
3343       if (FieldOffset >= EndBit) break;
3344
3345       unsigned FieldStart = FieldOffset < StartBit ? StartBit-FieldOffset :0;
3346       if (!BitsContainNoUserData(i->getType(), FieldStart, EndBit-FieldOffset,
3347                                  Context))
3348         return false;
3349     }
3350
3351     // If nothing in this record overlapped the area of interest, then we're
3352     // clean.
3353     return true;
3354   }
3355
3356   return false;
3357 }
3358
3359 /// ContainsFloatAtOffset - Return true if the specified LLVM IR type has a
3360 /// float member at the specified offset.  For example, {int,{float}} has a
3361 /// float at offset 4.  It is conservatively correct for this routine to return
3362 /// false.
3363 static bool ContainsFloatAtOffset(llvm::Type *IRType, unsigned IROffset,
3364                                   const llvm::DataLayout &TD) {
3365   // Base case if we find a float.
3366   if (IROffset == 0 && IRType->isFloatTy())
3367     return true;
3368
3369   // If this is a struct, recurse into the field at the specified offset.
3370   if (llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType)) {
3371     const llvm::StructLayout *SL = TD.getStructLayout(STy);
3372     unsigned Elt = SL->getElementContainingOffset(IROffset);
3373     IROffset -= SL->getElementOffset(Elt);
3374     return ContainsFloatAtOffset(STy->getElementType(Elt), IROffset, TD);
3375   }
3376
3377   // If this is an array, recurse into the field at the specified offset.
3378   if (llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(IRType)) {
3379     llvm::Type *EltTy = ATy->getElementType();
3380     unsigned EltSize = TD.getTypeAllocSize(EltTy);
3381     IROffset -= IROffset/EltSize*EltSize;
3382     return ContainsFloatAtOffset(EltTy, IROffset, TD);
3383   }
3384
3385   return false;
3386 }
3387
3388
3389 /// GetSSETypeAtOffset - Return a type that will be passed by the backend in the
3390 /// low 8 bytes of an XMM register, corresponding to the SSE class.
3391 llvm::Type *X86_64ABIInfo::
3392 GetSSETypeAtOffset(llvm::Type *IRType, unsigned IROffset,
3393                    QualType SourceTy, unsigned SourceOffset) const {
3394   // The only three choices we have are either double, <2 x float>, or float. We
3395   // pass as float if the last 4 bytes is just padding.  This happens for
3396   // structs that contain 3 floats.
3397   if (BitsContainNoUserData(SourceTy, SourceOffset*8+32,
3398                             SourceOffset*8+64, getContext()))
3399     return llvm::Type::getFloatTy(getVMContext());
3400
3401   // We want to pass as <2 x float> if the LLVM IR type contains a float at
3402   // offset+0 and offset+4.  Walk the LLVM IR type to find out if this is the
3403   // case.
3404   if (ContainsFloatAtOffset(IRType, IROffset, getDataLayout()) &&
3405       ContainsFloatAtOffset(IRType, IROffset+4, getDataLayout()))
3406     return llvm::FixedVectorType::get(llvm::Type::getFloatTy(getVMContext()),
3407                                       2);
3408
3409   return llvm::Type::getDoubleTy(getVMContext());
3410 }
3411
3412
3413 /// GetINTEGERTypeAtOffset - The ABI specifies that a value should be passed in
3414 /// an 8-byte GPR.  This means that we either have a scalar or we are talking
3415 /// about the high or low part of an up-to-16-byte struct.  This routine picks
3416 /// the best LLVM IR type to represent this, which may be i64 or may be anything
3417 /// else that the backend will pass in a GPR that works better (e.g. i8, %foo*,
3418 /// etc).
3419 ///
3420 /// PrefType is an LLVM IR type that corresponds to (part of) the IR type for
3421 /// the source type.  IROffset is an offset in bytes into the LLVM IR type that
3422 /// the 8-byte value references.  PrefType may be null.
3423 ///
3424 /// SourceTy is the source-level type for the entire argument.  SourceOffset is
3425 /// an offset into this that we're processing (which is always either 0 or 8).
3426 ///
3427 llvm::Type *X86_64ABIInfo::
3428 GetINTEGERTypeAtOffset(llvm::Type *IRType, unsigned IROffset,
3429                        QualType SourceTy, unsigned SourceOffset) const {
3430   // If we're dealing with an un-offset LLVM IR type, then it means that we're
3431   // returning an 8-byte unit starting with it.  See if we can safely use it.
3432   if (IROffset == 0) {
3433     // Pointers and int64's always fill the 8-byte unit.
3434     if ((isa<llvm::PointerType>(IRType) && Has64BitPointers) ||
3435         IRType->isIntegerTy(64))
3436       return IRType;
3437
3438     // If we have a 1/2/4-byte integer, we can use it only if the rest of the
3439     // goodness in the source type is just tail padding.  This is allowed to
3440     // kick in for struct {double,int} on the int, but not on
3441     // struct{double,int,int} because we wouldn't return the second int.  We
3442     // have to do this analysis on the source type because we can't depend on
3443     // unions being lowered a specific way etc.
3444     if (IRType->isIntegerTy(8) || IRType->isIntegerTy(16) ||
3445         IRType->isIntegerTy(32) ||
3446         (isa<llvm::PointerType>(IRType) && !Has64BitPointers)) {
3447       unsigned BitWidth = isa<llvm::PointerType>(IRType) ? 32 :
3448           cast<llvm::IntegerType>(IRType)->getBitWidth();
3449
3450       if (BitsContainNoUserData(SourceTy, SourceOffset*8+BitWidth,
3451                                 SourceOffset*8+64, getContext()))
3452         return IRType;
3453     }
3454   }
3455
3456   if (llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType)) {
3457     // If this is a struct, recurse into the field at the specified offset.
3458     const llvm::StructLayout *SL = getDataLayout().getStructLayout(STy);
3459     if (IROffset < SL->getSizeInBytes()) {
3460       unsigned FieldIdx = SL->getElementContainingOffset(IROffset);
3461       IROffset -= SL->getElementOffset(FieldIdx);
3462
3463       return GetINTEGERTypeAtOffset(STy->getElementType(FieldIdx), IROffset,
3464                                     SourceTy, SourceOffset);
3465     }
3466   }
3467
3468   if (llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(IRType)) {
3469     llvm::Type *EltTy = ATy->getElementType();
3470     unsigned EltSize = getDataLayout().getTypeAllocSize(EltTy);
3471     unsigned EltOffset = IROffset/EltSize*EltSize;
3472     return GetINTEGERTypeAtOffset(EltTy, IROffset-EltOffset, SourceTy,
3473                                   SourceOffset);
3474   }
3475
3476   // Okay, we don't have any better idea of what to pass, so we pass this in an
3477   // integer register that isn't too big to fit the rest of the struct.
3478   unsigned TySizeInBytes =
3479     (unsigned)getContext().getTypeSizeInChars(SourceTy).getQuantity();
3480
3481   assert(TySizeInBytes != SourceOffset && "Empty field?");
3482
3483   // It is always safe to classify this as an integer type up to i64 that
3484   // isn't larger than the structure.
3485   return llvm::IntegerType::get(getVMContext(),
3486                                 std::min(TySizeInBytes-SourceOffset, 8U)*8);
3487 }
3488
3489
3490 /// GetX86_64ByValArgumentPair - Given a high and low type that can ideally
3491 /// be used as elements of a two register pair to pass or return, return a
3492 /// first class aggregate to represent them.  For example, if the low part of
3493 /// a by-value argument should be passed as i32* and the high part as float,
3494 /// return {i32*, float}.
3495 static llvm::Type *
3496 GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi,
3497                            const llvm::DataLayout &TD) {
3498   // In order to correctly satisfy the ABI, we need to the high part to start
3499   // at offset 8.  If the high and low parts we inferred are both 4-byte types
3500   // (e.g. i32 and i32) then the resultant struct type ({i32,i32}) won't have
3501   // the second element at offset 8.  Check for this:
3502   unsigned LoSize = (unsigned)TD.getTypeAllocSize(Lo);
3503   unsigned HiAlign = TD.getABITypeAlignment(Hi);
3504   unsigned HiStart = llvm::alignTo(LoSize, HiAlign);
3505   assert(HiStart != 0 && HiStart <= 8 && "Invalid x86-64 argument pair!");
3506
3507   // To handle this, we have to increase the size of the low part so that the
3508   // second element will start at an 8 byte offset.  We can't increase the size
3509   // of the second element because it might make us access off the end of the
3510   // struct.
3511   if (HiStart != 8) {
3512     // There are usually two sorts of types the ABI generation code can produce
3513     // for the low part of a pair that aren't 8 bytes in size: float or
3514     // i8/i16/i32.  This can also include pointers when they are 32-bit (X32 and
3515     // NaCl).
3516     // Promote these to a larger type.
3517     if (Lo->isFloatTy())
3518       Lo = llvm::Type::getDoubleTy(Lo->getContext());
3519     else {
3520       assert((Lo->isIntegerTy() || Lo->isPointerTy())
3521              && "Invalid/unknown lo type");
3522       Lo = llvm::Type::getInt64Ty(Lo->getContext());
3523     }
3524   }
3525
3526   llvm::StructType *Result = llvm::StructType::get(Lo, Hi);
3527
3528   // Verify that the second element is at an 8-byte offset.
3529   assert(TD.getStructLayout(Result)->getElementOffset(1) == 8 &&
3530          "Invalid x86-64 argument pair!");
3531   return Result;
3532 }
3533
3534 ABIArgInfo X86_64ABIInfo::
3535 classifyReturnType(QualType RetTy) const {
3536   // AMD64-ABI 3.2.3p4: Rule 1. Classify the return type with the
3537   // classification algorithm.
3538   X86_64ABIInfo::Class Lo, Hi;
3539   classify(RetTy, 0, Lo, Hi, /*isNamedArg*/ true);
3540
3541   // Check some invariants.
3542   assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
3543   assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
3544
3545   llvm::Type *ResType = nullptr;
3546   switch (Lo) {
3547   case NoClass: