clang  6.0.0
TargetInfo.cpp
Go to the documentation of this file.
1 //===---- TargetInfo.cpp - Encapsulate target details -----------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // These classes wrap the information about a call or function
11 // definition used to handle ABI compliancy.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "TargetInfo.h"
16 #include "ABIInfo.h"
17 #include "CGBlocks.h"
18 #include "CGCXXABI.h"
19 #include "CGValue.h"
20 #include "CodeGenFunction.h"
21 #include "clang/AST/RecordLayout.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/ADT/StringSwitch.h"
27 #include "llvm/ADT/Triple.h"
28 #include "llvm/ADT/Twine.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Type.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include <algorithm> // std::sort
33 
34 using namespace clang;
35 using namespace CodeGen;
36 
37 // Helper for coercing an aggregate argument or return value into an integer
38 // array of the same size (including padding) and alignment. This alternate
39 // coercion happens only for the RenderScript ABI and can be removed after
40 // runtimes that rely on it are no longer supported.
41 //
42 // RenderScript assumes that the size of the argument / return value in the IR
43 // is the same as the size of the corresponding qualified type. This helper
44 // coerces the aggregate type into an array of the same size (including
45 // padding). This coercion is used in lieu of expansion of struct members or
46 // other canonical coercions that return a coerced-type of larger size.
47 //
48 // Ty - The argument / return value type
49 // Context - The associated ASTContext
50 // LLVMContext - The associated LLVMContext
52  ASTContext &Context,
53  llvm::LLVMContext &LLVMContext) {
54  // Alignment and Size are measured in bits.
55  const uint64_t Size = Context.getTypeSize(Ty);
56  const uint64_t Alignment = Context.getTypeAlign(Ty);
57  llvm::Type *IntType = llvm::Type::getIntNTy(LLVMContext, Alignment);
58  const uint64_t NumElements = (Size + Alignment - 1) / Alignment;
59  return ABIArgInfo::getDirect(llvm::ArrayType::get(IntType, NumElements));
60 }
61 
63  llvm::Value *Array,
65  unsigned FirstIndex,
66  unsigned LastIndex) {
67  // Alternatively, we could emit this as a loop in the source.
68  for (unsigned I = FirstIndex; I <= LastIndex; ++I) {
69  llvm::Value *Cell =
70  Builder.CreateConstInBoundsGEP1_32(Builder.getInt8Ty(), Array, I);
71  Builder.CreateAlignedStore(Value, Cell, CharUnits::One());
72  }
73 }
74 
78 }
79 
81 ABIInfo::getNaturalAlignIndirect(QualType Ty, bool ByRef, bool Realign,
82  llvm::Type *Padding) const {
83  return ABIArgInfo::getIndirect(getContext().getTypeAlignInChars(Ty),
84  ByRef, Realign, Padding);
85 }
86 
89  return ABIArgInfo::getIndirectInReg(getContext().getTypeAlignInChars(Ty),
90  /*ByRef*/ false, Realign);
91 }
92 
94  QualType Ty) const {
95  return Address::invalid();
96 }
97 
99 
100 /// Does the given lowering require more than the given number of
101 /// registers when expanded?
102 ///
103 /// This is intended to be the basis of a reasonable basic implementation
104 /// of should{Pass,Return}IndirectlyForSwift.
105 ///
106 /// For most targets, a limit of four total registers is reasonable; this
107 /// limits the amount of code required in order to move around the value
108 /// in case it wasn't produced immediately prior to the call by the caller
109 /// (or wasn't produced in exactly the right registers) or isn't used
110 /// immediately within the callee. But some targets may need to further
111 /// limit the register count due to an inability to support that many
112 /// return registers.
114  ArrayRef<llvm::Type*> scalarTypes,
115  unsigned maxAllRegisters) {
116  unsigned intCount = 0, fpCount = 0;
117  for (llvm::Type *type : scalarTypes) {
118  if (type->isPointerTy()) {
119  intCount++;
120  } else if (auto intTy = dyn_cast<llvm::IntegerType>(type)) {
121  auto ptrWidth = cgt.getTarget().getPointerWidth(0);
122  intCount += (intTy->getBitWidth() + ptrWidth - 1) / ptrWidth;
123  } else {
124  assert(type->isVectorTy() || type->isFloatingPointTy());
125  fpCount++;
126  }
127  }
128 
129  return (intCount + fpCount > maxAllRegisters);
130 }
131 
133  llvm::Type *eltTy,
134  unsigned numElts) const {
135  // The default implementation of this assumes that the target guarantees
136  // 128-bit SIMD support but nothing more.
137  return (vectorSize.getQuantity() > 8 && vectorSize.getQuantity() <= 16);
138 }
139 
141  CGCXXABI &CXXABI) {
142  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
143  if (!RD)
144  return CGCXXABI::RAA_Default;
145  return CXXABI.getRecordArgABI(RD);
146 }
147 
149  CGCXXABI &CXXABI) {
150  const RecordType *RT = T->getAs<RecordType>();
151  if (!RT)
152  return CGCXXABI::RAA_Default;
153  return getRecordArgABI(RT, CXXABI);
154 }
155 
156 /// Pass transparent unions as if they were the type of the first element. Sema
157 /// should ensure that all elements of the union have the same "machine type".
159  if (const RecordType *UT = Ty->getAsUnionType()) {
160  const RecordDecl *UD = UT->getDecl();
161  if (UD->hasAttr<TransparentUnionAttr>()) {
162  assert(!UD->field_empty() && "sema created an empty transparent union");
163  return UD->field_begin()->getType();
164  }
165  }
166  return Ty;
167 }
168 
170  return CGT.getCXXABI();
171 }
172 
174  return CGT.getContext();
175 }
176 
177 llvm::LLVMContext &ABIInfo::getVMContext() const {
178  return CGT.getLLVMContext();
179 }
180 
181 const llvm::DataLayout &ABIInfo::getDataLayout() const {
182  return CGT.getDataLayout();
183 }
184 
186  return CGT.getTarget();
187 }
188 
190  return CGT.getCodeGenOpts();
191 }
192 
193 bool ABIInfo::isAndroid() const { return getTarget().getTriple().isAndroid(); }
194 
196  return false;
197 }
198 
200  uint64_t Members) const {
201  return false;
202 }
203 
205  return false;
206 }
207 
208 LLVM_DUMP_METHOD void ABIArgInfo::dump() const {
209  raw_ostream &OS = llvm::errs();
210  OS << "(ABIArgInfo Kind=";
211  switch (TheKind) {
212  case Direct:
213  OS << "Direct Type=";
214  if (llvm::Type *Ty = getCoerceToType())
215  Ty->print(OS);
216  else
217  OS << "null";
218  break;
219  case Extend:
220  OS << "Extend";
221  break;
222  case Ignore:
223  OS << "Ignore";
224  break;
225  case InAlloca:
226  OS << "InAlloca Offset=" << getInAllocaFieldIndex();
227  break;
228  case Indirect:
229  OS << "Indirect Align=" << getIndirectAlign().getQuantity()
230  << " ByVal=" << getIndirectByVal()
231  << " Realign=" << getIndirectRealign();
232  break;
233  case Expand:
234  OS << "Expand";
235  break;
236  case CoerceAndExpand:
237  OS << "CoerceAndExpand Type=";
238  getCoerceAndExpandType()->print(OS);
239  break;
240  }
241  OS << ")\n";
242 }
243 
244 // Dynamically round a pointer up to a multiple of the given alignment.
246  llvm::Value *Ptr,
247  CharUnits Align) {
248  llvm::Value *PtrAsInt = Ptr;
249  // OverflowArgArea = (OverflowArgArea + Align - 1) & -Align;
250  PtrAsInt = CGF.Builder.CreatePtrToInt(PtrAsInt, CGF.IntPtrTy);
251  PtrAsInt = CGF.Builder.CreateAdd(PtrAsInt,
252  llvm::ConstantInt::get(CGF.IntPtrTy, Align.getQuantity() - 1));
253  PtrAsInt = CGF.Builder.CreateAnd(PtrAsInt,
254  llvm::ConstantInt::get(CGF.IntPtrTy, -Align.getQuantity()));
255  PtrAsInt = CGF.Builder.CreateIntToPtr(PtrAsInt,
256  Ptr->getType(),
257  Ptr->getName() + ".aligned");
258  return PtrAsInt;
259 }
260 
261 /// Emit va_arg for a platform using the common void* representation,
262 /// where arguments are simply emitted in an array of slots on the stack.
263 ///
264 /// This version implements the core direct-value passing rules.
265 ///
266 /// \param SlotSize - The size and alignment of a stack slot.
267 /// Each argument will be allocated to a multiple of this number of
268 /// slots, and all the slots will be aligned to this value.
269 /// \param AllowHigherAlign - The slot alignment is not a cap;
270 /// an argument type with an alignment greater than the slot size
271 /// will be emitted on a higher-alignment address, potentially
272 /// leaving one or more empty slots behind as padding. If this
273 /// is false, the returned address might be less-aligned than
274 /// DirectAlign.
276  Address VAListAddr,
277  llvm::Type *DirectTy,
278  CharUnits DirectSize,
279  CharUnits DirectAlign,
280  CharUnits SlotSize,
281  bool AllowHigherAlign) {
282  // Cast the element type to i8* if necessary. Some platforms define
283  // va_list as a struct containing an i8* instead of just an i8*.
284  if (VAListAddr.getElementType() != CGF.Int8PtrTy)
285  VAListAddr = CGF.Builder.CreateElementBitCast(VAListAddr, CGF.Int8PtrTy);
286 
287  llvm::Value *Ptr = CGF.Builder.CreateLoad(VAListAddr, "argp.cur");
288 
289  // If the CC aligns values higher than the slot size, do so if needed.
290  Address Addr = Address::invalid();
291  if (AllowHigherAlign && DirectAlign > SlotSize) {
292  Addr = Address(emitRoundPointerUpToAlignment(CGF, Ptr, DirectAlign),
293  DirectAlign);
294  } else {
295  Addr = Address(Ptr, SlotSize);
296  }
297 
298  // Advance the pointer past the argument, then store that back.
299  CharUnits FullDirectSize = DirectSize.alignTo(SlotSize);
300  llvm::Value *NextPtr =
301  CGF.Builder.CreateConstInBoundsByteGEP(Addr.getPointer(), FullDirectSize,
302  "argp.next");
303  CGF.Builder.CreateStore(NextPtr, VAListAddr);
304 
305  // If the argument is smaller than a slot, and this is a big-endian
306  // target, the argument will be right-adjusted in its slot.
307  if (DirectSize < SlotSize && CGF.CGM.getDataLayout().isBigEndian() &&
308  !DirectTy->isStructTy()) {
309  Addr = CGF.Builder.CreateConstInBoundsByteGEP(Addr, SlotSize - DirectSize);
310  }
311 
312  Addr = CGF.Builder.CreateElementBitCast(Addr, DirectTy);
313  return Addr;
314 }
315 
316 /// Emit va_arg for a platform using the common void* representation,
317 /// where arguments are simply emitted in an array of slots on the stack.
318 ///
319 /// \param IsIndirect - Values of this type are passed indirectly.
320 /// \param ValueInfo - The size and alignment of this type, generally
321 /// computed with getContext().getTypeInfoInChars(ValueTy).
322 /// \param SlotSizeAndAlign - The size and alignment of a stack slot.
323 /// Each argument will be allocated to a multiple of this number of
324 /// slots, and all the slots will be aligned to this value.
325 /// \param AllowHigherAlign - The slot alignment is not a cap;
326 /// an argument type with an alignment greater than the slot size
327 /// will be emitted on a higher-alignment address, potentially
328 /// leaving one or more empty slots behind as padding.
330  QualType ValueTy, bool IsIndirect,
331  std::pair<CharUnits, CharUnits> ValueInfo,
332  CharUnits SlotSizeAndAlign,
333  bool AllowHigherAlign) {
334  // The size and alignment of the value that was passed directly.
335  CharUnits DirectSize, DirectAlign;
336  if (IsIndirect) {
337  DirectSize = CGF.getPointerSize();
338  DirectAlign = CGF.getPointerAlign();
339  } else {
340  DirectSize = ValueInfo.first;
341  DirectAlign = ValueInfo.second;
342  }
343 
344  // Cast the address we've calculated to the right type.
345  llvm::Type *DirectTy = CGF.ConvertTypeForMem(ValueTy);
346  if (IsIndirect)
347  DirectTy = DirectTy->getPointerTo(0);
348 
349  Address Addr = emitVoidPtrDirectVAArg(CGF, VAListAddr, DirectTy,
350  DirectSize, DirectAlign,
351  SlotSizeAndAlign,
352  AllowHigherAlign);
353 
354  if (IsIndirect) {
355  Addr = Address(CGF.Builder.CreateLoad(Addr), ValueInfo.second);
356  }
357 
358  return Addr;
359 
360 }
361 
363  Address Addr1, llvm::BasicBlock *Block1,
364  Address Addr2, llvm::BasicBlock *Block2,
365  const llvm::Twine &Name = "") {
366  assert(Addr1.getType() == Addr2.getType());
367  llvm::PHINode *PHI = CGF.Builder.CreatePHI(Addr1.getType(), 2, Name);
368  PHI->addIncoming(Addr1.getPointer(), Block1);
369  PHI->addIncoming(Addr2.getPointer(), Block2);
370  CharUnits Align = std::min(Addr1.getAlignment(), Addr2.getAlignment());
371  return Address(PHI, Align);
372 }
373 
375 
376 // If someone can figure out a general rule for this, that would be great.
377 // It's probably just doomed to be platform-dependent, though.
379  // Verified for:
380  // x86-64 FreeBSD, Linux, Darwin
381  // x86-32 FreeBSD, Linux, Darwin
382  // PowerPC Linux, Darwin
383  // ARM Darwin (*not* EABI)
384  // AArch64 Linux
385  return 32;
386 }
387 
389  const FunctionNoProtoType *fnType) const {
390  // The following conventions are known to require this to be false:
391  // x86_stdcall
392  // MIPS
393  // For everything else, we just prefer false unless we opt out.
394  return false;
395 }
396 
397 void
399  llvm::SmallString<24> &Opt) const {
400  // This assumes the user is passing a library name like "rt" instead of a
401  // filename like "librt.a/so", and that they don't care whether it's static or
402  // dynamic.
403  Opt = "-l";
404  Opt += Lib;
405 }
406 
408  // OpenCL kernels are called via an explicit runtime API with arguments
409  // set with clSetKernelArg(), not as normal sub-functions.
410  // Return SPIR_KERNEL by default as the kernel calling convention to
411  // ensure the fingerprint is fixed such way that each OpenCL argument
412  // gets one matching argument in the produced kernel function argument
413  // list to enable feasible implementation of clSetKernelArg() with
414  // aggregates etc. In case we would use the default C calling conv here,
415  // clSetKernelArg() might break depending on the target-specific
416  // conventions; different targets might split structs passed as values
417  // to multiple function arguments etc.
418  return llvm::CallingConv::SPIR_KERNEL;
419 }
420 
422  llvm::PointerType *T, QualType QT) const {
423  return llvm::ConstantPointerNull::get(T);
424 }
425 
427  const VarDecl *D) const {
428  assert(!CGM.getLangOpts().OpenCL &&
429  !(CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) &&
430  "Address space agnostic languages only");
431  return D ? D->getType().getAddressSpace() : LangAS::Default;
432 }
433 
435  CodeGen::CodeGenFunction &CGF, llvm::Value *Src, LangAS SrcAddr,
436  LangAS DestAddr, llvm::Type *DestTy, bool isNonNull) const {
437  // Since target may map different address spaces in AST to the same address
438  // space, an address space conversion may end up as a bitcast.
439  if (auto *C = dyn_cast<llvm::Constant>(Src))
440  return performAddrSpaceCast(CGF.CGM, C, SrcAddr, DestAddr, DestTy);
441  return CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DestTy);
442 }
443 
444 llvm::Constant *
446  LangAS SrcAddr, LangAS DestAddr,
447  llvm::Type *DestTy) const {
448  // Since target may map different address spaces in AST to the same address
449  // space, an address space conversion may end up as a bitcast.
450  return llvm::ConstantExpr::getPointerCast(Src, DestTy);
451 }
452 
454 TargetCodeGenInfo::getLLVMSyncScopeID(SyncScope S, llvm::LLVMContext &C) const {
455  return C.getOrInsertSyncScopeID(""); /* default sync scope */
456 }
457 
458 static bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays);
459 
460 /// isEmptyField - Return true iff a the field is "empty", that is it
461 /// is an unnamed bit-field or an (array of) empty record(s).
462 static bool isEmptyField(ASTContext &Context, const FieldDecl *FD,
463  bool AllowArrays) {
464  if (FD->isUnnamedBitfield())
465  return true;
466 
467  QualType FT = FD->getType();
468 
469  // Constant arrays of empty records count as empty, strip them off.
470  // Constant arrays of zero length always count as empty.
471  if (AllowArrays)
472  while (const ConstantArrayType *AT = Context.getAsConstantArrayType(FT)) {
473  if (AT->getSize() == 0)
474  return true;
475  FT = AT->getElementType();
476  }
477 
478  const RecordType *RT = FT->getAs<RecordType>();
479  if (!RT)
480  return false;
481 
482  // C++ record fields are never empty, at least in the Itanium ABI.
483  //
484  // FIXME: We should use a predicate for whether this behavior is true in the
485  // current ABI.
486  if (isa<CXXRecordDecl>(RT->getDecl()))
487  return false;
488 
489  return isEmptyRecord(Context, FT, AllowArrays);
490 }
491 
492 /// isEmptyRecord - Return true iff a structure contains only empty
493 /// fields. Note that a structure with a flexible array member is not
494 /// considered empty.
495 static bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays) {
496  const RecordType *RT = T->getAs<RecordType>();
497  if (!RT)
498  return false;
499  const RecordDecl *RD = RT->getDecl();
500  if (RD->hasFlexibleArrayMember())
501  return false;
502 
503  // If this is a C++ record, check the bases first.
504  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
505  for (const auto &I : CXXRD->bases())
506  if (!isEmptyRecord(Context, I.getType(), true))
507  return false;
508 
509  for (const auto *I : RD->fields())
510  if (!isEmptyField(Context, I, AllowArrays))
511  return false;
512  return true;
513 }
514 
515 /// isSingleElementStruct - Determine if a structure is a "single
516 /// element struct", i.e. it has exactly one non-empty field or
517 /// exactly one field which is itself a single element
518 /// struct. Structures with flexible array members are never
519 /// considered single element structs.
520 ///
521 /// \return The field declaration for the single non-empty field, if
522 /// it exists.
523 static const Type *isSingleElementStruct(QualType T, ASTContext &Context) {
524  const RecordType *RT = T->getAs<RecordType>();
525  if (!RT)
526  return nullptr;
527 
528  const RecordDecl *RD = RT->getDecl();
529  if (RD->hasFlexibleArrayMember())
530  return nullptr;
531 
532  const Type *Found = nullptr;
533 
534  // If this is a C++ record, check the bases first.
535  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
536  for (const auto &I : CXXRD->bases()) {
537  // Ignore empty records.
538  if (isEmptyRecord(Context, I.getType(), true))
539  continue;
540 
541  // If we already found an element then this isn't a single-element struct.
542  if (Found)
543  return nullptr;
544 
545  // If this is non-empty and not a single element struct, the composite
546  // cannot be a single element struct.
547  Found = isSingleElementStruct(I.getType(), Context);
548  if (!Found)
549  return nullptr;
550  }
551  }
552 
553  // Check for single element.
554  for (const auto *FD : RD->fields()) {
555  QualType FT = FD->getType();
556 
557  // Ignore empty fields.
558  if (isEmptyField(Context, FD, true))
559  continue;
560 
561  // If we already found an element then this isn't a single-element
562  // struct.
563  if (Found)
564  return nullptr;
565 
566  // Treat single element arrays as the element.
567  while (const ConstantArrayType *AT = Context.getAsConstantArrayType(FT)) {
568  if (AT->getSize().getZExtValue() != 1)
569  break;
570  FT = AT->getElementType();
571  }
572 
573  if (!isAggregateTypeForABI(FT)) {
574  Found = FT.getTypePtr();
575  } else {
576  Found = isSingleElementStruct(FT, Context);
577  if (!Found)
578  return nullptr;
579  }
580  }
581 
582  // We don't consider a struct a single-element struct if it has
583  // padding beyond the element type.
584  if (Found && Context.getTypeSize(Found) != Context.getTypeSize(T))
585  return nullptr;
586 
587  return Found;
588 }
589 
590 namespace {
591 Address EmitVAArgInstr(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
592  const ABIArgInfo &AI) {
593  // This default implementation defers to the llvm backend's va_arg
594  // instruction. It can handle only passing arguments directly
595  // (typically only handled in the backend for primitive types), or
596  // aggregates passed indirectly by pointer (NOTE: if the "byval"
597  // flag has ABI impact in the callee, this implementation cannot
598  // work.)
599 
600  // Only a few cases are covered here at the moment -- those needed
601  // by the default abi.
602  llvm::Value *Val;
603 
604  if (AI.isIndirect()) {
605  assert(!AI.getPaddingType() &&
606  "Unexpected PaddingType seen in arginfo in generic VAArg emitter!");
607  assert(
608  !AI.getIndirectRealign() &&
609  "Unexpected IndirectRealign seen in arginfo in generic VAArg emitter!");
610 
611  auto TyInfo = CGF.getContext().getTypeInfoInChars(Ty);
612  CharUnits TyAlignForABI = TyInfo.second;
613 
614  llvm::Type *BaseTy =
615  llvm::PointerType::getUnqual(CGF.ConvertTypeForMem(Ty));
616  llvm::Value *Addr =
617  CGF.Builder.CreateVAArg(VAListAddr.getPointer(), BaseTy);
618  return Address(Addr, TyAlignForABI);
619  } else {
620  assert((AI.isDirect() || AI.isExtend()) &&
621  "Unexpected ArgInfo Kind in generic VAArg emitter!");
622 
623  assert(!AI.getInReg() &&
624  "Unexpected InReg seen in arginfo in generic VAArg emitter!");
625  assert(!AI.getPaddingType() &&
626  "Unexpected PaddingType seen in arginfo in generic VAArg emitter!");
627  assert(!AI.getDirectOffset() &&
628  "Unexpected DirectOffset seen in arginfo in generic VAArg emitter!");
629  assert(!AI.getCoerceToType() &&
630  "Unexpected CoerceToType seen in arginfo in generic VAArg emitter!");
631 
632  Address Temp = CGF.CreateMemTemp(Ty, "varet");
633  Val = CGF.Builder.CreateVAArg(VAListAddr.getPointer(), CGF.ConvertType(Ty));
634  CGF.Builder.CreateStore(Val, Temp);
635  return Temp;
636  }
637 }
638 
639 /// DefaultABIInfo - The default implementation for ABI specific
640 /// details. This implementation provides information which results in
641 /// self-consistent and sensible LLVM IR generation, but does not
642 /// conform to any particular ABI.
643 class DefaultABIInfo : public ABIInfo {
644 public:
645  DefaultABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}
646 
649 
650  void computeInfo(CGFunctionInfo &FI) const override {
651  if (!getCXXABI().classifyReturnType(FI))
653  for (auto &I : FI.arguments())
654  I.info = classifyArgumentType(I.type);
655  }
656 
657  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
658  QualType Ty) const override {
659  return EmitVAArgInstr(CGF, VAListAddr, Ty, classifyArgumentType(Ty));
660  }
661 };
662 
663 class DefaultTargetCodeGenInfo : public TargetCodeGenInfo {
664 public:
665  DefaultTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
666  : TargetCodeGenInfo(new DefaultABIInfo(CGT)) {}
667 };
668 
671 
672  if (isAggregateTypeForABI(Ty)) {
673  // Records with non-trivial destructors/copy-constructors should not be
674  // passed by value.
677 
678  return getNaturalAlignIndirect(Ty);
679  }
680 
681  // Treat an enum type as its underlying type.
682  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
683  Ty = EnumTy->getDecl()->getIntegerType();
684 
685  return (Ty->isPromotableIntegerType() ?
687 }
688 
690  if (RetTy->isVoidType())
691  return ABIArgInfo::getIgnore();
692 
693  if (isAggregateTypeForABI(RetTy))
694  return getNaturalAlignIndirect(RetTy);
695 
696  // Treat an enum type as its underlying type.
697  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
698  RetTy = EnumTy->getDecl()->getIntegerType();
699 
700  return (RetTy->isPromotableIntegerType() ?
702 }
703 
704 //===----------------------------------------------------------------------===//
705 // WebAssembly ABI Implementation
706 //
707 // This is a very simple ABI that relies a lot on DefaultABIInfo.
708 //===----------------------------------------------------------------------===//
709 
710 class WebAssemblyABIInfo final : public DefaultABIInfo {
711 public:
712  explicit WebAssemblyABIInfo(CodeGen::CodeGenTypes &CGT)
713  : DefaultABIInfo(CGT) {}
714 
715 private:
718 
719  // DefaultABIInfo's classifyReturnType and classifyArgumentType are
720  // non-virtual, but computeInfo and EmitVAArg are virtual, so we
721  // overload them.
722  void computeInfo(CGFunctionInfo &FI) const override {
723  if (!getCXXABI().classifyReturnType(FI))
725  for (auto &Arg : FI.arguments())
726  Arg.info = classifyArgumentType(Arg.type);
727  }
728 
729  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
730  QualType Ty) const override;
731 };
732 
733 class WebAssemblyTargetCodeGenInfo final : public TargetCodeGenInfo {
734 public:
735  explicit WebAssemblyTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
736  : TargetCodeGenInfo(new WebAssemblyABIInfo(CGT)) {}
737 };
738 
739 /// \brief Classify argument of given type \p Ty.
742 
743  if (isAggregateTypeForABI(Ty)) {
744  // Records with non-trivial destructors/copy-constructors should not be
745  // passed by value.
746  if (auto RAA = getRecordArgABI(Ty, getCXXABI()))
748  // Ignore empty structs/unions.
749  if (isEmptyRecord(getContext(), Ty, true))
750  return ABIArgInfo::getIgnore();
751  // Lower single-element structs to just pass a regular value. TODO: We
752  // could do reasonable-size multiple-element structs too, using getExpand(),
753  // though watch out for things like bitfields.
754  if (const Type *SeltTy = isSingleElementStruct(Ty, getContext()))
755  return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
756  }
757 
758  // Otherwise just do the default thing.
760 }
761 
763  if (isAggregateTypeForABI(RetTy)) {
764  // Records with non-trivial destructors/copy-constructors should not be
765  // returned by value.
766  if (!getRecordArgABI(RetTy, getCXXABI())) {
767  // Ignore empty structs/unions.
768  if (isEmptyRecord(getContext(), RetTy, true))
769  return ABIArgInfo::getIgnore();
770  // Lower single-element structs to just return a regular value. TODO: We
771  // could do reasonable-size multiple-element structs too, using
772  // ABIArgInfo::getDirect().
773  if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
774  return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
775  }
776  }
777 
778  // Otherwise just do the default thing.
780 }
781 
782 Address WebAssemblyABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
783  QualType Ty) const {
784  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*Indirect=*/ false,
785  getContext().getTypeInfoInChars(Ty),
787  /*AllowHigherAlign=*/ true);
788 }
789 
790 //===----------------------------------------------------------------------===//
791 // le32/PNaCl bitcode ABI Implementation
792 //
793 // This is a simplified version of the x86_32 ABI. Arguments and return values
794 // are always passed on the stack.
795 //===----------------------------------------------------------------------===//
796 
797 class PNaClABIInfo : public ABIInfo {
798  public:
799  PNaClABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}
800 
803 
804  void computeInfo(CGFunctionInfo &FI) const override;
806  Address VAListAddr, QualType Ty) const override;
807 };
808 
809 class PNaClTargetCodeGenInfo : public TargetCodeGenInfo {
810  public:
811  PNaClTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
812  : TargetCodeGenInfo(new PNaClABIInfo(CGT)) {}
813 };
814 
815 void PNaClABIInfo::computeInfo(CGFunctionInfo &FI) const {
816  if (!getCXXABI().classifyReturnType(FI))
818 
819  for (auto &I : FI.arguments())
820  I.info = classifyArgumentType(I.type);
821 }
822 
823 Address PNaClABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
824  QualType Ty) const {
825  // The PNaCL ABI is a bit odd, in that varargs don't use normal
826  // function classification. Structs get passed directly for varargs
827  // functions, through a rewriting transform in
828  // pnacl-llvm/lib/Transforms/NaCl/ExpandVarArgs.cpp, which allows
829  // this target to actually support a va_arg instructions with an
830  // aggregate type, unlike other targets.
831  return EmitVAArgInstr(CGF, VAListAddr, Ty, ABIArgInfo::getDirect());
832 }
833 
834 /// \brief Classify argument of given type \p Ty.
836  if (isAggregateTypeForABI(Ty)) {
839  return getNaturalAlignIndirect(Ty);
840  } else if (const EnumType *EnumTy = Ty->getAs<EnumType>()) {
841  // Treat an enum type as its underlying type.
842  Ty = EnumTy->getDecl()->getIntegerType();
843  } else if (Ty->isFloatingType()) {
844  // Floating-point types don't go inreg.
845  return ABIArgInfo::getDirect();
846  }
847 
848  return (Ty->isPromotableIntegerType() ?
850 }
851 
853  if (RetTy->isVoidType())
854  return ABIArgInfo::getIgnore();
855 
856  // In the PNaCl ABI we always return records/structures on the stack.
857  if (isAggregateTypeForABI(RetTy))
858  return getNaturalAlignIndirect(RetTy);
859 
860  // Treat an enum type as its underlying type.
861  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
862  RetTy = EnumTy->getDecl()->getIntegerType();
863 
864  return (RetTy->isPromotableIntegerType() ?
866 }
867 
868 /// IsX86_MMXType - Return true if this is an MMX type.
869 bool IsX86_MMXType(llvm::Type *IRType) {
870  // Return true if the type is an MMX type <2 x i32>, <4 x i16>, or <8 x i8>.
871  return IRType->isVectorTy() && IRType->getPrimitiveSizeInBits() == 64 &&
872  cast<llvm::VectorType>(IRType)->getElementType()->isIntegerTy() &&
873  IRType->getScalarSizeInBits() != 64;
874 }
875 
876 static llvm::Type* X86AdjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
877  StringRef Constraint,
878  llvm::Type* Ty) {
879  bool IsMMXCons = llvm::StringSwitch<bool>(Constraint)
880  .Cases("y", "&y", "^Ym", true)
881  .Default(false);
882  if (IsMMXCons && Ty->isVectorTy()) {
883  if (cast<llvm::VectorType>(Ty)->getBitWidth() != 64) {
884  // Invalid MMX constraint
885  return nullptr;
886  }
887 
888  return llvm::Type::getX86_MMXTy(CGF.getLLVMContext());
889  }
890 
891  // No operation needed
892  return Ty;
893 }
894 
895 /// Returns true if this type can be passed in SSE registers with the
896 /// X86_VectorCall calling convention. Shared between x86_32 and x86_64.
897 static bool isX86VectorTypeForVectorCall(ASTContext &Context, QualType Ty) {
898  if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
899  if (BT->isFloatingPoint() && BT->getKind() != BuiltinType::Half) {
900  if (BT->getKind() == BuiltinType::LongDouble) {
901  if (&Context.getTargetInfo().getLongDoubleFormat() ==
902  &llvm::APFloat::x87DoubleExtended())
903  return false;
904  }
905  return true;
906  }
907  } else if (const VectorType *VT = Ty->getAs<VectorType>()) {
908  // vectorcall can pass XMM, YMM, and ZMM vectors. We don't pass SSE1 MMX
909  // registers specially.
910  unsigned VecSize = Context.getTypeSize(VT);
911  if (VecSize == 128 || VecSize == 256 || VecSize == 512)
912  return true;
913  }
914  return false;
915 }
916 
917 /// Returns true if this aggregate is small enough to be passed in SSE registers
918 /// in the X86_VectorCall calling convention. Shared between x86_32 and x86_64.
919 static bool isX86VectorCallAggregateSmallEnough(uint64_t NumMembers) {
920  return NumMembers <= 4;
921 }
922 
923 /// Returns a Homogeneous Vector Aggregate ABIArgInfo, used in X86.
924 static ABIArgInfo getDirectX86Hva(llvm::Type* T = nullptr) {
925  auto AI = ABIArgInfo::getDirect(T);
926  AI.setInReg(true);
927  AI.setCanBeFlattened(false);
928  return AI;
929 }
930 
931 //===----------------------------------------------------------------------===//
932 // X86-32 ABI Implementation
933 //===----------------------------------------------------------------------===//
934 
935 /// \brief Similar to llvm::CCState, but for Clang.
936 struct CCState {
937  CCState(unsigned CC) : CC(CC), FreeRegs(0), FreeSSERegs(0) {}
938 
939  unsigned CC;
940  unsigned FreeRegs;
941  unsigned FreeSSERegs;
942 };
943 
944 enum {
945  // Vectorcall only allows the first 6 parameters to be passed in registers.
946  VectorcallMaxParamNumAsReg = 6
947 };
948 
949 /// X86_32ABIInfo - The X86-32 ABI information.
950 class X86_32ABIInfo : public SwiftABIInfo {
951  enum Class {
952  Integer,
953  Float
954  };
955 
956  static const unsigned MinABIStackAlignInBytes = 4;
957 
958  bool IsDarwinVectorABI;
959  bool IsRetSmallStructInRegABI;
960  bool IsWin32StructABI;
961  bool IsSoftFloatABI;
962  bool IsMCUABI;
963  unsigned DefaultNumRegisterParameters;
964 
965  static bool isRegisterSize(unsigned Size) {
966  return (Size == 8 || Size == 16 || Size == 32 || Size == 64);
967  }
968 
969  bool isHomogeneousAggregateBaseType(QualType Ty) const override {
970  // FIXME: Assumes vectorcall is in use.
971  return isX86VectorTypeForVectorCall(getContext(), Ty);
972  }
973 
975  uint64_t NumMembers) const override {
976  // FIXME: Assumes vectorcall is in use.
977  return isX86VectorCallAggregateSmallEnough(NumMembers);
978  }
979 
980  bool shouldReturnTypeInRegister(QualType Ty, ASTContext &Context) const;
981 
982  /// getIndirectResult - Give a source type \arg Ty, return a suitable result
983  /// such that the argument will be passed in memory.
984  ABIArgInfo getIndirectResult(QualType Ty, bool ByVal, CCState &State) const;
985 
986  ABIArgInfo getIndirectReturnResult(QualType Ty, CCState &State) const;
987 
988  /// \brief Return the alignment to use for the given type on the stack.
989  unsigned getTypeStackAlignInBytes(QualType Ty, unsigned Align) const;
990 
991  Class classify(QualType Ty) const;
992  ABIArgInfo classifyReturnType(QualType RetTy, CCState &State) const;
993  ABIArgInfo classifyArgumentType(QualType RetTy, CCState &State) const;
994 
995  /// \brief Updates the number of available free registers, returns
996  /// true if any registers were allocated.
997  bool updateFreeRegs(QualType Ty, CCState &State) const;
998 
999  bool shouldAggregateUseDirect(QualType Ty, CCState &State, bool &InReg,
1000  bool &NeedsPadding) const;
1001  bool shouldPrimitiveUseInReg(QualType Ty, CCState &State) const;
1002 
1003  bool canExpandIndirectArgument(QualType Ty) const;
1004 
1005  /// \brief Rewrite the function info so that all memory arguments use
1006  /// inalloca.
1007  void rewriteWithInAlloca(CGFunctionInfo &FI) const;
1008 
1009  void addFieldToArgStruct(SmallVector<llvm::Type *, 6> &FrameFields,
1010  CharUnits &StackOffset, ABIArgInfo &Info,
1011  QualType Type) const;
1012  void computeVectorCallArgs(CGFunctionInfo &FI, CCState &State,
1013  bool &UsedInAlloca) const;
1014 
1015 public:
1016 
1017  void computeInfo(CGFunctionInfo &FI) const override;
1018  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
1019  QualType Ty) const override;
1020 
1021  X86_32ABIInfo(CodeGen::CodeGenTypes &CGT, bool DarwinVectorABI,
1022  bool RetSmallStructInRegABI, bool Win32StructABI,
1023  unsigned NumRegisterParameters, bool SoftFloatABI)
1024  : SwiftABIInfo(CGT), IsDarwinVectorABI(DarwinVectorABI),
1025  IsRetSmallStructInRegABI(RetSmallStructInRegABI),
1026  IsWin32StructABI(Win32StructABI),
1027  IsSoftFloatABI(SoftFloatABI),
1028  IsMCUABI(CGT.getTarget().getTriple().isOSIAMCU()),
1029  DefaultNumRegisterParameters(NumRegisterParameters) {}
1030 
1031  bool shouldPassIndirectlyForSwift(CharUnits totalSize,
1032  ArrayRef<llvm::Type*> scalars,
1033  bool asReturnValue) const override {
1034  // LLVM's x86-32 lowering currently only assigns up to three
1035  // integer registers and three fp registers. Oddly, it'll use up to
1036  // four vector registers for vectors, but those can overlap with the
1037  // scalar registers.
1038  return occupiesMoreThan(CGT, scalars, /*total*/ 3);
1039  }
1040 
1041  bool isSwiftErrorInRegister() const override {
1042  // x86-32 lowering does not support passing swifterror in a register.
1043  return false;
1044  }
1045 };
1046 
1047 class X86_32TargetCodeGenInfo : public TargetCodeGenInfo {
1048 public:
1049  X86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool DarwinVectorABI,
1050  bool RetSmallStructInRegABI, bool Win32StructABI,
1051  unsigned NumRegisterParameters, bool SoftFloatABI)
1052  : TargetCodeGenInfo(new X86_32ABIInfo(
1053  CGT, DarwinVectorABI, RetSmallStructInRegABI, Win32StructABI,
1054  NumRegisterParameters, SoftFloatABI)) {}
1055 
1056  static bool isStructReturnInRegABI(
1057  const llvm::Triple &Triple, const CodeGenOptions &Opts);
1058 
1059  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
1061  ForDefinition_t IsForDefinition) const override;
1062 
1063  int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
1064  // Darwin uses different dwarf register numbers for EH.
1065  if (CGM.getTarget().getTriple().isOSDarwin()) return 5;
1066  return 4;
1067  }
1068 
1069  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
1070  llvm::Value *Address) const override;
1071 
1072  llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
1073  StringRef Constraint,
1074  llvm::Type* Ty) const override {
1075  return X86AdjustInlineAsmType(CGF, Constraint, Ty);
1076  }
1077 
1078  void addReturnRegisterOutputs(CodeGenFunction &CGF, LValue ReturnValue,
1079  std::string &Constraints,
1080  std::vector<llvm::Type *> &ResultRegTypes,
1081  std::vector<llvm::Type *> &ResultTruncRegTypes,
1082  std::vector<LValue> &ResultRegDests,
1083  std::string &AsmString,
1084  unsigned NumOutputs) const override;
1085 
1086  llvm::Constant *
1087  getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const override {
1088  unsigned Sig = (0xeb << 0) | // jmp rel8
1089  (0x06 << 8) | // .+0x08
1090  ('v' << 16) |
1091  ('2' << 24);
1092  return llvm::ConstantInt::get(CGM.Int32Ty, Sig);
1093  }
1094 
1095  StringRef getARCRetainAutoreleasedReturnValueMarker() const override {
1096  return "movl\t%ebp, %ebp"
1097  "\t\t// marker for objc_retainAutoreleaseReturnValue";
1098  }
1099 };
1100 
1101 }
1102 
1103 /// Rewrite input constraint references after adding some output constraints.
1104 /// In the case where there is one output and one input and we add one output,
1105 /// we need to replace all operand references greater than or equal to 1:
1106 /// mov $0, $1
1107 /// mov eax, $1
1108 /// The result will be:
1109 /// mov $0, $2
1110 /// mov eax, $2
1111 static void rewriteInputConstraintReferences(unsigned FirstIn,
1112  unsigned NumNewOuts,
1113  std::string &AsmString) {
1114  std::string Buf;
1115  llvm::raw_string_ostream OS(Buf);
1116  size_t Pos = 0;
1117  while (Pos < AsmString.size()) {
1118  size_t DollarStart = AsmString.find('$', Pos);
1119  if (DollarStart == std::string::npos)
1120  DollarStart = AsmString.size();
1121  size_t DollarEnd = AsmString.find_first_not_of('$', DollarStart);
1122  if (DollarEnd == std::string::npos)
1123  DollarEnd = AsmString.size();
1124  OS << StringRef(&AsmString[Pos], DollarEnd - Pos);
1125  Pos = DollarEnd;
1126  size_t NumDollars = DollarEnd - DollarStart;
1127  if (NumDollars % 2 != 0 && Pos < AsmString.size()) {
1128  // We have an operand reference.
1129  size_t DigitStart = Pos;
1130  size_t DigitEnd = AsmString.find_first_not_of("0123456789", DigitStart);
1131  if (DigitEnd == std::string::npos)
1132  DigitEnd = AsmString.size();
1133  StringRef OperandStr(&AsmString[DigitStart], DigitEnd - DigitStart);
1134  unsigned OperandIndex;
1135  if (!OperandStr.getAsInteger(10, OperandIndex)) {
1136  if (OperandIndex >= FirstIn)
1137  OperandIndex += NumNewOuts;
1138  OS << OperandIndex;
1139  } else {
1140  OS << OperandStr;
1141  }
1142  Pos = DigitEnd;
1143  }
1144  }
1145  AsmString = std::move(OS.str());
1146 }
1147 
1148 /// Add output constraints for EAX:EDX because they are return registers.
1149 void X86_32TargetCodeGenInfo::addReturnRegisterOutputs(
1150  CodeGenFunction &CGF, LValue ReturnSlot, std::string &Constraints,
1151  std::vector<llvm::Type *> &ResultRegTypes,
1152  std::vector<llvm::Type *> &ResultTruncRegTypes,
1153  std::vector<LValue> &ResultRegDests, std::string &AsmString,
1154  unsigned NumOutputs) const {
1155  uint64_t RetWidth = CGF.getContext().getTypeSize(ReturnSlot.getType());
1156 
1157  // Use the EAX constraint if the width is 32 or smaller and EAX:EDX if it is
1158  // larger.
1159  if (!Constraints.empty())
1160  Constraints += ',';
1161  if (RetWidth <= 32) {
1162  Constraints += "={eax}";
1163  ResultRegTypes.push_back(CGF.Int32Ty);
1164  } else {
1165  // Use the 'A' constraint for EAX:EDX.
1166  Constraints += "=A";
1167  ResultRegTypes.push_back(CGF.Int64Ty);
1168  }
1169 
1170  // Truncate EAX or EAX:EDX to an integer of the appropriate size.
1171  llvm::Type *CoerceTy = llvm::IntegerType::get(CGF.getLLVMContext(), RetWidth);
1172  ResultTruncRegTypes.push_back(CoerceTy);
1173 
1174  // Coerce the integer by bitcasting the return slot pointer.
1175  ReturnSlot.setAddress(CGF.Builder.CreateBitCast(ReturnSlot.getAddress(),
1176  CoerceTy->getPointerTo()));
1177  ResultRegDests.push_back(ReturnSlot);
1178 
1179  rewriteInputConstraintReferences(NumOutputs, 1, AsmString);
1180 }
1181 
1182 /// shouldReturnTypeInRegister - Determine if the given type should be
1183 /// returned in a register (for the Darwin and MCU ABI).
1184 bool X86_32ABIInfo::shouldReturnTypeInRegister(QualType Ty,
1185  ASTContext &Context) const {
1186  uint64_t Size = Context.getTypeSize(Ty);
1187 
1188  // For i386, type must be register sized.
1189  // For the MCU ABI, it only needs to be <= 8-byte
1190  if ((IsMCUABI && Size > 64) || (!IsMCUABI && !isRegisterSize(Size)))
1191  return false;
1192 
1193  if (Ty->isVectorType()) {
1194  // 64- and 128- bit vectors inside structures are not returned in
1195  // registers.
1196  if (Size == 64 || Size == 128)
1197  return false;
1198 
1199  return true;
1200  }
1201 
1202  // If this is a builtin, pointer, enum, complex type, member pointer, or
1203  // member function pointer it is ok.
1204  if (Ty->getAs<BuiltinType>() || Ty->hasPointerRepresentation() ||
1205  Ty->isAnyComplexType() || Ty->isEnumeralType() ||
1206  Ty->isBlockPointerType() || Ty->isMemberPointerType())
1207  return true;
1208 
1209  // Arrays are treated like records.
1210  if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty))
1211  return shouldReturnTypeInRegister(AT->getElementType(), Context);
1212 
1213  // Otherwise, it must be a record type.
1214  const RecordType *RT = Ty->getAs<RecordType>();
1215  if (!RT) return false;
1216 
1217  // FIXME: Traverse bases here too.
1218 
1219  // Structure types are passed in register if all fields would be
1220  // passed in a register.
1221  for (const auto *FD : RT->getDecl()->fields()) {
1222  // Empty fields are ignored.
1223  if (isEmptyField(Context, FD, true))
1224  continue;
1225 
1226  // Check fields recursively.
1227  if (!shouldReturnTypeInRegister(FD->getType(), Context))
1228  return false;
1229  }
1230  return true;
1231 }
1232 
1233 static bool is32Or64BitBasicType(QualType Ty, ASTContext &Context) {
1234  // Treat complex types as the element type.
1235  if (const ComplexType *CTy = Ty->getAs<ComplexType>())
1236  Ty = CTy->getElementType();
1237 
1238  // Check for a type which we know has a simple scalar argument-passing
1239  // convention without any padding. (We're specifically looking for 32
1240  // and 64-bit integer and integer-equivalents, float, and double.)
1241  if (!Ty->getAs<BuiltinType>() && !Ty->hasPointerRepresentation() &&
1242  !Ty->isEnumeralType() && !Ty->isBlockPointerType())
1243  return false;
1244 
1245  uint64_t Size = Context.getTypeSize(Ty);
1246  return Size == 32 || Size == 64;
1247 }
1248 
1249 static bool addFieldSizes(ASTContext &Context, const RecordDecl *RD,
1250  uint64_t &Size) {
1251  for (const auto *FD : RD->fields()) {
1252  // Scalar arguments on the stack get 4 byte alignment on x86. If the
1253  // argument is smaller than 32-bits, expanding the struct will create
1254  // alignment padding.
1255  if (!is32Or64BitBasicType(FD->getType(), Context))
1256  return false;
1257 
1258  // FIXME: Reject bit-fields wholesale; there are two problems, we don't know
1259  // how to expand them yet, and the predicate for telling if a bitfield still
1260  // counts as "basic" is more complicated than what we were doing previously.
1261  if (FD->isBitField())
1262  return false;
1263 
1264  Size += Context.getTypeSize(FD->getType());
1265  }
1266  return true;
1267 }
1268 
1269 static bool addBaseAndFieldSizes(ASTContext &Context, const CXXRecordDecl *RD,
1270  uint64_t &Size) {
1271  // Don't do this if there are any non-empty bases.
1272  for (const CXXBaseSpecifier &Base : RD->bases()) {
1273  if (!addBaseAndFieldSizes(Context, Base.getType()->getAsCXXRecordDecl(),
1274  Size))
1275  return false;
1276  }
1277  if (!addFieldSizes(Context, RD, Size))
1278  return false;
1279  return true;
1280 }
1281 
1282 /// Test whether an argument type which is to be passed indirectly (on the
1283 /// stack) would have the equivalent layout if it was expanded into separate
1284 /// arguments. If so, we prefer to do the latter to avoid inhibiting
1285 /// optimizations.
1286 bool X86_32ABIInfo::canExpandIndirectArgument(QualType Ty) const {
1287  // We can only expand structure types.
1288  const RecordType *RT = Ty->getAs<RecordType>();
1289  if (!RT)
1290  return false;
1291  const RecordDecl *RD = RT->getDecl();
1292  uint64_t Size = 0;
1293  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
1294  if (!IsWin32StructABI) {
1295  // On non-Windows, we have to conservatively match our old bitcode
1296  // prototypes in order to be ABI-compatible at the bitcode level.
1297  if (!CXXRD->isCLike())
1298  return false;
1299  } else {
1300  // Don't do this for dynamic classes.
1301  if (CXXRD->isDynamicClass())
1302  return false;
1303  }
1304  if (!addBaseAndFieldSizes(getContext(), CXXRD, Size))
1305  return false;
1306  } else {
1307  if (!addFieldSizes(getContext(), RD, Size))
1308  return false;
1309  }
1310 
1311  // We can do this if there was no alignment padding.
1312  return Size == getContext().getTypeSize(Ty);
1313 }
1314 
1315 ABIArgInfo X86_32ABIInfo::getIndirectReturnResult(QualType RetTy, CCState &State) const {
1316  // If the return value is indirect, then the hidden argument is consuming one
1317  // integer register.
1318  if (State.FreeRegs) {
1319  --State.FreeRegs;
1320  if (!IsMCUABI)
1321  return getNaturalAlignIndirectInReg(RetTy);
1322  }
1323  return getNaturalAlignIndirect(RetTy, /*ByVal=*/false);
1324 }
1325 
1327  CCState &State) const {
1328  if (RetTy->isVoidType())
1329  return ABIArgInfo::getIgnore();
1330 
1331  const Type *Base = nullptr;
1332  uint64_t NumElts = 0;
1333  if ((State.CC == llvm::CallingConv::X86_VectorCall ||
1334  State.CC == llvm::CallingConv::X86_RegCall) &&
1335  isHomogeneousAggregate(RetTy, Base, NumElts)) {
1336  // The LLVM struct type for such an aggregate should lower properly.
1337  return ABIArgInfo::getDirect();
1338  }
1339 
1340  if (const VectorType *VT = RetTy->getAs<VectorType>()) {
1341  // On Darwin, some vectors are returned in registers.
1342  if (IsDarwinVectorABI) {
1343  uint64_t Size = getContext().getTypeSize(RetTy);
1344 
1345  // 128-bit vectors are a special case; they are returned in
1346  // registers and we need to make sure to pick a type the LLVM
1347  // backend will like.
1348  if (Size == 128)
1349  return ABIArgInfo::getDirect(llvm::VectorType::get(
1350  llvm::Type::getInt64Ty(getVMContext()), 2));
1351 
1352  // Always return in register if it fits in a general purpose
1353  // register, or if it is 64 bits and has a single element.
1354  if ((Size == 8 || Size == 16 || Size == 32) ||
1355  (Size == 64 && VT->getNumElements() == 1))
1356  return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
1357  Size));
1358 
1359  return getIndirectReturnResult(RetTy, State);
1360  }
1361 
1362  return ABIArgInfo::getDirect();
1363  }
1364 
1365  if (isAggregateTypeForABI(RetTy)) {
1366  if (const RecordType *RT = RetTy->getAs<RecordType>()) {
1367  // Structures with flexible arrays are always indirect.
1368  if (RT->getDecl()->hasFlexibleArrayMember())
1369  return getIndirectReturnResult(RetTy, State);
1370  }
1371 
1372  // If specified, structs and unions are always indirect.
1373  if (!IsRetSmallStructInRegABI && !RetTy->isAnyComplexType())
1374  return getIndirectReturnResult(RetTy, State);
1375 
1376  // Ignore empty structs/unions.
1377  if (isEmptyRecord(getContext(), RetTy, true))
1378  return ABIArgInfo::getIgnore();
1379 
1380  // Small structures which are register sized are generally returned
1381  // in a register.
1382  if (shouldReturnTypeInRegister(RetTy, getContext())) {
1383  uint64_t Size = getContext().getTypeSize(RetTy);
1384 
1385  // As a special-case, if the struct is a "single-element" struct, and
1386  // the field is of type "float" or "double", return it in a
1387  // floating-point register. (MSVC does not apply this special case.)
1388  // We apply a similar transformation for pointer types to improve the
1389  // quality of the generated IR.
1390  if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
1391  if ((!IsWin32StructABI && SeltTy->isRealFloatingType())
1392  || SeltTy->hasPointerRepresentation())
1393  return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
1394 
1395  // FIXME: We should be able to narrow this integer in cases with dead
1396  // padding.
1397  return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),Size));
1398  }
1399 
1400  return getIndirectReturnResult(RetTy, State);
1401  }
1402 
1403  // Treat an enum type as its underlying type.
1404  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
1405  RetTy = EnumTy->getDecl()->getIntegerType();
1406 
1407  return (RetTy->isPromotableIntegerType() ?
1409 }
1410 
1411 static bool isSSEVectorType(ASTContext &Context, QualType Ty) {
1412  return Ty->getAs<VectorType>() && Context.getTypeSize(Ty) == 128;
1413 }
1414 
1415 static bool isRecordWithSSEVectorType(ASTContext &Context, QualType Ty) {
1416  const RecordType *RT = Ty->getAs<RecordType>();
1417  if (!RT)
1418  return 0;
1419  const RecordDecl *RD = RT->getDecl();
1420 
1421  // If this is a C++ record, check the bases first.
1422  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1423  for (const auto &I : CXXRD->bases())
1424  if (!isRecordWithSSEVectorType(Context, I.getType()))
1425  return false;
1426 
1427  for (const auto *i : RD->fields()) {
1428  QualType FT = i->getType();
1429 
1430  if (isSSEVectorType(Context, FT))
1431  return true;
1432 
1433  if (isRecordWithSSEVectorType(Context, FT))
1434  return true;
1435  }
1436 
1437  return false;
1438 }
1439 
1440 unsigned X86_32ABIInfo::getTypeStackAlignInBytes(QualType Ty,
1441  unsigned Align) const {
1442  // Otherwise, if the alignment is less than or equal to the minimum ABI
1443  // alignment, just use the default; the backend will handle this.
1444  if (Align <= MinABIStackAlignInBytes)
1445  return 0; // Use default alignment.
1446 
1447  // On non-Darwin, the stack type alignment is always 4.
1448  if (!IsDarwinVectorABI) {
1449  // Set explicit alignment, since we may need to realign the top.
1450  return MinABIStackAlignInBytes;
1451  }
1452 
1453  // Otherwise, if the type contains an SSE vector type, the alignment is 16.
1454  if (Align >= 16 && (isSSEVectorType(getContext(), Ty) ||
1456  return 16;
1457 
1458  return MinABIStackAlignInBytes;
1459 }
1460 
1461 ABIArgInfo X86_32ABIInfo::getIndirectResult(QualType Ty, bool ByVal,
1462  CCState &State) const {
1463  if (!ByVal) {
1464  if (State.FreeRegs) {
1465  --State.FreeRegs; // Non-byval indirects just use one pointer.
1466  if (!IsMCUABI)
1467  return getNaturalAlignIndirectInReg(Ty);
1468  }
1469  return getNaturalAlignIndirect(Ty, false);
1470  }
1471 
1472  // Compute the byval alignment.
1473  unsigned TypeAlign = getContext().getTypeAlign(Ty) / 8;
1474  unsigned StackAlign = getTypeStackAlignInBytes(Ty, TypeAlign);
1475  if (StackAlign == 0)
1476  return ABIArgInfo::getIndirect(CharUnits::fromQuantity(4), /*ByVal=*/true);
1477 
1478  // If the stack alignment is less than the type alignment, realign the
1479  // argument.
1480  bool Realign = TypeAlign > StackAlign;
1482  /*ByVal=*/true, Realign);
1483 }
1484 
1485 X86_32ABIInfo::Class X86_32ABIInfo::classify(QualType Ty) const {
1486  const Type *T = isSingleElementStruct(Ty, getContext());
1487  if (!T)
1488  T = Ty.getTypePtr();
1489 
1490  if (const BuiltinType *BT = T->getAs<BuiltinType>()) {
1491  BuiltinType::Kind K = BT->getKind();
1492  if (K == BuiltinType::Float || K == BuiltinType::Double)
1493  return Float;
1494  }
1495  return Integer;
1496 }
1497 
1498 bool X86_32ABIInfo::updateFreeRegs(QualType Ty, CCState &State) const {
1499  if (!IsSoftFloatABI) {
1500  Class C = classify(Ty);
1501  if (C == Float)
1502  return false;
1503  }
1504 
1505  unsigned Size = getContext().getTypeSize(Ty);
1506  unsigned SizeInRegs = (Size + 31) / 32;
1507 
1508  if (SizeInRegs == 0)
1509  return false;
1510 
1511  if (!IsMCUABI) {
1512  if (SizeInRegs > State.FreeRegs) {
1513  State.FreeRegs = 0;
1514  return false;
1515  }
1516  } else {
1517  // The MCU psABI allows passing parameters in-reg even if there are
1518  // earlier parameters that are passed on the stack. Also,
1519  // it does not allow passing >8-byte structs in-register,
1520  // even if there are 3 free registers available.
1521  if (SizeInRegs > State.FreeRegs || SizeInRegs > 2)
1522  return false;
1523  }
1524 
1525  State.FreeRegs -= SizeInRegs;
1526  return true;
1527 }
1528 
1529 bool X86_32ABIInfo::shouldAggregateUseDirect(QualType Ty, CCState &State,
1530  bool &InReg,
1531  bool &NeedsPadding) const {
1532  // On Windows, aggregates other than HFAs are never passed in registers, and
1533  // they do not consume register slots. Homogenous floating-point aggregates
1534  // (HFAs) have already been dealt with at this point.
1535  if (IsWin32StructABI && isAggregateTypeForABI(Ty))
1536  return false;
1537 
1538  NeedsPadding = false;
1539  InReg = !IsMCUABI;
1540 
1541  if (!updateFreeRegs(Ty, State))
1542  return false;
1543 
1544  if (IsMCUABI)
1545  return true;
1546 
1547  if (State.CC == llvm::CallingConv::X86_FastCall ||
1548  State.CC == llvm::CallingConv::X86_VectorCall ||
1549  State.CC == llvm::CallingConv::X86_RegCall) {
1550  if (getContext().getTypeSize(Ty) <= 32 && State.FreeRegs)
1551  NeedsPadding = true;
1552 
1553  return false;
1554  }
1555 
1556  return true;
1557 }
1558 
1559 bool X86_32ABIInfo::shouldPrimitiveUseInReg(QualType Ty, CCState &State) const {
1560  if (!updateFreeRegs(Ty, State))
1561  return false;
1562 
1563  if (IsMCUABI)
1564  return false;
1565 
1566  if (State.CC == llvm::CallingConv::X86_FastCall ||
1567  State.CC == llvm::CallingConv::X86_VectorCall ||
1568  State.CC == llvm::CallingConv::X86_RegCall) {
1569  if (getContext().getTypeSize(Ty) > 32)
1570  return false;
1571 
1572  return (Ty->isIntegralOrEnumerationType() || Ty->isPointerType() ||
1573  Ty->isReferenceType());
1574  }
1575 
1576  return true;
1577 }
1578 
1580  CCState &State) const {
1581  // FIXME: Set alignment on indirect arguments.
1582 
1584 
1585  // Check with the C++ ABI first.
1586  const RecordType *RT = Ty->getAs<RecordType>();
1587  if (RT) {
1589  if (RAA == CGCXXABI::RAA_Indirect) {
1590  return getIndirectResult(Ty, false, State);
1591  } else if (RAA == CGCXXABI::RAA_DirectInMemory) {
1592  // The field index doesn't matter, we'll fix it up later.
1593  return ABIArgInfo::getInAlloca(/*FieldIndex=*/0);
1594  }
1595  }
1596 
1597  // Regcall uses the concept of a homogenous vector aggregate, similar
1598  // to other targets.
1599  const Type *Base = nullptr;
1600  uint64_t NumElts = 0;
1601  if (State.CC == llvm::CallingConv::X86_RegCall &&
1602  isHomogeneousAggregate(Ty, Base, NumElts)) {
1603 
1604  if (State.FreeSSERegs >= NumElts) {
1605  State.FreeSSERegs -= NumElts;
1606  if (Ty->isBuiltinType() || Ty->isVectorType())
1607  return ABIArgInfo::getDirect();
1608  return ABIArgInfo::getExpand();
1609  }
1610  return getIndirectResult(Ty, /*ByVal=*/false, State);
1611  }
1612 
1613  if (isAggregateTypeForABI(Ty)) {
1614  // Structures with flexible arrays are always indirect.
1615  // FIXME: This should not be byval!
1616  if (RT && RT->getDecl()->hasFlexibleArrayMember())
1617  return getIndirectResult(Ty, true, State);
1618 
1619  // Ignore empty structs/unions on non-Windows.
1620  if (!IsWin32StructABI && isEmptyRecord(getContext(), Ty, true))
1621  return ABIArgInfo::getIgnore();
1622 
1623  llvm::LLVMContext &LLVMContext = getVMContext();
1624  llvm::IntegerType *Int32 = llvm::Type::getInt32Ty(LLVMContext);
1625  bool NeedsPadding = false;
1626  bool InReg;
1627  if (shouldAggregateUseDirect(Ty, State, InReg, NeedsPadding)) {
1628  unsigned SizeInRegs = (getContext().getTypeSize(Ty) + 31) / 32;
1629  SmallVector<llvm::Type*, 3> Elements(SizeInRegs, Int32);
1630  llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements);
1631  if (InReg)
1632  return ABIArgInfo::getDirectInReg(Result);
1633  else
1634  return ABIArgInfo::getDirect(Result);
1635  }
1636  llvm::IntegerType *PaddingType = NeedsPadding ? Int32 : nullptr;
1637 
1638  // Expand small (<= 128-bit) record types when we know that the stack layout
1639  // of those arguments will match the struct. This is important because the
1640  // LLVM backend isn't smart enough to remove byval, which inhibits many
1641  // optimizations.
1642  // Don't do this for the MCU if there are still free integer registers
1643  // (see X86_64 ABI for full explanation).
1644  if (getContext().getTypeSize(Ty) <= 4 * 32 &&
1645  (!IsMCUABI || State.FreeRegs == 0) && canExpandIndirectArgument(Ty))
1647  State.CC == llvm::CallingConv::X86_FastCall ||
1648  State.CC == llvm::CallingConv::X86_VectorCall ||
1649  State.CC == llvm::CallingConv::X86_RegCall,
1650  PaddingType);
1651 
1652  return getIndirectResult(Ty, true, State);
1653  }
1654 
1655  if (const VectorType *VT = Ty->getAs<VectorType>()) {
1656  // On Darwin, some vectors are passed in memory, we handle this by passing
1657  // it as an i8/i16/i32/i64.
1658  if (IsDarwinVectorABI) {
1659  uint64_t Size = getContext().getTypeSize(Ty);
1660  if ((Size == 8 || Size == 16 || Size == 32) ||
1661  (Size == 64 && VT->getNumElements() == 1))
1662  return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
1663  Size));
1664  }
1665 
1666  if (IsX86_MMXType(CGT.ConvertType(Ty)))
1667  return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(), 64));
1668 
1669  return ABIArgInfo::getDirect();
1670  }
1671 
1672 
1673  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
1674  Ty = EnumTy->getDecl()->getIntegerType();
1675 
1676  bool InReg = shouldPrimitiveUseInReg(Ty, State);
1677 
1678  if (Ty->isPromotableIntegerType()) {
1679  if (InReg)
1680  return ABIArgInfo::getExtendInReg();
1681  return ABIArgInfo::getExtend();
1682  }
1683 
1684  if (InReg)
1685  return ABIArgInfo::getDirectInReg();
1686  return ABIArgInfo::getDirect();
1687 }
1688 
1689 void X86_32ABIInfo::computeVectorCallArgs(CGFunctionInfo &FI, CCState &State,
1690  bool &UsedInAlloca) const {
1691  // Vectorcall x86 works subtly different than in x64, so the format is
1692  // a bit different than the x64 version. First, all vector types (not HVAs)
1693  // are assigned, with the first 6 ending up in the YMM0-5 or XMM0-5 registers.
1694  // This differs from the x64 implementation, where the first 6 by INDEX get
1695  // registers.
1696  // After that, integers AND HVAs are assigned Left to Right in the same pass.
1697  // Integers are passed as ECX/EDX if one is available (in order). HVAs will
1698  // first take up the remaining YMM/XMM registers. If insufficient registers
1699  // remain but an integer register (ECX/EDX) is available, it will be passed
1700  // in that, else, on the stack.
1701  for (auto &I : FI.arguments()) {
1702  // First pass do all the vector types.
1703  const Type *Base = nullptr;
1704  uint64_t NumElts = 0;
1705  const QualType& Ty = I.type;
1706  if ((Ty->isVectorType() || Ty->isBuiltinType()) &&
1707  isHomogeneousAggregate(Ty, Base, NumElts)) {
1708  if (State.FreeSSERegs >= NumElts) {
1709  State.FreeSSERegs -= NumElts;
1710  I.info = ABIArgInfo::getDirect();
1711  } else {
1712  I.info = classifyArgumentType(Ty, State);
1713  }
1714  UsedInAlloca |= (I.info.getKind() == ABIArgInfo::InAlloca);
1715  }
1716  }
1717 
1718  for (auto &I : FI.arguments()) {
1719  // Second pass, do the rest!
1720  const Type *Base = nullptr;
1721  uint64_t NumElts = 0;
1722  const QualType& Ty = I.type;
1723  bool IsHva = isHomogeneousAggregate(Ty, Base, NumElts);
1724 
1725  if (IsHva && !Ty->isVectorType() && !Ty->isBuiltinType()) {
1726  // Assign true HVAs (non vector/native FP types).
1727  if (State.FreeSSERegs >= NumElts) {
1728  State.FreeSSERegs -= NumElts;
1729  I.info = getDirectX86Hva();
1730  } else {
1731  I.info = getIndirectResult(Ty, /*ByVal=*/false, State);
1732  }
1733  } else if (!IsHva) {
1734  // Assign all Non-HVAs, so this will exclude Vector/FP args.
1735  I.info = classifyArgumentType(Ty, State);
1736  UsedInAlloca |= (I.info.getKind() == ABIArgInfo::InAlloca);
1737  }
1738  }
1739 }
1740 
1741 void X86_32ABIInfo::computeInfo(CGFunctionInfo &FI) const {
1742  CCState State(FI.getCallingConvention());
1743  if (IsMCUABI)
1744  State.FreeRegs = 3;
1745  else if (State.CC == llvm::CallingConv::X86_FastCall)
1746  State.FreeRegs = 2;
1747  else if (State.CC == llvm::CallingConv::X86_VectorCall) {
1748  State.FreeRegs = 2;
1749  State.FreeSSERegs = 6;
1750  } else if (FI.getHasRegParm())
1751  State.FreeRegs = FI.getRegParm();
1752  else if (State.CC == llvm::CallingConv::X86_RegCall) {
1753  State.FreeRegs = 5;
1754  State.FreeSSERegs = 8;
1755  } else
1756  State.FreeRegs = DefaultNumRegisterParameters;
1757 
1758  if (!getCXXABI().classifyReturnType(FI)) {
1760  } else if (FI.getReturnInfo().isIndirect()) {
1761  // The C++ ABI is not aware of register usage, so we have to check if the
1762  // return value was sret and put it in a register ourselves if appropriate.
1763  if (State.FreeRegs) {
1764  --State.FreeRegs; // The sret parameter consumes a register.
1765  if (!IsMCUABI)
1766  FI.getReturnInfo().setInReg(true);
1767  }
1768  }
1769 
1770  // The chain argument effectively gives us another free register.
1771  if (FI.isChainCall())
1772  ++State.FreeRegs;
1773 
1774  bool UsedInAlloca = false;
1775  if (State.CC == llvm::CallingConv::X86_VectorCall) {
1776  computeVectorCallArgs(FI, State, UsedInAlloca);
1777  } else {
1778  // If not vectorcall, revert to normal behavior.
1779  for (auto &I : FI.arguments()) {
1780  I.info = classifyArgumentType(I.type, State);
1781  UsedInAlloca |= (I.info.getKind() == ABIArgInfo::InAlloca);
1782  }
1783  }
1784 
1785  // If we needed to use inalloca for any argument, do a second pass and rewrite
1786  // all the memory arguments to use inalloca.
1787  if (UsedInAlloca)
1788  rewriteWithInAlloca(FI);
1789 }
1790 
1791 void
1792 X86_32ABIInfo::addFieldToArgStruct(SmallVector<llvm::Type *, 6> &FrameFields,
1793  CharUnits &StackOffset, ABIArgInfo &Info,
1794  QualType Type) const {
1795  // Arguments are always 4-byte-aligned.
1796  CharUnits FieldAlign = CharUnits::fromQuantity(4);
1797 
1798  assert(StackOffset.isMultipleOf(FieldAlign) && "unaligned inalloca struct");
1799  Info = ABIArgInfo::getInAlloca(FrameFields.size());
1800  FrameFields.push_back(CGT.ConvertTypeForMem(Type));
1801  StackOffset += getContext().getTypeSizeInChars(Type);
1802 
1803  // Insert padding bytes to respect alignment.
1804  CharUnits FieldEnd = StackOffset;
1805  StackOffset = FieldEnd.alignTo(FieldAlign);
1806  if (StackOffset != FieldEnd) {
1807  CharUnits NumBytes = StackOffset - FieldEnd;
1808  llvm::Type *Ty = llvm::Type::getInt8Ty(getVMContext());
1809  Ty = llvm::ArrayType::get(Ty, NumBytes.getQuantity());
1810  FrameFields.push_back(Ty);
1811  }
1812 }
1813 
1814 static bool isArgInAlloca(const ABIArgInfo &Info) {
1815  // Leave ignored and inreg arguments alone.
1816  switch (Info.getKind()) {
1817  case ABIArgInfo::InAlloca:
1818  return true;
1819  case ABIArgInfo::Indirect:
1820  assert(Info.getIndirectByVal());
1821  return true;
1822  case ABIArgInfo::Ignore:
1823  return false;
1824  case ABIArgInfo::Direct:
1825  case ABIArgInfo::Extend:
1826  if (Info.getInReg())
1827  return false;
1828  return true;
1829  case ABIArgInfo::Expand:
1831  // These are aggregate types which are never passed in registers when
1832  // inalloca is involved.
1833  return true;
1834  }
1835  llvm_unreachable("invalid enum");
1836 }
1837 
1838 void X86_32ABIInfo::rewriteWithInAlloca(CGFunctionInfo &FI) const {
1839  assert(IsWin32StructABI && "inalloca only supported on win32");
1840 
1841  // Build a packed struct type for all of the arguments in memory.
1842  SmallVector<llvm::Type *, 6> FrameFields;
1843 
1844  // The stack alignment is always 4.
1845  CharUnits StackAlign = CharUnits::fromQuantity(4);
1846 
1847  CharUnits StackOffset;
1848  CGFunctionInfo::arg_iterator I = FI.arg_begin(), E = FI.arg_end();
1849 
1850  // Put 'this' into the struct before 'sret', if necessary.
1851  bool IsThisCall =
1852  FI.getCallingConvention() == llvm::CallingConv::X86_ThisCall;
1853  ABIArgInfo &Ret = FI.getReturnInfo();
1854  if (Ret.isIndirect() && Ret.isSRetAfterThis() && !IsThisCall &&
1855  isArgInAlloca(I->info)) {
1856  addFieldToArgStruct(FrameFields, StackOffset, I->info, I->type);
1857  ++I;
1858  }
1859 
1860  // Put the sret parameter into the inalloca struct if it's in memory.
1861  if (Ret.isIndirect() && !Ret.getInReg()) {
1863  addFieldToArgStruct(FrameFields, StackOffset, Ret, PtrTy);
1864  // On Windows, the hidden sret parameter is always returned in eax.
1865  Ret.setInAllocaSRet(IsWin32StructABI);
1866  }
1867 
1868  // Skip the 'this' parameter in ecx.
1869  if (IsThisCall)
1870  ++I;
1871 
1872  // Put arguments passed in memory into the struct.
1873  for (; I != E; ++I) {
1874  if (isArgInAlloca(I->info))
1875  addFieldToArgStruct(FrameFields, StackOffset, I->info, I->type);
1876  }
1877 
1878  FI.setArgStruct(llvm::StructType::get(getVMContext(), FrameFields,
1879  /*isPacked=*/true),
1880  StackAlign);
1881 }
1882 
1883 Address X86_32ABIInfo::EmitVAArg(CodeGenFunction &CGF,
1884  Address VAListAddr, QualType Ty) const {
1885 
1886  auto TypeInfo = getContext().getTypeInfoInChars(Ty);
1887 
1888  // x86-32 changes the alignment of certain arguments on the stack.
1889  //
1890  // Just messing with TypeInfo like this works because we never pass
1891  // anything indirectly.
1893  getTypeStackAlignInBytes(Ty, TypeInfo.second.getQuantity()));
1894 
1895  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*Indirect*/ false,
1897  /*AllowHigherAlign*/ true);
1898 }
1899 
1900 bool X86_32TargetCodeGenInfo::isStructReturnInRegABI(
1901  const llvm::Triple &Triple, const CodeGenOptions &Opts) {
1902  assert(Triple.getArch() == llvm::Triple::x86);
1903 
1904  switch (Opts.getStructReturnConvention()) {
1906  break;
1907  case CodeGenOptions::SRCK_OnStack: // -fpcc-struct-return
1908  return false;
1909  case CodeGenOptions::SRCK_InRegs: // -freg-struct-return
1910  return true;
1911  }
1912 
1913  if (Triple.isOSDarwin() || Triple.isOSIAMCU())
1914  return true;
1915 
1916  switch (Triple.getOS()) {
1917  case llvm::Triple::DragonFly:
1918  case llvm::Triple::FreeBSD:
1919  case llvm::Triple::OpenBSD:
1920  case llvm::Triple::Win32:
1921  return true;
1922  default:
1923  return false;
1924  }
1925 }
1926 
1927 void X86_32TargetCodeGenInfo::setTargetAttributes(
1928  const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM,
1929  ForDefinition_t IsForDefinition) const {
1930  if (!IsForDefinition)
1931  return;
1932  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
1933  if (FD->hasAttr<X86ForceAlignArgPointerAttr>()) {
1934  // Get the LLVM function.
1935  llvm::Function *Fn = cast<llvm::Function>(GV);
1936 
1937  // Now add the 'alignstack' attribute with a value of 16.
1938  llvm::AttrBuilder B;
1939  B.addStackAlignmentAttr(16);
1940  Fn->addAttributes(llvm::AttributeList::FunctionIndex, B);
1941  }
1942  if (FD->hasAttr<AnyX86InterruptAttr>()) {
1943  llvm::Function *Fn = cast<llvm::Function>(GV);
1944  Fn->setCallingConv(llvm::CallingConv::X86_INTR);
1945  }
1946  }
1947 }
1948 
1949 bool X86_32TargetCodeGenInfo::initDwarfEHRegSizeTable(
1951  llvm::Value *Address) const {
1952  CodeGen::CGBuilderTy &Builder = CGF.Builder;
1953 
1954  llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
1955 
1956  // 0-7 are the eight integer registers; the order is different
1957  // on Darwin (for EH), but the range is the same.
1958  // 8 is %eip.
1959  AssignToArrayRange(Builder, Address, Four8, 0, 8);
1960 
1961  if (CGF.CGM.getTarget().getTriple().isOSDarwin()) {
1962  // 12-16 are st(0..4). Not sure why we stop at 4.
1963  // These have size 16, which is sizeof(long double) on
1964  // platforms with 8-byte alignment for that type.
1965  llvm::Value *Sixteen8 = llvm::ConstantInt::get(CGF.Int8Ty, 16);
1966  AssignToArrayRange(Builder, Address, Sixteen8, 12, 16);
1967 
1968  } else {
1969  // 9 is %eflags, which doesn't get a size on Darwin for some
1970  // reason.
1971  Builder.CreateAlignedStore(
1972  Four8, Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, Address, 9),
1973  CharUnits::One());
1974 
1975  // 11-16 are st(0..5). Not sure why we stop at 5.
1976  // These have size 12, which is sizeof(long double) on
1977  // platforms with 4-byte alignment for that type.
1978  llvm::Value *Twelve8 = llvm::ConstantInt::get(CGF.Int8Ty, 12);
1979  AssignToArrayRange(Builder, Address, Twelve8, 11, 16);
1980  }
1981 
1982  return false;
1983 }
1984 
1985 //===----------------------------------------------------------------------===//
1986 // X86-64 ABI Implementation
1987 //===----------------------------------------------------------------------===//
1988 
1989 
1990 namespace {
1991 /// The AVX ABI level for X86 targets.
1992 enum class X86AVXABILevel {
1993  None,
1994  AVX,
1995  AVX512
1996 };
1997 
1998 /// \p returns the size in bits of the largest (native) vector for \p AVXLevel.
1999 static unsigned getNativeVectorSizeForAVXABI(X86AVXABILevel AVXLevel) {
2000  switch (AVXLevel) {
2001  case X86AVXABILevel::AVX512:
2002  return 512;
2003  case X86AVXABILevel::AVX:
2004  return 256;
2005  case X86AVXABILevel::None:
2006  return 128;
2007  }
2008  llvm_unreachable("Unknown AVXLevel");
2009 }
2010 
2011 /// X86_64ABIInfo - The X86_64 ABI information.
2012 class X86_64ABIInfo : public SwiftABIInfo {
2013  enum Class {
2014  Integer = 0,
2015  SSE,
2016  SSEUp,
2017  X87,
2018  X87Up,
2019  ComplexX87,
2020  NoClass,
2021  Memory
2022  };
2023 
2024  /// merge - Implement the X86_64 ABI merging algorithm.
2025  ///
2026  /// Merge an accumulating classification \arg Accum with a field
2027  /// classification \arg Field.
2028  ///
2029  /// \param Accum - The accumulating classification. This should
2030  /// always be either NoClass or the result of a previous merge
2031  /// call. In addition, this should never be Memory (the caller
2032  /// should just return Memory for the aggregate).
2033  static Class merge(Class Accum, Class Field);
2034 
2035  /// postMerge - Implement the X86_64 ABI post merging algorithm.
2036  ///
2037  /// Post merger cleanup, reduces a malformed Hi and Lo pair to
2038  /// final MEMORY or SSE classes when necessary.
2039  ///
2040  /// \param AggregateSize - The size of the current aggregate in
2041  /// the classification process.
2042  ///
2043  /// \param Lo - The classification for the parts of the type
2044  /// residing in the low word of the containing object.
2045  ///
2046  /// \param Hi - The classification for the parts of the type
2047  /// residing in the higher words of the containing object.
2048  ///
2049  void postMerge(unsigned AggregateSize, Class &Lo, Class &Hi) const;
2050 
2051  /// classify - Determine the x86_64 register classes in which the
2052  /// given type T should be passed.
2053  ///
2054  /// \param Lo - The classification for the parts of the type
2055  /// residing in the low word of the containing object.
2056  ///
2057  /// \param Hi - The classification for the parts of the type
2058  /// residing in the high word of the containing object.
2059  ///
2060  /// \param OffsetBase - The bit offset of this type in the
2061  /// containing object. Some parameters are classified different
2062  /// depending on whether they straddle an eightbyte boundary.
2063  ///
2064  /// \param isNamedArg - Whether the argument in question is a "named"
2065  /// argument, as used in AMD64-ABI 3.5.7.
2066  ///
2067  /// If a word is unused its result will be NoClass; if a type should
2068  /// be passed in Memory then at least the classification of \arg Lo
2069  /// will be Memory.
2070  ///
2071  /// The \arg Lo class will be NoClass iff the argument is ignored.
2072  ///
2073  /// If the \arg Lo class is ComplexX87, then the \arg Hi class will
2074  /// also be ComplexX87.
2075  void classify(QualType T, uint64_t OffsetBase, Class &Lo, Class &Hi,
2076  bool isNamedArg) const;
2077 
2078  llvm::Type *GetByteVectorType(QualType Ty) const;
2079  llvm::Type *GetSSETypeAtOffset(llvm::Type *IRType,
2080  unsigned IROffset, QualType SourceTy,
2081  unsigned SourceOffset) const;
2082  llvm::Type *GetINTEGERTypeAtOffset(llvm::Type *IRType,
2083  unsigned IROffset, QualType SourceTy,
2084  unsigned SourceOffset) const;
2085 
2086  /// getIndirectResult - Give a source type \arg Ty, return a suitable result
2087  /// such that the argument will be returned in memory.
2088  ABIArgInfo getIndirectReturnResult(QualType Ty) const;
2089 
2090  /// getIndirectResult - Give a source type \arg Ty, return a suitable result
2091  /// such that the argument will be passed in memory.
2092  ///
2093  /// \param freeIntRegs - The number of free integer registers remaining
2094  /// available.
2095  ABIArgInfo getIndirectResult(QualType Ty, unsigned freeIntRegs) const;
2096 
2097  ABIArgInfo classifyReturnType(QualType RetTy) const;
2098 
2099  ABIArgInfo classifyArgumentType(QualType Ty, unsigned freeIntRegs,
2100  unsigned &neededInt, unsigned &neededSSE,
2101  bool isNamedArg) const;
2102 
2103  ABIArgInfo classifyRegCallStructType(QualType Ty, unsigned &NeededInt,
2104  unsigned &NeededSSE) const;
2105 
2106  ABIArgInfo classifyRegCallStructTypeImpl(QualType Ty, unsigned &NeededInt,
2107  unsigned &NeededSSE) const;
2108 
2109  bool IsIllegalVectorType(QualType Ty) const;
2110 
2111  /// The 0.98 ABI revision clarified a lot of ambiguities,
2112  /// unfortunately in ways that were not always consistent with
2113  /// certain previous compilers. In particular, platforms which
2114  /// required strict binary compatibility with older versions of GCC
2115  /// may need to exempt themselves.
2116  bool honorsRevision0_98() const {
2117  return !getTarget().getTriple().isOSDarwin();
2118  }
2119 
2120  /// GCC classifies <1 x long long> as SSE but some platform ABIs choose to
2121  /// classify it as INTEGER (for compatibility with older clang compilers).
2122  bool classifyIntegerMMXAsSSE() const {
2123  // Clang <= 3.8 did not do this.
2124  if (getCodeGenOpts().getClangABICompat() <=
2126  return false;
2127 
2128  const llvm::Triple &Triple = getTarget().getTriple();
2129  if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::PS4)
2130  return false;
2131  if (Triple.isOSFreeBSD() && Triple.getOSMajorVersion() >= 10)
2132  return false;
2133  return true;
2134  }
2135 
2136  X86AVXABILevel AVXLevel;
2137  // Some ABIs (e.g. X32 ABI and Native Client OS) use 32 bit pointers on
2138  // 64-bit hardware.
2139  bool Has64BitPointers;
2140 
2141 public:
2142  X86_64ABIInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel) :
2143  SwiftABIInfo(CGT), AVXLevel(AVXLevel),
2144  Has64BitPointers(CGT.getDataLayout().getPointerSize(0) == 8) {
2145  }
2146 
2147  bool isPassedUsingAVXType(QualType type) const {
2148  unsigned neededInt, neededSSE;
2149  // The freeIntRegs argument doesn't matter here.
2150  ABIArgInfo info = classifyArgumentType(type, 0, neededInt, neededSSE,
2151  /*isNamedArg*/true);
2152  if (info.isDirect()) {
2153  llvm::Type *ty = info.getCoerceToType();
2154  if (llvm::VectorType *vectorTy = dyn_cast_or_null<llvm::VectorType>(ty))
2155  return (vectorTy->getBitWidth() > 128);
2156  }
2157  return false;
2158  }
2159 
2160  void computeInfo(CGFunctionInfo &FI) const override;
2161 
2162  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
2163  QualType Ty) const override;
2164  Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
2165  QualType Ty) const override;
2166 
2167  bool has64BitPointers() const {
2168  return Has64BitPointers;
2169  }
2170 
2171  bool shouldPassIndirectlyForSwift(CharUnits totalSize,
2172  ArrayRef<llvm::Type*> scalars,
2173  bool asReturnValue) const override {
2174  return occupiesMoreThan(CGT, scalars, /*total*/ 4);
2175  }
2176  bool isSwiftErrorInRegister() const override {
2177  return true;
2178  }
2179 };
2180 
2181 /// WinX86_64ABIInfo - The Windows X86_64 ABI information.
2182 class WinX86_64ABIInfo : public SwiftABIInfo {
2183 public:
2184  WinX86_64ABIInfo(CodeGen::CodeGenTypes &CGT)
2185  : SwiftABIInfo(CGT),
2186  IsMingw64(getTarget().getTriple().isWindowsGNUEnvironment()) {}
2187 
2188  void computeInfo(CGFunctionInfo &FI) const override;
2189 
2190  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
2191  QualType Ty) const override;
2192 
2193  bool isHomogeneousAggregateBaseType(QualType Ty) const override {
2194  // FIXME: Assumes vectorcall is in use.
2195  return isX86VectorTypeForVectorCall(getContext(), Ty);
2196  }
2197 
2198  bool isHomogeneousAggregateSmallEnough(const Type *Ty,
2199  uint64_t NumMembers) const override {
2200  // FIXME: Assumes vectorcall is in use.
2201  return isX86VectorCallAggregateSmallEnough(NumMembers);
2202  }
2203 
2204  bool shouldPassIndirectlyForSwift(CharUnits totalSize,
2205  ArrayRef<llvm::Type *> scalars,
2206  bool asReturnValue) const override {
2207  return occupiesMoreThan(CGT, scalars, /*total*/ 4);
2208  }
2209 
2210  bool isSwiftErrorInRegister() const override {
2211  return true;
2212  }
2213 
2214 private:
2215  ABIArgInfo classify(QualType Ty, unsigned &FreeSSERegs, bool IsReturnType,
2216  bool IsVectorCall, bool IsRegCall) const;
2217  ABIArgInfo reclassifyHvaArgType(QualType Ty, unsigned &FreeSSERegs,
2218  const ABIArgInfo &current) const;
2219  void computeVectorCallArgs(CGFunctionInfo &FI, unsigned FreeSSERegs,
2220  bool IsVectorCall, bool IsRegCall) const;
2221 
2222  bool IsMingw64;
2223 };
2224 
2225 class X86_64TargetCodeGenInfo : public TargetCodeGenInfo {
2226 public:
2227  X86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel)
2228  : TargetCodeGenInfo(new X86_64ABIInfo(CGT, AVXLevel)) {}
2229 
2230  const X86_64ABIInfo &getABIInfo() const {
2231  return static_cast<const X86_64ABIInfo&>(TargetCodeGenInfo::getABIInfo());
2232  }
2233 
2234  int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
2235  return 7;
2236  }
2237 
2238  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2239  llvm::Value *Address) const override {
2240  llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
2241 
2242  // 0-15 are the 16 integer registers.
2243  // 16 is %rip.
2244  AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
2245  return false;
2246  }
2247 
2248  llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
2249  StringRef Constraint,
2250  llvm::Type* Ty) const override {
2251  return X86AdjustInlineAsmType(CGF, Constraint, Ty);
2252  }
2253 
2254  bool isNoProtoCallVariadic(const CallArgList &args,
2255  const FunctionNoProtoType *fnType) const override {
2256  // The default CC on x86-64 sets %al to the number of SSA
2257  // registers used, and GCC sets this when calling an unprototyped
2258  // function, so we override the default behavior. However, don't do
2259  // that when AVX types are involved: the ABI explicitly states it is
2260  // undefined, and it doesn't work in practice because of how the ABI
2261  // defines varargs anyway.
2262  if (fnType->getCallConv() == CC_C) {
2263  bool HasAVXType = false;
2264  for (CallArgList::const_iterator
2265  it = args.begin(), ie = args.end(); it != ie; ++it) {
2266  if (getABIInfo().isPassedUsingAVXType(it->Ty)) {
2267  HasAVXType = true;
2268  break;
2269  }
2270  }
2271 
2272  if (!HasAVXType)
2273  return true;
2274  }
2275 
2276  return TargetCodeGenInfo::isNoProtoCallVariadic(args, fnType);
2277  }
2278 
2279  llvm::Constant *
2280  getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const override {
2281  unsigned Sig = (0xeb << 0) | // jmp rel8
2282  (0x06 << 8) | // .+0x08
2283  ('v' << 16) |
2284  ('2' << 24);
2285  return llvm::ConstantInt::get(CGM.Int32Ty, Sig);
2286  }
2287 
2288  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
2290  ForDefinition_t IsForDefinition) const override {
2291  if (!IsForDefinition)
2292  return;
2293  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
2294  if (FD->hasAttr<X86ForceAlignArgPointerAttr>()) {
2295  // Get the LLVM function.
2296  auto *Fn = cast<llvm::Function>(GV);
2297 
2298  // Now add the 'alignstack' attribute with a value of 16.
2299  llvm::AttrBuilder B;
2300  B.addStackAlignmentAttr(16);
2301  Fn->addAttributes(llvm::AttributeList::FunctionIndex, B);
2302  }
2303  if (FD->hasAttr<AnyX86InterruptAttr>()) {
2304  llvm::Function *Fn = cast<llvm::Function>(GV);
2305  Fn->setCallingConv(llvm::CallingConv::X86_INTR);
2306  }
2307  }
2308  }
2309 };
2310 
2311 class PS4TargetCodeGenInfo : public X86_64TargetCodeGenInfo {
2312 public:
2313  PS4TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel)
2314  : X86_64TargetCodeGenInfo(CGT, AVXLevel) {}
2315 
2316  void getDependentLibraryOption(llvm::StringRef Lib,
2317  llvm::SmallString<24> &Opt) const override {
2318  Opt = "\01";
2319  // If the argument contains a space, enclose it in quotes.
2320  if (Lib.find(" ") != StringRef::npos)
2321  Opt += "\"" + Lib.str() + "\"";
2322  else
2323  Opt += Lib;
2324  }
2325 };
2326 
2327 static std::string qualifyWindowsLibrary(llvm::StringRef Lib) {
2328  // If the argument does not end in .lib, automatically add the suffix.
2329  // If the argument contains a space, enclose it in quotes.
2330  // This matches the behavior of MSVC.
2331  bool Quote = (Lib.find(" ") != StringRef::npos);
2332  std::string ArgStr = Quote ? "\"" : "";
2333  ArgStr += Lib;
2334  if (!Lib.endswith_lower(".lib"))
2335  ArgStr += ".lib";
2336  ArgStr += Quote ? "\"" : "";
2337  return ArgStr;
2338 }
2339 
2340 class WinX86_32TargetCodeGenInfo : public X86_32TargetCodeGenInfo {
2341 public:
2342  WinX86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,
2343  bool DarwinVectorABI, bool RetSmallStructInRegABI, bool Win32StructABI,
2344  unsigned NumRegisterParameters)
2345  : X86_32TargetCodeGenInfo(CGT, DarwinVectorABI, RetSmallStructInRegABI,
2346  Win32StructABI, NumRegisterParameters, false) {}
2347 
2348  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
2350  ForDefinition_t IsForDefinition) const override;
2351 
2352  void getDependentLibraryOption(llvm::StringRef Lib,
2353  llvm::SmallString<24> &Opt) const override {
2354  Opt = "/DEFAULTLIB:";
2355  Opt += qualifyWindowsLibrary(Lib);
2356  }
2357 
2358  void getDetectMismatchOption(llvm::StringRef Name,
2359  llvm::StringRef Value,
2360  llvm::SmallString<32> &Opt) const override {
2361  Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
2362  }
2363 };
2364 
2365 static void addStackProbeSizeTargetAttribute(const Decl *D,
2366  llvm::GlobalValue *GV,
2367  CodeGen::CodeGenModule &CGM) {
2368  if (D && isa<FunctionDecl>(D)) {
2369  if (CGM.getCodeGenOpts().StackProbeSize != 4096) {
2370  llvm::Function *Fn = cast<llvm::Function>(GV);
2371 
2372  Fn->addFnAttr("stack-probe-size",
2373  llvm::utostr(CGM.getCodeGenOpts().StackProbeSize));
2374  }
2375  }
2376 }
2377 
2378 void WinX86_32TargetCodeGenInfo::setTargetAttributes(
2379  const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM,
2380  ForDefinition_t IsForDefinition) const {
2381  X86_32TargetCodeGenInfo::setTargetAttributes(D, GV, CGM, IsForDefinition);
2382  if (!IsForDefinition)
2383  return;
2384  addStackProbeSizeTargetAttribute(D, GV, CGM);
2385 }
2386 
2387 class WinX86_64TargetCodeGenInfo : public TargetCodeGenInfo {
2388 public:
2389  WinX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,
2390  X86AVXABILevel AVXLevel)
2391  : TargetCodeGenInfo(new WinX86_64ABIInfo(CGT)) {}
2392 
2393  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
2395  ForDefinition_t IsForDefinition) const override;
2396 
2397  int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
2398  return 7;
2399  }
2400 
2401  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2402  llvm::Value *Address) const override {
2403  llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
2404 
2405  // 0-15 are the 16 integer registers.
2406  // 16 is %rip.
2407  AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
2408  return false;
2409  }
2410 
2411  void getDependentLibraryOption(llvm::StringRef Lib,
2412  llvm::SmallString<24> &Opt) const override {
2413  Opt = "/DEFAULTLIB:";
2414  Opt += qualifyWindowsLibrary(Lib);
2415  }
2416 
2417  void getDetectMismatchOption(llvm::StringRef Name,
2418  llvm::StringRef Value,
2419  llvm::SmallString<32> &Opt) const override {
2420  Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
2421  }
2422 };
2423 
2424 void WinX86_64TargetCodeGenInfo::setTargetAttributes(
2425  const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM,
2426  ForDefinition_t IsForDefinition) const {
2427  TargetCodeGenInfo::setTargetAttributes(D, GV, CGM, IsForDefinition);
2428  if (!IsForDefinition)
2429  return;
2430  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
2431  if (FD->hasAttr<X86ForceAlignArgPointerAttr>()) {
2432  // Get the LLVM function.
2433  auto *Fn = cast<llvm::Function>(GV);
2434 
2435  // Now add the 'alignstack' attribute with a value of 16.
2436  llvm::AttrBuilder B;
2437  B.addStackAlignmentAttr(16);
2438  Fn->addAttributes(llvm::AttributeList::FunctionIndex, B);
2439  }
2440  if (FD->hasAttr<AnyX86InterruptAttr>()) {
2441  llvm::Function *Fn = cast<llvm::Function>(GV);
2442  Fn->setCallingConv(llvm::CallingConv::X86_INTR);
2443  }
2444  }
2445 
2446  addStackProbeSizeTargetAttribute(D, GV, CGM);
2447 }
2448 }
2449 
2450 void X86_64ABIInfo::postMerge(unsigned AggregateSize, Class &Lo,
2451  Class &Hi) const {
2452  // AMD64-ABI 3.2.3p2: Rule 5. Then a post merger cleanup is done:
2453  //
2454  // (a) If one of the classes is Memory, the whole argument is passed in
2455  // memory.
2456  //
2457  // (b) If X87UP is not preceded by X87, the whole argument is passed in
2458  // memory.
2459  //
2460  // (c) If the size of the aggregate exceeds two eightbytes and the first
2461  // eightbyte isn't SSE or any other eightbyte isn't SSEUP, the whole
2462  // argument is passed in memory. NOTE: This is necessary to keep the
2463  // ABI working for processors that don't support the __m256 type.
2464  //
2465  // (d) If SSEUP is not preceded by SSE or SSEUP, it is converted to SSE.
2466  //
2467  // Some of these are enforced by the merging logic. Others can arise
2468  // only with unions; for example:
2469  // union { _Complex double; unsigned; }
2470  //
2471  // Note that clauses (b) and (c) were added in 0.98.
2472  //
2473  if (Hi == Memory)
2474  Lo = Memory;
2475  if (Hi == X87Up && Lo != X87 && honorsRevision0_98())
2476  Lo = Memory;
2477  if (AggregateSize > 128 && (Lo != SSE || Hi != SSEUp))
2478  Lo = Memory;
2479  if (Hi == SSEUp && Lo != SSE)
2480  Hi = SSE;
2481 }
2482 
2483 X86_64ABIInfo::Class X86_64ABIInfo::merge(Class Accum, Class Field) {
2484  // AMD64-ABI 3.2.3p2: Rule 4. Each field of an object is
2485  // classified recursively so that always two fields are
2486  // considered. The resulting class is calculated according to
2487  // the classes of the fields in the eightbyte:
2488  //
2489  // (a) If both classes are equal, this is the resulting class.
2490  //
2491  // (b) If one of the classes is NO_CLASS, the resulting class is
2492  // the other class.
2493  //
2494  // (c) If one of the classes is MEMORY, the result is the MEMORY
2495  // class.
2496  //
2497  // (d) If one of the classes is INTEGER, the result is the
2498  // INTEGER.
2499  //
2500  // (e) If one of the classes is X87, X87UP, COMPLEX_X87 class,
2501  // MEMORY is used as class.
2502  //
2503  // (f) Otherwise class SSE is used.
2504 
2505  // Accum should never be memory (we should have returned) or
2506  // ComplexX87 (because this cannot be passed in a structure).
2507  assert((Accum != Memory && Accum != ComplexX87) &&
2508  "Invalid accumulated classification during merge.");
2509  if (Accum == Field || Field == NoClass)
2510  return Accum;
2511  if (Field == Memory)
2512  return Memory;
2513  if (Accum == NoClass)
2514  return Field;
2515  if (Accum == Integer || Field == Integer)
2516  return Integer;
2517  if (Field == X87 || Field == X87Up || Field == ComplexX87 ||
2518  Accum == X87 || Accum == X87Up)
2519  return Memory;
2520  return SSE;
2521 }
2522 
2523 void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase,
2524  Class &Lo, Class &Hi, bool isNamedArg) const {
2525  // FIXME: This code can be simplified by introducing a simple value class for
2526  // Class pairs with appropriate constructor methods for the various
2527  // situations.
2528 
2529  // FIXME: Some of the split computations are wrong; unaligned vectors
2530  // shouldn't be passed in registers for example, so there is no chance they
2531  // can straddle an eightbyte. Verify & simplify.
2532 
2533  Lo = Hi = NoClass;
2534 
2535  Class &Current = OffsetBase < 64 ? Lo : Hi;
2536  Current = Memory;
2537 
2538  if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
2539  BuiltinType::Kind k = BT->getKind();
2540 
2541  if (k == BuiltinType::Void) {
2542  Current = NoClass;
2543  } else if (k == BuiltinType::Int128 || k == BuiltinType::UInt128) {
2544  Lo = Integer;
2545  Hi = Integer;
2546  } else if (k >= BuiltinType::Bool && k <= BuiltinType::LongLong) {
2547  Current = Integer;
2548  } else if (k == BuiltinType::Float || k == BuiltinType::Double) {
2549  Current = SSE;
2550  } else if (k == BuiltinType::LongDouble) {
2551  const llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();
2552  if (LDF == &llvm::APFloat::IEEEquad()) {
2553  Lo = SSE;
2554  Hi = SSEUp;
2555  } else if (LDF == &llvm::APFloat::x87DoubleExtended()) {
2556  Lo = X87;
2557  Hi = X87Up;
2558  } else if (LDF == &llvm::APFloat::IEEEdouble()) {
2559  Current = SSE;
2560  } else
2561  llvm_unreachable("unexpected long double representation!");
2562  }
2563  // FIXME: _Decimal32 and _Decimal64 are SSE.
2564  // FIXME: _float128 and _Decimal128 are (SSE, SSEUp).
2565  return;
2566  }
2567 
2568  if (const EnumType *ET = Ty->getAs<EnumType>()) {
2569  // Classify the underlying integer type.
2570  classify(ET->getDecl()->getIntegerType(), OffsetBase, Lo, Hi, isNamedArg);
2571  return;
2572  }
2573 
2574  if (Ty->hasPointerRepresentation()) {
2575  Current = Integer;
2576  return;
2577  }
2578 
2579  if (Ty->isMemberPointerType()) {
2580  if (Ty->isMemberFunctionPointerType()) {
2581  if (Has64BitPointers) {
2582  // If Has64BitPointers, this is an {i64, i64}, so classify both
2583  // Lo and Hi now.
2584  Lo = Hi = Integer;
2585  } else {
2586  // Otherwise, with 32-bit pointers, this is an {i32, i32}. If that
2587  // straddles an eightbyte boundary, Hi should be classified as well.
2588  uint64_t EB_FuncPtr = (OffsetBase) / 64;
2589  uint64_t EB_ThisAdj = (OffsetBase + 64 - 1) / 64;
2590  if (EB_FuncPtr != EB_ThisAdj) {
2591  Lo = Hi = Integer;
2592  } else {
2593  Current = Integer;
2594  }
2595  }
2596  } else {
2597  Current = Integer;
2598  }
2599  return;
2600  }
2601 
2602  if (const VectorType *VT = Ty->getAs<VectorType>()) {
2603  uint64_t Size = getContext().getTypeSize(VT);
2604  if (Size == 1 || Size == 8 || Size == 16 || Size == 32) {
2605  // gcc passes the following as integer:
2606  // 4 bytes - <4 x char>, <2 x short>, <1 x int>, <1 x float>
2607  // 2 bytes - <2 x char>, <1 x short>
2608  // 1 byte - <1 x char>
2609  Current = Integer;
2610 
2611  // If this type crosses an eightbyte boundary, it should be
2612  // split.
2613  uint64_t EB_Lo = (OffsetBase) / 64;
2614  uint64_t EB_Hi = (OffsetBase + Size - 1) / 64;
2615  if (EB_Lo != EB_Hi)
2616  Hi = Lo;
2617  } else if (Size == 64) {
2618  QualType ElementType = VT->getElementType();
2619 
2620  // gcc passes <1 x double> in memory. :(
2621  if (ElementType->isSpecificBuiltinType(BuiltinType::Double))
2622  return;
2623 
2624  // gcc passes <1 x long long> as SSE but clang used to unconditionally
2625  // pass them as integer. For platforms where clang is the de facto
2626  // platform compiler, we must continue to use integer.
2627  if (!classifyIntegerMMXAsSSE() &&
2628  (ElementType->isSpecificBuiltinType(BuiltinType::LongLong) ||
2629  ElementType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
2630  ElementType->isSpecificBuiltinType(BuiltinType::Long) ||
2631  ElementType->isSpecificBuiltinType(BuiltinType::ULong)))
2632  Current = Integer;
2633  else
2634  Current = SSE;
2635 
2636  // If this type crosses an eightbyte boundary, it should be
2637  // split.
2638  if (OffsetBase && OffsetBase != 64)
2639  Hi = Lo;
2640  } else if (Size == 128 ||
2641  (isNamedArg && Size <= getNativeVectorSizeForAVXABI(AVXLevel))) {
2642  // Arguments of 256-bits are split into four eightbyte chunks. The
2643  // least significant one belongs to class SSE and all the others to class
2644  // SSEUP. The original Lo and Hi design considers that types can't be
2645  // greater than 128-bits, so a 64-bit split in Hi and Lo makes sense.
2646  // This design isn't correct for 256-bits, but since there're no cases
2647  // where the upper parts would need to be inspected, avoid adding
2648  // complexity and just consider Hi to match the 64-256 part.
2649  //
2650  // Note that per 3.5.7 of AMD64-ABI, 256-bit args are only passed in
2651  // registers if they are "named", i.e. not part of the "..." of a
2652  // variadic function.
2653  //
2654  // Similarly, per 3.2.3. of the AVX512 draft, 512-bits ("named") args are
2655  // split into eight eightbyte chunks, one SSE and seven SSEUP.
2656  Lo = SSE;
2657  Hi = SSEUp;
2658  }
2659  return;
2660  }
2661 
2662  if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
2663  QualType ET = getContext().getCanonicalType(CT->getElementType());
2664 
2665  uint64_t Size = getContext().getTypeSize(Ty);
2666  if (ET->isIntegralOrEnumerationType()) {
2667  if (Size <= 64)
2668  Current = Integer;
2669  else if (Size <= 128)
2670  Lo = Hi = Integer;
2671  } else if (ET == getContext().FloatTy) {
2672  Current = SSE;
2673  } else if (ET == getContext().DoubleTy) {
2674  Lo = Hi = SSE;
2675  } else if (ET == getContext().LongDoubleTy) {
2676  const llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();
2677  if (LDF == &llvm::APFloat::IEEEquad())
2678  Current = Memory;
2679  else if (LDF == &llvm::APFloat::x87DoubleExtended())
2680  Current = ComplexX87;
2681  else if (LDF == &llvm::APFloat::IEEEdouble())
2682  Lo = Hi = SSE;
2683  else
2684  llvm_unreachable("unexpected long double representation!");
2685  }
2686 
2687  // If this complex type crosses an eightbyte boundary then it
2688  // should be split.
2689  uint64_t EB_Real = (OffsetBase) / 64;
2690  uint64_t EB_Imag = (OffsetBase + getContext().getTypeSize(ET)) / 64;
2691  if (Hi == NoClass && EB_Real != EB_Imag)
2692  Hi = Lo;
2693 
2694  return;
2695  }
2696 
2697  if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
2698  // Arrays are treated like structures.
2699 
2700  uint64_t Size = getContext().getTypeSize(Ty);
2701 
2702  // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger
2703  // than eight eightbytes, ..., it has class MEMORY.
2704  if (Size > 512)
2705  return;
2706 
2707  // AMD64-ABI 3.2.3p2: Rule 1. If ..., or it contains unaligned
2708  // fields, it has class MEMORY.
2709  //
2710  // Only need to check alignment of array base.
2711  if (OffsetBase % getContext().getTypeAlign(AT->getElementType()))
2712  return;
2713 
2714  // Otherwise implement simplified merge. We could be smarter about
2715  // this, but it isn't worth it and would be harder to verify.
2716  Current = NoClass;
2717  uint64_t EltSize = getContext().getTypeSize(AT->getElementType());
2718  uint64_t ArraySize = AT->getSize().getZExtValue();
2719 
2720  // The only case a 256-bit wide vector could be used is when the array
2721  // contains a single 256-bit element. Since Lo and Hi logic isn't extended
2722  // to work for sizes wider than 128, early check and fallback to memory.
2723  //
2724  if (Size > 128 &&
2725  (Size != EltSize || Size > getNativeVectorSizeForAVXABI(AVXLevel)))
2726  return;
2727 
2728  for (uint64_t i=0, Offset=OffsetBase; i<ArraySize; ++i, Offset += EltSize) {
2729  Class FieldLo, FieldHi;
2730  classify(AT->getElementType(), Offset, FieldLo, FieldHi, isNamedArg);
2731  Lo = merge(Lo, FieldLo);
2732  Hi = merge(Hi, FieldHi);
2733  if (Lo == Memory || Hi == Memory)
2734  break;
2735  }
2736 
2737  postMerge(Size, Lo, Hi);
2738  assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp array classification.");
2739  return;
2740  }
2741 
2742  if (const RecordType *RT = Ty->getAs<RecordType>()) {
2743  uint64_t Size = getContext().getTypeSize(Ty);
2744 
2745  // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger
2746  // than eight eightbytes, ..., it has class MEMORY.
2747  if (Size > 512)
2748  return;
2749 
2750  // AMD64-ABI 3.2.3p2: Rule 2. If a C++ object has either a non-trivial
2751  // copy constructor or a non-trivial destructor, it is passed by invisible
2752  // reference.
2753  if (getRecordArgABI(RT, getCXXABI()))
2754  return;
2755 
2756  const RecordDecl *RD = RT->getDecl();
2757 
2758  // Assume variable sized types are passed in memory.
2759  if (RD->hasFlexibleArrayMember())
2760  return;
2761 
2762  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
2763 
2764  // Reset Lo class, this will be recomputed.
2765  Current = NoClass;
2766 
2767  // If this is a C++ record, classify the bases first.
2768  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
2769  for (const auto &I : CXXRD->bases()) {
2770  assert(!I.isVirtual() && !I.getType()->isDependentType() &&
2771  "Unexpected base class!");
2772  const CXXRecordDecl *Base =
2773  cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
2774 
2775  // Classify this field.
2776  //
2777  // AMD64-ABI 3.2.3p2: Rule 3. If the size of the aggregate exceeds a
2778  // single eightbyte, each is classified separately. Each eightbyte gets
2779  // initialized to class NO_CLASS.
2780  Class FieldLo, FieldHi;
2781  uint64_t Offset =
2782  OffsetBase + getContext().toBits(Layout.getBaseClassOffset(Base));
2783  classify(I.getType(), Offset, FieldLo, FieldHi, isNamedArg);
2784  Lo = merge(Lo, FieldLo);
2785  Hi = merge(Hi, FieldHi);
2786  if (Lo == Memory || Hi == Memory) {
2787  postMerge(Size, Lo, Hi);
2788  return;
2789  }
2790  }
2791  }
2792 
2793  // Classify the fields one at a time, merging the results.
2794  unsigned idx = 0;
2795  for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
2796  i != e; ++i, ++idx) {
2797  uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx);
2798  bool BitField = i->isBitField();
2799 
2800  // Ignore padding bit-fields.
2801  if (BitField && i->isUnnamedBitfield())
2802  continue;
2803 
2804  // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger than
2805  // four eightbytes, or it contains unaligned fields, it has class MEMORY.
2806  //
2807  // The only case a 256-bit wide vector could be used is when the struct
2808  // contains a single 256-bit element. Since Lo and Hi logic isn't extended
2809  // to work for sizes wider than 128, early check and fallback to memory.
2810  //
2811  if (Size > 128 && (Size != getContext().getTypeSize(i->getType()) ||
2812  Size > getNativeVectorSizeForAVXABI(AVXLevel))) {
2813  Lo = Memory;
2814  postMerge(Size, Lo, Hi);
2815  return;
2816  }
2817  // Note, skip this test for bit-fields, see below.
2818  if (!BitField && Offset % getContext().getTypeAlign(i->getType())) {
2819  Lo = Memory;
2820  postMerge(Size, Lo, Hi);
2821  return;
2822  }
2823 
2824  // Classify this field.
2825  //
2826  // AMD64-ABI 3.2.3p2: Rule 3. If the size of the aggregate
2827  // exceeds a single eightbyte, each is classified
2828  // separately. Each eightbyte gets initialized to class
2829  // NO_CLASS.
2830  Class FieldLo, FieldHi;
2831 
2832  // Bit-fields require special handling, they do not force the
2833  // structure to be passed in memory even if unaligned, and
2834  // therefore they can straddle an eightbyte.
2835  if (BitField) {
2836  assert(!i->isUnnamedBitfield());
2837  uint64_t Offset = OffsetBase + Layout.getFieldOffset(idx);
2838  uint64_t Size = i->getBitWidthValue(getContext());
2839 
2840  uint64_t EB_Lo = Offset / 64;
2841  uint64_t EB_Hi = (Offset + Size - 1) / 64;
2842 
2843  if (EB_Lo) {
2844  assert(EB_Hi == EB_Lo && "Invalid classification, type > 16 bytes.");
2845  FieldLo = NoClass;
2846  FieldHi = Integer;
2847  } else {
2848  FieldLo = Integer;
2849  FieldHi = EB_Hi ? Integer : NoClass;
2850  }
2851  } else
2852  classify(i->getType(), Offset, FieldLo, FieldHi, isNamedArg);
2853  Lo = merge(Lo, FieldLo);
2854  Hi = merge(Hi, FieldHi);
2855  if (Lo == Memory || Hi == Memory)
2856  break;
2857  }
2858 
2859  postMerge(Size, Lo, Hi);
2860  }
2861 }
2862 
2863 ABIArgInfo X86_64ABIInfo::getIndirectReturnResult(QualType Ty) const {
2864  // If this is a scalar LLVM value then assume LLVM will pass it in the right
2865  // place naturally.
2866  if (!isAggregateTypeForABI(Ty)) {
2867  // Treat an enum type as its underlying type.
2868  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
2869  Ty = EnumTy->getDecl()->getIntegerType();
2870 
2871  return (Ty->isPromotableIntegerType() ?
2873  }
2874 
2875  return getNaturalAlignIndirect(Ty);
2876 }
2877 
2878 bool X86_64ABIInfo::IsIllegalVectorType(QualType Ty) const {
2879  if (const VectorType *VecTy = Ty->getAs<VectorType>()) {
2880  uint64_t Size = getContext().getTypeSize(VecTy);
2881  unsigned LargestVector = getNativeVectorSizeForAVXABI(AVXLevel);
2882  if (Size <= 64 || Size > LargestVector)
2883  return true;
2884  }
2885 
2886  return false;
2887 }
2888 
2889 ABIArgInfo X86_64ABIInfo::getIndirectResult(QualType Ty,
2890  unsigned freeIntRegs) const {
2891  // If this is a scalar LLVM value then assume LLVM will pass it in the right
2892  // place naturally.
2893  //
2894  // This assumption is optimistic, as there could be free registers available
2895  // when we need to pass this argument in memory, and LLVM could try to pass
2896  // the argument in the free register. This does not seem to happen currently,
2897  // but this code would be much safer if we could mark the argument with
2898  // 'onstack'. See PR12193.
2899  if (!isAggregateTypeForABI(Ty) && !IsIllegalVectorType(Ty)) {
2900  // Treat an enum type as its underlying type.
2901  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
2902  Ty = EnumTy->getDecl()->getIntegerType();
2903 
2904  return (Ty->isPromotableIntegerType() ?
2906  }
2907 
2910 
2911  // Compute the byval alignment. We specify the alignment of the byval in all
2912  // cases so that the mid-level optimizer knows the alignment of the byval.
2913  unsigned Align = std::max(getContext().getTypeAlign(Ty) / 8, 8U);
2914 
2915  // Attempt to avoid passing indirect results using byval when possible. This
2916  // is important for good codegen.
2917  //
2918  // We do this by coercing the value into a scalar type which the backend can
2919  // handle naturally (i.e., without using byval).
2920  //
2921  // For simplicity, we currently only do this when we have exhausted all of the
2922  // free integer registers. Doing this when there are free integer registers
2923  // would require more care, as we would have to ensure that the coerced value
2924  // did not claim the unused register. That would require either reording the
2925  // arguments to the function (so that any subsequent inreg values came first),
2926  // or only doing this optimization when there were no following arguments that
2927  // might be inreg.
2928  //
2929  // We currently expect it to be rare (particularly in well written code) for
2930  // arguments to be passed on the stack when there are still free integer
2931  // registers available (this would typically imply large structs being passed
2932  // by value), so this seems like a fair tradeoff for now.
2933  //
2934  // We can revisit this if the backend grows support for 'onstack' parameter
2935  // attributes. See PR12193.
2936  if (freeIntRegs == 0) {
2937  uint64_t Size = getContext().getTypeSize(Ty);
2938 
2939  // If this type fits in an eightbyte, coerce it into the matching integral
2940  // type, which will end up on the stack (with alignment 8).
2941  if (Align == 8 && Size <= 64)
2942  return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(),
2943  Size));
2944  }
2945 
2947 }
2948 
2949 /// The ABI specifies that a value should be passed in a full vector XMM/YMM
2950 /// register. Pick an LLVM IR type that will be passed as a vector register.
2951 llvm::Type *X86_64ABIInfo::GetByteVectorType(QualType Ty) const {
2952  // Wrapper structs/arrays that only contain vectors are passed just like
2953  // vectors; strip them off if present.
2954  if (const Type *InnerTy = isSingleElementStruct(Ty, getContext()))
2955  Ty = QualType(InnerTy, 0);
2956 
2957  llvm::Type *IRType = CGT.ConvertType(Ty);
2958  if (isa<llvm::VectorType>(IRType) ||
2959  IRType->getTypeID() == llvm::Type::FP128TyID)
2960  return IRType;
2961 
2962  // We couldn't find the preferred IR vector type for 'Ty'.
2963  uint64_t Size = getContext().getTypeSize(Ty);
2964  assert((Size == 128 || Size == 256 || Size == 512) && "Invalid type found!");
2965 
2966  // Return a LLVM IR vector type based on the size of 'Ty'.
2967  return llvm::VectorType::get(llvm::Type::getDoubleTy(getVMContext()),
2968  Size / 64);
2969 }
2970 
2971 /// BitsContainNoUserData - Return true if the specified [start,end) bit range
2972 /// is known to either be off the end of the specified type or being in
2973 /// alignment padding. The user type specified is known to be at most 128 bits
2974 /// in size, and have passed through X86_64ABIInfo::classify with a successful
2975 /// classification that put one of the two halves in the INTEGER class.
2976 ///
2977 /// It is conservatively correct to return false.
2978 static bool BitsContainNoUserData(QualType Ty, unsigned StartBit,
2979  unsigned EndBit, ASTContext &Context) {
2980  // If the bytes being queried are off the end of the type, there is no user
2981  // data hiding here. This handles analysis of builtins, vectors and other
2982  // types that don't contain interesting padding.
2983  unsigned TySize = (unsigned)Context.getTypeSize(Ty);
2984  if (TySize <= StartBit)
2985  return true;
2986 
2987  if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) {
2988  unsigned EltSize = (unsigned)Context.getTypeSize(AT->getElementType());
2989  unsigned NumElts = (unsigned)AT->getSize().getZExtValue();
2990 
2991  // Check each element to see if the element overlaps with the queried range.
2992  for (unsigned i = 0; i != NumElts; ++i) {
2993  // If the element is after the span we care about, then we're done..
2994  unsigned EltOffset = i*EltSize;
2995  if (EltOffset >= EndBit) break;
2996 
2997  unsigned EltStart = EltOffset < StartBit ? StartBit-EltOffset :0;
2998  if (!BitsContainNoUserData(AT->getElementType(), EltStart,
2999  EndBit-EltOffset, Context))
3000  return false;
3001  }
3002  // If it overlaps no elements, then it is safe to process as padding.
3003  return true;
3004  }
3005 
3006  if (const RecordType *RT = Ty->getAs<RecordType>()) {
3007  const RecordDecl *RD = RT->getDecl();
3008  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
3009 
3010  // If this is a C++ record, check the bases first.
3011  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3012  for (const auto &I : CXXRD->bases()) {
3013  assert(!I.isVirtual() && !I.getType()->isDependentType() &&
3014  "Unexpected base class!");
3015  const CXXRecordDecl *Base =
3016  cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
3017 
3018  // If the base is after the span we care about, ignore it.
3019  unsigned BaseOffset = Context.toBits(Layout.getBaseClassOffset(Base));
3020  if (BaseOffset >= EndBit) continue;
3021 
3022  unsigned BaseStart = BaseOffset < StartBit ? StartBit-BaseOffset :0;
3023  if (!BitsContainNoUserData(I.getType(), BaseStart,
3024  EndBit-BaseOffset, Context))
3025  return false;
3026  }
3027  }
3028 
3029  // Verify that no field has data that overlaps the region of interest. Yes
3030  // this could be sped up a lot by being smarter about queried fields,
3031  // however we're only looking at structs up to 16 bytes, so we don't care
3032  // much.
3033  unsigned idx = 0;
3034  for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
3035  i != e; ++i, ++idx) {
3036  unsigned FieldOffset = (unsigned)Layout.getFieldOffset(idx);
3037 
3038  // If we found a field after the region we care about, then we're done.
3039  if (FieldOffset >= EndBit) break;
3040 
3041  unsigned FieldStart = FieldOffset < StartBit ? StartBit-FieldOffset :0;
3042  if (!BitsContainNoUserData(i->getType(), FieldStart, EndBit-FieldOffset,
3043  Context))
3044  return false;
3045  }
3046 
3047  // If nothing in this record overlapped the area of interest, then we're
3048  // clean.
3049  return true;
3050  }
3051 
3052  return false;
3053 }
3054 
3055 /// ContainsFloatAtOffset - Return true if the specified LLVM IR type has a
3056 /// float member at the specified offset. For example, {int,{float}} has a
3057 /// float at offset 4. It is conservatively correct for this routine to return
3058 /// false.
3059 static bool ContainsFloatAtOffset(llvm::Type *IRType, unsigned IROffset,
3060  const llvm::DataLayout &TD) {
3061  // Base case if we find a float.
3062  if (IROffset == 0 && IRType->isFloatTy())
3063  return true;
3064 
3065  // If this is a struct, recurse into the field at the specified offset.
3066  if (llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType)) {
3067  const llvm::StructLayout *SL = TD.getStructLayout(STy);
3068  unsigned Elt = SL->getElementContainingOffset(IROffset);
3069  IROffset -= SL->getElementOffset(Elt);
3070  return ContainsFloatAtOffset(STy->getElementType(Elt), IROffset, TD);
3071  }
3072 
3073  // If this is an array, recurse into the field at the specified offset.
3074  if (llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(IRType)) {
3075  llvm::Type *EltTy = ATy->getElementType();
3076  unsigned EltSize = TD.getTypeAllocSize(EltTy);
3077  IROffset -= IROffset/EltSize*EltSize;
3078  return ContainsFloatAtOffset(EltTy, IROffset, TD);
3079  }
3080 
3081  return false;
3082 }
3083 
3084 
3085 /// GetSSETypeAtOffset - Return a type that will be passed by the backend in the
3086 /// low 8 bytes of an XMM register, corresponding to the SSE class.
3087 llvm::Type *X86_64ABIInfo::
3088 GetSSETypeAtOffset(llvm::Type *IRType, unsigned IROffset,
3089  QualType SourceTy, unsigned SourceOffset) const {
3090  // The only three choices we have are either double, <2 x float>, or float. We
3091  // pass as float if the last 4 bytes is just padding. This happens for
3092  // structs that contain 3 floats.
3093  if (BitsContainNoUserData(SourceTy, SourceOffset*8+32,
3094  SourceOffset*8+64, getContext()))
3095  return llvm::Type::getFloatTy(getVMContext());
3096 
3097  // We want to pass as <2 x float> if the LLVM IR type contains a float at
3098  // offset+0 and offset+4. Walk the LLVM IR type to find out if this is the
3099  // case.
3100  if (ContainsFloatAtOffset(IRType, IROffset, getDataLayout()) &&
3101  ContainsFloatAtOffset(IRType, IROffset+4, getDataLayout()))
3102  return llvm::VectorType::get(llvm::Type::getFloatTy(getVMContext()), 2);
3103 
3104  return llvm::Type::getDoubleTy(getVMContext());
3105 }
3106 
3107 
3108 /// GetINTEGERTypeAtOffset - The ABI specifies that a value should be passed in
3109 /// an 8-byte GPR. This means that we either have a scalar or we are talking
3110 /// about the high or low part of an up-to-16-byte struct. This routine picks
3111 /// the best LLVM IR type to represent this, which may be i64 or may be anything
3112 /// else that the backend will pass in a GPR that works better (e.g. i8, %foo*,
3113 /// etc).
3114 ///
3115 /// PrefType is an LLVM IR type that corresponds to (part of) the IR type for
3116 /// the source type. IROffset is an offset in bytes into the LLVM IR type that
3117 /// the 8-byte value references. PrefType may be null.
3118 ///
3119 /// SourceTy is the source-level type for the entire argument. SourceOffset is
3120 /// an offset into this that we're processing (which is always either 0 or 8).
3121 ///
3122 llvm::Type *X86_64ABIInfo::
3123 GetINTEGERTypeAtOffset(llvm::Type *IRType, unsigned IROffset,
3124  QualType SourceTy, unsigned SourceOffset) const {
3125  // If we're dealing with an un-offset LLVM IR type, then it means that we're
3126  // returning an 8-byte unit starting with it. See if we can safely use it.
3127  if (IROffset == 0) {
3128  // Pointers and int64's always fill the 8-byte unit.
3129  if ((isa<llvm::PointerType>(IRType) && Has64BitPointers) ||
3130  IRType->isIntegerTy(64))
3131  return IRType;
3132 
3133  // If we have a 1/2/4-byte integer, we can use it only if the rest of the
3134  // goodness in the source type is just tail padding. This is allowed to
3135  // kick in for struct {double,int} on the int, but not on
3136  // struct{double,int,int} because we wouldn't return the second int. We
3137  // have to do this analysis on the source type because we can't depend on
3138  // unions being lowered a specific way etc.
3139  if (IRType->isIntegerTy(8) || IRType->isIntegerTy(16) ||
3140  IRType->isIntegerTy(32) ||
3141  (isa<llvm::PointerType>(IRType) && !Has64BitPointers)) {
3142  unsigned BitWidth = isa<llvm::PointerType>(IRType) ? 32 :
3143  cast<llvm::IntegerType>(IRType)->getBitWidth();
3144 
3145  if (BitsContainNoUserData(SourceTy, SourceOffset*8+BitWidth,
3146  SourceOffset*8+64, getContext()))
3147  return IRType;
3148  }
3149  }
3150 
3151  if (llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType)) {
3152  // If this is a struct, recurse into the field at the specified offset.
3153  const llvm::StructLayout *SL = getDataLayout().getStructLayout(STy);
3154  if (IROffset < SL->getSizeInBytes()) {
3155  unsigned FieldIdx = SL->getElementContainingOffset(IROffset);
3156  IROffset -= SL->getElementOffset(FieldIdx);
3157 
3158  return GetINTEGERTypeAtOffset(STy->getElementType(FieldIdx), IROffset,
3159  SourceTy, SourceOffset);
3160  }
3161  }
3162 
3163  if (llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(IRType)) {
3164  llvm::Type *EltTy = ATy->getElementType();
3165  unsigned EltSize = getDataLayout().getTypeAllocSize(EltTy);
3166  unsigned EltOffset = IROffset/EltSize*EltSize;
3167  return GetINTEGERTypeAtOffset(EltTy, IROffset-EltOffset, SourceTy,
3168  SourceOffset);
3169  }
3170 
3171  // Okay, we don't have any better idea of what to pass, so we pass this in an
3172  // integer register that isn't too big to fit the rest of the struct.
3173  unsigned TySizeInBytes =
3174  (unsigned)getContext().getTypeSizeInChars(SourceTy).getQuantity();
3175 
3176  assert(TySizeInBytes != SourceOffset && "Empty field?");
3177 
3178  // It is always safe to classify this as an integer type up to i64 that
3179  // isn't larger than the structure.
3180  return llvm::IntegerType::get(getVMContext(),
3181  std::min(TySizeInBytes-SourceOffset, 8U)*8);
3182 }
3183 
3184 
3185 /// GetX86_64ByValArgumentPair - Given a high and low type that can ideally
3186 /// be used as elements of a two register pair to pass or return, return a
3187 /// first class aggregate to represent them. For example, if the low part of
3188 /// a by-value argument should be passed as i32* and the high part as float,
3189 /// return {i32*, float}.
3190 static llvm::Type *
3192  const llvm::DataLayout &TD) {
3193  // In order to correctly satisfy the ABI, we need to the high part to start
3194  // at offset 8. If the high and low parts we inferred are both 4-byte types
3195  // (e.g. i32 and i32) then the resultant struct type ({i32,i32}) won't have
3196  // the second element at offset 8. Check for this:
3197  unsigned LoSize = (unsigned)TD.getTypeAllocSize(Lo);
3198  unsigned HiAlign = TD.getABITypeAlignment(Hi);
3199  unsigned HiStart = llvm::alignTo(LoSize, HiAlign);
3200  assert(HiStart != 0 && HiStart <= 8 && "Invalid x86-64 argument pair!");
3201 
3202  // To handle this, we have to increase the size of the low part so that the
3203  // second element will start at an 8 byte offset. We can't increase the size
3204  // of the second element because it might make us access off the end of the
3205  // struct.
3206  if (HiStart != 8) {
3207  // There are usually two sorts of types the ABI generation code can produce
3208  // for the low part of a pair that aren't 8 bytes in size: float or
3209  // i8/i16/i32. This can also include pointers when they are 32-bit (X32 and
3210  // NaCl).
3211  // Promote these to a larger type.
3212  if (Lo->isFloatTy())
3213  Lo = llvm::Type::getDoubleTy(Lo->getContext());
3214  else {
3215  assert((Lo->isIntegerTy() || Lo->isPointerTy())
3216  && "Invalid/unknown lo type");
3217  Lo = llvm::Type::getInt64Ty(Lo->getContext());
3218  }
3219  }
3220 
3221  llvm::StructType *Result = llvm::StructType::get(Lo, Hi);
3222 
3223  // Verify that the second element is at an 8-byte offset.
3224  assert(TD.getStructLayout(Result)->getElementOffset(1) == 8 &&
3225  "Invalid x86-64 argument pair!");
3226  return Result;
3227 }
3228 
3230 classifyReturnType(QualType RetTy) const {
3231  // AMD64-ABI 3.2.3p4: Rule 1. Classify the return type with the
3232  // classification algorithm.
3233  X86_64ABIInfo::Class Lo, Hi;
3234  classify(RetTy, 0, Lo, Hi, /*isNamedArg*/ true);
3235 
3236  // Check some invariants.
3237  assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
3238  assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
3239 
3240  llvm::Type *ResType = nullptr;
3241  switch (Lo) {
3242  case NoClass:
3243  if (Hi == NoClass)
3244  return ABIArgInfo::getIgnore();
3245  // If the low part is just padding, it takes no register, leave ResType
3246  // null.
3247  assert((Hi == SSE || Hi == Integer || Hi == X87Up) &&
3248  "Unknown missing lo part");
3249  break;
3250 
3251  case SSEUp:
3252  case X87Up:
3253  llvm_unreachable("Invalid classification for lo word.");
3254 
3255  // AMD64-ABI 3.2.3p4: Rule 2. Types of class memory are returned via
3256  // hidden argument.
3257  case Memory:
3258  return getIndirectReturnResult(RetTy);
3259 
3260  // AMD64-ABI 3.2.3p4: Rule 3. If the class is INTEGER, the next
3261  // available register of the sequence %rax, %rdx is used.
3262  case Integer:
3263  ResType = GetINTEGERTypeAtOffset(CGT.ConvertType(RetTy), 0, RetTy, 0);
3264 
3265  // If we have a sign or zero extended integer, make sure to return Extend
3266  // so that the parameter gets the right LLVM IR attributes.
3267  if (Hi == NoClass && isa<llvm::IntegerType>(ResType)) {
3268  // Treat an enum type as its underlying type.
3269  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
3270  RetTy = EnumTy->getDecl()->getIntegerType();
3271 
3272  if (RetTy->isIntegralOrEnumerationType() &&
3273  RetTy->isPromotableIntegerType())
3274  return ABIArgInfo::getExtend();
3275  }
3276  break;
3277 
3278  // AMD64-ABI 3.2.3p4: Rule 4. If the class is SSE, the next
3279  // available SSE register of the sequence %xmm0, %xmm1 is used.
3280  case SSE:
3281  ResType = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 0, RetTy, 0);
3282  break;
3283 
3284  // AMD64-ABI 3.2.3p4: Rule 6. If the class is X87, the value is
3285  // returned on the X87 stack in %st0 as 80-bit x87 number.
3286  case X87:
3287  ResType = llvm::Type::getX86_FP80Ty(getVMContext());
3288  break;
3289 
3290  // AMD64-ABI 3.2.3p4: Rule 8. If the class is COMPLEX_X87, the real
3291  // part of the value is returned in %st0 and the imaginary part in
3292  // %st1.
3293  case ComplexX87:
3294  assert(Hi == ComplexX87 && "Unexpected ComplexX87 classification.");
3295  ResType = llvm::StructType::get(llvm::Type::getX86_FP80Ty(getVMContext()),
3296  llvm::Type::getX86_FP80Ty(getVMContext()));
3297  break;
3298  }
3299 
3300  llvm::Type *HighPart = nullptr;
3301  switch (Hi) {
3302  // Memory was handled previously and X87 should
3303  // never occur as a hi class.
3304  case Memory:
3305  case X87:
3306  llvm_unreachable("Invalid classification for hi word.");
3307 
3308  case ComplexX87: // Previously handled.
3309  case NoClass:
3310  break;
3311 
3312  case Integer:
3313  HighPart = GetINTEGERTypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);
3314  if (Lo == NoClass) // Return HighPart at offset 8 in memory.
3315  return ABIArgInfo::getDirect(HighPart, 8);
3316  break;
3317  case SSE:
3318  HighPart = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);
3319  if (Lo == NoClass) // Return HighPart at offset 8 in memory.
3320  return ABIArgInfo::getDirect(HighPart, 8);
3321  break;
3322 
3323  // AMD64-ABI 3.2.3p4: Rule 5. If the class is SSEUP, the eightbyte
3324  // is passed in the next available eightbyte chunk if the last used
3325  // vector register.
3326  //
3327  // SSEUP should always be preceded by SSE, just widen.
3328  case SSEUp:
3329  assert(Lo == SSE && "Unexpected SSEUp classification.");
3330  ResType = GetByteVectorType(RetTy);
3331  break;
3332 
3333  // AMD64-ABI 3.2.3p4: Rule 7. If the class is X87UP, the value is
3334  // returned together with the previous X87 value in %st0.
3335  case X87Up:
3336  // If X87Up is preceded by X87, we don't need to do
3337  // anything. However, in some cases with unions it may not be
3338  // preceded by X87. In such situations we follow gcc and pass the
3339  // extra bits in an SSE reg.
3340  if (Lo != X87) {
3341  HighPart = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);
3342  if (Lo == NoClass) // Return HighPart at offset 8 in memory.
3343  return ABIArgInfo::getDirect(HighPart, 8);
3344  }
3345  break;
3346  }
3347 
3348  // If a high part was specified, merge it together with the low part. It is
3349  // known to pass in the high eightbyte of the result. We do this by forming a
3350  // first class struct aggregate with the high and low part: {low, high}
3351  if (HighPart)
3352  ResType = GetX86_64ByValArgumentPair(ResType, HighPart, getDataLayout());
3353 
3354  return ABIArgInfo::getDirect(ResType);
3355 }
3356 
3358  QualType Ty, unsigned freeIntRegs, unsigned &neededInt, unsigned &neededSSE,
3359  bool isNamedArg)
3360  const
3361 {
3363 
3364  X86_64ABIInfo::Class Lo, Hi;
3365  classify(Ty, 0, Lo, Hi, isNamedArg);
3366 
3367  // Check some invariants.
3368  // FIXME: Enforce these by construction.
3369  assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
3370  assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
3371 
3372  neededInt = 0;
3373  neededSSE = 0;
3374  llvm::Type *ResType = nullptr;
3375  switch (Lo) {
3376  case NoClass:
3377  if (Hi == NoClass)
3378  return ABIArgInfo::getIgnore();
3379  // If the low part is just padding, it takes no register, leave ResType
3380  // null.
3381  assert((Hi == SSE || Hi == Integer || Hi == X87Up) &&
3382  "Unknown missing lo part");
3383  break;
3384 
3385  // AMD64-ABI 3.2.3p3: Rule 1. If the class is MEMORY, pass the argument
3386  // on the stack.
3387  case Memory:
3388 
3389  // AMD64-ABI 3.2.3p3: Rule 5. If the class is X87, X87UP or
3390  // COMPLEX_X87, it is passed in memory.
3391  case X87:
3392  case ComplexX87:
3394  ++neededInt;
3395  return getIndirectResult(Ty, freeIntRegs);
3396 
3397  case SSEUp:
3398  case X87Up:
3399  llvm_unreachable("Invalid classification for lo word.");
3400 
3401  // AMD64-ABI 3.2.3p3: Rule 2. If the class is INTEGER, the next
3402  // available register of the sequence %rdi, %rsi, %rdx, %rcx, %r8
3403  // and %r9 is used.
3404  case Integer:
3405  ++neededInt;
3406 
3407  // Pick an 8-byte type based on the preferred type.
3408  ResType = GetINTEGERTypeAtOffset(CGT.ConvertType(Ty), 0, Ty, 0);
3409 
3410  // If we have a sign or zero extended integer, make sure to return Extend
3411  // so that the parameter gets the right LLVM IR attributes.
3412  if (Hi == NoClass && isa<llvm::IntegerType>(ResType)) {
3413  // Treat an enum type as its underlying type.
3414  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
3415  Ty = EnumTy->getDecl()->getIntegerType();
3416 
3417  if (Ty->isIntegralOrEnumerationType() &&
3419  return ABIArgInfo::getExtend();
3420  }
3421 
3422  break;
3423 
3424  // AMD64-ABI 3.2.3p3: Rule 3. If the class is SSE, the next
3425  // available SSE register is used, the registers are taken in the
3426  // order from %xmm0 to %xmm7.
3427  case SSE: {
3428  llvm::Type *IRType = CGT.ConvertType(Ty);
3429  ResType = GetSSETypeAtOffset(IRType, 0, Ty, 0);
3430  ++neededSSE;
3431  break;
3432  }
3433  }
3434 
3435  llvm::Type *HighPart = nullptr;
3436  switch (Hi) {
3437  // Memory was handled previously, ComplexX87 and X87 should
3438  // never occur as hi classes, and X87Up must be preceded by X87,
3439  // which is passed in memory.
3440  case Memory:
3441  case X87:
3442  case ComplexX87:
3443  llvm_unreachable("Invalid classification for hi word.");
3444 
3445  case NoClass: break;
3446 
3447  case Integer:
3448  ++neededInt;
3449  // Pick an 8-byte type based on the preferred type.
3450  HighPart = GetINTEGERTypeAtOffset(CGT.ConvertType(Ty), 8, Ty, 8);
3451 
3452  if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
3453  return ABIArgInfo::getDirect(HighPart, 8);
3454  break;
3455 
3456  // X87Up generally doesn't occur here (long double is passed in
3457  // memory), except in situations involving unions.
3458  case X87Up:
3459  case SSE:
3460  HighPart = GetSSETypeAtOffset(CGT.ConvertType(Ty), 8, Ty, 8);
3461 
3462  if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
3463  return ABIArgInfo::getDirect(HighPart, 8);
3464 
3465  ++neededSSE;
3466  break;
3467 
3468  // AMD64-ABI 3.2.3p3: Rule 4. If the class is SSEUP, the
3469  // eightbyte is passed in the upper half of the last used SSE
3470  // register. This only happens when 128-bit vectors are passed.
3471  case SSEUp:
3472  assert(Lo == SSE && "Unexpected SSEUp classification");
3473  ResType = GetByteVectorType(Ty);
3474  break;
3475  }
3476 
3477  // If a high part was specified, merge it together with the low part. It is
3478  // known to pass in the high eightbyte of the result. We do this by forming a
3479  // first class struct aggregate with the high and low part: {low, high}
3480  if (HighPart)
3481  ResType = GetX86_64ByValArgumentPair(ResType, HighPart, getDataLayout());
3482 
3483  return ABIArgInfo::getDirect(ResType);
3484 }
3485 
3486 ABIArgInfo
3487 X86_64ABIInfo::classifyRegCallStructTypeImpl(QualType Ty, unsigned &NeededInt,
3488  unsigned &NeededSSE) const {
3489  auto RT = Ty->getAs<RecordType>();
3490  assert(RT && "classifyRegCallStructType only valid with struct types");
3491 
3492  if (RT->getDecl()->hasFlexibleArrayMember())
3493  return getIndirectReturnResult(Ty);
3494 
3495  // Sum up bases
3496  if (auto CXXRD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
3497  if (CXXRD->isDynamicClass()) {
3498  NeededInt = NeededSSE = 0;
3499  return getIndirectReturnResult(Ty);
3500  }
3501 
3502  for (const auto &I : CXXRD->bases())
3503  if (classifyRegCallStructTypeImpl(I.getType(), NeededInt, NeededSSE)
3504  .isIndirect()) {
3505  NeededInt = NeededSSE = 0;
3506  return getIndirectReturnResult(Ty);
3507  }
3508  }
3509 
3510  // Sum up members
3511  for (const auto *FD : RT->getDecl()->fields()) {
3512  if (FD->getType()->isRecordType() && !FD->getType()->isUnionType()) {
3513  if (classifyRegCallStructTypeImpl(FD->getType(), NeededInt, NeededSSE)
3514  .isIndirect()) {
3515  NeededInt = NeededSSE = 0;
3516  return getIndirectReturnResult(Ty);
3517  }
3518  } else {
3519  unsigned LocalNeededInt, LocalNeededSSE;
3520  if (classifyArgumentType(FD->getType(), UINT_MAX, LocalNeededInt,
3521  LocalNeededSSE, true)
3522  .isIndirect()) {
3523  NeededInt = NeededSSE = 0;
3524  return getIndirectReturnResult(Ty);
3525  }
3526  NeededInt += LocalNeededInt;
3527  NeededSSE += LocalNeededSSE;
3528  }
3529  }
3530 
3531  return ABIArgInfo::getDirect();
3532 }
3533 
3534 ABIArgInfo X86_64ABIInfo::classifyRegCallStructType(QualType Ty,
3535  unsigned &NeededInt,
3536  unsigned &NeededSSE) const {
3537 
3538  NeededInt = 0;
3539  NeededSSE = 0;
3540 
3541  return classifyRegCallStructTypeImpl(Ty, NeededInt, NeededSSE);
3542 }
3543 
3544 void X86_64ABIInfo::computeInfo(CGFunctionInfo &FI) const {
3545 
3546  const unsigned CallingConv = FI.getCallingConvention();
3547  // It is possible to force Win64 calling convention on any x86_64 target by
3548  // using __attribute__((ms_abi)). In such case to correctly emit Win64
3549  // compatible code delegate this call to WinX86_64ABIInfo::computeInfo.
3550  if (CallingConv == llvm::CallingConv::Win64) {
3551  WinX86_64ABIInfo Win64ABIInfo(CGT);
3552  Win64ABIInfo.computeInfo(FI);
3553  return;
3554  }
3555 
3556  bool IsRegCall = CallingConv == llvm::CallingConv::X86_RegCall;
3557 
3558  // Keep track of the number of assigned registers.
3559  unsigned FreeIntRegs = IsRegCall ? 11 : 6;
3560  unsigned FreeSSERegs = IsRegCall ? 16 : 8;
3561  unsigned NeededInt, NeededSSE;
3562 
3563  if (!getCXXABI().classifyReturnType(FI)) {
3564  if (IsRegCall && FI.getReturnType()->getTypePtr()->isRecordType() &&
3565  !FI.getReturnType()->getTypePtr()->isUnionType()) {
3566  FI.getReturnInfo() =
3567  classifyRegCallStructType(FI.getReturnType(), NeededInt, NeededSSE);
3568  if (FreeIntRegs >= NeededInt && FreeSSERegs >= NeededSSE) {
3569  FreeIntRegs -= NeededInt;
3570  FreeSSERegs -= NeededSSE;
3571  } else {
3572  FI.getReturnInfo() = getIndirectReturnResult(FI.getReturnType());
3573  }
3574  } else if (IsRegCall && FI.getReturnType()->getAs<ComplexType>()) {
3575  // Complex Long Double Type is passed in Memory when Regcall
3576  // calling convention is used.
3577  const ComplexType *CT = FI.getReturnType()->getAs<ComplexType>();
3580  FI.getReturnInfo() = getIndirectReturnResult(FI.getReturnType());
3581  } else
3583  }
3584 
3585  // If the return value is indirect, then the hidden argument is consuming one
3586  // integer register.
3587  if (FI.getReturnInfo().isIndirect())
3588  --FreeIntRegs;
3589 
3590  // The chain argument effectively gives us another free register.
3591  if (FI.isChainCall())
3592  ++FreeIntRegs;
3593 
3594  unsigned NumRequiredArgs = FI.getNumRequiredArgs();
3595  // AMD64-ABI 3.2.3p3: Once arguments are classified, the registers
3596  // get assigned (in left-to-right order) for passing as follows...
3597  unsigned ArgNo = 0;
3598  for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
3599  it != ie; ++it, ++ArgNo) {
3600  bool IsNamedArg = ArgNo < NumRequiredArgs;
3601 
3602  if (IsRegCall && it->type->isStructureOrClassType())
3603  it->info = classifyRegCallStructType(it->type, NeededInt, NeededSSE);
3604  else
3605  it->info = classifyArgumentType(it->type, FreeIntRegs, NeededInt,
3606  NeededSSE, IsNamedArg);
3607 
3608  // AMD64-ABI 3.2.3p3: If there are no registers available for any
3609  // eightbyte of an argument, the whole argument is passed on the
3610  // stack. If registers have already been assigned for some
3611  // eightbytes of such an argument, the assignments get reverted.
3612  if (FreeIntRegs >= NeededInt && FreeSSERegs >= NeededSSE) {
3613  FreeIntRegs -= NeededInt;
3614  FreeSSERegs -= NeededSSE;
3615  } else {
3616  it->info = getIndirectResult(it->type, FreeIntRegs);
3617  }
3618  }
3619 }
3620 
3622  Address VAListAddr, QualType Ty) {
3623  Address overflow_arg_area_p = CGF.Builder.CreateStructGEP(
3624  VAListAddr, 2, CharUnits::fromQuantity(8), "overflow_arg_area_p");
3625  llvm::Value *overflow_arg_area =
3626  CGF.Builder.CreateLoad(overflow_arg_area_p, "overflow_arg_area");
3627 
3628  // AMD64-ABI 3.5.7p5: Step 7. Align l->overflow_arg_area upwards to a 16
3629  // byte boundary if alignment needed by type exceeds 8 byte boundary.
3630  // It isn't stated explicitly in the standard, but in practice we use
3631  // alignment greater than 16 where necessary.
3632  CharUnits Align = CGF.getContext().getTypeAlignInChars(Ty);
3633  if (Align > CharUnits::fromQuantity(8)) {
3634  overflow_arg_area = emitRoundPointerUpToAlignment(CGF, overflow_arg_area,
3635  Align);
3636  }
3637 
3638  // AMD64-ABI 3.5.7p5: Step 8. Fetch type from l->overflow_arg_area.
3639  llvm::Type *LTy = CGF.ConvertTypeForMem(Ty);
3640  llvm::Value *Res =
3641  CGF.Builder.CreateBitCast(overflow_arg_area,
3642  llvm::PointerType::getUnqual(LTy));
3643 
3644  // AMD64-ABI 3.5.7p5: Step 9. Set l->overflow_arg_area to:
3645  // l->overflow_arg_area + sizeof(type).
3646  // AMD64-ABI 3.5.7p5: Step 10. Align l->overflow_arg_area upwards to
3647  // an 8 byte boundary.
3648 
3649  uint64_t SizeInBytes = (CGF.getContext().getTypeSize(Ty) + 7) / 8;
3650  llvm::Value *Offset =
3651  llvm::ConstantInt::get(CGF.Int32Ty, (SizeInBytes + 7) & ~7);
3652  overflow_arg_area = CGF.Builder.CreateGEP(overflow_arg_area, Offset,
3653  "overflow_arg_area.next");
3654  CGF.Builder.CreateStore(overflow_arg_area, overflow_arg_area_p);
3655 
3656  // AMD64-ABI 3.5.7p5: Step 11. Return the fetched type.
3657  return Address(Res, Align);
3658 }
3659 
3660 Address X86_64ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
3661  QualType Ty) const {
3662  // Assume that va_list type is correct; should be pointer to LLVM type:
3663  // struct {
3664  // i32 gp_offset;
3665  // i32 fp_offset;
3666  // i8* overflow_arg_area;
3667  // i8* reg_save_area;
3668  // };
3669  unsigned neededInt, neededSSE;
3670 
3671  Ty = getContext().getCanonicalType(Ty);
3672  ABIArgInfo AI = classifyArgumentType(Ty, 0, neededInt, neededSSE,
3673  /*isNamedArg*/false);
3674 
3675  // AMD64-ABI 3.5.7p5: Step 1. Determine whether type may be passed
3676  // in the registers. If not go to step 7.
3677  if (!neededInt && !neededSSE)
3678  return EmitX86_64VAArgFromMemory(CGF, VAListAddr, Ty);
3679 
3680  // AMD64-ABI 3.5.7p5: Step 2. Compute num_gp to hold the number of
3681  // general purpose registers needed to pass type and num_fp to hold
3682  // the number of floating point registers needed.
3683 
3684  // AMD64-ABI 3.5.7p5: Step 3. Verify whether arguments fit into
3685  // registers. In the case: l->gp_offset > 48 - num_gp * 8 or
3686  // l->fp_offset > 304 - num_fp * 16 go to step 7.
3687  //
3688  // NOTE: 304 is a typo, there are (6 * 8 + 8 * 16) = 176 bytes of
3689  // register save space).
3690 
3691  llvm::Value *InRegs = nullptr;
3692  Address gp_offset_p = Address::invalid(), fp_offset_p = Address::invalid();
3693  llvm::Value *gp_offset = nullptr, *fp_offset = nullptr;
3694  if (neededInt) {
3695  gp_offset_p =
3696  CGF.Builder.CreateStructGEP(VAListAddr, 0, CharUnits::Zero(),
3697  "gp_offset_p");
3698  gp_offset = CGF.Builder.CreateLoad(gp_offset_p, "gp_offset");
3699  InRegs = llvm::ConstantInt::get(CGF.Int32Ty, 48 - neededInt * 8);
3700  InRegs = CGF.Builder.CreateICmpULE(gp_offset, InRegs, "fits_in_gp");
3701  }
3702 
3703  if (neededSSE) {
3704  fp_offset_p =
3705  CGF.Builder.CreateStructGEP(VAListAddr, 1, CharUnits::fromQuantity(4),
3706  "fp_offset_p");
3707  fp_offset = CGF.Builder.CreateLoad(fp_offset_p, "fp_offset");
3708  llvm::Value *FitsInFP =
3709  llvm::ConstantInt::get(CGF.Int32Ty, 176 - neededSSE * 16);
3710  FitsInFP = CGF.Builder.CreateICmpULE(fp_offset, FitsInFP, "fits_in_fp");
3711  InRegs = InRegs ? CGF.Builder.CreateAnd(InRegs, FitsInFP) : FitsInFP;
3712  }
3713 
3714  llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg");
3715  llvm::BasicBlock *InMemBlock = CGF.createBasicBlock("vaarg.in_mem");
3716  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end");
3717  CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);
3718 
3719  // Emit code to load the value if it was passed in registers.
3720 
3721  CGF.EmitBlock(InRegBlock);
3722 
3723  // AMD64-ABI 3.5.7p5: Step 4. Fetch type from l->reg_save_area with
3724  // an offset of l->gp_offset and/or l->fp_offset. This may require
3725  // copying to a temporary location in case the parameter is passed
3726  // in different register classes or requires an alignment greater
3727  // than 8 for general purpose registers and 16 for XMM registers.
3728  //
3729  // FIXME: This really results in shameful code when we end up needing to
3730  // collect arguments from different places; often what should result in a
3731  // simple assembling of a structure from scattered addresses has many more
3732  // loads than necessary. Can we clean this up?
3733  llvm::Type *LTy = CGF.ConvertTypeForMem(Ty);
3734  llvm::Value *RegSaveArea = CGF.Builder.CreateLoad(
3735  CGF.Builder.CreateStructGEP(VAListAddr, 3, CharUnits::fromQuantity(16)),
3736  "reg_save_area");
3737 
3738  Address RegAddr = Address::invalid();
3739  if (neededInt && neededSSE) {
3740  // FIXME: Cleanup.
3741  assert(AI.isDirect() && "Unexpected ABI info for mixed regs");
3742  llvm::StructType *ST = cast<llvm::StructType>(AI.getCoerceToType());
3743  Address Tmp = CGF.CreateMemTemp(Ty);
3744  Tmp = CGF.Builder.CreateElementBitCast(Tmp, ST);
3745  assert(ST->getNumElements() == 2 && "Unexpected ABI info for mixed regs");
3746  llvm::Type *TyLo = ST->getElementType(0);
3747  llvm::Type *TyHi = ST->getElementType(1);
3748  assert((TyLo->isFPOrFPVectorTy() ^ TyHi->isFPOrFPVectorTy()) &&
3749  "Unexpected ABI info for mixed regs");
3750  llvm::Type *PTyLo = llvm::PointerType::getUnqual(TyLo);
3751  llvm::Type *PTyHi = llvm::PointerType::getUnqual(TyHi);
3752  llvm::Value *GPAddr = CGF.Builder.CreateGEP(RegSaveArea, gp_offset);
3753  llvm::Value *FPAddr = CGF.Builder.CreateGEP(RegSaveArea, fp_offset);
3754  llvm::Value *RegLoAddr = TyLo->isFPOrFPVectorTy() ? FPAddr : GPAddr;
3755  llvm::Value *RegHiAddr = TyLo->isFPOrFPVectorTy() ? GPAddr : FPAddr;
3756 
3757  // Copy the first element.
3758  // FIXME: Our choice of alignment here and below is probably pessimistic.
3760  TyLo, CGF.Builder.CreateBitCast(RegLoAddr, PTyLo),
3761  CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(TyLo)));
3762  CGF.Builder.CreateStore(V,
3763  CGF.Builder.CreateStructGEP(Tmp, 0, CharUnits::Zero()));
3764 
3765  // Copy the second element.
3766  V = CGF.Builder.CreateAlignedLoad(
3767  TyHi, CGF.Builder.CreateBitCast(RegHiAddr, PTyHi),
3768  CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(TyHi)));
3770  getDataLayout().getStructLayout(ST)->getElementOffset(1));
3771  CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1, Offset));
3772 
3773  RegAddr = CGF.Builder.CreateElementBitCast(Tmp, LTy);
3774  } else if (neededInt) {
3775  RegAddr = Address(CGF.Builder.CreateGEP(RegSaveArea, gp_offset),
3777  RegAddr = CGF.Builder.CreateElementBitCast(RegAddr, LTy);
3778 
3779  // Copy to a temporary if necessary to ensure the appropriate alignment.
3780  std::pair<CharUnits, CharUnits> SizeAlign =
3782  uint64_t TySize = SizeAlign.first.getQuantity();
3783  CharUnits TyAlign = SizeAlign.second;
3784 
3785  // Copy into a temporary if the type is more aligned than the
3786  // register save area.
3787  if (TyAlign.getQuantity() > 8) {
3788  Address Tmp = CGF.CreateMemTemp(Ty);
3789  CGF.Builder.CreateMemCpy(Tmp, RegAddr, TySize, false);
3790  RegAddr = Tmp;
3791  }
3792 
3793  } else if (neededSSE == 1) {
3794  RegAddr = Address(CGF.Builder.CreateGEP(RegSaveArea, fp_offset),
3796  RegAddr = CGF.Builder.CreateElementBitCast(RegAddr, LTy);
3797  } else {
3798  assert(neededSSE == 2 && "Invalid number of needed registers!");
3799  // SSE registers are spaced 16 bytes apart in the register save
3800  // area, we need to collect the two eightbytes together.
3801  // The ABI isn't explicit about this, but it seems reasonable
3802  // to assume that the slots are 16-byte aligned, since the stack is
3803  // naturally 16-byte aligned and the prologue is expected to store
3804  // all the SSE registers to the RSA.
3805  Address RegAddrLo = Address(CGF.Builder.CreateGEP(RegSaveArea, fp_offset),
3807  Address RegAddrHi =
3808  CGF.Builder.CreateConstInBoundsByteGEP(RegAddrLo,
3810  llvm::Type *DoubleTy = CGF.DoubleTy;
3811  llvm::StructType *ST = llvm::StructType::get(DoubleTy, DoubleTy);
3812  llvm::Value *V;
3813  Address Tmp = CGF.CreateMemTemp(Ty);
3814  Tmp = CGF.Builder.CreateElementBitCast(Tmp, ST);
3815  V = CGF.Builder.CreateLoad(
3816  CGF.Builder.CreateElementBitCast(RegAddrLo, DoubleTy));
3817  CGF.Builder.CreateStore(V,
3818  CGF.Builder.CreateStructGEP(Tmp, 0, CharUnits::Zero()));
3819  V = CGF.Builder.CreateLoad(
3820  CGF.Builder.CreateElementBitCast(RegAddrHi, DoubleTy));
3821  CGF.Builder.CreateStore(V,
3823 
3824  RegAddr = CGF.Builder.CreateElementBitCast(Tmp, LTy);
3825  }
3826 
3827  // AMD64-ABI 3.5.7p5: Step 5. Set:
3828  // l->gp_offset = l->gp_offset + num_gp * 8
3829  // l->fp_offset = l->fp_offset + num_fp * 16.
3830  if (neededInt) {
3831  llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, neededInt * 8);
3832  CGF.Builder.CreateStore(CGF.Builder.CreateAdd(gp_offset, Offset),
3833  gp_offset_p);
3834  }
3835  if (neededSSE) {
3836  llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, neededSSE * 16);
3837  CGF.Builder.CreateStore(CGF.Builder.CreateAdd(fp_offset, Offset),
3838  fp_offset_p);
3839  }
3840  CGF.EmitBranch(ContBlock);
3841 
3842  // Emit code to load the value if it was passed in memory.
3843 
3844  CGF.EmitBlock(InMemBlock);
3845  Address MemAddr = EmitX86_64VAArgFromMemory(CGF, VAListAddr, Ty);
3846 
3847  // Return the appropriate result.
3848 
3849  CGF.EmitBlock(ContBlock);
3850  Address ResAddr = emitMergePHI(CGF, RegAddr, InRegBlock, MemAddr, InMemBlock,
3851  "vaarg.addr");
3852  return ResAddr;
3853 }
3854 
3855 Address X86_64ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
3856  QualType Ty) const {
3857  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*indirect*/ false,
3858  CGF.getContext().getTypeInfoInChars(Ty),
3860  /*allowHigherAlign*/ false);
3861 }
3862 
3863 ABIArgInfo
3864 WinX86_64ABIInfo::reclassifyHvaArgType(QualType Ty, unsigned &FreeSSERegs,
3865  const ABIArgInfo &current) const {
3866  // Assumes vectorCall calling convention.
3867  const Type *Base = nullptr;
3868  uint64_t NumElts = 0;
3869 
3870  if (!Ty->isBuiltinType() && !Ty->isVectorType() &&
3871  isHomogeneousAggregate(Ty, Base, NumElts) && FreeSSERegs >= NumElts) {
3872  FreeSSERegs -= NumElts;
3873  return getDirectX86Hva();
3874  }
3875  return current;
3876 }
3877 
3878 ABIArgInfo WinX86_64ABIInfo::classify(QualType Ty, unsigned &FreeSSERegs,
3879  bool IsReturnType, bool IsVectorCall,
3880  bool IsRegCall) const {
3881 
3882  if (Ty->isVoidType())
3883  return ABIArgInfo::getIgnore();
3884 
3885  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
3886  Ty = EnumTy->getDecl()->getIntegerType();
3887 
3888  TypeInfo Info = getContext().getTypeInfo(Ty);
3889  uint64_t Width = Info.Width;
3891 
3892  const RecordType *RT = Ty->getAs<RecordType>();
3893  if (RT) {
3894  if (!IsReturnType) {
3897  }
3898 
3899  if (RT->getDecl()->hasFlexibleArrayMember())
3900  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
3901 
3902  }
3903 
3904  const Type *Base = nullptr;
3905  uint64_t NumElts = 0;
3906  // vectorcall adds the concept of a homogenous vector aggregate, similar to
3907  // other targets.
3908  if ((IsVectorCall || IsRegCall) &&
3909  isHomogeneousAggregate(Ty, Base, NumElts)) {
3910  if (IsRegCall) {
3911  if (FreeSSERegs >= NumElts) {
3912  FreeSSERegs -= NumElts;
3913  if (IsReturnType || Ty->isBuiltinType() || Ty->isVectorType())
3914  return ABIArgInfo::getDirect();
3915  return ABIArgInfo::getExpand();
3916  }
3917  return ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
3918  } else if (IsVectorCall) {
3919  if (FreeSSERegs >= NumElts &&
3920  (IsReturnType || Ty->isBuiltinType() || Ty->isVectorType())) {
3921  FreeSSERegs -= NumElts;
3922  return ABIArgInfo::getDirect();
3923  } else if (IsReturnType) {
3924  return ABIArgInfo::getExpand();
3925  } else if (!Ty->isBuiltinType() && !Ty->isVectorType()) {
3926  // HVAs are delayed and reclassified in the 2nd step.
3927  return ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
3928  }
3929  }
3930  }
3931 
3932  if (Ty->isMemberPointerType()) {
3933  // If the member pointer is represented by an LLVM int or ptr, pass it
3934  // directly.
3935  llvm::Type *LLTy = CGT.ConvertType(Ty);
3936  if (LLTy->isPointerTy() || LLTy->isIntegerTy())
3937  return ABIArgInfo::getDirect();
3938  }
3939 
3940  if (RT || Ty->isAnyComplexType() || Ty->isMemberPointerType()) {
3941  // MS x64 ABI requirement: "Any argument that doesn't fit in 8 bytes, or is
3942  // not 1, 2, 4, or 8 bytes, must be passed by reference."
3943  if (Width > 64 || !llvm::isPowerOf2_64(Width))
3944  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
3945 
3946  // Otherwise, coerce it to a small integer.
3947  return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(), Width));
3948  }
3949 
3950  // Bool type is always extended to the ABI, other builtin types are not
3951  // extended.
3952  const BuiltinType *BT = Ty->getAs<BuiltinType>();
3953  if (BT && BT->getKind() == BuiltinType::Bool)
3954  return ABIArgInfo::getExtend();
3955 
3956  // Mingw64 GCC uses the old 80 bit extended precision floating point unit. It
3957  // passes them indirectly through memory.
3958  if (IsMingw64 && BT && BT->getKind() == BuiltinType::LongDouble) {
3959  const llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();
3960  if (LDF == &llvm::APFloat::x87DoubleExtended())
3961  return ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
3962  }
3963 
3964  return ABIArgInfo::getDirect();
3965 }
3966 
3967 void WinX86_64ABIInfo::computeVectorCallArgs(CGFunctionInfo &FI,
3968  unsigned FreeSSERegs,
3969  bool IsVectorCall,
3970  bool IsRegCall) const {
3971  unsigned Count = 0;
3972  for (auto &I : FI.arguments()) {
3973  // Vectorcall in x64 only permits the first 6 arguments to be passed
3974  // as XMM/YMM registers.
3975  if (Count < VectorcallMaxParamNumAsReg)
3976  I.info = classify(I.type, FreeSSERegs, false, IsVectorCall, IsRegCall);
3977  else {
3978  // Since these cannot be passed in registers, pretend no registers
3979  // are left.
3980  unsigned ZeroSSERegsAvail = 0;
3981  I.info = classify(I.type, /*FreeSSERegs=*/ZeroSSERegsAvail, false,
3982  IsVectorCall, IsRegCall);
3983  }
3984  ++Count;
3985  }
3986 
3987  for (auto &I : FI.arguments()) {
3988  I.info = reclassifyHvaArgType(I.type, FreeSSERegs, I.info);
3989  }
3990 }
3991 
3992 void WinX86_64ABIInfo::computeInfo(CGFunctionInfo &FI) const {
3993  bool IsVectorCall =
3994  FI.getCallingConvention() == llvm::CallingConv::X86_VectorCall;
3995  bool IsRegCall = FI.getCallingConvention() == llvm::CallingConv::X86_RegCall;
3996 
3997  unsigned FreeSSERegs = 0;
3998  if (IsVectorCall) {
3999  // We can use up to 4 SSE return registers with vectorcall.
4000  FreeSSERegs = 4;
4001  } else if (IsRegCall) {
4002  // RegCall gives us 16 SSE registers.
4003  FreeSSERegs = 16;
4004  }
4005 
4006  if (!getCXXABI().classifyReturnType(FI))
4007  FI.getReturnInfo() = classify(FI.getReturnType(), FreeSSERegs, true,
4008  IsVectorCall, IsRegCall);
4009 
4010  if (IsVectorCall) {
4011  // We can use up to 6 SSE register parameters with vectorcall.
4012  FreeSSERegs = 6;
4013  } else if (IsRegCall) {
4014  // RegCall gives us 16 SSE registers, we can reuse the return registers.
4015  FreeSSERegs = 16;
4016  }
4017 
4018  if (IsVectorCall) {
4019  computeVectorCallArgs(FI, FreeSSERegs, IsVectorCall, IsRegCall);
4020  } else {
4021  for (auto &I : FI.arguments())
4022  I.info = classify(I.type, FreeSSERegs, false, IsVectorCall, IsRegCall);
4023  }
4024 
4025 }
4026 
4027 Address WinX86_64ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4028  QualType Ty) const {
4029 
4030  bool IsIndirect = false;
4031 
4032  // MS x64 ABI requirement: "Any argument that doesn't fit in 8 bytes, or is
4033  // not 1, 2, 4, or 8 bytes, must be passed by reference."
4034  if (isAggregateTypeForABI(Ty) || Ty->isMemberPointerType()) {
4035  uint64_t Width = getContext().getTypeSize(Ty);
4036  IsIndirect = Width > 64 || !llvm::isPowerOf2_64(Width);
4037  }
4038 
4039  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, IsIndirect,
4040  CGF.getContext().getTypeInfoInChars(Ty),
4042  /*allowHigherAlign*/ false);
4043 }
4044 
4045 // PowerPC-32
4046 namespace {
4047 /// PPC32_SVR4_ABIInfo - The 32-bit PowerPC ELF (SVR4) ABI information.
4048 class PPC32_SVR4_ABIInfo : public DefaultABIInfo {
4049  bool IsSoftFloatABI;
4050 
4051  CharUnits getParamTypeAlignment(QualType Ty) const;
4052 
4053 public:
4054  PPC32_SVR4_ABIInfo(CodeGen::CodeGenTypes &CGT, bool SoftFloatABI)
4055  : DefaultABIInfo(CGT), IsSoftFloatABI(SoftFloatABI) {}
4056 
4057  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4058  QualType Ty) const override;
4059 };
4060 
4061 class PPC32TargetCodeGenInfo : public TargetCodeGenInfo {
4062 public:
4063  PPC32TargetCodeGenInfo(CodeGenTypes &CGT, bool SoftFloatABI)
4064  : TargetCodeGenInfo(new PPC32_SVR4_ABIInfo(CGT, SoftFloatABI)) {}
4065 
4066  int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
4067  // This is recovered from gcc output.
4068  return 1; // r1 is the dedicated stack pointer
4069  }
4070 
4071  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
4072  llvm::Value *Address) const override;
4073 };
4074 }
4075 
4076 CharUnits PPC32_SVR4_ABIInfo::getParamTypeAlignment(QualType Ty) const {
4077  // Complex types are passed just like their elements
4078  if (const ComplexType *CTy = Ty->getAs<ComplexType>())
4079  Ty = CTy->getElementType();
4080 
4081  if (Ty->isVectorType())
4082  return CharUnits::fromQuantity(getContext().getTypeSize(Ty) == 128 ? 16
4083  : 4);
4084 
4085  // For single-element float/vector structs, we consider the whole type
4086  // to have the same alignment requirements as its single element.
4087  const Type *AlignTy = nullptr;
4088  if (const Type *EltType = isSingleElementStruct(Ty, getContext())) {
4089  const BuiltinType *BT = EltType->getAs<BuiltinType>();
4090  if ((EltType->isVectorType() && getContext().getTypeSize(EltType) == 128) ||
4091  (BT && BT->isFloatingPoint()))
4092  AlignTy = EltType;
4093  }
4094 
4095  if (AlignTy)
4096  return CharUnits::fromQuantity(AlignTy->isVectorType() ? 16 : 4);
4097  return CharUnits::fromQuantity(4);
4098 }
4099 
4100 // TODO: this implementation is now likely redundant with
4101 // DefaultABIInfo::EmitVAArg.
4102 Address PPC32_SVR4_ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAList,
4103  QualType Ty) const {
4104  if (getTarget().getTriple().isOSDarwin()) {
4105  auto TI = getContext().getTypeInfoInChars(Ty);
4106  TI.second = getParamTypeAlignment(Ty);
4107 
4108  CharUnits SlotSize = CharUnits::fromQuantity(4);
4109  return emitVoidPtrVAArg(CGF, VAList, Ty,
4110  classifyArgumentType(Ty).isIndirect(), TI, SlotSize,
4111  /*AllowHigherAlign=*/true);
4112  }
4113 
4114  const unsigned OverflowLimit = 8;
4115  if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
4116  // TODO: Implement this. For now ignore.
4117  (void)CTy;
4118  return Address::invalid(); // FIXME?
4119  }
4120 
4121  // struct __va_list_tag {
4122  // unsigned char gpr;
4123  // unsigned char fpr;
4124  // unsigned short reserved;
4125  // void *overflow_arg_area;
4126  // void *reg_save_area;
4127  // };
4128 
4129  bool isI64 = Ty->isIntegerType() && getContext().getTypeSize(Ty) == 64;
4130  bool isInt =
4131  Ty->isIntegerType() || Ty->isPointerType() || Ty->isAggregateType();
4132  bool isF64 = Ty->isFloatingType() && getContext().getTypeSize(Ty) == 64;
4133 
4134  // All aggregates are passed indirectly? That doesn't seem consistent
4135  // with the argument-lowering code.
4136  bool isIndirect = Ty->isAggregateType();
4137 
4138  CGBuilderTy &Builder = CGF.Builder;
4139 
4140  // The calling convention either uses 1-2 GPRs or 1 FPR.
4141  Address NumRegsAddr = Address::invalid();
4142  if (isInt || IsSoftFloatABI) {
4143  NumRegsAddr = Builder.CreateStructGEP(VAList, 0, CharUnits::Zero(), "gpr");
4144  } else {
4145  NumRegsAddr = Builder.CreateStructGEP(VAList, 1, CharUnits::One(), "fpr");
4146  }
4147 
4148  llvm::Value *NumRegs = Builder.CreateLoad(NumRegsAddr, "numUsedRegs");
4149 
4150  // "Align" the register count when TY is i64.
4151  if (isI64 || (isF64 && IsSoftFloatABI)) {
4152  NumRegs = Builder.CreateAdd(NumRegs, Builder.getInt8(1));
4153  NumRegs = Builder.CreateAnd(NumRegs, Builder.getInt8((uint8_t) ~1U));
4154  }
4155 
4156  llvm::Value *CC =
4157  Builder.CreateICmpULT(NumRegs, Builder.getInt8(OverflowLimit), "cond");
4158 
4159  llvm::BasicBlock *UsingRegs = CGF.createBasicBlock("using_regs");
4160  llvm::BasicBlock *UsingOverflow = CGF.createBasicBlock("using_overflow");
4161  llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
4162 
4163  Builder.CreateCondBr(CC, UsingRegs, UsingOverflow);
4164 
4165  llvm::Type *DirectTy = CGF.ConvertType(Ty);
4166  if (isIndirect) DirectTy = DirectTy->getPointerTo(0);
4167 
4168  // Case 1: consume registers.
4169  Address RegAddr = Address::invalid();
4170  {
4171  CGF.EmitBlock(UsingRegs);
4172 
4173  Address RegSaveAreaPtr =
4174  Builder.CreateStructGEP(VAList, 4, CharUnits::fromQuantity(8));
4175  RegAddr = Address(Builder.CreateLoad(RegSaveAreaPtr),
4177  assert(RegAddr.getElementType() == CGF.Int8Ty);
4178 
4179  // Floating-point registers start after the general-purpose registers.
4180  if (!(isInt || IsSoftFloatABI)) {
4181  RegAddr = Builder.CreateConstInBoundsByteGEP(RegAddr,
4183  }
4184 
4185  // Get the address of the saved value by scaling the number of
4186  // registers we've used by the number of
4187  CharUnits RegSize = CharUnits::fromQuantity((isInt || IsSoftFloatABI) ? 4 : 8);
4188  llvm::Value *RegOffset =
4189  Builder.CreateMul(NumRegs, Builder.getInt8(RegSize.getQuantity()));
4190  RegAddr = Address(Builder.CreateInBoundsGEP(CGF.Int8Ty,
4191  RegAddr.getPointer(), RegOffset),
4192  RegAddr.getAlignment().alignmentOfArrayElement(RegSize));
4193  RegAddr = Builder.CreateElementBitCast(RegAddr, DirectTy);
4194 
4195  // Increase the used-register count.
4196  NumRegs =
4197  Builder.CreateAdd(NumRegs,
4198  Builder.getInt8((isI64 || (isF64 && IsSoftFloatABI)) ? 2 : 1));
4199  Builder.CreateStore(NumRegs, NumRegsAddr);
4200 
4201  CGF.EmitBranch(Cont);
4202  }
4203 
4204  // Case 2: consume space in the overflow area.
4205  Address MemAddr = Address::invalid();
4206  {
4207  CGF.EmitBlock(UsingOverflow);
4208 
4209  Builder.CreateStore(Builder.getInt8(OverflowLimit), NumRegsAddr);
4210 
4211  // Everything in the overflow area is rounded up to a size of at least 4.
4212  CharUnits OverflowAreaAlign = CharUnits::fromQuantity(4);
4213 
4214  CharUnits Size;
4215  if (!isIndirect) {
4216  auto TypeInfo = CGF.getContext().getTypeInfoInChars(Ty);
4217  Size = TypeInfo.first.alignTo(OverflowAreaAlign);
4218  } else {
4219  Size = CGF.getPointerSize();
4220  }
4221 
4222  Address OverflowAreaAddr =
4223  Builder.CreateStructGEP(VAList, 3, CharUnits::fromQuantity(4));
4224  Address OverflowArea(Builder.CreateLoad(OverflowAreaAddr, "argp.cur"),
4225  OverflowAreaAlign);
4226  // Round up address of argument to alignment
4227  CharUnits Align = CGF.getContext().getTypeAlignInChars(Ty);
4228  if (Align > OverflowAreaAlign) {
4229  llvm::Value *Ptr = OverflowArea.getPointer();
4230  OverflowArea = Address(emitRoundPointerUpToAlignment(CGF, Ptr, Align),
4231  Align);
4232  }
4233 
4234  MemAddr = Builder.CreateElementBitCast(OverflowArea, DirectTy);
4235 
4236  // Increase the overflow area.
4237  OverflowArea = Builder.CreateConstInBoundsByteGEP(OverflowArea, Size);
4238  Builder.CreateStore(OverflowArea.getPointer(), OverflowAreaAddr);
4239  CGF.EmitBranch(Cont);
4240  }
4241 
4242  CGF.EmitBlock(Cont);
4243 
4244  // Merge the cases with a phi.
4245  Address Result = emitMergePHI(CGF, RegAddr, UsingRegs, MemAddr, UsingOverflow,
4246  "vaarg.addr");
4247 
4248  // Load the pointer if the argument was passed indirectly.
4249  if (isIndirect) {
4250  Result = Address(Builder.CreateLoad(Result, "aggr"),
4252  }
4253 
4254  return Result;
4255 }
4256 
4257 bool
4258 PPC32TargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
4259  llvm::Value *Address) const {
4260  // This is calculated from the LLVM and GCC tables and verified
4261  // against gcc output. AFAIK all ABIs use the same encoding.
4262 
4263  CodeGen::CGBuilderTy &Builder = CGF.Builder;
4264 
4265  llvm::IntegerType *i8 = CGF.Int8Ty;
4266  llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
4267  llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
4268  llvm::Value *Sixteen8 = llvm::ConstantInt::get(i8, 16);
4269 
4270  // 0-31: r0-31, the 4-byte general-purpose registers
4271  AssignToArrayRange(Builder, Address, Four8, 0, 31);
4272 
4273  // 32-63: fp0-31, the 8-byte floating-point registers
4274  AssignToArrayRange(Builder, Address, Eight8, 32, 63);
4275 
4276  // 64-76 are various 4-byte special-purpose registers:
4277  // 64: mq
4278  // 65: lr
4279  // 66: ctr
4280  // 67: ap
4281  // 68-75 cr0-7
4282  // 76: xer
4283  AssignToArrayRange(Builder, Address, Four8, 64, 76);
4284 
4285  // 77-108: v0-31, the 16-byte vector registers
4286  AssignToArrayRange(Builder, Address, Sixteen8, 77, 108);
4287 
4288  // 109: vrsave
4289  // 110: vscr
4290  // 111: spe_acc
4291  // 112: spefscr
4292  // 113: sfp
4293  AssignToArrayRange(Builder, Address, Four8, 109, 113);
4294 
4295  return false;
4296 }
4297 
4298 // PowerPC-64
4299 
4300 namespace {
4301 /// PPC64_SVR4_ABIInfo - The 64-bit PowerPC ELF (SVR4) ABI information.
4302 class PPC64_SVR4_ABIInfo : public ABIInfo {
4303 public:
4304  enum ABIKind {
4305  ELFv1 = 0,
4306  ELFv2
4307  };
4308 
4309 private:
4310  static const unsigned GPRBits = 64;
4311  ABIKind Kind;
4312  bool HasQPX;
4313  bool IsSoftFloatABI;
4314 
4315  // A vector of float or double will be promoted to <4 x f32> or <4 x f64> and
4316  // will be passed in a QPX register.
4317  bool IsQPXVectorTy(const Type *Ty) const {
4318  if (!HasQPX)
4319  return false;
4320 
4321  if (const VectorType *VT = Ty->getAs<VectorType>()) {
4322  unsigned NumElements = VT->getNumElements();
4323  if (NumElements == 1)
4324  return false;
4325 
4326  if (VT->getElementType()->isSpecificBuiltinType(BuiltinType::Double)) {
4327  if (getContext().getTypeSize(Ty) <= 256)
4328  return true;
4329  } else if (VT->getElementType()->
4330  isSpecificBuiltinType(BuiltinType::Float)) {
4331  if (getContext().getTypeSize(Ty) <= 128)
4332  return true;
4333  }
4334  }
4335 
4336  return false;
4337  }
4338 
4339  bool IsQPXVectorTy(QualType Ty) const {
4340  return IsQPXVectorTy(Ty.getTypePtr());
4341  }
4342 
4343 public:
4344  PPC64_SVR4_ABIInfo(CodeGen::CodeGenTypes &CGT, ABIKind Kind, bool HasQPX,
4345  bool SoftFloatABI)
4346  : ABIInfo(CGT), Kind(Kind), HasQPX(HasQPX),
4347  IsSoftFloatABI(SoftFloatABI) {}
4348 
4349  bool isPromotableTypeForABI(QualType Ty) const;
4350  CharUnits getParamTypeAlignment(QualType Ty) const;
4351 
4352  ABIArgInfo classifyReturnType(QualType RetTy) const;
4354 
4355  bool isHomogeneousAggregateBaseType(QualType Ty) const override;
4356  bool isHomogeneousAggregateSmallEnough(const Type *Ty,
4357  uint64_t Members) const override;
4358 
4359  // TODO: We can add more logic to computeInfo to improve performance.
4360  // Example: For aggregate arguments that fit in a register, we could
4361  // use getDirectInReg (as is done below for structs containing a single
4362  // floating-point value) to avoid pushing them to memory on function
4363  // entry. This would require changing the logic in PPCISelLowering
4364  // when lowering the parameters in the caller and args in the callee.
4365  void computeInfo(CGFunctionInfo &FI) const override {
4366  if (!getCXXABI().classifyReturnType(FI))
4368  for (auto &I : FI.arguments()) {
4369  // We rely on the default argument classification for the most part.
4370  // One exception: An aggregate containing a single floating-point
4371  // or vector item must be passed in a register if one is available.
4372  const Type *T = isSingleElementStruct(I.type, getContext());
4373  if (T) {
4374  const BuiltinType *BT = T->getAs<BuiltinType>();
4375  if (IsQPXVectorTy(T) ||
4376  (T->isVectorType() && getContext().getTypeSize(T) == 128) ||
4377  (BT && BT->isFloatingPoint())) {
4378  QualType QT(T, 0);
4379  I.info = ABIArgInfo::getDirectInReg(CGT.ConvertType(QT));
4380  continue;
4381  }
4382  }
4383  I.info = classifyArgumentType(I.type);
4384  }
4385  }
4386 
4387  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4388  QualType Ty) const override;
4389 };
4390 
4391 class PPC64_SVR4_TargetCodeGenInfo : public TargetCodeGenInfo {
4392 
4393 public:
4394  PPC64_SVR4_TargetCodeGenInfo(CodeGenTypes &CGT,
4395  PPC64_SVR4_ABIInfo::ABIKind Kind, bool HasQPX,
4396  bool SoftFloatABI)
4397  : TargetCodeGenInfo(new PPC64_SVR4_ABIInfo(CGT, Kind, HasQPX,
4398  SoftFloatABI)) {}
4399 
4400  int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
4401  // This is recovered from gcc output.
4402  return 1; // r1 is the dedicated stack pointer
4403  }
4404 
4405  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
4406  llvm::Value *Address) const override;
4407 };
4408 
4409 class PPC64TargetCodeGenInfo : public DefaultTargetCodeGenInfo {
4410 public:
4411  PPC64TargetCodeGenInfo(CodeGenTypes &CGT) : DefaultTargetCodeGenInfo(CGT) {}
4412 
4413  int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
4414  // This is recovered from gcc output.
4415  return 1; // r1 is the dedicated stack pointer
4416  }
4417 
4418  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
4419  llvm::Value *Address) const override;
4420 };
4421 
4422 }
4423 
4424 // Return true if the ABI requires Ty to be passed sign- or zero-
4425 // extended to 64 bits.
4426 bool
4427 PPC64_SVR4_ABIInfo::isPromotableTypeForABI(QualType Ty) const {
4428  // Treat an enum type as its underlying type.
4429  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
4430  Ty = EnumTy->getDecl()->getIntegerType();
4431 
4432  // Promotable integer types are required to be promoted by the ABI.
4433  if (Ty->isPromotableIntegerType())
4434  return true;
4435 
4436  // In addition to the usual promotable integer types, we also need to
4437  // extend all 32-bit types, since the ABI requires promotion to 64 bits.
4438  if (const BuiltinType *BT = Ty->getAs<BuiltinType>())
4439  switch (BT->getKind()) {
4440  case BuiltinType::Int:
4441  case BuiltinType::UInt:
4442  return true;
4443  default:
4444  break;
4445  }
4446 
4447  return false;
4448 }
4449 
4450 /// isAlignedParamType - Determine whether a type requires 16-byte or
4451 /// higher alignment in the parameter area. Always returns at least 8.
4452 CharUnits PPC64_SVR4_ABIInfo::getParamTypeAlignment(QualType Ty) const {
4453  // Complex types are passed just like their elements.
4454  if (const ComplexType *CTy = Ty->getAs<ComplexType>())
4455  Ty = CTy->getElementType();
4456 
4457  // Only vector types of size 16 bytes need alignment (larger types are
4458  // passed via reference, smaller types are not aligned).
4459  if (IsQPXVectorTy(Ty)) {
4460  if (getContext().getTypeSize(Ty) > 128)
4461  return CharUnits::fromQuantity(32);
4462 
4463  return CharUnits::fromQuantity(16);
4464  } else if (Ty->isVectorType()) {
4465  return CharUnits::fromQuantity(getContext().getTypeSize(Ty) == 128 ? 16 : 8);
4466  }
4467 
4468  // For single-element float/vector structs, we consider the whole type
4469  // to have the same alignment requirements as its single element.
4470  const Type *AlignAsType = nullptr;
4471  const Type *EltType = isSingleElementStruct(Ty, getContext());
4472  if (EltType) {
4473  const BuiltinType *BT = EltType->getAs<BuiltinType>();
4474  if (IsQPXVectorTy(EltType) || (EltType->isVectorType() &&
4475  getContext().getTypeSize(EltType) == 128) ||
4476  (BT && BT->isFloatingPoint()))
4477  AlignAsType = EltType;
4478  }
4479 
4480  // Likewise for ELFv2 homogeneous aggregates.
4481  const Type *Base = nullptr;
4482  uint64_t Members = 0;
4483  if (!AlignAsType && Kind == ELFv2 &&
4484  isAggregateTypeForABI(Ty) && isHomogeneousAggregate(Ty, Base, Members))
4485  AlignAsType = Base;
4486 
4487  // With special case aggregates, only vector base types need alignment.
4488  if (AlignAsType && IsQPXVectorTy(AlignAsType)) {
4489  if (getContext().getTypeSize(AlignAsType) > 128)
4490  return CharUnits::fromQuantity(32);
4491 
4492  return CharUnits::fromQuantity(16);
4493  } else if (AlignAsType) {
4494  return CharUnits::fromQuantity(AlignAsType->isVectorType() ? 16 : 8);
4495  }
4496 
4497  // Otherwise, we only need alignment for any aggregate type that
4498  // has an alignment requirement of >= 16 bytes.
4499  if (isAggregateTypeForABI(Ty) && getContext().getTypeAlign(Ty) >= 128) {
4500  if (HasQPX && getContext().getTypeAlign(Ty) >= 256)
4501  return CharUnits::fromQuantity(32);
4502  return CharUnits::fromQuantity(16);
4503  }
4504 
4505  return CharUnits::fromQuantity(8);
4506 }
4507 
4508 /// isHomogeneousAggregate - Return true if a type is an ELFv2 homogeneous
4509 /// aggregate. Base is set to the base element type, and Members is set
4510 /// to the number of base elements.
4512  uint64_t &Members) const {
4513  if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
4514  uint64_t NElements = AT->getSize().getZExtValue();
4515  if (NElements == 0)
4516  return false;
4517  if (!isHomogeneousAggregate(AT->getElementType(), Base, Members))
4518  return false;
4519  Members *= NElements;
4520  } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
4521  const RecordDecl *RD = RT->getDecl();
4522  if (RD->hasFlexibleArrayMember())
4523  return false;
4524 
4525  Members = 0;
4526 
4527  // If this is a C++ record, check the bases first.
4528  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
4529  for (const auto &I : CXXRD->bases()) {
4530  // Ignore empty records.
4531  if (isEmptyRecord(getContext(), I.getType(), true))
4532  continue;
4533 
4534  uint64_t FldMembers;
4535  if (!isHomogeneousAggregate(I.getType(), Base, FldMembers))
4536  return false;
4537 
4538  Members += FldMembers;
4539  }
4540  }
4541 
4542  for (const auto *FD : RD->fields()) {
4543  // Ignore (non-zero arrays of) empty records.
4544  QualType FT = FD->getType();
4545  while (const ConstantArrayType *AT =
4546  getContext().getAsConstantArrayType(FT)) {
4547  if (AT->getSize().getZExtValue() == 0)
4548  return false;
4549  FT = AT->getElementType();
4550  }
4551  if (isEmptyRecord(getContext(), FT, true))
4552  continue;
4553 
4554  // For compatibility with GCC, ignore empty bitfields in C++ mode.
4555  if (getContext().getLangOpts().CPlusPlus &&
4556  FD->isBitField() && FD->getBitWidthValue(getContext()) == 0)
4557  continue;
4558 
4559  uint64_t FldMembers;
4560  if (!isHomogeneousAggregate(FD->getType(), Base, FldMembers))
4561  return false;
4562 
4563  Members = (RD->isUnion() ?
4564  std::max(Members, FldMembers) : Members + FldMembers);
4565  }
4566 
4567  if (!Base)
4568  return false;
4569 
4570  // Ensure there is no padding.
4571  if (getContext().getTypeSize(Base) * Members !=
4572  getContext().getTypeSize(Ty))
4573  return false;
4574  } else {
4575  Members = 1;
4576  if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
4577  Members = 2;
4578  Ty = CT->getElementType();
4579  }
4580 
4581  // Most ABIs only support float, double, and some vector type widths.
4583  return false;
4584 
4585  // The base type must be the same for all members. Types that
4586  // agree in both total size and mode (float vs. vector) are
4587  // treated as being equivalent here.
4588  const Type *TyPtr = Ty.getTypePtr();
4589  if (!Base) {
4590  Base = TyPtr;
4591  // If it's a non-power-of-2 vector, its size is already a power-of-2,
4592  // so make sure to widen it explicitly.
4593  if (const VectorType *VT = Base->getAs<VectorType>()) {
4594  QualType EltTy = VT->getElementType();
4595  unsigned NumElements =
4596  getContext().getTypeSize(VT) / getContext().getTypeSize(EltTy);
4597  Base = getContext()
4598  .getVectorType(EltTy, NumElements, VT->getVectorKind())
4599  .getTypePtr();
4600  }
4601  }
4602 
4603  if (Base->isVectorType() != TyPtr->isVectorType() ||
4604  getContext().getTypeSize(Base) != getContext().getTypeSize(TyPtr))
4605  return false;
4606  }
4607  return Members > 0 && isHomogeneousAggregateSmallEnough(Base, Members);
4608 }
4609 
4610 bool PPC64_SVR4_ABIInfo::isHomogeneousAggregateBaseType(QualType Ty) const {
4611  // Homogeneous aggregates for ELFv2 must have base types of float,
4612  // double, long double, or 128-bit vectors.
4613  if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
4614  if (BT->getKind() == BuiltinType::Float ||
4615  BT->getKind() == BuiltinType::Double ||
4616  BT->getKind() == BuiltinType::LongDouble) {
4617  if (IsSoftFloatABI)
4618  return false;
4619  return true;
4620  }
4621  }
4622  if (const VectorType *VT = Ty->getAs<VectorType>()) {
4623  if (getContext().getTypeSize(VT) == 128 || IsQPXVectorTy(Ty))
4624  return true;
4625  }
4626  return false;
4627 }
4628 
4629 bool PPC64_SVR4_ABIInfo::isHomogeneousAggregateSmallEnough(
4630  const Type *Base, uint64_t Members) const {
4631  // Vector types require one register, floating point types require one
4632  // or two registers depending on their size.
4633  uint32_t NumRegs =
4634  Base->isVectorType() ? 1 : (getContext().getTypeSize(Base) + 63) / 64;
4635 
4636  // Homogeneous Aggregates may occupy at most 8 registers.
4637  return Members * NumRegs <= 8;
4638 }
4639 
4640 ABIArgInfo
4643 
4644  if (Ty->isAnyComplexType())
4645  return ABIArgInfo::getDirect();
4646 
4647  // Non-Altivec vector types are passed in GPRs (smaller than 16 bytes)
4648  // or via reference (larger than 16 bytes).
4649  if (Ty->isVectorType() && !IsQPXVectorTy(Ty)) {
4650  uint64_t Size = getContext().getTypeSize(Ty);
4651  if (Size > 128)
4652  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
4653  else if (Size < 128) {
4654  llvm::Type *CoerceTy = llvm::IntegerType::get(getVMContext(), Size);
4655  return ABIArgInfo::getDirect(CoerceTy);
4656  }
4657  }
4658 
4659  if (isAggregateTypeForABI(Ty)) {
4662 
4663  uint64_t ABIAlign = getParamTypeAlignment(Ty).getQuantity();
4664  uint64_t TyAlign = getContext().getTypeAlignInChars(Ty).getQuantity();
4665 
4666  // ELFv2 homogeneous aggregates are passed as array types.
4667  const Type *Base = nullptr;
4668  uint64_t Members = 0;
4669  if (Kind == ELFv2 &&
4670  isHomogeneousAggregate(Ty, Base, Members)) {
4671  llvm::Type *BaseTy = CGT.ConvertType(QualType(Base, 0));
4672  llvm::Type *CoerceTy = llvm::ArrayType::get(BaseTy, Members);
4673  return ABIArgInfo::getDirect(CoerceTy);
4674  }
4675 
4676  // If an aggregate may end up fully in registers, we do not
4677  // use the ByVal method, but pass the aggregate as array.
4678  // This is usually beneficial since we avoid forcing the
4679  // back-end to store the argument to memory.
4680  uint64_t Bits = getContext().getTypeSize(Ty);
4681  if (Bits > 0 && Bits <= 8 * GPRBits) {
4682  llvm::Type *CoerceTy;
4683 
4684  // Types up to 8 bytes are passed as integer type (which will be
4685  // properly aligned in the argument save area doubleword).
4686  if (Bits <= GPRBits)
4687  CoerceTy =
4688  llvm::IntegerType::get(getVMContext(), llvm::alignTo(Bits, 8));
4689  // Larger types are passed as arrays, with the base type selected
4690  // according to the required alignment in the save area.
4691  else {
4692  uint64_t RegBits = ABIAlign * 8;
4693  uint64_t NumRegs = llvm::alignTo(Bits, RegBits) / RegBits;
4694  llvm::Type *RegTy = llvm::IntegerType::get(getVMContext(), RegBits);
4695  CoerceTy = llvm::ArrayType::get(RegTy, NumRegs);
4696  }
4697 
4698  return ABIArgInfo::getDirect(CoerceTy);
4699  }
4700 
4701  // All other aggregates are passed ByVal.
4703  /*ByVal=*/true,
4704  /*Realign=*/TyAlign > ABIAlign);
4705  }
4706 
4707  return (isPromotableTypeForABI(Ty) ?
4709 }
4710 
4711 ABIArgInfo
4713  if (RetTy->isVoidType())
4714  return ABIArgInfo::getIgnore();
4715 
4716  if (RetTy->isAnyComplexType())
4717  return ABIArgInfo::getDirect();
4718 
4719  // Non-Altivec vector types are returned in GPRs (smaller than 16 bytes)
4720  // or via reference (larger than 16 bytes).
4721  if (RetTy->isVectorType() && !IsQPXVectorTy(RetTy)) {
4722  uint64_t Size = getContext().getTypeSize(RetTy);
4723  if (Size > 128)
4724  return getNaturalAlignIndirect(RetTy);
4725  else if (Size < 128) {
4726  llvm::Type *CoerceTy = llvm::IntegerType::get(getVMContext(), Size);
4727  return ABIArgInfo::getDirect(CoerceTy);
4728  }
4729  }
4730 
4731  if (isAggregateTypeForABI(RetTy)) {
4732  // ELFv2 homogeneous aggregates are returned as array types.
4733  const Type *Base = nullptr;
4734  uint64_t Members = 0;
4735  if (Kind == ELFv2 &&
4736  isHomogeneousAggregate(RetTy, Base, Members)) {
4737  llvm::Type *BaseTy = CGT.ConvertType(QualType(Base, 0));
4738  llvm::Type *CoerceTy = llvm::ArrayType::get(BaseTy, Members);
4739  return ABIArgInfo::getDirect(CoerceTy);
4740  }
4741 
4742  // ELFv2 small aggregates are returned in up to two registers.
4743  uint64_t Bits = getContext().getTypeSize(RetTy);
4744  if (Kind == ELFv2 && Bits <= 2 * GPRBits) {
4745  if (Bits == 0)
4746  return ABIArgInfo::getIgnore();
4747 
4748  llvm::Type *CoerceTy;
4749  if (Bits > GPRBits) {
4750  CoerceTy = llvm::IntegerType::get(getVMContext(), GPRBits);
4751  CoerceTy = llvm::StructType::get(CoerceTy, CoerceTy);
4752  } else
4753  CoerceTy =
4754  llvm::IntegerType::get(getVMContext(), llvm::alignTo(Bits, 8));
4755  return ABIArgInfo::getDirect(CoerceTy);
4756  }
4757 
4758  // All other aggregates are returned indirectly.
4759  return getNaturalAlignIndirect(RetTy);
4760  }
4761 
4762  return (isPromotableTypeForABI(RetTy) ?
4764 }
4765 
4766 // Based on ARMABIInfo::EmitVAArg, adjusted for 64-bit machine.
4767 Address PPC64_SVR4_ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4768  QualType Ty) const {
4769  auto TypeInfo = getContext().getTypeInfoInChars(Ty);
4770  TypeInfo.second = getParamTypeAlignment(Ty);
4771 
4772  CharUnits SlotSize = CharUnits::fromQuantity(8);
4773 
4774  // If we have a complex type and the base type is smaller than 8 bytes,
4775  // the ABI calls for the real and imaginary parts to be right-adjusted
4776  // in separate doublewords. However, Clang expects us to produce a
4777  // pointer to a structure with the two parts packed tightly. So generate
4778  // loads of the real and imaginary parts relative to the va_list pointer,
4779  // and store them to a temporary structure.
4780  if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
4781  CharUnits EltSize = TypeInfo.first / 2;
4782  if (EltSize < SlotSize) {
4783  Address Addr = emitVoidPtrDirectVAArg(CGF, VAListAddr, CGF.Int8Ty,
4784  SlotSize * 2, SlotSize,
4785  SlotSize, /*AllowHigher*/ true);
4786 
4787  Address RealAddr = Addr;
4788  Address ImagAddr = RealAddr;
4789  if (CGF.CGM.getDataLayout().isBigEndian()) {
4790  RealAddr = CGF.Builder.CreateConstInBoundsByteGEP(RealAddr,
4791  SlotSize - EltSize);
4792  ImagAddr = CGF.Builder.CreateConstInBoundsByteGEP(ImagAddr,
4793  2 * SlotSize - EltSize);
4794  } else {
4795  ImagAddr = CGF.Builder.CreateConstInBoundsByteGEP(RealAddr, SlotSize);
4796  }
4797 
4798  llvm::Type *EltTy = CGF.ConvertTypeForMem(CTy->getElementType());
4799  RealAddr = CGF.Builder.CreateElementBitCast(RealAddr, EltTy);
4800  ImagAddr = CGF.Builder.CreateElementBitCast(ImagAddr, EltTy);
4801  llvm::Value *Real = CGF.Builder.CreateLoad(RealAddr, ".vareal");
4802  llvm::Value *Imag = CGF.Builder.CreateLoad(ImagAddr, ".vaimag");
4803 
4804  Address Temp = CGF.CreateMemTemp(Ty, "vacplx");
4805  CGF.EmitStoreOfComplex({Real, Imag}, CGF.MakeAddrLValue(Temp, Ty),
4806  /*init*/ true);
4807  return Temp;
4808  }
4809  }
4810 
4811  // Otherwise, just use the general rule.
4812  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*Indirect*/ false,
4813  TypeInfo, SlotSize, /*AllowHigher*/ true);
4814 }
4815 
4816 static bool
4818  llvm::Value *Address) {
4819  // This is calculated from the LLVM and GCC tables and verified
4820  // against gcc output. AFAIK all ABIs use the same encoding.
4821 
4822  CodeGen::CGBuilderTy &Builder = CGF.Builder;
4823 
4824  llvm::IntegerType *i8 = CGF.Int8Ty;
4825  llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
4826  llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
4827  llvm::Value *Sixteen8 = llvm::ConstantInt::get(i8, 16);
4828 
4829  // 0-31: r0-31, the 8-byte general-purpose registers
4830  AssignToArrayRange(Builder, Address, Eight8, 0, 31);
4831 
4832  // 32-63: fp0-31, the 8-byte floating-point registers
4833  AssignToArrayRange(Builder, Address, Eight8, 32, 63);
4834 
4835  // 64-67 are various 8-byte special-purpose registers:
4836  // 64: mq
4837  // 65: lr
4838  // 66: ctr
4839  // 67: ap
4840  AssignToArrayRange(Builder, Address, Eight8, 64, 67);
4841 
4842  // 68-76 are various 4-byte special-purpose registers:
4843  // 68-75 cr0-7
4844  // 76: xer
4845  AssignToArrayRange(Builder, Address, Four8, 68, 76);
4846 
4847  // 77-108: v0-31, the 16-byte vector registers
4848  AssignToArrayRange(Builder, Address, Sixteen8, 77, 108);
4849 
4850  // 109: vrsave
4851  // 110: vscr
4852  // 111: spe_acc
4853  // 112: spefscr
4854  // 113: sfp
4855  // 114: tfhar
4856  // 115: tfiar
4857  // 116: texasr
4858  AssignToArrayRange(Builder, Address, Eight8, 109, 116);
4859 
4860  return false;
4861 }
4862 
4863 bool
4864 PPC64_SVR4_TargetCodeGenInfo::initDwarfEHRegSizeTable(
4866  llvm::Value *Address) const {
4867 
4868  return PPC64_initDwarfEHRegSizeTable(CGF, Address);
4869 }
4870 
4871 bool
4872 PPC64TargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
4873  llvm::Value *Address) const {
4874 
4875  return PPC64_initDwarfEHRegSizeTable(CGF, Address);
4876 }
4877 
4878 //===----------------------------------------------------------------------===//
4879 // AArch64 ABI Implementation
4880 //===----------------------------------------------------------------------===//
4881 
4882 namespace {
4883 
4884 class AArch64ABIInfo : public SwiftABIInfo {
4885 public:
4886  enum ABIKind {
4887  AAPCS = 0,
4888  DarwinPCS,
4889  Win64
4890  };
4891 
4892 private:
4893  ABIKind Kind;
4894 
4895 public:
4896  AArch64ABIInfo(CodeGenTypes &CGT, ABIKind Kind)
4897  : SwiftABIInfo(CGT), Kind(Kind) {}
4898 
4899 private:
4900  ABIKind getABIKind() const { return Kind; }
4901  bool isDarwinPCS() const { return Kind == DarwinPCS; }
4902 
4903  ABIArgInfo classifyReturnType(QualType RetTy) const;
4905  bool isHomogeneousAggregateBaseType(QualType Ty) const override;
4906  bool isHomogeneousAggregateSmallEnough(const Type *Ty,
4907  uint64_t Members) const override;
4908 
4909  bool isIllegalVectorType(QualType Ty) const;
4910 
4911  void computeInfo(CGFunctionInfo &FI) const override {
4912  if (!getCXXABI().classifyReturnType(FI))
4914 
4915  for (auto &it : FI.arguments())
4916  it.info = classifyArgumentType(it.type);
4917  }
4918 
4919  Address EmitDarwinVAArg(Address VAListAddr, QualType Ty,
4920  CodeGenFunction &CGF) const;
4921 
4922  Address EmitAAPCSVAArg(Address VAListAddr, QualType Ty,
4923  CodeGenFunction &CGF) const;
4924 
4925  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4926  QualType Ty) const override {
4927  return Kind == Win64 ? EmitMSVAArg(CGF, VAListAddr, Ty)
4928  : isDarwinPCS() ? EmitDarwinVAArg(VAListAddr, Ty, CGF)
4929  : EmitAAPCSVAArg(VAListAddr, Ty, CGF);
4930  }
4931 
4932  Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
4933  QualType Ty) const override;
4934 
4935  bool shouldPassIndirectlyForSwift(CharUnits totalSize,
4936  ArrayRef<llvm::Type*> scalars,
4937  bool asReturnValue) const override {
4938  return occupiesMoreThan(CGT, scalars, /*total*/ 4);
4939  }
4940  bool isSwiftErrorInRegister() const override {
4941  return true;
4942  }
4943 
4944  bool isLegalVectorTypeForSwift(CharUnits totalSize, llvm::Type *eltTy,
4945  unsigned elts) const override;
4946 };
4947 
4948 class AArch64TargetCodeGenInfo : public TargetCodeGenInfo {
4949 public:
4950  AArch64TargetCodeGenInfo(CodeGenTypes &CGT, AArch64ABIInfo::ABIKind Kind)
4951  : TargetCodeGenInfo(new AArch64ABIInfo(CGT, Kind)) {}
4952 
4953  StringRef getARCRetainAutoreleasedReturnValueMarker() const override {
4954  return "mov\tfp, fp\t\t// marker for objc_retainAutoreleaseReturnValue";
4955  }
4956 
4957  int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
4958  return 31;
4959  }
4960 
4961  bool doesReturnSlotInterfereWithArgs() const override { return false; }
4962 };
4963 
4964 class WindowsAArch64TargetCodeGenInfo : public AArch64TargetCodeGenInfo {
4965 public:
4966  WindowsAArch64TargetCodeGenInfo(CodeGenTypes &CGT, AArch64ABIInfo::ABIKind K)
4967  : AArch64TargetCodeGenInfo(CGT, K) {}
4968 
4969  void getDependentLibraryOption(llvm::StringRef Lib,
4970  llvm::SmallString<24> &Opt) const override {
4971  Opt = "/DEFAULTLIB:" + qualifyWindowsLibrary(Lib);
4972  }
4973 
4974  void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value,
4975  llvm::SmallString<32> &Opt) const override {
4976  Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
4977  }
4978 };
4979 }
4980 
4983 
4984  // Handle illegal vector types here.
4985  if (isIllegalVectorType(Ty)) {
4986  uint64_t Size = getContext().getTypeSize(Ty);
4987  // Android promotes <2 x i8> to i16, not i32
4988  if (isAndroid() && (Size <= 16)) {
4989  llvm::Type *ResType = llvm::Type::getInt16Ty(getVMContext());
4990  return ABIArgInfo::getDirect(ResType);
4991  }
4992  if (Size <= 32) {
4993  llvm::Type *ResType = llvm::Type::getInt32Ty(getVMContext());
4994  return ABIArgInfo::getDirect(ResType);
4995  }
4996  if (Size == 64) {
4997  llvm::Type *ResType =
4998  llvm::VectorType::get(llvm::Type::getInt32Ty(getVMContext()), 2);
4999  return ABIArgInfo::getDirect(ResType);
5000  }
5001  if (Size == 128) {
5002  llvm::Type *ResType =
5003  llvm::VectorType::get(llvm::Type::getInt32Ty(getVMContext()), 4);
5004  return ABIArgInfo::getDirect(ResType);
5005  }
5006  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
5007  }
5008 
5009  if (!isAggregateTypeForABI(Ty)) {
5010  // Treat an enum type as its underlying type.
5011  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
5012  Ty = EnumTy->getDecl()->getIntegerType();
5013 
5014  return (Ty->isPromotableIntegerType() && isDarwinPCS()
5016  : ABIArgInfo::getDirect());
5017  }
5018 
5019  // Structures with either a non-trivial destructor or a non-trivial
5020  // copy constructor are always indirect.
5022  return getNaturalAlignIndirect(Ty, /*ByVal=*/RAA ==
5024  }
5025 
5026  // Empty records are always ignored on Darwin, but actually passed in C++ mode
5027  // elsewhere for GNU compatibility.
5028  uint64_t Size = getContext().getTypeSize(Ty);
5029  bool IsEmpty = isEmptyRecord(getContext(), Ty, true);
5030  if (IsEmpty || Size == 0) {
5031  if (!getContext().getLangOpts().CPlusPlus || isDarwinPCS())
5032  return ABIArgInfo::getIgnore();
5033 
5034  // GNU C mode. The only argument that gets ignored is an empty one with size
5035  // 0.
5036  if (IsEmpty && Size == 0)
5037  return ABIArgInfo::getIgnore();
5038  return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
5039  }
5040 
5041  // Homogeneous Floating-point Aggregates (HFAs) need to be expanded.
5042  const Type *Base = nullptr;
5043  uint64_t Members = 0;
5044  if (isHomogeneousAggregate(Ty, Base, Members)) {
5045  return ABIArgInfo::getDirect(
5046  llvm::ArrayType::get(CGT.ConvertType(QualType(Base, 0)), Members));
5047  }
5048 
5049  // Aggregates <= 16 bytes are passed directly in registers or on the stack.
5050  if (Size <= 128) {
5051  // On RenderScript, coerce Aggregates <= 16 bytes to an integer array of
5052  // same size and alignment.
5053  if (getTarget().isRenderScriptTarget()) {
5054  return coerceToIntArray(Ty, getContext(), getVMContext());
5055  }
5056  unsigned Alignment = getContext().getTypeAlign(Ty);
5057  Size = llvm::alignTo(Size, 64); // round up to multiple of 8 bytes
5058 
5059  // We use a pair of i64 for 16-byte aggregate with 8-byte alignment.
5060  // For aggregates with 16-byte alignment, we use i128.
5061  if (Alignment < 128 && Size == 128) {
5062  llvm::Type *BaseTy = llvm::Type::getInt64Ty(getVMContext());
5063  return ABIArgInfo::getDirect(llvm::ArrayType::get(BaseTy, Size / 64));
5064  }
5065  return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(), Size));
5066  }
5067 
5068  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
5069 }
5070 
5072  if (RetTy->isVoidType())
5073  return ABIArgInfo::getIgnore();
5074 
5075  // Large vector types should be returned via memory.
5076  if (RetTy->isVectorType() && getContext().getTypeSize(RetTy) > 128)
5077  return getNaturalAlignIndirect(RetTy);
5078 
5079  if (!isAggregateTypeForABI(RetTy)) {
5080  // Treat an enum type as its underlying type.
5081  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
5082  RetTy = EnumTy->getDecl()->getIntegerType();
5083 
5084  return (RetTy->isPromotableIntegerType() && isDarwinPCS()
5086  : ABIArgInfo::getDirect());
5087  }
5088 
5089  uint64_t Size = getContext().getTypeSize(RetTy);
5090  if (isEmptyRecord(getContext(), RetTy, true) || Size == 0)
5091  return ABIArgInfo::getIgnore();
5092 
5093  const Type *Base = nullptr;
5094  uint64_t Members = 0;
5095  if (isHomogeneousAggregate(RetTy, Base, Members))
5096  // Homogeneous Floating-point Aggregates (HFAs) are returned directly.
5097  return ABIArgInfo::getDirect();
5098 
5099  // Aggregates <= 16 bytes are returned directly in registers or on the stack.
5100  if (Size <= 128) {
5101  // On RenderScript, coerce Aggregates <= 16 bytes to an integer array of
5102  // same size and alignment.
5103  if (getTarget().isRenderScriptTarget()) {
5104  return coerceToIntArray(RetTy, getContext(), getVMContext());
5105  }
5106  unsigned Alignment = getContext().getTypeAlign(RetTy);
5107  Size = llvm::alignTo(Size, 64); // round up to multiple of 8 bytes
5108 
5109  // We use a pair of i64 for 16-byte aggregate with 8-byte alignment.
5110  // For aggregates with 16-byte alignment, we use i128.
5111  if (Alignment < 128 && Size == 128) {
5112  llvm::Type *BaseTy = llvm::Type::getInt64Ty(getVMContext());
5113  return ABIArgInfo::getDirect(llvm::ArrayType::get(BaseTy, Size / 64));
5114  }
5115  return ABIArgInfo::getDirect(llvm::IntegerType::get(getVMContext(), Size));
5116  }
5117 
5118  return getNaturalAlignIndirect(RetTy);
5119 }
5120 
5121 /// isIllegalVectorType - check whether the vector type is legal for AArch64.
5122 bool AArch64ABIInfo::isIllegalVectorType(QualType Ty) const {
5123  if (const VectorType *VT = Ty->getAs<VectorType>()) {
5124  // Check whether VT is legal.
5125  unsigned NumElements = VT->getNumElements();
5126  uint64_t Size = getContext().getTypeSize(VT);
5127  // NumElements should be power of 2.
5128  if (!llvm::isPowerOf2_32(NumElements))
5129  return true;
5130  return Size != 64 && (Size != 128 || NumElements == 1);
5131  }
5132  return false;
5133 }
5134 
5135 bool AArch64ABIInfo::isLegalVectorTypeForSwift(CharUnits totalSize,
5136  llvm::Type *eltTy,
5137  unsigned elts) const {
5138  if (!llvm::isPowerOf2_32(elts))
5139  return false;
5140  if (totalSize.getQuantity() != 8 &&
5141  (totalSize.getQuantity() != 16 || elts == 1))
5142  return false;
5143  return true;
5144 }
5145 
5146 bool AArch64ABIInfo::isHomogeneousAggregateBaseType(QualType Ty) const {
5147  // Homogeneous aggregates for AAPCS64 must have base types of a floating
5148  // point type or a short-vector type. This is the same as the 32-bit ABI,
5149  // but with the difference that any floating-point type is allowed,
5150  // including __fp16.
5151  if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
5152  if (BT->isFloatingPoint())
5153  return true;
5154  } else if (const VectorType *VT = Ty->getAs<VectorType>()) {
5155  unsigned VecSize = getContext().getTypeSize(VT);
5156  if (VecSize == 64 || VecSize == 128)
5157  return true;
5158  }
5159  return false;
5160 }
5161 
5162 bool AArch64ABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
5163  uint64_t Members) const {
5164  return Members <= 4;
5165 }
5166 
5167 Address AArch64ABIInfo::EmitAAPCSVAArg(Address VAListAddr,
5168  QualType Ty,
5169  CodeGenFunction &CGF) const {
5171  bool IsIndirect = AI.isIndirect();
5172 
5173  llvm::Type *BaseTy = CGF.ConvertType(Ty);
5174  if (IsIndirect)
5175  BaseTy = llvm::PointerType::getUnqual(BaseTy);
5176  else if (AI.getCoerceToType())
5177  BaseTy = AI.getCoerceToType();
5178 
5179  unsigned NumRegs = 1;
5180  if (llvm::ArrayType *ArrTy = dyn_cast<llvm::ArrayType>(BaseTy)) {
5181  BaseTy = ArrTy->getElementType();
5182  NumRegs = ArrTy->getNumElements();
5183  }
5184  bool IsFPR = BaseTy->isFloatingPointTy() || BaseTy->isVectorTy();
5185 
5186  // The AArch64 va_list type and handling is specified in the Procedure Call
5187  // Standard, section B.4:
5188  //
5189  // struct {
5190  // void *__stack;
5191  // void *__gr_top;
5192  // void *__vr_top;
5193  // int __gr_offs;
5194  // int __vr_offs;
5195  // };
5196 
5197  llvm::BasicBlock *MaybeRegBlock = CGF.createBasicBlock("vaarg.maybe_reg");
5198  llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg");
5199  llvm::BasicBlock *OnStackBlock = CGF.createBasicBlock("vaarg.on_stack");
5200  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end");
5201 
5202  auto TyInfo = getContext().getTypeInfoInChars(Ty);
5203  CharUnits TyAlign = TyInfo.second;
5204 
5205  Address reg_offs_p = Address::invalid();
5206  llvm::Value *reg_offs = nullptr;
5207  int reg_top_index;
5208  CharUnits reg_top_offset;
5209  int RegSize = IsIndirect ? 8 : TyInfo.first.getQuantity();
5210  if (!IsFPR) {
5211  // 3 is the field number of __gr_offs
5212  reg_offs_p =
5213  CGF.Builder.CreateStructGEP(VAListAddr, 3, CharUnits::fromQuantity(24),
5214  "gr_offs_p");
5215  reg_offs = CGF.Builder.CreateLoad(reg_offs_p, "gr_offs");
5216  reg_top_index = 1; // field number for __gr_top
5217  reg_top_offset = CharUnits::fromQuantity(8);
5218  RegSize = llvm::alignTo(RegSize, 8);
5219  } else {
5220  // 4 is the field number of __vr_offs.
5221  reg_offs_p =
5222  CGF.Builder.CreateStructGEP(VAListAddr, 4, CharUnits::fromQuantity(28),
5223  "vr_offs_p");
5224  reg_offs = CGF.Builder.CreateLoad(reg_offs_p, "vr_offs");
5225  reg_top_index = 2; // field number for __vr_top
5226  reg_top_offset = CharUnits::fromQuantity(16);
5227  RegSize = 16 * NumRegs;
5228  }
5229 
5230  //=======================================
5231  // Find out where argument was passed
5232  //=======================================
5233 
5234  // If reg_offs >= 0 we're already using the stack for this type of
5235  // argument. We don't want to keep updating reg_offs (in case it overflows,
5236  // though anyone passing 2GB of arguments, each at most 16 bytes, deserves
5237  // whatever they get).
5238  llvm::Value *UsingStack = nullptr;
5239  UsingStack = CGF.Builder.CreateICmpSGE(
5240  reg_offs, llvm::ConstantInt::get(CGF.Int32Ty, 0));
5241 
5242  CGF.Builder.CreateCondBr(UsingStack, OnStackBlock, MaybeRegBlock);
5243 
5244  // Otherwise, at least some kind of argument could go in these registers, the
5245  // question is whether this particular type is too big.
5246  CGF.EmitBlock(MaybeRegBlock);
5247 
5248  // Integer arguments may need to correct register alignment (for example a
5249  // "struct { __int128 a; };" gets passed in x_2N, x_{2N+1}). In this case we
5250  // align __gr_offs to calculate the potential address.
5251  if (!IsFPR && !IsIndirect && TyAlign.getQuantity() > 8) {
5252  int Align = TyAlign.getQuantity();
5253 
5254  reg_offs = CGF.Builder.CreateAdd(
5255  reg_offs, llvm::ConstantInt::get(CGF.Int32Ty, Align - 1),
5256  "align_regoffs");
5257  reg_offs = CGF.Builder.CreateAnd(
5258  reg_offs, llvm::ConstantInt::get(CGF.Int32Ty, -Align),
5259  "aligned_regoffs");
5260  }
5261 
5262  // Update the gr_offs/vr_offs pointer for next call to va_arg on this va_list.
5263  // The fact that this is done unconditionally reflects the fact that
5264  // allocating an argument to the stack also uses up all the remaining
5265  // registers of the appropriate kind.
5266  llvm::Value *NewOffset = nullptr;
5267  NewOffset = CGF.Builder.CreateAdd(
5268  reg_offs, llvm::ConstantInt::get(CGF.Int32Ty, RegSize), "new_reg_offs");
5269  CGF.Builder.CreateStore(NewOffset, reg_offs_p);
5270 
5271  // Now we're in a position to decide whether this argument really was in
5272  // registers or not.
5273  llvm::Value *InRegs = nullptr;
5274  InRegs = CGF.Builder.CreateICmpSLE(
5275  NewOffset, llvm::ConstantInt::get(CGF.Int32Ty, 0), "inreg");
5276 
5277  CGF.Builder.CreateCondBr(InRegs, InRegBlock, OnStackBlock);
5278 
5279  //=======================================
5280  // Argument was in registers
5281  //=======================================
5282 
5283  // Now we emit the code for if the argument was originally passed in
5284  // registers. First start the appropriate block:
5285  CGF.EmitBlock(InRegBlock);
5286 
5287  llvm::Value *reg_top = nullptr;
5288  Address reg_top_p = CGF.Builder.CreateStructGEP(VAListAddr, reg_top_index,
5289  reg_top_offset, "reg_top_p");
5290  reg_top = CGF.Builder.CreateLoad(reg_top_p, "reg_top");
5291  Address BaseAddr(CGF.Builder.CreateInBoundsGEP(reg_top, reg_offs),
5292  CharUnits::fromQuantity(IsFPR ? 16 : 8));
5293  Address RegAddr = Address::invalid();
5294  llvm::Type *MemTy = CGF.ConvertTypeForMem(Ty);
5295 
5296  if (IsIndirect) {
5297  // If it's been passed indirectly (actually a struct), whatever we find from
5298  // stored registers or on the stack will actually be a struct **.
5299  MemTy = llvm::PointerType::getUnqual(MemTy);
5300  }
5301 
5302  const Type *Base = nullptr;
5303  uint64_t NumMembers = 0;
5304  bool IsHFA = isHomogeneousAggregate(Ty, Base, NumMembers);
5305  if (IsHFA && NumMembers > 1) {
5306  // Homogeneous aggregates passed in registers will have their elements split
5307  // and stored 16-bytes apart regardless of size (they're notionally in qN,
5308  // qN+1, ...). We reload and store into a temporary local variable
5309  // contiguously.
5310  assert(!IsIndirect && "Homogeneous aggregates should be passed directly");
5311  auto BaseTyInfo = getContext().getTypeInfoInChars(QualType(Base, 0));
5312  llvm::Type *BaseTy = CGF.ConvertType(QualType(Base, 0));
5313  llvm::Type *HFATy = llvm::ArrayType::get(BaseTy, NumMembers);
5314  Address Tmp = CGF.CreateTempAlloca(HFATy,
5315  std::max(TyAlign, BaseTyInfo.second));
5316 
5317  // On big-endian platforms, the value will be right-aligned in its slot.
5318  int Offset = 0;
5319  if (CGF.CGM.getDataLayout().isBigEndian() &&
5320  BaseTyInfo.first.getQuantity() < 16)
5321  Offset = 16 - BaseTyInfo.first.getQuantity();
5322 
5323  for (unsigned i = 0; i < NumMembers; ++i) {
5324  CharUnits BaseOffset = CharUnits::fromQuantity(16 * i + Offset);
5325  Address LoadAddr =
5326  CGF.Builder.CreateConstInBoundsByteGEP(BaseAddr, BaseOffset);
5327  LoadAddr = CGF.Builder.CreateElementBitCast(LoadAddr, BaseTy);
5328 
5329  Address StoreAddr =
5330  CGF.Builder.CreateConstArrayGEP(Tmp, i, BaseTyInfo.first);
5331 
5332  llvm::Value *Elem = CGF.Builder.CreateLoad(LoadAddr);
5333  CGF.Builder.CreateStore(Elem, StoreAddr);
5334  }
5335 
5336  RegAddr = CGF.Builder.CreateElementBitCast(Tmp, MemTy);
5337  } else {
5338  // Otherwise the object is contiguous in memory.
5339 
5340  // It might be right-aligned in its slot.
5341  CharUnits SlotSize = BaseAddr.getAlignment();
5342  if (CGF.CGM.getDataLayout().isBigEndian() && !IsIndirect &&
5343  (IsHFA || !isAggregateTypeForABI(Ty)) &&
5344  TyInfo.first < SlotSize) {
5345  CharUnits Offset = SlotSize - TyInfo.first;
5346  BaseAddr = CGF.Builder.CreateConstInBoundsByteGEP(BaseAddr, Offset);
5347  }
5348 
5349  RegAddr = CGF.Builder.CreateElementBitCast(BaseAddr, MemTy);
5350  }
5351 
5352  CGF.EmitBranch(ContBlock);
5353 
5354  //=======================================
5355  // Argument was on the stack
5356  //=======================================
5357  CGF.EmitBlock(OnStackBlock);
5358 
5359  Address stack_p = CGF.Builder.CreateStructGEP(VAListAddr, 0,
5360  CharUnits::Zero(), "stack_p");
5361  llvm::Value *OnStackPtr = CGF.Builder.CreateLoad(stack_p, "stack");
5362 
5363  // Again, stack arguments may need realignment. In this case both integer and
5364  // floating-point ones might be affected.
5365  if (!IsIndirect && TyAlign.getQuantity() > 8) {
5366  int Align = TyAlign.getQuantity();
5367 
5368  OnStackPtr = CGF.Builder.CreatePtrToInt(OnStackPtr, CGF.Int64Ty);
5369 
5370  OnStackPtr = CGF.Builder.CreateAdd(
5371  OnStackPtr, llvm::ConstantInt::get(CGF.Int64Ty, Align - 1),
5372  "align_stack");
5373  OnStackPtr = CGF.Builder.CreateAnd(
5374  OnStackPtr, llvm::ConstantInt::get(CGF.Int64Ty, -Align),
5375  "align_stack");
5376 
5377  OnStackPtr = CGF.Builder.CreateIntToPtr(OnStackPtr, CGF.Int8PtrTy);
5378  }
5379  Address OnStackAddr(OnStackPtr,
5380  std::max(CharUnits::fromQuantity(8), TyAlign));
5381 
5382  // All stack slots are multiples of 8 bytes.
5383  CharUnits StackSlotSize = CharUnits::fromQuantity(8);
5384  CharUnits StackSize;
5385  if (IsIndirect)
5386  StackSize = StackSlotSize;
5387  else
5388  StackSize = TyInfo.first.alignTo(StackSlotSize);
5389 
5390  llvm::Value *StackSizeC = CGF.Builder.getSize(StackSize);
5391  llvm::Value *NewStack =
5392  CGF.Builder.CreateInBoundsGEP(OnStackPtr, StackSizeC, "new_stack");
5393 
5394  // Write the new value of __stack for the next call to va_arg
5395  CGF.Builder.CreateStore(NewStack, stack_p);
5396 
5397  if (CGF.CGM.getDataLayout().isBigEndian() && !isAggregateTypeForABI(Ty) &&
5398  TyInfo.first < StackSlotSize) {
5399  CharUnits Offset = StackSlotSize - TyInfo.first;
5400  OnStackAddr = CGF.Builder.CreateConstInBoundsByteGEP(OnStackAddr, Offset);
5401  }
5402 
5403  OnStackAddr = CGF.Builder.CreateElementBitCast(OnStackAddr, MemTy);
5404 
5405  CGF.EmitBranch(ContBlock);
5406 
5407  //=======================================
5408  // Tidy up
5409  //=======================================
5410  CGF.EmitBlock(ContBlock);
5411 
5412  Address ResAddr = emitMergePHI(CGF, RegAddr, InRegBlock,
5413  OnStackAddr, OnStackBlock, "vaargs.addr");
5414 
5415  if (IsIndirect)
5416  return Address(CGF.Builder.CreateLoad(ResAddr, "vaarg.addr"),
5417  TyInfo.second);
5418 
5419  return ResAddr;
5420 }
5421 
5422 Address AArch64ABIInfo::EmitDarwinVAArg(Address VAListAddr, QualType Ty,
5423  CodeGenFunction &CGF) const {
5424  // The backend's lowering doesn't support va_arg for aggregates or
5425  // illegal vector types. Lower VAArg here for these cases and use
5426  // the LLVM va_arg instruction for everything else.
5427  if (!isAggregateTypeForABI(Ty) && !isIllegalVectorType(Ty))
5428  return EmitVAArgInstr(CGF, VAListAddr, Ty, ABIArgInfo::getDirect());
5429 
5430  CharUnits SlotSize = CharUnits::fromQuantity(8);
5431 
5432  // Empty records are ignored for parameter passing purposes.
5433  if (isEmptyRecord(getContext(), Ty, true)) {
5434  Address Addr(CGF.Builder.CreateLoad(VAListAddr, "ap.cur"), SlotSize);
5435  Addr = CGF.Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(Ty));
5436  return Addr;
5437  }
5438 
5439  // The size of the actual thing passed, which might end up just
5440  // being a pointer for indirect types.
5441  auto TyInfo = getContext().getTypeInfoInChars(Ty);
5442 
5443  // Arguments bigger than 16 bytes which aren't homogeneous
5444  // aggregates should be passed indirectly.
5445  bool IsIndirect = false;
5446  if (TyInfo.first.getQuantity() > 16) {
5447  const Type *Base = nullptr;
5448  uint64_t Members = 0;
5449  IsIndirect = !isHomogeneousAggregate(Ty, Base, Members);
5450  }
5451 
5452  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, IsIndirect,
5453  TyInfo, SlotSize, /*AllowHigherAlign*/ true);
5454 }
5455 
5456 Address AArch64ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
5457  QualType Ty) const {
5458  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*indirect*/ false,
5459  CGF.getContext().getTypeInfoInChars(Ty),
5461  /*allowHigherAlign*/ false);
5462 }
5463 
5464 //===----------------------------------------------------------------------===//
5465 // ARM ABI Implementation
5466 //===----------------------------------------------------------------------===//
5467 
5468 namespace {
5469 
5470 class ARMABIInfo : public SwiftABIInfo {
5471 public:
5472  enum ABIKind {
5473  APCS = 0,
5474  AAPCS = 1,
5475  AAPCS_VFP = 2,
5476  AAPCS16_VFP = 3,
5477  };
5478 
5479 private:
5480  ABIKind Kind;
5481 
5482 public:
5483  ARMABIInfo(CodeGenTypes &CGT, ABIKind _Kind)
5484  : SwiftABIInfo(CGT), Kind(_Kind) {
5485  setCCs();
5486  }
5487 
5488  bool isEABI() const {
5489  switch (getTarget().getTriple().getEnvironment()) {
5490  case llvm::Triple::Android:
5491  case llvm::Triple::EABI:
5492  case llvm::Triple::EABIHF:
5493  case llvm::Triple::GNUEABI:
5494  case llvm::Triple::GNUEABIHF:
5495  case llvm::Triple::MuslEABI:
5496  case llvm::Triple::MuslEABIHF:
5497  return true;
5498  default:
5499  return false;
5500  }
5501  }
5502 
5503  bool isEABIHF() const {
5504  switch (getTarget().getTriple().getEnvironment()) {
5505  case llvm::Triple::EABIHF:
5506  case llvm::Triple::GNUEABIHF:
5507  case llvm::Triple::MuslEABIHF:
5508  return true;
5509  default:
5510  return false;
5511  }
5512  }
5513 
5514  ABIKind getABIKind() const { return Kind; }
5515 
5516 private:
5517  ABIArgInfo classifyReturnType(QualType RetTy, bool isVariadic) const;
5518  ABIArgInfo classifyArgumentType(QualType RetTy, bool isVariadic) const;
5519  bool isIllegalVectorType(QualType Ty) const;
5520 
5521  bool isHomogeneousAggregateBaseType(QualType Ty) const override;
5522  bool isHomogeneousAggregateSmallEnough(const Type *Ty,
5523  uint64_t Members) const override;
5524 
5525  void computeInfo(CGFunctionInfo &FI) const override;
5526 
5527  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
5528  QualType Ty) const override;
5529 
5530  llvm::CallingConv::ID getLLVMDefaultCC() const;
5531  llvm::CallingConv::ID getABIDefaultCC() const;
5532  void setCCs();
5533 
5534  bool shouldPassIndirectlyForSwift(CharUnits totalSize,
5535  ArrayRef<llvm::Type*> scalars,
5536  bool asReturnValue) const override {
5537  return occupiesMoreThan(CGT, scalars, /*total*/ 4);
5538  }
5539  bool isSwiftErrorInRegister() const override {
5540  return true;
5541  }
5542  bool isLegalVectorTypeForSwift(CharUnits totalSize, llvm::Type *eltTy,
5543  unsigned elts) const override;
5544 };
5545 
5546 class ARMTargetCodeGenInfo : public TargetCodeGenInfo {
5547 public:
5548  ARMTargetCodeGenInfo(CodeGenTypes &CGT, ARMABIInfo::ABIKind K)
5549  :TargetCodeGenInfo(new ARMABIInfo(CGT, K)) {}
5550 
5551  const ARMABIInfo &getABIInfo() const {
5552  return static_cast<const ARMABIInfo&>(TargetCodeGenInfo::getABIInfo());
5553  }
5554 
5555  int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
5556  return 13;
5557  }
5558 
5559  StringRef getARCRetainAutoreleasedReturnValueMarker() const override {
5560  return "mov\tr7, r7\t\t// marker for objc_retainAutoreleaseReturnValue";
5561  }
5562 
5563  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
5564  llvm::Value *Address) const override {
5565  llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
5566 
5567  // 0-15 are the 16 integer registers.
5568  AssignToArrayRange(CGF.Builder, Address, Four8, 0, 15);
5569  return false;
5570  }
5571 
5572  unsigned getSizeOfUnwindException() const override {
5573  if (getABIInfo().isEABI()) return 88;
5575  }
5576 
5577  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
5579  ForDefinition_t IsForDefinition) const override {
5580  if (!IsForDefinition)
5581  return;
5582  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
5583  if (!FD)
5584  return;
5585 
5586  const ARMInterruptAttr *Attr = FD->getAttr<ARMInterruptAttr>();
5587  if (!Attr)
5588  return;
5589 
5590  const char *Kind;
5591  switch (Attr->getInterrupt()) {
5592  case ARMInterruptAttr::Generic: Kind = ""; break;
5593  case ARMInterruptAttr::IRQ: Kind = "IRQ"; break;
5594  case ARMInterruptAttr::FIQ: Kind = "FIQ"; break;
5595  case ARMInterruptAttr::SWI: Kind = "SWI"; break;
5596  case ARMInterruptAttr::ABORT: Kind = "ABORT"; break;
5597  case ARMInterruptAttr::UNDEF: Kind = "UNDEF"; break;
5598  }
5599 
5600  llvm::Function *Fn = cast<llvm::Function>(GV);
5601 
5602  Fn->addFnAttr("interrupt", Kind);
5603 
5604  ARMABIInfo::ABIKind ABI = cast<ARMABIInfo>(getABIInfo()).getABIKind();
5605  if (ABI == ARMABIInfo::APCS)
5606  return;
5607 
5608  // AAPCS guarantees that sp will be 8-byte aligned on any public interface,
5609  // however this is not necessarily true on taking any interrupt. Instruct
5610  // the backend to perform a realignment as part of the function prologue.
5611  llvm::AttrBuilder B;
5612  B.addStackAlignmentAttr(8);
5613  Fn->addAttributes(llvm::AttributeList::FunctionIndex, B);
5614  }
5615 };
5616 
5617 class WindowsARMTargetCodeGenInfo : public ARMTargetCodeGenInfo {
5618 public:
5619  WindowsARMTargetCodeGenInfo(CodeGenTypes &CGT, ARMABIInfo::ABIKind K)
5620  : ARMTargetCodeGenInfo(CGT, K) {}
5621 
5622  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
5624  ForDefinition_t IsForDefinition) const override;
5625 
5626  void getDependentLibraryOption(llvm::StringRef Lib,
5627  llvm::SmallString<24> &Opt) const override {
5628  Opt = "/DEFAULTLIB:" + qualifyWindowsLibrary(Lib);
5629  }
5630 
5631  void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value,
5632  llvm::SmallString<32> &Opt) const override {
5633  Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
5634  }
5635 };
5636 
5637 void WindowsARMTargetCodeGenInfo::setTargetAttributes(
5638  const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM,
5639  ForDefinition_t IsForDefinition) const {
5640  ARMTargetCodeGenInfo::setTargetAttributes(D, GV, CGM, IsForDefinition);
5641  if (!IsForDefinition)
5642  return;
5643  addStackProbeSizeTargetAttribute(D, GV, CGM);
5644 }
5645 }
5646 
5647 void ARMABIInfo::computeInfo(CGFunctionInfo &FI) const {
5648  if (!getCXXABI().classifyReturnType(FI))
5649  FI.getReturnInfo() =
5651 
5652  for (auto &I : FI.arguments())
5653  I.info = classifyArgumentType(I.type, FI.isVariadic());
5654 
5655  // Always honor user-specified calling convention.
5657  return;
5658 
5660  if (cc != llvm::CallingConv::C)
5662 }
5663 
5664 /// Return the default calling convention that LLVM will use.
5665 llvm::CallingConv::ID ARMABIInfo::getLLVMDefaultCC() const {
5666  // The default calling convention that LLVM will infer.
5667  if (isEABIHF() || getTarget().getTriple().isWatchABI())
5668  return llvm::CallingConv::ARM_AAPCS_VFP;
5669  else if (isEABI())
5670  return llvm::CallingConv::ARM_AAPCS;
5671  else
5672  return llvm::CallingConv::ARM_APCS;
5673 }
5674 
5675 /// Return the calling convention that our ABI would like us to use
5676 /// as the C calling convention.
5677 llvm::CallingConv::ID ARMABIInfo::getABIDefaultCC() const {
5678  switch (getABIKind()) {
5679  case APCS: return llvm::CallingConv::ARM_APCS;
5680  case AAPCS: return llvm::CallingConv::ARM_AAPCS;
5681  case AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP;
5682  case AAPCS16_VFP: return llvm::CallingConv::ARM_AAPCS_VFP;
5683  }
5684  llvm_unreachable("bad ABI kind");
5685 }
5686 
5687 void ARMABIInfo::setCCs() {
5688  assert(getRuntimeCC() == llvm::CallingConv::C);
5689 
5690  // Don't muddy up the IR with a ton of explicit annotations if
5691  // they'd just match what LLVM will infer from the triple.
5692  llvm::CallingConv::ID abiCC = getABIDefaultCC();
5693  if (abiCC != getLLVMDefaultCC())
5694  RuntimeCC = abiCC;
5695 
5696  // AAPCS apparently requires runtime support functions to be soft-float, but
5697  // that's almost certainly for historic reasons (Thumb1 not supporting VFP
5698  // most likely). It's more convenient for AAPCS16_VFP to be hard-float.
5699 
5700  // The Run-time ABI for the ARM Architecture section 4.1.2 requires
5701  // AEABI-complying FP helper functions to use the base AAPCS.
5702  // These AEABI functions are expanded in the ARM llvm backend, all the builtin
5703  // support functions emitted by clang such as the _Complex helpers follow the
5704  // abiCC.
5705  if (abiCC != getLLVMDefaultCC())
5706  BuiltinCC = abiCC;
5707 }
5708 
5710  bool isVariadic) const {
5711  // 6.1.2.1 The following argument types are VFP CPRCs:
5712  // A single-precision floating-point type (including promoted
5713  // half-precision types); A double-precision floating-point type;
5714  // A 64-bit or 128-bit containerized vector type; Homogeneous Aggregate
5715  // with a Base Type of a single- or double-precision floating-point type,
5716  // 64-bit containerized vectors or 128-bit containerized vectors with one
5717  // to four Elements.
5718  bool IsEffectivelyAAPCS_VFP = getABIKind() == AAPCS_VFP && !isVariadic;
5719 
5721 
5722  // Handle illegal vector types here.
5723  if (isIllegalVectorType(Ty)) {
5724  uint64_t Size = getContext().getTypeSize(Ty);
5725  if (Size <= 32) {
5726  llvm::Type *ResType =
5727  llvm::Type::getInt32Ty(getVMContext());
5728  return ABIArgInfo::getDirect(ResType);
5729  }
5730  if (Size == 64) {
5731  llvm::Type *ResType = llvm::VectorType::get(
5732  llvm::Type::getInt32Ty(getVMContext()), 2);
5733  return ABIArgInfo::getDirect(ResType);
5734  }
5735  if (Size == 128) {
5736  llvm::Type *ResType = llvm::VectorType::get(
5737  llvm::Type::getInt32Ty(getVMContext()), 4);
5738  return ABIArgInfo::getDirect(ResType);
5739  }
5740  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
5741  }
5742 
5743  // __fp16 gets passed as if it were an int or float, but with the top 16 bits
5744  // unspecified. This is not done for OpenCL as it handles the half type
5745  // natively, and does not need to interwork with AAPCS code.
5746  if (Ty->isHalfType() && !getContext().getLangOpts().NativeHalfArgsAndReturns) {
5747  llvm::Type *ResType = IsEffectivelyAAPCS_VFP ?
5748  llvm::Type::getFloatTy(getVMContext()) :
5749  llvm::Type::getInt32Ty(getVMContext());
5750  return ABIArgInfo::getDirect(ResType);
5751  }
5752 
5753  if (!isAggregateTypeForABI(Ty)) {
5754  // Treat an enum type as its underlying type.
5755  if (const EnumType *EnumTy = Ty->getAs<EnumType>()) {
5756  Ty = EnumTy->getDecl()->getIntegerType();
5757  }
5758 
5760  : ABIArgInfo::getDirect());
5761  }
5762 
5765  }
5766 
5767  // Ignore empty records.
5768  if (isEmptyRecord(getContext(), Ty, true))
5769  return ABIArgInfo::getIgnore();
5770 
5771  if (IsEffectivelyAAPCS_VFP) {
5772  // Homogeneous Aggregates need to be expanded when we can fit the aggregate
5773  // into VFP registers.
5774  const Type *Base = nullptr;
5775  uint64_t Members = 0;
5776  if (isHomogeneousAggregate(Ty, Base, Members)) {
5777  assert(Base && "Base class should be set for homogeneous aggregate");
5778  // Base can be a floating-point or a vector.
5779  return ABIArgInfo::getDirect(nullptr, 0, nullptr, false);
5780  }
5781  } else if (getABIKind() == ARMABIInfo::AAPCS16_VFP) {
5782  // WatchOS does have homogeneous aggregates. Note that we intentionally use
5783  // this convention even for a variadic function: the backend will use GPRs
5784  // if needed.
5785  const Type *Base = nullptr;
5786  uint64_t Members = 0;
5787  if (isHomogeneousAggregate(Ty, Base, Members)) {
5788  assert(Base && Members <= 4 && "unexpected homogeneous aggregate");
5789  llvm::Type *Ty =
5790  llvm::ArrayType::get(CGT.ConvertType(QualType(Base, 0)), Members);
5791  return ABIArgInfo::getDirect(Ty, 0, nullptr, false);
5792  }
5793  }
5794 
5795  if (getABIKind() == ARMABIInfo::AAPCS16_VFP &&
5796  getContext().getTypeSizeInChars(Ty) > CharUnits::fromQuantity(16)) {
5797  // WatchOS is adopting the 64-bit AAPCS rule on composite types: if they're
5798  // bigger than 128-bits, they get placed in space allocated by the caller,
5799  // and a pointer is passed.
5800  return ABIArgInfo::getIndirect(
5801  CharUnits::fromQuantity(getContext().getTypeAlign(Ty) / 8), false);
5802  }
5803 
5804  // Support byval for ARM.
5805  // The ABI alignment for APCS is 4-byte and for AAPCS at least 4-byte and at
5806  // most 8-byte. We realign the indirect argument if type alignment is bigger
5807  // than ABI alignment.
5808  uint64_t ABIAlign = 4;
5809  uint64_t TyAlign = getContext().getTypeAlign(Ty) / 8;
5810  if (getABIKind() == ARMABIInfo::AAPCS_VFP ||
5811  getABIKind() == ARMABIInfo::AAPCS)
5812  ABIAlign = std::min(std::max(TyAlign, (uint64_t)4), (uint64_t)8);
5813 
5814  if (getContext().getTypeSizeInChars(Ty) > CharUnits::fromQuantity(64)) {
5815  assert(getABIKind() != ARMABIInfo::AAPCS16_VFP && "unexpected byval");
5817  /*ByVal=*/true,
5818  /*Realign=*/TyAlign > ABIAlign);
5819  }
5820 
5821  // On RenderScript, coerce Aggregates <= 64 bytes to an integer array of
5822  // same size and alignment.
5823  if (getTarget().isRenderScriptTarget()) {
5824  return coerceToIntArray(Ty, getContext(), getVMContext());
5825  }
5826 
5827  // Otherwise, pass by coercing to a structure of the appropriate size.
5828  llvm::Type* ElemTy;
5829  unsigned SizeRegs;
5830  // FIXME: Try to match the types of the arguments more accurately where
5831  // we can.
5832  if (getContext().getTypeAlign(Ty) <= 32) {
5833  ElemTy = llvm::Type::getInt32Ty(getVMContext());
5834  SizeRegs = (getContext().getTypeSize(Ty) + 31) / 32;
5835  } else {
5836  ElemTy = llvm::Type::getInt64Ty(getVMContext());
5837  SizeRegs = (getContext().getTypeSize(Ty) + 63) / 64;
5838  }
5839 
5840  return ABIArgInfo::getDirect(llvm::ArrayType::get(ElemTy, SizeRegs));
5841 }
5842 
5843 static bool isIntegerLikeType(QualType Ty, ASTContext &Context,
5844  llvm::LLVMContext &VMContext) {
5845  // APCS, C Language Calling Conventions, Non-Simple Return Values: A structure
5846  // is called integer-like if its size is less than or equal to one word, and
5847  // the offset of each of its addressable sub-fields is zero.
5848 
5849  uint64_t Size = Context.getTypeSize(Ty);
5850 
5851  // Check that the type fits in a word.
5852  if (Size > 32)
5853  return false;
5854 
5855  // FIXME: Handle vector types!
5856  if (Ty->isVectorType())
5857  return false;
5858 
5859  // Float types are never treated as "integer like".
5860  if (Ty->isRealFloatingType())
5861  return false;
5862 
5863  // If this is a builtin or pointer type then it is ok.
5864  if (Ty->getAs<BuiltinType>() || Ty->isPointerType())
5865  return true;
5866 
5867  // Small complex integer types are "integer like".
5868  if (const ComplexType *CT = Ty->getAs<ComplexType>())
5869  return isIntegerLikeType(CT->getElementType(), Context, VMContext);
5870 
5871  // Single element and zero sized arrays should be allowed, by the definition
5872  // above, but they are not.
5873 
5874  // Otherwise, it must be a record type.
5875  const RecordType *RT = Ty->getAs<RecordType>();
5876  if (!RT) return false;
5877 
5878  // Ignore records with flexible arrays.
5879  const RecordDecl *RD = RT->getDecl();
5880  if (RD->hasFlexibleArrayMember())
5881  return false;
5882 
5883  // Check that all sub-fields are at offset 0, and are themselves "integer
5884  // like".
5885  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
5886 
5887  bool HadField = false;
5888  unsigned idx = 0;
5889  for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
5890  i != e; ++i, ++idx) {
5891  const FieldDecl *FD = *i;
5892 
5893  // Bit-fields are not addressable, we only need to verify they are "integer
5894  // like". We still have to disallow a subsequent non-bitfield, for example:
5895  // struct { int : 0; int x }
5896  // is non-integer like according to gcc.
5897  if (FD->isBitField()) {
5898  if (!RD->isUnion())
5899  HadField = true;
5900 
5901  if (!isIntegerLikeType(FD->getType(), Context, VMContext))
5902  return false;
5903 
5904  continue;
5905  }
5906 
5907  // Check if this field is at offset 0.
5908  if (Layout.getFieldOffset(idx) != 0)
5909  return false;
5910 
5911  if (!isIntegerLikeType(FD->getType(), Context, VMContext))
5912  return false;
5913 
5914  // Only allow at most one field in a structure. This doesn't match the
5915  // wording above, but follows gcc in situations with a field following an
5916  // empty structure.
5917  if (!RD->isUnion()) {
5918  if (HadField)
5919  return false;
5920 
5921  HadField = true;
5922  }
5923  }
5924 
5925  return true;
5926 }
5927 
5929  bool isVariadic) const {
5930  bool IsEffectivelyAAPCS_VFP =
5931  (getABIKind() == AAPCS_VFP || getABIKind() == AAPCS16_VFP) && !isVariadic;
5932 
5933  if (RetTy->isVoidType())
5934  return ABIArgInfo::getIgnore();
5935 
5936  // Large vector types should be returned via memory.
5937  if (RetTy->isVectorType() && getContext().getTypeSize(RetTy) > 128) {
5938  return getNaturalAlignIndirect(RetTy);
5939  }
5940 
5941  // __fp16 gets returned as if it were an int or float, but with the top 16
5942  // bits unspecified. This is not done for OpenCL as it handles the half type
5943  // natively, and does not need to interwork with AAPCS code.
5944  if (RetTy->isHalfType() && !getContext().getLangOpts().NativeHalfArgsAndReturns) {
5945  llvm::Type *ResType = IsEffectivelyAAPCS_VFP ?
5946  llvm::Type::getFloatTy(getVMContext()) :
5947  llvm::Type::getInt32Ty(getVMContext());
5948  return ABIArgInfo::getDirect(ResType);
5949  }
5950 
5951  if (!isAggregateTypeForABI(RetTy)) {
5952  // Treat an enum type as its underlying type.
5953  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
5954  RetTy = EnumTy->getDecl()->getIntegerType();
5955 
5958  }
5959 
5960  // Are we following APCS?
5961  if (getABIKind() == APCS) {
5962  if (isEmptyRecord(getContext(), RetTy, false))
5963  return ABIArgInfo::getIgnore();
5964 
5965  // Complex types are all returned as packed integers.
5966  //
5967  // FIXME: Consider using 2 x vector types if the back end handles them
5968  // correctly.
5969  if (RetTy->isAnyComplexType())
5970  return ABIArgInfo::getDirect(llvm::IntegerType::get(
5971  getVMContext(), getContext().getTypeSize(RetTy)));
5972 
5973  // Integer like structures are returned in r0.
5974  if (isIntegerLikeType(RetTy, getContext(), getVMContext())) {
5975  // Return in the smallest viable integer type.
5976  uint64_t Size = getContext().getTypeSize(RetTy);
5977  if (Size <= 8)
5978  return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
5979  if (Size <= 16)
5980  return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
5981  return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
5982  }
5983 
5984  // Otherwise return in memory.
5985  return getNaturalAlignIndirect(RetTy);
5986  }
5987 
5988  // Otherwise this is an AAPCS variant.
5989 
5990  if (isEmptyRecord(getContext(), RetTy, true))
5991  return ABIArgInfo::getIgnore();
5992 
5993  // Check for homogeneous aggregates with AAPCS-VFP.
5994  if (IsEffectivelyAAPCS_VFP) {
5995  const Type *Base = nullptr;
5996  uint64_t Members = 0;
5997  if (isHomogeneousAggregate(RetTy, Base, Members)) {
5998  assert(Base && "Base class should be set for homogeneous aggregate");
5999  // Homogeneous Aggregates are returned directly.
6000  return ABIArgInfo::getDirect(nullptr, 0, nullptr, false);
6001  }
6002  }
6003 
6004  // Aggregates <= 4 bytes are returned in r0; other aggregates
6005  // are returned indirectly.
6006  uint64_t Size = getContext().getTypeSize(RetTy);
6007  if (Size <= 32) {
6008  // On RenderScript, coerce Aggregates <= 4 bytes to an integer array of
6009  // same size and alignment.
6010  if (getTarget().isRenderScriptTarget()) {
6011  return coerceToIntArray(RetTy, getContext(), getVMContext());
6012  }
6013  if (getDataLayout().isBigEndian())
6014  // Return in 32 bit integer integer type (as if loaded by LDR, AAPCS 5.4)
6015  return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
6016 
6017  // Return in the smallest viable integer type.
6018  if (Size <= 8)
6019  return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
6020  if (Size <= 16)
6021  return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
6022  return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
6023  } else if (Size <= 128 && getABIKind() == AAPCS16_VFP) {
6024  llvm::Type *Int32Ty = llvm::Type::getInt32Ty(getVMContext());
6025  llvm::Type *CoerceTy =
6026  llvm::ArrayType::get(Int32Ty, llvm::alignTo(Size, 32) / 32);
6027  return ABIArgInfo::getDirect(CoerceTy);
6028  }
6029 
6030  return getNaturalAlignIndirect(RetTy);
6031 }
6032 
6033 /// isIllegalVector - check whether Ty is an illegal vector type.
6034 bool ARMABIInfo::isIllegalVectorType(QualType Ty) const {
6035  if (const VectorType *VT = Ty->getAs<VectorType> ()) {
6036  if (isAndroid()) {
6037  // Android shipped using Clang 3.1, which supported a slightly different
6038  // vector ABI. The primary differences were that 3-element vector types
6039  // were legal, and so were sub 32-bit vectors (i.e. <2 x i8>). This path
6040  // accepts that legacy behavior for Android only.
6041  // Check whether VT is legal.
6042  unsigned NumElements = VT->getNumElements();
6043  // NumElements should be power of 2 or equal to 3.
6044  if (!llvm::isPowerOf2_32(NumElements) && NumElements != 3)
6045  return true;
6046  } else {
6047  // Check whether VT is legal.
6048  unsigned NumElements = VT->getNumElements();
6049  uint64_t Size = getContext().getTypeSize(VT);
6050  // NumElements should be power of 2.
6051  if (!llvm::isPowerOf2_32(NumElements))
6052  return true;
6053  // Size should be greater than 32 bits.
6054  return Size <= 32;
6055  }
6056  }
6057  return false;
6058 }
6059 
6060 bool ARMABIInfo::isLegalVectorTypeForSwift(CharUnits vectorSize,
6061  llvm::Type *eltTy,
6062  unsigned numElts) const {
6063  if (!llvm::isPowerOf2_32(numElts))
6064  return false;
6065  unsigned size = getDataLayout().getTypeStoreSizeInBits(eltTy);
6066  if (size > 64)
6067  return false;
6068  if (vectorSize.getQuantity() != 8 &&
6069  (vectorSize.getQuantity() != 16 || numElts == 1))
6070  return false;
6071  return true;
6072 }
6073 
6074 bool ARMABIInfo::isHomogeneousAggregateBaseType(QualType Ty) const {
6075  // Homogeneous aggregates for AAPCS-VFP must have base types of float,
6076  // double, or 64-bit or 128-bit vectors.
6077  if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
6078  if (BT->getKind() == BuiltinType::Float ||
6079  BT->getKind() == BuiltinType::Double ||
6080  BT->getKind() == BuiltinType::LongDouble)
6081  return true;
6082  } else if (const VectorType *VT = Ty->getAs<VectorType>()) {
6083  unsigned VecSize = getContext().getTypeSize(VT);
6084  if (VecSize == 64 || VecSize == 128)
6085  return true;
6086  }
6087  return false;
6088 }
6089 
6090 bool ARMABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
6091  uint64_t Members) const {
6092  return Members <= 4;
6093 }
6094 
6095 Address ARMABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6096  QualType Ty) const {
6097  CharUnits SlotSize = CharUnits::fromQuantity(4);
6098 
6099  // Empty records are ignored for parameter passing purposes.
6100  if (isEmptyRecord(getContext(), Ty, true)) {
6101  Address Addr(CGF.Builder.CreateLoad(VAListAddr), SlotSize);
6102  Addr = CGF.Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(Ty));
6103  return Addr;
6104  }
6105 
6106  auto TyInfo = getContext().getTypeInfoInChars(Ty);
6107  CharUnits TyAlignForABI = TyInfo.second;
6108 
6109  // Use indirect if size of the illegal vector is bigger than 16 bytes.
6110  bool IsIndirect = false;
6111  const Type *Base = nullptr;
6112  uint64_t Members = 0;
6113  if (TyInfo.first > CharUnits::fromQuantity(16) && isIllegalVectorType(Ty)) {
6114  IsIndirect = true;
6115 
6116  // ARMv7k passes structs bigger than 16 bytes indirectly, in space
6117  // allocated by the caller.
6118  } else if (TyInfo.first > CharUnits::fromQuantity(16) &&
6119  getABIKind() == ARMABIInfo::AAPCS16_VFP &&
6120  !isHomogeneousAggregate(Ty, Base, Members)) {
6121  IsIndirect = true;
6122 
6123  // Otherwise, bound the type's ABI alignment.
6124  // The ABI alignment for 64-bit or 128-bit vectors is 8 for AAPCS and 4 for
6125  // APCS. For AAPCS, the ABI alignment is at least 4-byte and at most 8-byte.
6126  // Our callers should be prepared to handle an under-aligned address.
6127  } else if (getABIKind() == ARMABIInfo::AAPCS_VFP ||
6128  getABIKind() == ARMABIInfo::AAPCS) {
6129  TyAlignForABI = std::max(TyAlignForABI, CharUnits::fromQuantity(4));
6130  TyAlignForABI = std::min(TyAlignForABI, CharUnits::fromQuantity(8));
6131  } else if (getABIKind() == ARMABIInfo::AAPCS16_VFP) {
6132  // ARMv7k allows type alignment up to 16 bytes.
6133  TyAlignForABI = std::max(TyAlignForABI, CharUnits::fromQuantity(4));
6134  TyAlignForABI = std::min(TyAlignForABI, CharUnits::fromQuantity(16));
6135  } else {
6136  TyAlignForABI = CharUnits::fromQuantity(4);
6137  }
6138  TyInfo.second = TyAlignForABI;
6139 
6140  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, IsIndirect, TyInfo,
6141  SlotSize, /*AllowHigherAlign*/ true);
6142 }
6143 
6144 //===----------------------------------------------------------------------===//
6145 // NVPTX ABI Implementation
6146 //===----------------------------------------------------------------------===//
6147 
6148 namespace {
6149 
6150 class NVPTXABIInfo : public ABIInfo {
6151 public:
6152  NVPTXABIInfo(CodeGenTypes &CGT) : ABIInfo(CGT) {}
6153 
6154  ABIArgInfo classifyReturnType(QualType RetTy) const;
6156 
6157  void computeInfo(CGFunctionInfo &FI) const override;
6158  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6159  QualType Ty) const override;
6160 };
6161 
6162 class NVPTXTargetCodeGenInfo : public TargetCodeGenInfo {
6163 public:
6164  NVPTXTargetCodeGenInfo(CodeGenTypes &CGT)
6165  : TargetCodeGenInfo(new NVPTXABIInfo(CGT)) {}
6166 
6167  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
6169  ForDefinition_t IsForDefinition) const override;
6170 
6171 private:
6172  // Adds a NamedMDNode with F, Name, and Operand as operands, and adds the
6173  // resulting MDNode to the nvvm.annotations MDNode.
6174  static void addNVVMMetadata(llvm::Function *F, StringRef Name, int Operand);
6175 };
6176 
6178  if (RetTy->isVoidType())
6179  return ABIArgInfo::getIgnore();
6180 
6181  // note: this is different from default ABI
6182  if (!RetTy->isScalarType())
6183  return ABIArgInfo::getDirect();
6184 
6185  // Treat an enum type as its underlying type.
6186  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
6187  RetTy = EnumTy->getDecl()->getIntegerType();
6188 
6189  return (RetTy->isPromotableIntegerType() ?
6191 }
6192 
6194  // Treat an enum type as its underlying type.
6195  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
6196  Ty = EnumTy->getDecl()->getIntegerType();
6197 
6198  // Return aggregates type as indirect by value
6199  if (isAggregateTypeForABI(Ty))
6200  return getNaturalAlignIndirect(Ty, /* byval */ true);
6201 
6202  return (Ty->isPromotableIntegerType() ?
6204 }
6205 
6206 void NVPTXABIInfo::computeInfo(CGFunctionInfo &FI) const {
6207  if (!getCXXABI().classifyReturnType(FI))
6209  for (auto &I : FI.arguments())
6210  I.info = classifyArgumentType(I.type);
6211 
6212  // Always honor user-specified calling convention.
6214  return;
6215 
6217 }
6218 
6219 Address NVPTXABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6220  QualType Ty) const {
6221  llvm_unreachable("NVPTX does not support varargs");
6222 }
6223 
6224 void NVPTXTargetCodeGenInfo::setTargetAttributes(
6225  const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M,
6226  ForDefinition_t IsForDefinition) const {
6227  if (!IsForDefinition)
6228  return;
6229  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
6230  if (!FD) return;
6231 
6232  llvm::Function *F = cast<llvm::Function>(GV);
6233 
6234  // Perform special handling in OpenCL mode
6235  if (M.getLangOpts().OpenCL) {
6236  // Use OpenCL function attributes to check for kernel functions
6237  // By default, all functions are device functions
6238  if (FD->hasAttr<OpenCLKernelAttr>()) {
6239  // OpenCL __kernel functions get kernel metadata
6240  // Create !{<func-ref>, metadata !"kernel", i32 1} node
6241  addNVVMMetadata(F, "kernel", 1);
6242  // And kernel functions are not subject to inlining
6243  F->addFnAttr(llvm::Attribute::NoInline);
6244  }
6245  }
6246 
6247  // Perform special handling in CUDA mode.
6248  if (M.getLangOpts().CUDA) {
6249  // CUDA __global__ functions get a kernel metadata entry. Since
6250  // __global__ functions cannot be called from the device, we do not
6251  // need to set the noinline attribute.
6252  if (FD->hasAttr<CUDAGlobalAttr>()) {
6253  // Create !{<func-ref>, metadata !"kernel", i32 1} node
6254  addNVVMMetadata(F, "kernel", 1);
6255  }
6256  if (CUDALaunchBoundsAttr *Attr = FD->getAttr<CUDALaunchBoundsAttr>()) {
6257  // Create !{<func-ref>, metadata !"maxntidx", i32 <val>} node
6258  llvm::APSInt MaxThreads(32);
6259  MaxThreads = Attr->getMaxThreads()->EvaluateKnownConstInt(M.getContext());
6260  if (MaxThreads > 0)
6261  addNVVMMetadata(F, "maxntidx", MaxThreads.getExtValue());
6262 
6263  // min blocks is an optional argument for CUDALaunchBoundsAttr. If it was
6264  // not specified in __launch_bounds__ or if the user specified a 0 value,
6265  // we don't have to add a PTX directive.
6266  if (Attr->getMinBlocks()) {
6267  llvm::APSInt MinBlocks(32);
6268  MinBlocks = Attr->getMinBlocks()->EvaluateKnownConstInt(M.getContext());
6269  if (MinBlocks > 0)
6270  // Create !{<func-ref>, metadata !"minctasm", i32 <val>} node
6271  addNVVMMetadata(F, "minctasm", MinBlocks.getExtValue());
6272  }
6273  }
6274  }
6275 }
6276 
6277 void NVPTXTargetCodeGenInfo::addNVVMMetadata(llvm::Function *F, StringRef Name,
6278  int Operand) {
6279  llvm::Module *M = F->getParent();
6280  llvm::LLVMContext &Ctx = M->getContext();
6281 
6282  // Get "nvvm.annotations" metadata node
6283  llvm::NamedMDNode *MD = M->getOrInsertNamedMetadata("nvvm.annotations");
6284 
6285  llvm::Metadata *MDVals[] = {
6286  llvm::ConstantAsMetadata::get(F), llvm::MDString::get(Ctx, Name),
6287  llvm::ConstantAsMetadata::get(
6288  llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx), Operand))};
6289  // Append metadata to nvvm.annotations
6290  MD->addOperand(llvm::MDNode::get(Ctx, MDVals));
6291 }
6292 }
6293 
6294 //===----------------------------------------------------------------------===//
6295 // SystemZ ABI Implementation
6296 //===----------------------------------------------------------------------===//
6297 
6298 namespace {
6299 
6300 class SystemZABIInfo : public SwiftABIInfo {
6301  bool HasVector;
6302 
6303 public:
6304  SystemZABIInfo(CodeGenTypes &CGT, bool HV)
6305  : SwiftABIInfo(CGT), HasVector(HV) {}
6306 
6307  bool isPromotableIntegerType(QualType Ty) const;
6308  bool isCompoundType(QualType Ty) const;
6309  bool isVectorArgumentType(QualType Ty) const;
6310  bool isFPArgumentType(QualType Ty) const;
6311  QualType GetSingleElementType(QualType Ty) const;
6312 
6313  ABIArgInfo classifyReturnType(QualType RetTy) const;
6315 
6316  void computeInfo(CGFunctionInfo &FI) const override {
6317  if (!getCXXABI().classifyReturnType(FI))
6319  for (auto &I : FI.arguments())
6320  I.info = classifyArgumentType(I.type);
6321  }
6322 
6323  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6324  QualType Ty) const override;
6325 
6326  bool shouldPassIndirectlyForSwift(CharUnits totalSize,
6327  ArrayRef<llvm::Type*> scalars,
6328  bool asReturnValue) const override {
6329  return occupiesMoreThan(CGT, scalars, /*total*/ 4);
6330  }
6331  bool isSwiftErrorInRegister() const override {
6332  return false;
6333  }
6334 };
6335 
6336 class SystemZTargetCodeGenInfo : public TargetCodeGenInfo {
6337 public:
6338  SystemZTargetCodeGenInfo(CodeGenTypes &CGT, bool HasVector)
6339  : TargetCodeGenInfo(new SystemZABIInfo(CGT, HasVector)) {}
6340 };
6341 
6342 }
6343 
6344 bool SystemZABIInfo::isPromotableIntegerType(QualType Ty) const {
6345  // Treat an enum type as its underlying type.
6346  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
6347  Ty = EnumTy->getDecl()->getIntegerType();
6348 
6349  // Promotable integer types are required to be promoted by the ABI.
6350  if (Ty->isPromotableIntegerType())
6351  return true;
6352 
6353  // 32-bit values must also be promoted.
6354  if (const BuiltinType *BT = Ty->getAs<BuiltinType>())
6355  switch (BT->getKind()) {
6356  case BuiltinType::Int:
6357  case BuiltinType::UInt:
6358  return true;
6359  default:
6360  return false;
6361  }
6362  return false;
6363 }
6364 
6365 bool SystemZABIInfo::isCompoundType(QualType Ty) const {
6366  return (Ty->isAnyComplexType() ||
6367  Ty->isVectorType() ||
6368  isAggregateTypeForABI(Ty));
6369 }
6370 
6371 bool SystemZABIInfo::isVectorArgumentType(QualType Ty) const {
6372  return (HasVector &&
6373  Ty->isVectorType() &&
6374  getContext().getTypeSize(Ty) <= 128);
6375 }
6376 
6377 bool SystemZABIInfo::isFPArgumentType(QualType Ty) const {
6378  if (const BuiltinType *BT = Ty->getAs<BuiltinType>())
6379  switch (BT->getKind()) {
6380  case BuiltinType::Float:
6381  case BuiltinType::Double:
6382  return true;
6383  default:
6384  return false;
6385  }
6386 
6387  return false;
6388 }
6389 
6390 QualType SystemZABIInfo::GetSingleElementType(QualType Ty) const {
6391  if (const RecordType *RT = Ty->getAsStructureType()) {
6392  const RecordDecl *RD = RT->getDecl();
6393  QualType Found;
6394 
6395  // If this is a C++ record, check the bases first.
6396  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
6397  for (const auto &I : CXXRD->bases()) {
6398  QualType Base = I.getType();
6399 
6400  // Empty bases don't affect things either way.
6401  if (isEmptyRecord(getContext(), Base, true))
6402  continue;
6403 
6404  if (!Found.isNull())
6405  return Ty;
6406  Found = GetSingleElementType(Base);
6407  }
6408 
6409  // Check the fields.
6410  for (const auto *FD : RD->fields()) {
6411  // For compatibility with GCC, ignore empty bitfields in C++ mode.
6412  // Unlike isSingleElementStruct(), empty structure and array fields
6413  // do count. So do anonymous bitfields that aren't zero-sized.
6414  if (getContext().getLangOpts().CPlusPlus &&
6415  FD->isBitField() && FD->getBitWidthValue(getContext()) == 0)
6416  continue;
6417 
6418  // Unlike isSingleElementStruct(), arrays do not count.
6419  // Nested structures still do though.
6420  if (!Found.isNull())
6421  return Ty;
6422  Found = GetSingleElementType(FD->getType());
6423  }
6424 
6425  // Unlike isSingleElementStruct(), trailing padding is allowed.
6426  // An 8-byte aligned struct s { float f; } is passed as a double.
6427  if (!Found.isNull())
6428  return Found;
6429  }
6430 
6431  return Ty;
6432 }
6433 
6434 Address SystemZABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6435  QualType Ty) const {
6436  // Assume that va_list type is correct; should be pointer to LLVM type:
6437  // struct {
6438  // i64 __gpr;
6439  // i64 __fpr;
6440  // i8 *__overflow_arg_area;
6441  // i8 *__reg_save_area;
6442  // };
6443 
6444  // Every non-vector argument occupies 8 bytes and is passed by preference
6445  // in either GPRs or FPRs. Vector arguments occupy 8 or 16 bytes and are
6446  // always passed on the stack.
6447  Ty = getContext().getCanonicalType(Ty);
6448  auto TyInfo = getContext().getTypeInfoInChars(Ty);
6449  llvm::Type *ArgTy = CGF.ConvertTypeForMem(Ty);
6450  llvm::Type *DirectTy = ArgTy;
6452  bool IsIndirect = AI.isIndirect();
6453  bool InFPRs = false;
6454  bool IsVector = false;
6455  CharUnits UnpaddedSize;
6456  CharUnits DirectAlign;
6457  if (IsIndirect) {
6458  DirectTy = llvm::PointerType::getUnqual(DirectTy);
6459  UnpaddedSize = DirectAlign = CharUnits::fromQuantity(8);
6460  } else {
6461  if (AI.getCoerceToType())
6462  ArgTy = AI.getCoerceToType();
6463  InFPRs = ArgTy->isFloatTy() || ArgTy->isDoubleTy();
6464  IsVector = ArgTy->isVectorTy();
6465  UnpaddedSize = TyInfo.first;
6466  DirectAlign = TyInfo.second;
6467  }
6468  CharUnits PaddedSize = CharUnits::fromQuantity(8);
6469  if (IsVector && UnpaddedSize > PaddedSize)
6470  PaddedSize = CharUnits::fromQuantity(16);
6471  assert((UnpaddedSize <= PaddedSize) && "Invalid argument size.");
6472 
6473  CharUnits Padding = (PaddedSize - UnpaddedSize);
6474 
6475  llvm::Type *IndexTy = CGF.Int64Ty;
6476  llvm::Value *PaddedSizeV =
6477  llvm::ConstantInt::get(IndexTy, PaddedSize.getQuantity());
6478 
6479  if (IsVector) {
6480  // Work out the address of a vector argument on the stack.
6481  // Vector arguments are always passed in the high bits of a
6482  // single (8 byte) or double (16 byte) stack slot.
6483  Address OverflowArgAreaPtr =
6484  CGF.Builder.CreateStructGEP(VAListAddr, 2, CharUnits::fromQuantity(16),
6485  "overflow_arg_area_ptr");
6486  Address OverflowArgArea =
6487  Address(CGF.Builder.CreateLoad(OverflowArgAreaPtr, "overflow_arg_area"),
6488  TyInfo.second);
6489  Address MemAddr =
6490  CGF.Builder.CreateElementBitCast(OverflowArgArea, DirectTy, "mem_addr");
6491 
6492  // Update overflow_arg_area_ptr pointer
6493  llvm::Value *NewOverflowArgArea =
6494  CGF.Builder.CreateGEP(OverflowArgArea.getPointer(), PaddedSizeV,
6495  "overflow_arg_area");
6496  CGF.Builder.CreateStore(NewOverflowArgArea, OverflowArgAreaPtr);
6497 
6498  return MemAddr;
6499  }
6500 
6501  assert(PaddedSize.getQuantity() == 8);
6502 
6503  unsigned MaxRegs, RegCountField, RegSaveIndex;
6504  CharUnits RegPadding;
6505  if (InFPRs) {
6506  MaxRegs = 4; // Maximum of 4 FPR arguments
6507  RegCountField = 1; // __fpr
6508  RegSaveIndex = 16; // save offset for f0
6509  RegPadding = CharUnits(); // floats are passed in the high bits of an FPR
6510  } else {
6511  MaxRegs = 5; // Maximum of 5 GPR arguments
6512  RegCountField = 0; // __gpr
6513  RegSaveIndex = 2; // save offset for r2
6514  RegPadding = Padding; // values are passed in the low bits of a GPR
6515  }
6516 
6517  Address RegCountPtr = CGF.Builder.CreateStructGEP(
6518  VAListAddr, RegCountField, RegCountField * CharUnits::fromQuantity(8),
6519  "reg_count_ptr");
6520  llvm::Value *RegCount = CGF.Builder.CreateLoad(RegCountPtr, "reg_count");
6521  llvm::Value *MaxRegsV = llvm::ConstantInt::get(IndexTy, MaxRegs);
6522  llvm::Value *InRegs = CGF.Builder.CreateICmpULT(RegCount, MaxRegsV,
6523  "fits_in_regs");
6524 
6525  llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg");
6526  llvm::BasicBlock *InMemBlock = CGF.createBasicBlock("vaarg.in_mem");
6527  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end");
6528  CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);
6529 
6530  // Emit code to load the value if it was passed in registers.
6531  CGF.EmitBlock(InRegBlock);
6532 
6533  // Work out the address of an argument register.
6534  llvm::Value *ScaledRegCount =
6535  CGF.Builder.CreateMul(RegCount, PaddedSizeV, "scaled_reg_count");
6536  llvm::Value *RegBase =
6537  llvm::ConstantInt::get(IndexTy, RegSaveIndex * PaddedSize.getQuantity()
6538  + RegPadding.getQuantity());
6539  llvm::Value *RegOffset =
6540  CGF.Builder.CreateAdd(ScaledRegCount, RegBase, "reg_offset");
6541  Address RegSaveAreaPtr =
6542  CGF.Builder.CreateStructGEP(VAListAddr, 3, CharUnits::fromQuantity(24),
6543  "reg_save_area_ptr");
6544  llvm::Value *RegSaveArea =
6545  CGF.Builder.CreateLoad(RegSaveAreaPtr, "reg_save_area");
6546  Address RawRegAddr(CGF.Builder.CreateGEP(RegSaveArea, RegOffset,
6547  "raw_reg_addr"),
6548  PaddedSize);
6549  Address RegAddr =
6550  CGF.Builder.CreateElementBitCast(RawRegAddr, DirectTy, "reg_addr");
6551 
6552  // Update the register count
6553  llvm::Value *One = llvm::ConstantInt::get(IndexTy, 1);
6554  llvm::Value *NewRegCount =
6555  CGF.Builder.CreateAdd(RegCount, One, "reg_count");
6556  CGF.Builder.CreateStore(NewRegCount, RegCountPtr);
6557  CGF.EmitBranch(ContBlock);
6558 
6559  // Emit code to load the value if it was passed in memory.
6560  CGF.EmitBlock(InMemBlock);
6561 
6562  // Work out the address of a stack argument.
6563  Address OverflowArgAreaPtr = CGF.Builder.CreateStructGEP(
6564  VAListAddr, 2, CharUnits::fromQuantity(16), "overflow_arg_area_ptr");
6565  Address OverflowArgArea =
6566  Address(CGF.Builder.CreateLoad(OverflowArgAreaPtr, "overflow_arg_area"),
6567  PaddedSize);
6568  Address RawMemAddr =
6569  CGF.Builder.CreateConstByteGEP(OverflowArgArea, Padding, "raw_mem_addr");
6570  Address MemAddr =
6571  CGF.Builder.CreateElementBitCast(RawMemAddr, DirectTy, "mem_addr");
6572 
6573  // Update overflow_arg_area_ptr pointer
6574  llvm::Value *NewOverflowArgArea =
6575  CGF.Builder.CreateGEP(OverflowArgArea.getPointer(), PaddedSizeV,
6576  "overflow_arg_area");
6577  CGF.Builder.CreateStore(NewOverflowArgArea, OverflowArgAreaPtr);
6578  CGF.EmitBranch(ContBlock);
6579 
6580  // Return the appropriate result.
6581  CGF.EmitBlock(ContBlock);
6582  Address ResAddr = emitMergePHI(CGF, RegAddr, InRegBlock,
6583  MemAddr, InMemBlock, "va_arg.addr");
6584 
6585  if (IsIndirect)
6586  ResAddr = Address(CGF.Builder.CreateLoad(ResAddr, "indirect_arg"),
6587  TyInfo.second);
6588 
6589  return ResAddr;
6590 }
6591 
6593  if (RetTy->isVoidType())
6594  return ABIArgInfo::getIgnore();
6595  if (isVectorArgumentType(RetTy))
6596  return ABIArgInfo::getDirect();
6597  if (isCompoundType(RetTy) || getContext().getTypeSize(RetTy) > 64)
6598  return getNaturalAlignIndirect(RetTy);
6599  return (isPromotableIntegerType(RetTy) ?
6601 }
6602 
6604  // Handle the generic C++ ABI.
6607 
6608  // Integers and enums are extended to full register width.
6609  if (isPromotableIntegerType(Ty))
6610  return ABIArgInfo::getExtend();
6611 
6612  // Handle vector types and vector-like structure types. Note that
6613  // as opposed to float-like structure types, we do not allow any
6614  // padding for vector-like structures, so verify the sizes match.
6615  uint64_t Size = getContext().getTypeSize(Ty);
6616  QualType SingleElementTy = GetSingleElementType(Ty);
6617  if (isVectorArgumentType(SingleElementTy) &&
6618  getContext().getTypeSize(SingleElementTy) == Size)
6619  return ABIArgInfo::getDirect(CGT.ConvertType(SingleElementTy));
6620 
6621  // Values that are not 1, 2, 4 or 8 bytes in size are passed indirectly.
6622  if (Size != 8 && Size != 16 && Size != 32 && Size != 64)
6623  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
6624 
6625  // Handle small structures.
6626  if (const RecordType *RT = Ty->getAs<RecordType>()) {
6627  // Structures with flexible arrays have variable length, so really
6628  // fail the size test above.
6629  const RecordDecl *RD = RT->getDecl();
6630  if (RD->hasFlexibleArrayMember())
6631  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
6632 
6633  // The structure is passed as an unextended integer, a float, or a double.
6634  llvm::Type *PassTy;
6635  if (isFPArgumentType(SingleElementTy)) {
6636  assert(Size == 32 || Size == 64);
6637  if (Size == 32)
6638  PassTy = llvm::Type::getFloatTy(getVMContext());
6639  else
6640  PassTy = llvm::Type::getDoubleTy(getVMContext());
6641  } else
6642  PassTy = llvm::IntegerType::get(getVMContext(), Size);
6643  return ABIArgInfo::getDirect(PassTy);
6644  }
6645 
6646  // Non-structure compounds are passed indirectly.
6647  if (isCompoundType(Ty))
6648  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
6649 
6650  return ABIArgInfo::getDirect(nullptr);
6651 }
6652 
6653 //===----------------------------------------------------------------------===//
6654 // MSP430 ABI Implementation
6655 //===----------------------------------------------------------------------===//
6656 
6657 namespace {
6658 
6659 class MSP430TargetCodeGenInfo : public TargetCodeGenInfo {
6660 public:
6661  MSP430TargetCodeGenInfo(CodeGenTypes &CGT)
6662  : TargetCodeGenInfo(new DefaultABIInfo(CGT)) {}
6663  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
6665  ForDefinition_t IsForDefinition) const override;
6666 };
6667 
6668 }
6669 
6670 void MSP430TargetCodeGenInfo::setTargetAttributes(
6671  const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M,
6672  ForDefinition_t IsForDefinition) const {
6673  if (!IsForDefinition)
6674  return;
6675  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
6676  if (const MSP430InterruptAttr *attr = FD->getAttr<MSP430InterruptAttr>()) {
6677  // Handle 'interrupt' attribute:
6678  llvm::Function *F = cast<llvm::Function>(GV);
6679 
6680  // Step 1: Set ISR calling convention.
6681  F->setCallingConv(llvm::CallingConv::MSP430_INTR);
6682 
6683  // Step 2: Add attributes goodness.
6684  F->addFnAttr(llvm::Attribute::NoInline);
6685 
6686  // Step 3: Emit ISR vector alias.
6687  unsigned Num = attr->getNumber() / 2;
6689  "__isr_" + Twine(Num), F);
6690  }
6691  }
6692 }
6693 
6694 //===----------------------------------------------------------------------===//
6695 // MIPS ABI Implementation. This works for both little-endian and
6696 // big-endian variants.
6697 //===----------------------------------------------------------------------===//
6698 
6699 namespace {
6700 class MipsABIInfo : public ABIInfo {
6701  bool IsO32;
6702  unsigned MinABIStackAlignInBytes, StackAlignInBytes;
6703  void CoerceToIntArgs(uint64_t TySize,
6704  SmallVectorImpl<llvm::Type *> &ArgList) const;
6705  llvm::Type* HandleAggregates(QualType Ty, uint64_t TySize) const;
6706  llvm::Type* returnAggregateInRegs(QualType RetTy, uint64_t Size) const;
6707  llvm::Type* getPaddingType(uint64_t Align, uint64_t Offset) const;
6708 public:
6709  MipsABIInfo(CodeGenTypes &CGT, bool _IsO32) :
6710  ABIInfo(CGT), IsO32(_IsO32), MinABIStackAlignInBytes(IsO32 ? 4 : 8),
6711  StackAlignInBytes(IsO32 ? 8 : 16) {}
6712 
6713  ABIArgInfo classifyReturnType(QualType RetTy) const;
6714  ABIArgInfo classifyArgumentType(QualType RetTy, uint64_t &Offset) const;
6715  void computeInfo(CGFunctionInfo &FI) const override;
6716  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6717  QualType Ty) const override;
6718  bool shouldSignExtUnsignedType(QualType Ty) const override;
6719 };
6720 
6721 class MIPSTargetCodeGenInfo : public TargetCodeGenInfo {
6722  unsigned SizeOfUnwindException;
6723 public:
6724  MIPSTargetCodeGenInfo(CodeGenTypes &CGT, bool IsO32)
6725  : TargetCodeGenInfo(new MipsABIInfo(CGT, IsO32)),
6726  SizeOfUnwindException(IsO32 ? 24 : 32) {}
6727 
6728  int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
6729  return 29;
6730  }
6731 
6732  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
6734  ForDefinition_t IsForDefinition) const override {
6735  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
6736  if (!FD) return;
6737  llvm::Function *Fn = cast<llvm::Function>(GV);
6738 
6739  if (FD->hasAttr<MipsLongCallAttr>())
6740  Fn->addFnAttr("long-call");
6741  else if (FD->hasAttr<MipsShortCallAttr>())
6742  Fn->addFnAttr("short-call");
6743 
6744  // Other attributes do not have a meaning for declarations.
6745  if (!IsForDefinition)
6746  return;
6747 
6748  if (FD->hasAttr<Mips16Attr>()) {
6749  Fn->addFnAttr("mips16");
6750  }
6751  else if (FD->hasAttr<NoMips16Attr>()) {
6752  Fn->addFnAttr("nomips16");
6753  }
6754 
6755  if (FD->hasAttr<MicroMipsAttr>())
6756  Fn->addFnAttr("micromips");
6757  else if (FD->hasAttr<NoMicroMipsAttr>())
6758  Fn->addFnAttr("nomicromips");
6759 
6760  const MipsInterruptAttr *Attr = FD->getAttr<MipsInterruptAttr>();
6761  if (!Attr)
6762  return;
6763 
6764  const char *Kind;
6765  switch (Attr->getInterrupt()) {
6766  case MipsInterruptAttr::eic: Kind = "eic"; break;
6767  case MipsInterruptAttr::sw0: Kind = "sw0"; break;
6768  case MipsInterruptAttr::sw1: Kind = "sw1"; break;
6769  case MipsInterruptAttr::hw0: Kind = "hw0"; break;
6770  case MipsInterruptAttr::hw1: Kind = "hw1"; break;
6771  case MipsInterruptAttr::hw2: Kind = "hw2"; break;
6772  case MipsInterruptAttr::hw3: Kind = "hw3"; break;
6773  case MipsInterruptAttr::hw4: Kind = "hw4"; break;
6774  case MipsInterruptAttr::hw5: Kind = "hw5"; break;
6775  }
6776 
6777  Fn->addFnAttr("interrupt", Kind);
6778 
6779  }
6780 
6781  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
6782  llvm::Value *Address) const override;
6783 
6784  unsigned getSizeOfUnwindException() const override {
6785  return SizeOfUnwindException;
6786  }
6787 };
6788 }
6789 
6790 void MipsABIInfo::CoerceToIntArgs(
6791  uint64_t TySize, SmallVectorImpl<llvm::Type *> &ArgList) const {
6792  llvm::IntegerType *IntTy =
6793  llvm::IntegerType::get(getVMContext(), MinABIStackAlignInBytes * 8);
6794 
6795  // Add (TySize / MinABIStackAlignInBytes) args of IntTy.
6796  for (unsigned N = TySize / (MinABIStackAlignInBytes * 8); N; --N)
6797  ArgList.push_back(IntTy);
6798 
6799  // If necessary, add one more integer type to ArgList.
6800  unsigned R = TySize % (MinABIStackAlignInBytes * 8);
6801 
6802  if (R)
6803  ArgList.push_back(llvm::IntegerType::get(getVMContext(), R));
6804 }
6805 
6806 // In N32/64, an aligned double precision floating point field is passed in
6807 // a register.
6808 llvm::Type* MipsABIInfo::HandleAggregates(QualType Ty, uint64_t TySize) const {
6809  SmallVector<llvm::Type*, 8> ArgList, IntArgList;
6810 
6811  if (IsO32) {
6812  CoerceToIntArgs(TySize, ArgList);
6813  return llvm::StructType::get(getVMContext(), ArgList);
6814  }
6815 
6816  if (Ty->isComplexType())
6817  return CGT.ConvertType(Ty);
6818 
6819  const RecordType *RT = Ty->getAs<RecordType>();
6820 
6821  // Unions/vectors are passed in integer registers.
6822  if (!RT || !RT->isStructureOrClassType()) {
6823  CoerceToIntArgs(TySize, ArgList);
6824  return llvm::StructType::get(getVMContext(), ArgList);
6825  }
6826 
6827  const RecordDecl *RD = RT->getDecl();
6828  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
6829  assert(!(TySize % 8) && "Size of structure must be multiple of 8.");
6830 
6831  uint64_t LastOffset = 0;
6832  unsigned idx = 0;
6833  llvm::IntegerType *I64 = llvm::IntegerType::get(getVMContext(), 64);
6834 
6835  // Iterate over fields in the struct/class and check if there are any aligned
6836  // double fields.
6837  for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
6838  i != e; ++i, ++idx) {
6839  const QualType Ty = i->getType();
6840  const BuiltinType *BT = Ty->getAs<BuiltinType>();
6841 
6842  if (!BT || BT->getKind() != BuiltinType::Double)
6843  continue;
6844 
6845  uint64_t Offset = Layout.getFieldOffset(idx);
6846  if (Offset % 64) // Ignore doubles that are not aligned.
6847  continue;
6848 
6849  // Add ((Offset - LastOffset) / 64) args of type i64.
6850  for (unsigned j = (Offset - LastOffset) / 64; j > 0; --j)
6851  ArgList.push_back(I64);
6852 
6853  // Add double type.
6854  ArgList.push_back(llvm::Type::getDoubleTy(getVMContext()));
6855  LastOffset = Offset + 64;
6856  }
6857 
6858  CoerceToIntArgs(TySize - LastOffset, IntArgList);
6859  ArgList.append(IntArgList.begin(), IntArgList.end());
6860 
6861  return llvm::StructType::get(getVMContext(), ArgList);
6862 }
6863 
6864 llvm::Type *MipsABIInfo::getPaddingType(uint64_t OrigOffset,
6865  uint64_t Offset) const {
6866  if (OrigOffset + MinABIStackAlignInBytes > Offset)
6867  return nullptr;
6868 
6869  return llvm::IntegerType::get(getVMContext(), (Offset - OrigOffset) * 8);
6870 }
6871 
6872 ABIArgInfo
6873 MipsABIInfo::classifyArgumentType(QualType Ty, uint64_t &Offset) const {
6875 
6876  uint64_t OrigOffset = Offset;
6877  uint64_t TySize = getContext().getTypeSize(Ty);
6878  uint64_t Align = getContext().getTypeAlign(Ty) / 8;
6879 
6880  Align = std::min(std::max(Align, (uint64_t)MinABIStackAlignInBytes),
6881  (uint64_t)StackAlignInBytes);
6882  unsigned CurrOffset = llvm::alignTo(Offset, Align);
6883  Offset = CurrOffset + llvm::alignTo(TySize, Align * 8) / 8;
6884 
6885  if (isAggregateTypeForABI(Ty) || Ty->isVectorType()) {
6886  // Ignore empty aggregates.
6887  if (TySize == 0)
6888  return ABIArgInfo::getIgnore();
6889 
6891  Offset = OrigOffset + MinABIStackAlignInBytes;
6893  }
6894 
6895  // If we have reached here, aggregates are passed directly by coercing to
6896  // another structure type. Padding is inserted if the offset of the
6897  // aggregate is unaligned.
6898  ABIArgInfo ArgInfo =
6899  ABIArgInfo::getDirect(HandleAggregates(Ty, TySize), 0,
6900  getPaddingType(OrigOffset, CurrOffset));
6901  ArgInfo.setInReg(true);
6902  return ArgInfo;
6903  }
6904 
6905  // Treat an enum type as its underlying type.
6906  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
6907  Ty = EnumTy->getDecl()->getIntegerType();
6908 
6909  // All integral types are promoted to the GPR width.
6910  if (Ty->isIntegralOrEnumerationType())
6911  return ABIArgInfo::getExtend();
6912 
6913  return ABIArgInfo::getDirect(
6914  nullptr, 0, IsO32 ? nullptr : getPaddingType(OrigOffset, CurrOffset));
6915 }
6916 
6917 llvm::Type*
6918 MipsABIInfo::returnAggregateInRegs(QualType RetTy, uint64_t Size) const {
6919  const RecordType *RT = RetTy->getAs<RecordType>();
6921 
6922  if (RT && RT->isStructureOrClassType()) {
6923  const RecordDecl *RD = RT->getDecl();
6924  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
6925  unsigned FieldCnt = Layout.getFieldCount();
6926 
6927  // N32/64 returns struct/classes in floating point registers if the
6928  // following conditions are met:
6929  // 1. The size of the struct/class is no larger than 128-bit.
6930  // 2. The struct/class has one or two fields all of which are floating
6931  // point types.
6932  // 3. The offset of the first field is zero (this follows what gcc does).
6933  //
6934  // Any other composite results are returned in integer registers.
6935  //
6936  if (FieldCnt && (FieldCnt <= 2) && !Layout.getFieldOffset(0)) {
6937  RecordDecl::field_iterator b = RD->field_begin(), e = RD->field_end();
6938  for (; b != e; ++b) {
6939  const BuiltinType *BT = b->getType()->getAs<BuiltinType>();
6940 
6941  if (!BT || !BT->isFloatingPoint())
6942  break;
6943 
6944  RTList.push_back(CGT.ConvertType(b->getType()));
6945  }
6946 
6947  if (b == e)
6948  return llvm::StructType::get(getVMContext(), RTList,
6949  RD->hasAttr<PackedAttr>());
6950 
6951  RTList.clear();
6952  }
6953  }
6954 
6955  CoerceToIntArgs(Size, RTList);
6956  return llvm::StructType::get(getVMContext(), RTList);
6957 }
6958 
6960  uint64_t Size = getContext().getTypeSize(RetTy);
6961 
6962  if (RetTy->isVoidType())
6963  return ABIArgInfo::getIgnore();
6964 
6965  // O32 doesn't treat zero-sized structs differently from other structs.
6966  // However, N32/N64 ignores zero sized return values.
6967  if (!IsO32 && Size == 0)
6968  return ABIArgInfo::getIgnore();
6969 
6970  if (isAggregateTypeForABI(RetTy) || RetTy->isVectorType()) {
6971  if (Size <= 128) {
6972  if (RetTy->isAnyComplexType())
6973  return ABIArgInfo::getDirect();
6974 
6975  // O32 returns integer vectors in registers and N32/N64 returns all small
6976  // aggregates in registers.
6977  if (!IsO32 ||
6978  (RetTy->isVectorType() && !RetTy->hasFloatingRepresentation())) {
6979  ABIArgInfo ArgInfo =
6980  ABIArgInfo::getDirect(returnAggregateInRegs(RetTy, Size));
6981  ArgInfo.setInReg(true);
6982  return ArgInfo;
6983  }
6984  }
6985 
6986  return getNaturalAlignIndirect(RetTy);
6987  }
6988 
6989  // Treat an enum type as its underlying type.
6990  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
6991  RetTy = EnumTy->getDecl()->getIntegerType();
6992 
6993  return (RetTy->isPromotableIntegerType() ?
6995 }
6996 
6997 void MipsABIInfo::computeInfo(CGFunctionInfo &FI) const {
6998  ABIArgInfo &RetInfo = FI.getReturnInfo();
6999  if (!getCXXABI().classifyReturnType(FI))
7000  RetInfo = classifyReturnType(FI.getReturnType());
7001 
7002  // Check if a pointer to an aggregate is passed as a hidden argument.
7003  uint64_t Offset = RetInfo.isIndirect() ? MinABIStackAlignInBytes : 0;
7004 
7005  for (auto &I : FI.arguments())
7006  I.info = classifyArgumentType(I.type, Offset);
7007 }
7008 
7009 Address MipsABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7010  QualType OrigTy) const {
7011  QualType Ty = OrigTy;
7012 
7013  // Integer arguments are promoted to 32-bit on O32 and 64-bit on N32/N64.
7014  // Pointers are also promoted in the same way but this only matters for N32.
7015  unsigned SlotSizeInBits = IsO32 ? 32 : 64;
7016  unsigned PtrWidth = getTarget().getPointerWidth(0);
7017  bool DidPromote = false;
7018  if ((Ty->isIntegerType() &&
7019  getContext().getIntWidth(Ty) < SlotSizeInBits) ||
7020  (Ty->isPointerType() && PtrWidth < SlotSizeInBits)) {
7021  DidPromote = true;
7022  Ty = getContext().getIntTypeForBitwidth(SlotSizeInBits,
7023  Ty->isSignedIntegerType());
7024  }
7025 
7026  auto TyInfo = getContext().getTypeInfoInChars(Ty);
7027 
7028  // The alignment of things in the argument area is never larger than
7029  // StackAlignInBytes.
7030  TyInfo.second =
7031  std::min(TyInfo.second, CharUnits::fromQuantity(StackAlignInBytes));
7032 
7033  // MinABIStackAlignInBytes is the size of argument slots on the stack.
7034  CharUnits ArgSlotSize = CharUnits::fromQuantity(MinABIStackAlignInBytes);
7035 
7036  Address Addr = emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*indirect*/ false,
7037  TyInfo, ArgSlotSize, /*AllowHigherAlign*/ true);
7038 
7039 
7040  // If there was a promotion, "unpromote" into a temporary.
7041  // TODO: can we just use a pointer into a subset of the original slot?
7042  if (DidPromote) {
7043  Address Temp = CGF.CreateMemTemp(OrigTy, "vaarg.promotion-temp");
7044  llvm::Value *Promoted = CGF.Builder.CreateLoad(Addr);
7045 
7046  // Truncate down to the right width.
7047  llvm::Type *IntTy = (OrigTy->isIntegerType() ? Temp.getElementType()
7048  : CGF.IntPtrTy);
7049  llvm::Value *V = CGF.Builder.CreateTrunc(Promoted, IntTy);
7050  if (OrigTy->isPointerType())
7051  V = CGF.Builder.CreateIntToPtr(V, Temp.getElementType());
7052 
7053  CGF.Builder.CreateStore(V, Temp);
7054  Addr = Temp;
7055  }
7056 
7057  return Addr;
7058 }
7059 
7060 bool MipsABIInfo::shouldSignExtUnsignedType(QualType Ty) const {
7061  int TySize = getContext().getTypeSize(Ty);
7062 
7063  // MIPS64 ABI requires unsigned 32 bit integers to be sign extended.
7064  if (Ty->isUnsignedIntegerOrEnumerationType() && TySize == 32)
7065  return true;
7066 
7067  return false;
7068 }
7069 
7070 bool
7071 MIPSTargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
7072  llvm::Value *Address) const {
7073  // This information comes from gcc's implementation, which seems to
7074  // as canonical as it gets.
7075 
7076  // Everything on MIPS is 4 bytes. Double-precision FP registers
7077  // are aliased to pairs of single-precision FP registers.
7078  llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
7079 
7080  // 0-31 are the general purpose registers, $0 - $31.
7081  // 32-63 are the floating-point registers, $f0 - $f31.
7082  // 64 and 65 are the multiply/divide registers, $hi and $lo.
7083  // 66 is the (notional, I think) register for signal-handler return.
7084  AssignToArrayRange(CGF.Builder, Address, Four8, 0, 65);
7085 
7086  // 67-74 are the floating-point status registers, $fcc0 - $fcc7.
7087  // They are one bit wide and ignored here.
7088 
7089  // 80-111 are the coprocessor 0 registers, $c0r0 - $c0r31.
7090  // (coprocessor 1 is the FP unit)
7091  // 112-143 are the coprocessor 2 registers, $c2r0 - $c2r31.
7092  // 144-175 are the coprocessor 3 registers, $c3r0 - $c3r31.
7093  // 176-181 are the DSP accumulator registers.
7094  AssignToArrayRange(CGF.Builder, Address, Four8, 80, 181);
7095  return false;
7096 }
7097 
7098 //===----------------------------------------------------------------------===//
7099 // AVR ABI Implementation.
7100 //===----------------------------------------------------------------------===//
7101 
7102 namespace {
7103 class AVRTargetCodeGenInfo : public TargetCodeGenInfo {
7104 public:
7105  AVRTargetCodeGenInfo(CodeGenTypes &CGT)
7106  : TargetCodeGenInfo(new DefaultABIInfo(CGT)) { }
7107 
7108  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
7110  ForDefinition_t IsForDefinition) const override {
7111  if (!IsForDefinition)
7112  return;
7113  const auto *FD = dyn_cast_or_null<FunctionDecl>(D);
7114  if (!FD) return;
7115  auto *Fn = cast<llvm::Function>(GV);
7116 
7117  if (FD->getAttr<AVRInterruptAttr>())
7118  Fn->addFnAttr("interrupt");
7119 
7120  if (FD->getAttr<AVRSignalAttr>())
7121  Fn->addFnAttr("signal");
7122  }
7123 };
7124 }
7125 
7126 //===----------------------------------------------------------------------===//
7127 // TCE ABI Implementation (see http://tce.cs.tut.fi). Uses mostly the defaults.
7128 // Currently subclassed only to implement custom OpenCL C function attribute
7129 // handling.
7130 //===----------------------------------------------------------------------===//
7131 
7132 namespace {
7133 
7134 class TCETargetCodeGenInfo : public DefaultTargetCodeGenInfo {
7135 public:
7136  TCETargetCodeGenInfo(CodeGenTypes &CGT)
7137  : DefaultTargetCodeGenInfo(CGT) {}
7138 
7139  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
7141  ForDefinition_t IsForDefinition) const override;
7142 };
7143 
7144 void TCETargetCodeGenInfo::setTargetAttributes(
7145  const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M,
7146  ForDefinition_t IsForDefinition) const {
7147  if (!IsForDefinition)
7148  return;
7149  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
7150  if (!FD) return;
7151 
7152  llvm::Function *F = cast<llvm::Function>(GV);
7153 
7154  if (M.getLangOpts().OpenCL) {
7155  if (FD->hasAttr<OpenCLKernelAttr>()) {
7156  // OpenCL C Kernel functions are not subject to inlining
7157  F->addFnAttr(llvm::Attribute::NoInline);
7158  const ReqdWorkGroupSizeAttr *Attr = FD->getAttr<ReqdWorkGroupSizeAttr>();
7159  if (Attr) {
7160  // Convert the reqd_work_group_size() attributes to metadata.
7161  llvm::LLVMContext &Context = F->getContext();
7162  llvm::NamedMDNode *OpenCLMetadata =
7163  M.getModule().getOrInsertNamedMetadata(
7164  "opencl.kernel_wg_size_info");
7165 
7167  Operands.push_back(llvm::ConstantAsMetadata::get(F));
7168 
7169  Operands.push_back(
7170  llvm::ConstantAsMetadata::get(llvm::Constant::getIntegerValue(
7171  M.Int32Ty, llvm::APInt(32, Attr->getXDim()))));
7172  Operands.push_back(
7173  llvm::ConstantAsMetadata::get(llvm::Constant::getIntegerValue(
7174  M.Int32Ty, llvm::APInt(32, Attr->getYDim()))));
7175  Operands.push_back(
7176  llvm::ConstantAsMetadata::get(llvm::Constant::getIntegerValue(
7177  M.Int32Ty, llvm::APInt(32, Attr->getZDim()))));
7178 
7179  // Add a boolean constant operand for "required" (true) or "hint"
7180  // (false) for implementing the work_group_size_hint attr later.
7181  // Currently always true as the hint is not yet implemented.
7182  Operands.push_back(
7183  llvm::ConstantAsMetadata::get(llvm::ConstantInt::getTrue(Context)));
7184  OpenCLMetadata->addOperand(llvm::MDNode::get(Context, Operands));
7185  }
7186  }
7187  }
7188 }
7189 
7190 }
7191 
7192 //===----------------------------------------------------------------------===//
7193 // Hexagon ABI Implementation
7194 //===----------------------------------------------------------------------===//
7195 
7196 namespace {
7197 
7198 class HexagonABIInfo : public ABIInfo {
7199 
7200 
7201 public:
7202  HexagonABIInfo(CodeGenTypes &CGT) : ABIInfo(CGT) {}
7203 
7204 private:
7205 
7206  ABIArgInfo classifyReturnType(QualType RetTy) const;
7208 
7209  void computeInfo(CGFunctionInfo &FI) const override;
7210 
7211  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7212  QualType Ty) const override;
7213 };
7214 
7215 class HexagonTargetCodeGenInfo : public TargetCodeGenInfo {
7216 public:
7217  HexagonTargetCodeGenInfo(CodeGenTypes &CGT)
7218  :TargetCodeGenInfo(new HexagonABIInfo(CGT)) {}
7219 
7220  int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
7221  return 29;
7222  }
7223 };
7224 
7225 }
7226 
7227 void HexagonABIInfo::computeInfo(CGFunctionInfo &FI) const {
7228  if (!getCXXABI().classifyReturnType(FI))
7230  for (auto &I : FI.arguments())
7231  I.info = classifyArgumentType(I.type);
7232 }
7233 
7235  if (!isAggregateTypeForABI(Ty)) {
7236  // Treat an enum type as its underlying type.
7237  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
7238  Ty = EnumTy->getDecl()->getIntegerType();
7239 
7240  return (Ty->isPromotableIntegerType() ?
7242  }
7243 
7246 
7247  // Ignore empty records.
7248  if (isEmptyRecord(getContext(), Ty, true))
7249  return ABIArgInfo::getIgnore();
7250 
7251  uint64_t Size = getContext().getTypeSize(Ty);
7252  if (Size > 64)
7253  return getNaturalAlignIndirect(Ty, /*ByVal=*/true);
7254  // Pass in the smallest viable integer type.
7255  else if (Size > 32)
7256  return ABIArgInfo::getDirect(llvm::Type::getInt64Ty(getVMContext()));
7257  else if (Size > 16)
7258  return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
7259  else if (Size > 8)
7260  return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
7261  else
7262  return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
7263 }
7264 
7266  if (RetTy->isVoidType())
7267  return ABIArgInfo::getIgnore();
7268 
7269  // Large vector types should be returned via memory.
7270  if (RetTy->isVectorType() && getContext().getTypeSize(RetTy) > 64)
7271  return getNaturalAlignIndirect(RetTy);
7272 
7273  if (!isAggregateTypeForABI(RetTy)) {
7274  // Treat an enum type as its underlying type.
7275  if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
7276  RetTy = EnumTy->getDecl()->getIntegerType();
7277 
7278  return (RetTy->isPromotableIntegerType() ?
7280  }
7281 
7282  if (isEmptyRecord(getContext(), RetTy, true))
7283  return ABIArgInfo::getIgnore();
7284 
7285  // Aggregates <= 8 bytes are returned in r0; other aggregates
7286  // are returned indirectly.
7287  uint64_t Size = getContext().getTypeSize(RetTy);
7288  if (Size <= 64) {
7289  // Return in the smallest viable integer type.
7290  if (Size <= 8)
7291  return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
7292  if (Size <= 16)
7293  return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
7294  if (Size <= 32)
7295  return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
7296  return ABIArgInfo::getDirect(llvm::Type::getInt64Ty(getVMContext()));
7297  }
7298 
7299  return getNaturalAlignIndirect(RetTy, /*ByVal=*/true);
7300 }
7301 
7302 Address HexagonABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7303  QualType Ty) const {
7304  // FIXME: Someone needs to audit that this handle alignment correctly.
7305  return emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*indirect*/ false,
7306  getContext().getTypeInfoInChars(Ty),
7308  /*AllowHigherAlign*/ true);
7309 }
7310 
7311 //===----------------------------------------------------------------------===//
7312 // Lanai ABI Implementation
7313 //===----------------------------------------------------------------------===//
7314 
7315 namespace {
7316 class LanaiABIInfo : public DefaultABIInfo {
7317 public:
7318  LanaiABIInfo(CodeGen::CodeGenTypes &CGT) : DefaultABIInfo(CGT) {}
7319 
7320  bool shouldUseInReg(QualType Ty, CCState &State) const;
7321 
7322  void computeInfo(CGFunctionInfo &FI) const override {
7323  CCState State(FI.getCallingConvention());
7324  // Lanai uses 4 registers to pass arguments unless the function has the
7325  // regparm attribute set.
7326  if (FI.getHasRegParm()) {
7327  State.FreeRegs = FI.getRegParm();
7328  } else {
7329  State.FreeRegs = 4;
7330  }
7331 
7332  if (!getCXXABI().classifyReturnType(FI))
7334  for (auto &I : FI.arguments())
7335  I.info = classifyArgumentType(I.type, State);
7336  }
7337 
7338  ABIArgInfo getIndirectResult(QualType Ty, bool ByVal, CCState &State) const;
7339  ABIArgInfo classifyArgumentType(QualType RetTy, CCState &State) const;
7340 };
7341 } // end anonymous namespace
7342 
7343 bool LanaiABIInfo::shouldUseInReg(QualType Ty, CCState &State) const {
7344  unsigned Size = getContext().getTypeSize(Ty);
7345  unsigned SizeInRegs = llvm::alignTo(Size, 32U) / 32U;
7346 
7347  if (SizeInRegs == 0)
7348  return false;
7349 
7350  if (SizeInRegs > State.FreeRegs) {
7351  State.FreeRegs = 0;
7352  return false;
7353  }
7354 
7355  State.FreeRegs -= SizeInRegs;
7356 
7357  return true;
7358 }
7359 
7360 ABIArgInfo LanaiABIInfo::getIndirectResult(QualType Ty, bool ByVal,
7361  CCState &State) const {
7362  if (!ByVal) {
7363  if (State.FreeRegs) {
7364  --State.FreeRegs; // Non-byval indirects just use one pointer.
7365  return getNaturalAlignIndirectInReg(Ty);
7366  }
7367  return getNaturalAlignIndirect(Ty, false);
7368  }
7369 
7370  // Compute the byval alignment.
7371  const unsigned MinABIStackAlignInBytes = 4;
7372  unsigned TypeAlign = getContext().getTypeAlign(Ty) / 8;
7373  return ABIArgInfo::getIndirect(CharUnits::fromQuantity(4), /*ByVal=*/true,
7374  /*Realign=*/TypeAlign >
7375  MinABIStackAlignInBytes);
7376 }
7377 
7379  CCState &State) const {
7380  // Check with the C++ ABI first.
7381  const RecordType *RT = Ty->getAs<RecordType>();
7382  if (RT) {
7384  if (RAA == CGCXXABI::RAA_Indirect) {
7385  return getIndirectResult(Ty, /*ByVal=*/false, State);
7386  } else if (RAA == CGCXXABI::RAA_DirectInMemory) {
7387  return getNaturalAlignIndirect(Ty, /*ByRef=*/true);
7388  }
7389  }
7390 
7391  if (isAggregateTypeForABI(Ty)) {
7392  // Structures with flexible arrays are always indirect.
7393  if (RT && RT->getDecl()->hasFlexibleArrayMember())
7394  return getIndirectResult(Ty, /*ByVal=*/true, State);
7395 
7396  // Ignore empty structs/unions.
7397  if (isEmptyRecord(getContext(), Ty, true))
7398  return ABIArgInfo::getIgnore();
7399 
7400  llvm::LLVMContext &LLVMContext = getVMContext();
7401  unsigned SizeInRegs = (getContext().getTypeSize(Ty) + 31) / 32;
7402  if (SizeInRegs <= State.FreeRegs) {
7403  llvm::IntegerType *Int32 = llvm::Type::getInt32Ty(LLVMContext);
7404  SmallVector<llvm::Type *, 3> Elements(SizeInRegs, Int32);
7405  llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements);
7406  State.FreeRegs -= SizeInRegs;
7407  return ABIArgInfo::getDirectInReg(Result);
7408  } else {
7409  State.FreeRegs = 0;
7410  }
7411  return getIndirectResult(Ty, true, State);
7412  }
7413 
7414  // Treat an enum type as its underlying type.
7415  if (const auto *EnumTy = Ty->getAs<EnumType>())
7416  Ty = EnumTy->getDecl()->getIntegerType();
7417 
7418  bool InReg = shouldUseInReg(Ty, State);
7419  if (Ty->isPromotableIntegerType()) {
7420  if (InReg)
7421  return ABIArgInfo::getDirectInReg();
7422  return ABIArgInfo::getExtend();
7423  }
7424  if (InReg)
7425  return ABIArgInfo::getDirectInReg();
7426  return ABIArgInfo::getDirect();
7427 }
7428 
7429 namespace {
7430 class LanaiTargetCodeGenInfo : public TargetCodeGenInfo {
7431 public:
7432  LanaiTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
7433  : TargetCodeGenInfo(new LanaiABIInfo(CGT)) {}
7434 };
7435 }
7436 
7437 //===----------------------------------------------------------------------===//
7438 // AMDGPU ABI Implementation
7439 //===----------------------------------------------------------------------===//
7440 
7441 namespace {
7442 
7443 class AMDGPUABIInfo final : public DefaultABIInfo {
7444 private:
7445  static const unsigned MaxNumRegsForArgsRet = 16;
7446 
7447  unsigned numRegsForType(QualType Ty) const;
7448 
7449  bool isHomogeneousAggregateBaseType(QualType Ty) const override;
7450  bool isHomogeneousAggregateSmallEnough(const Type *Base,
7451  uint64_t Members) const override;
7452 
7453 public:
7454  explicit AMDGPUABIInfo(CodeGen::CodeGenTypes &CGT) :
7455  DefaultABIInfo(CGT) {}
7456 
7457  ABIArgInfo classifyReturnType(QualType RetTy) const;
7458  ABIArgInfo classifyKernelArgumentType(QualType Ty) const;
7459  ABIArgInfo classifyArgumentType(QualType Ty, unsigned &NumRegsLeft) const;
7460 
7461  void computeInfo(CGFunctionInfo &FI) const override;
7462 };
7463 
7464 bool AMDGPUABIInfo::isHomogeneousAggregateBaseType(QualType Ty) const {
7465  return true;
7466 }
7467 
7468 bool AMDGPUABIInfo::isHomogeneousAggregateSmallEnough(
7469  const Type *Base, uint64_t Members) const {
7470  uint32_t NumRegs = (getContext().getTypeSize(Base) + 31) / 32;
7471 
7472  // Homogeneous Aggregates may occupy at most 16 registers.
7473  return Members * NumRegs <= MaxNumRegsForArgsRet;
7474 }
7475 
7476 /// Estimate number of registers the type will use when passed in registers.
7477 unsigned AMDGPUABIInfo::numRegsForType(QualType Ty) const {
7478  unsigned NumRegs = 0;
7479 
7480  if (const VectorType *VT = Ty->getAs<VectorType>()) {
7481  // Compute from the number of elements. The reported size is based on the
7482  // in-memory size, which includes the padding 4th element for 3-vectors.
7483  QualType EltTy = VT->getElementType();
7484  unsigned EltSize = getContext().getTypeSize(EltTy);
7485 
7486  // 16-bit element vectors should be passed as packed.
7487  if (EltSize == 16)
7488  return (VT->getNumElements() + 1) / 2;
7489 
7490  unsigned EltNumRegs = (EltSize + 31) / 32;
7491  return EltNumRegs * VT->getNumElements();
7492  }
7493 
7494  if (const RecordType *RT = Ty->getAs<RecordType>()) {
7495  const RecordDecl *RD = RT->getDecl();
7496  assert(!RD->hasFlexibleArrayMember());
7497 
7498  for (const FieldDecl *Field : RD->fields()) {
7499  QualType FieldTy = Field->getType();
7500  NumRegs += numRegsForType(FieldTy);
7501  }
7502 
7503  return NumRegs;
7504  }
7505 
7506  return (getContext().getTypeSize(Ty) + 31) / 32;
7507 }
7508 
7509 void AMDGPUABIInfo::computeInfo(CGFunctionInfo &FI) const {
7511 
7512  if (!getCXXABI().classifyReturnType(FI))
7514 
7515  unsigned NumRegsLeft = MaxNumRegsForArgsRet;
7516  for (auto &Arg : FI.arguments()) {
7517  if (CC == llvm::CallingConv::AMDGPU_KERNEL) {
7518  Arg.info = classifyKernelArgumentType(Arg.type);
7519  } else {
7520  Arg.info = classifyArgumentType(Arg.type, NumRegsLeft);
7521  }
7522  }
7523 }
7524 
7526  if (isAggregateTypeForABI(RetTy)) {
7527  // Records with non-trivial destructors/copy-constructors should not be
7528  // returned by value.
7529  if (!getRecordArgABI(RetTy, getCXXABI())) {
7530  // Ignore empty structs/unions.
7531  if (isEmptyRecord(getContext(), RetTy, true))
7532  return ABIArgInfo::getIgnore();
7533 
7534  // Lower single-element structs to just return a regular value.
7535  if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
7536  return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
7537 
7538  if (const RecordType *RT = RetTy->getAs<RecordType>()) {
7539  const RecordDecl *RD = RT->getDecl();
7540  if (RD->hasFlexibleArrayMember())
7541  return DefaultABIInfo::classifyReturnType(RetTy);
7542  }
7543 
7544  // Pack aggregates <= 4 bytes into single VGPR or pair.
7545  uint64_t Size = getContext().getTypeSize(RetTy);
7546  if (Size <= 16)
7547  return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
7548 
7549  if (Size <= 32)
7550  return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
7551 
7552  if (Size <= 64) {
7553  llvm::Type *I32Ty = llvm::Type::getInt32Ty(getVMContext());
7554  return ABIArgInfo::getDirect(llvm::ArrayType::get(I32Ty, 2));
7555  }
7556 
7557  if (numRegsForType(RetTy) <= MaxNumRegsForArgsRet)
7558  return ABIArgInfo::getDirect();
7559  }
7560  }
7561 
7562  // Otherwise just do the default thing.
7563  return DefaultABIInfo::classifyReturnType(RetTy);
7564 }
7565 
7566 /// For kernels all parameters are really passed in a special buffer. It doesn't
7567 /// make sense to pass anything byval, so everything must be direct.
7568 ABIArgInfo AMDGPUABIInfo::classifyKernelArgumentType(QualType Ty) const {
7570 
7571  // TODO: Can we omit empty structs?
7572 
7573  // Coerce single element structs to its element.
7574  if (const Type *SeltTy = isSingleElementStruct(Ty, getContext()))
7575  return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
7576 
7577  // If we set CanBeFlattened to true, CodeGen will expand the struct to its
7578  // individual elements, which confuses the Clover OpenCL backend; therefore we
7579  // have to set it to false here. Other args of getDirect() are just defaults.
7580  return ABIArgInfo::getDirect(nullptr, 0, nullptr, false);
7581 }
7582 
7584  unsigned &NumRegsLeft) const {
7585  assert(NumRegsLeft <= MaxNumRegsForArgsRet && "register estimate underflow");
7586 
7588 
7589  if (isAggregateTypeForABI(Ty)) {
7590  // Records with non-trivial destructors/copy-constructors should not be
7591  // passed by value.
7592  if (auto RAA = getRecordArgABI(Ty, getCXXABI()))
7594 
7595  // Ignore empty structs/unions.
7596  if (isEmptyRecord(getContext(), Ty, true))
7597  return ABIArgInfo::getIgnore();
7598 
7599  // Lower single-element structs to just pass a regular value. TODO: We
7600  // could do reasonable-size multiple-element structs too, using getExpand(),
7601  // though watch out for things like bitfields.
7602  if (const Type *SeltTy = isSingleElementStruct(Ty, getContext()))
7603  return ABIArgInfo::getDirect(CGT.ConvertType(QualType(SeltTy, 0)));
7604 
7605  if (const RecordType *RT = Ty->getAs<RecordType>()) {
7606  const RecordDecl *RD = RT->getDecl();
7607  if (RD->hasFlexibleArrayMember())
7609  }
7610 
7611  // Pack aggregates <= 8 bytes into single VGPR or pair.
7612  uint64_t Size = getContext().getTypeSize(Ty);
7613  if (Size <= 64) {
7614  unsigned NumRegs = (Size + 31) / 32;
7615  NumRegsLeft -= std::min(NumRegsLeft, NumRegs);
7616 
7617  if (Size <= 16)
7618  return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
7619 
7620  if (Size <= 32)
7621  return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
7622 
7623  // XXX: Should this be i64 instead, and should the limit increase?
7624  llvm::Type *I32Ty = llvm::Type::getInt32Ty(getVMContext());
7625  return ABIArgInfo::getDirect(llvm::ArrayType::get(I32Ty, 2));
7626  }
7627 
7628  if (NumRegsLeft > 0) {
7629  unsigned NumRegs = numRegsForType(Ty);
7630  if (NumRegsLeft >= NumRegs) {
7631  NumRegsLeft -= NumRegs;
7632  return ABIArgInfo::getDirect();
7633  }
7634  }
7635  }
7636 
7637  // Otherwise just do the default thing.
7639  if (!ArgInfo.isIndirect()) {
7640  unsigned NumRegs = numRegsForType(Ty);
7641  NumRegsLeft -= std::min(NumRegs, NumRegsLeft);
7642  }
7643 
7644  return ArgInfo;
7645 }
7646 
7647 class AMDGPUTargetCodeGenInfo : public TargetCodeGenInfo {
7648 public:
7649  AMDGPUTargetCodeGenInfo(CodeGenTypes &CGT)
7650  : TargetCodeGenInfo(new AMDGPUABIInfo(CGT)) {}
7651  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
7653  ForDefinition_t IsForDefinition) const override;
7654  unsigned getOpenCLKernelCallingConv() const override;
7655 
7656  llvm::Constant *getNullPointer(const CodeGen::CodeGenModule &CGM,
7657  llvm::PointerType *T, QualType QT) const override;
7658 
7659  LangAS getASTAllocaAddressSpace() const override {
7660  return getLangASFromTargetAS(
7661  getABIInfo().getDataLayout().getAllocaAddrSpace());
7662  }
7663  LangAS getGlobalVarAddressSpace(CodeGenModule &CGM,
7664  const VarDecl *D) const override;
7665  llvm::SyncScope::ID getLLVMSyncScopeID(SyncScope S,
7666  llvm::LLVMContext &C) const override;
7667  llvm::Function *
7668  createEnqueuedBlockKernel(CodeGenFunction &CGF,
7669  llvm::Function *BlockInvokeFunc,
7670  llvm::Value *BlockLiteral) const override;
7671 };
7672 }
7673 
7674 void AMDGPUTargetCodeGenInfo::setTargetAttributes(
7675  const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M,
7676  ForDefinition_t IsForDefinition) const {
7677  if (!IsForDefinition)
7678  return;
7679  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
7680  if (!FD)
7681  return;
7682 
7683  llvm::Function *F = cast<llvm::Function>(GV);
7684 
7685  const auto *ReqdWGS = M.getLangOpts().OpenCL ?
7686  FD->getAttr<ReqdWorkGroupSizeAttr>() : nullptr;
7687  const auto *FlatWGS = FD->getAttr<AMDGPUFlatWorkGroupSizeAttr>();
7688  if (ReqdWGS || FlatWGS) {
7689  unsigned Min = FlatWGS ? FlatWGS->getMin() : 0;
7690  unsigned Max = FlatWGS ? FlatWGS->getMax() : 0;
7691  if (ReqdWGS && Min == 0 && Max == 0)
7692  Min = Max = ReqdWGS->getXDim() * ReqdWGS->getYDim() * ReqdWGS->getZDim();
7693 
7694  if (Min != 0) {
7695  assert(Min <= Max && "Min must be less than or equal Max");
7696 
7697  std::string AttrVal = llvm::utostr(Min) + "," + llvm::utostr(Max);
7698  F->addFnAttr("amdgpu-flat-work-group-size", AttrVal);
7699  } else
7700  assert(Max == 0 && "Max must be zero");
7701  }
7702 
7703  if (const auto *Attr = FD->getAttr<AMDGPUWavesPerEUAttr>()) {
7704  unsigned Min = Attr->getMin();
7705  unsigned Max = Attr->getMax();
7706 
7707  if (Min != 0) {
7708  assert((Max == 0 || Min <= Max) && "Min must be less than or equal Max");
7709 
7710  std::string AttrVal = llvm::utostr(Min);
7711  if (Max != 0)
7712  AttrVal = AttrVal + "," + llvm::utostr(Max);
7713  F->addFnAttr("amdgpu-waves-per-eu", AttrVal);
7714  } else
7715  assert(Max == 0 && "Max must be zero");
7716  }
7717 
7718  if (const auto *Attr = FD->getAttr<AMDGPUNumSGPRAttr>()) {
7719  unsigned NumSGPR = Attr->getNumSGPR();
7720 
7721  if (NumSGPR != 0)
7722  F->addFnAttr("amdgpu-num-sgpr", llvm::utostr(NumSGPR));
7723  }
7724 
7725  if (const auto *Attr = FD->getAttr<AMDGPUNumVGPRAttr>()) {
7726  uint32_t NumVGPR = Attr->getNumVGPR();
7727 
7728  if (NumVGPR != 0)
7729  F->addFnAttr("amdgpu-num-vgpr", llvm::utostr(NumVGPR));
7730  }
7731 }
7732 
7733 unsigned AMDGPUTargetCodeGenInfo::getOpenCLKernelCallingConv() const {
7734  return llvm::CallingConv::AMDGPU_KERNEL;
7735 }
7736 
7737 // Currently LLVM assumes null pointers always have value 0,
7738 // which results in incorrectly transformed IR. Therefore, instead of
7739 // emitting null pointers in private and local address spaces, a null
7740 // pointer in generic address space is emitted which is casted to a
7741 // pointer in local or private address space.
7742 llvm::Constant *AMDGPUTargetCodeGenInfo::getNullPointer(
7743  const CodeGen::CodeGenModule &CGM, llvm::PointerType *PT,
7744  QualType QT) const {
7745  if (CGM.getContext().getTargetNullPointerValue(QT) == 0)
7746  return llvm::ConstantPointerNull::get(PT);
7747 
7748  auto &Ctx = CGM.getContext();
7749  auto NPT = llvm::PointerType::get(PT->getElementType(),
7750  Ctx.getTargetAddressSpace(LangAS::opencl_generic));
7751  return llvm::ConstantExpr::getAddrSpaceCast(
7752  llvm::ConstantPointerNull::get(NPT), PT);
7753 }
7754 
7755 LangAS
7756 AMDGPUTargetCodeGenInfo::getGlobalVarAddressSpace(CodeGenModule &CGM,
7757  const VarDecl *D) const {
7758  assert(!CGM.getLangOpts().OpenCL &&
7759  !(CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) &&
7760  "Address space agnostic languages only");
7761  LangAS DefaultGlobalAS = getLangASFromTargetAS(
7763  if (!D)
7764  return DefaultGlobalAS;
7765 
7766  LangAS AddrSpace = D->getType().getAddressSpace();
7767  assert(AddrSpace == LangAS::Default || isTargetAddressSpace(AddrSpace));
7768  if (AddrSpace != LangAS::Default)
7769  return AddrSpace;
7770 
7771  if (CGM.isTypeConstant(D->getType(), false)) {
7772  if (auto ConstAS = CGM.getTarget().getConstantAddressSpace())
7773  return ConstAS.getValue();
7774  }
7775  return DefaultGlobalAS;
7776 }
7777 
7779 AMDGPUTargetCodeGenInfo::getLLVMSyncScopeID(SyncScope S,
7780  llvm::LLVMContext &C) const {
7781  StringRef Name;
7782  switch (S) {
7784  Name = "workgroup";
7785  break;
7787  Name = "agent";
7788  break;
7790  Name = "";
7791  break;
7793  Name = "subgroup";
7794  }
7795  return C.getOrInsertSyncScopeID(Name);
7796 }
7797 
7798 //===----------------------------------------------------------------------===//
7799 // SPARC v8 ABI Implementation.
7800 // Based on the SPARC Compliance Definition version 2.4.1.
7801 //
7802 // Ensures that complex values are passed in registers.
7803 //
7804 namespace {
7805 class SparcV8ABIInfo : public DefaultABIInfo {
7806 public:
7807  SparcV8ABIInfo(CodeGenTypes &CGT) : DefaultABIInfo(CGT) {}
7808 
7809 private:
7810  ABIArgInfo classifyReturnType(QualType RetTy) const;
7811  void computeInfo(CGFunctionInfo &FI) const override;
7812 };
7813 } // end anonymous namespace
7814 
7815 
7816 ABIArgInfo
7818  if (Ty->isAnyComplexType()) {
7819  return ABIArgInfo::getDirect();
7820  }
7821  else {
7823  }
7824 }
7825 
7826 void SparcV8ABIInfo::computeInfo(CGFunctionInfo &FI) const {
7827 
7829  for (auto &Arg : FI.arguments())
7830  Arg.info = classifyArgumentType(Arg.type);
7831 }
7832 
7833 namespace {
7834 class SparcV8TargetCodeGenInfo : public TargetCodeGenInfo {
7835 public:
7836  SparcV8TargetCodeGenInfo(CodeGenTypes &CGT)
7837  : TargetCodeGenInfo(new SparcV8ABIInfo(CGT)) {}
7838 };
7839 } // end anonymous namespace
7840 
7841 //===----------------------------------------------------------------------===//
7842 // SPARC v9 ABI Implementation.
7843 // Based on the SPARC Compliance Definition version 2.4.1.
7844 //
7845 // Function arguments a mapped to a nominal "parameter array" and promoted to
7846 // registers depending on their type. Each argument occupies 8 or 16 bytes in
7847 // the array, structs larger than 16 bytes are passed indirectly.
7848 //
7849 // One case requires special care:
7850 //
7851 // struct mixed {
7852 // int i;
7853 // float f;
7854 // };
7855 //
7856 // When a struct mixed is passed by value, it only occupies 8 bytes in the
7857 // parameter array, but the int is passed in an integer register, and the float
7858 // is passed in a floating point register. This is represented as two arguments
7859 // with the LLVM IR inreg attribute:
7860 //
7861 // declare void f(i32 inreg %i, float inreg %f)
7862 //
7863 // The code generator will only allocate 4 bytes from the parameter array for
7864 // the inreg arguments. All other arguments are allocated a multiple of 8
7865 // bytes.
7866 //
7867 namespace {
7868 class SparcV9ABIInfo : public ABIInfo {
7869 public:
7870  SparcV9ABIInfo(CodeGenTypes &CGT) : ABIInfo(CGT) {}
7871 
7872 private:
7873  ABIArgInfo classifyType(QualType RetTy, unsigned SizeLimit) const;
7874  void computeInfo(CGFunctionInfo &FI) const override;
7875  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7876  QualType Ty) const override;
7877 
7878  // Coercion type builder for structs passed in registers. The coercion type
7879  // serves two purposes:
7880  //
7881  // 1. Pad structs to a multiple of 64 bits, so they are passed 'left-aligned'
7882  // in registers.
7883  // 2. Expose aligned floating point elements as first-level elements, so the
7884  // code generator knows to pass them in floating point registers.
7885  //
7886  // We also compute the InReg flag which indicates that the struct contains
7887  // aligned 32-bit floats.
7888  //
7889  struct CoerceBuilder {
7890  llvm::LLVMContext &Context;
7891  const llvm::DataLayout &DL;
7893  uint64_t Size;
7894  bool InReg;
7895 
7896  CoerceBuilder(llvm::LLVMContext &c, const llvm::DataLayout &dl)
7897  : Context(c), DL(dl), Size(0), InReg(false) {}
7898 
7899  // Pad Elems with integers until Size is ToSize.
7900  void pad(uint64_t ToSize) {
7901  assert(ToSize >= Size && "Cannot remove elements");
7902  if (ToSize == Size)
7903  return;
7904 
7905  // Finish the current 64-bit word.
7906  uint64_t Aligned = llvm::alignTo(Size, 64);
7907  if (Aligned > Size && Aligned <= ToSize) {
7908  Elems.push_back(llvm::IntegerType::get(Context, Aligned - Size));
7909  Size = Aligned;
7910  }
7911 
7912  // Add whole 64-bit words.
7913  while (Size + 64 <= ToSize) {
7914  Elems.push_back(llvm::Type::getInt64Ty(Context));
7915  Size += 64;
7916  }
7917 
7918  // Final in-word padding.
7919  if (Size < ToSize) {
7920  Elems.push_back(llvm::IntegerType::get(Context, ToSize - Size));
7921  Size = ToSize;
7922  }
7923  }
7924 
7925  // Add a floating point element at Offset.
7926  void addFloat(uint64_t Offset, llvm::Type *Ty, unsigned Bits) {
7927  // Unaligned floats are treated as integers.
7928  if (Offset % Bits)
7929  return;
7930  // The InReg flag is only required if there are any floats < 64 bits.
7931  if (Bits < 64)
7932  InReg = true;
7933  pad(Offset);
7934  Elems.push_back(Ty);
7935  Size = Offset + Bits;
7936  }
7937 
7938  // Add a struct type to the coercion type, starting at Offset (in bits).
7939  void addStruct(uint64_t Offset, llvm::StructType *StrTy) {
7940  const llvm::StructLayout *Layout = DL.getStructLayout(StrTy);
7941  for (unsigned i = 0, e = StrTy->getNumElements(); i != e; ++i) {
7942  llvm::Type *ElemTy = StrTy->getElementType(i);
7943  uint64_t ElemOffset = Offset + Layout->getElementOffsetInBits(i);
7944  switch (ElemTy->getTypeID()) {
7945  case llvm::Type::StructTyID:
7946  addStruct(ElemOffset, cast<llvm::StructType>(ElemTy));
7947  break;
7948  case llvm::Type::FloatTyID:
7949  addFloat(ElemOffset, ElemTy, 32);
7950  break;
7951  case llvm::Type::DoubleTyID:
7952  addFloat(ElemOffset, ElemTy, 64);
7953  break;
7954  case llvm::Type::FP128TyID:
7955  addFloat(ElemOffset, ElemTy, 128);
7956  break;
7957  case llvm::Type::PointerTyID:
7958  if (ElemOffset % 64 == 0) {
7959  pad(ElemOffset);
7960  Elems.push_back(ElemTy);
7961  Size += 64;
7962  }
7963  break;
7964  default:
7965  break;
7966  }
7967  }
7968  }
7969 
7970  // Check if Ty is a usable substitute for the coercion type.
7971  bool isUsableType(llvm::StructType *Ty) const {
7972  return llvm::makeArrayRef(Elems) == Ty->elements();
7973  }
7974 
7975  // Get the coercion type as a literal struct type.
7976  llvm::Type *getType() const {
7977  if (Elems.size() == 1)
7978  return Elems.front();
7979  else
7980  return llvm::StructType::get(Context, Elems);
7981  }
7982  };
7983 };
7984 } // end anonymous namespace
7985 
7986 ABIArgInfo
7987 SparcV9ABIInfo::classifyType(QualType Ty, unsigned SizeLimit) const {
7988  if (Ty->isVoidType())
7989  return ABIArgInfo::getIgnore();
7990 
7991  uint64_t Size = getContext().getTypeSize(Ty);
7992 
7993  // Anything too big to fit in registers is passed with an explicit indirect
7994  // pointer / sret pointer.
7995  if (Size > SizeLimit)
7996  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
7997 
7998  // Treat an enum type as its underlying type.
7999  if (const EnumType *EnumTy = Ty->getAs<EnumType>())
8000  Ty = EnumTy->getDecl()->getIntegerType();
8001 
8002  // Integer types smaller than a register are extended.
8003  if (Size < 64 && Ty->isIntegerType())
8004  return ABIArgInfo::getExtend();
8005 
8006  // Other non-aggregates go in registers.
8007  if (!isAggregateTypeForABI(Ty))
8008  return ABIArgInfo::getDirect();
8009 
8010  // If a C++ object has either a non-trivial copy constructor or a non-trivial
8011  // destructor, it is passed with an explicit indirect pointer / sret pointer.
8014 
8015  // This is a small aggregate type that should be passed in registers.
8016  // Build a coercion type from the LLVM struct type.
8017  llvm::StructType *StrTy = dyn_cast<llvm::StructType>(CGT.ConvertType(Ty));
8018  if (!StrTy)
8019  return ABIArgInfo::getDirect();
8020 
8021  CoerceBuilder CB(getVMContext(), getDataLayout());
8022  CB.addStruct(0, StrTy);
8023  CB.pad(llvm::alignTo(CB.DL.getTypeSizeInBits(StrTy), 64));
8024 
8025  // Try to use the original type for coercion.
8026  llvm::Type *CoerceTy = CB.isUsableType(StrTy) ? StrTy : CB.getType();
8027 
8028  if (CB.InReg)
8029  return ABIArgInfo::getDirectInReg(CoerceTy);
8030  else
8031  return ABIArgInfo::getDirect(CoerceTy);
8032 }
8033 
8034 Address SparcV9ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8035  QualType Ty) const {
8036  ABIArgInfo AI = classifyType(Ty, 16 * 8);
8037  llvm::Type *ArgTy = CGT.ConvertType(Ty);
8038  if (AI.canHaveCoerceToType() && !AI.getCoerceToType())
8039  AI.setCoerceToType(ArgTy);
8040 
8041  CharUnits SlotSize = CharUnits::fromQuantity(8);
8042 
8043  CGBuilderTy &Builder = CGF.Builder;
8044  Address Addr(Builder.CreateLoad(VAListAddr, "ap.cur"), SlotSize);
8045  llvm::Type *ArgPtrTy = llvm::PointerType::getUnqual(ArgTy);
8046 
8047  auto TypeInfo = getContext().getTypeInfoInChars(Ty);
8048 
8049  Address ArgAddr = Address::invalid();
8050  CharUnits Stride;
8051  switch (AI.getKind()) {
8052  case ABIArgInfo::Expand:
8054  case ABIArgInfo::InAlloca:
8055  llvm_unreachable("Unsupported ABI kind for va_arg");
8056 
8057  case ABIArgInfo::Extend: {
8058  Stride = SlotSize;
8059  CharUnits Offset = SlotSize - TypeInfo.first;
8060  ArgAddr = Builder.CreateConstInBoundsByteGEP(Addr, Offset, "extend");
8061  break;
8062  }
8063 
8064  case ABIArgInfo::Direct: {
8065  auto AllocSize = getDataLayout().getTypeAllocSize(AI.getCoerceToType());
8066  Stride = CharUnits::fromQuantity(AllocSize).alignTo(SlotSize);
8067  ArgAddr = Addr;
8068  break;
8069  }
8070 
8071  case ABIArgInfo::Indirect:
8072  Stride = SlotSize;
8073  ArgAddr = Builder.CreateElementBitCast(Addr, ArgPtrTy, "indirect");
8074  ArgAddr = Address(Builder.CreateLoad(ArgAddr, "indirect.arg"),
8075  TypeInfo.second);
8076  break;
8077 
8078  case ABIArgInfo::Ignore:
8079  return Address(llvm::UndefValue::get(ArgPtrTy), TypeInfo.second);
8080  }
8081 
8082  // Update VAList.
8083  llvm::Value *NextPtr =
8084  Builder.CreateConstInBoundsByteGEP(Addr.getPointer(), Stride, "ap.next");
8085  Builder.CreateStore(NextPtr, VAListAddr);
8086 
8087  return Builder.CreateBitCast(ArgAddr, ArgPtrTy, "arg.addr");
8088 }
8089 
8090 void SparcV9ABIInfo::computeInfo(CGFunctionInfo &FI) const {
8091  FI.getReturnInfo() = classifyType(FI.getReturnType(), 32 * 8);
8092  for (auto &I : FI.arguments())
8093  I.info = classifyType(I.type, 16 * 8);
8094 }
8095 
8096 namespace {
8097 class SparcV9TargetCodeGenInfo : public TargetCodeGenInfo {
8098 public:
8099  SparcV9TargetCodeGenInfo(CodeGenTypes &CGT)
8100  : TargetCodeGenInfo(new SparcV9ABIInfo(CGT)) {}
8101 
8102  int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
8103  return 14;
8104  }
8105 
8106  bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
8107  llvm::Value *Address) const override;
8108 };
8109 } // end anonymous namespace
8110 
8111 bool
8112 SparcV9TargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
8113  llvm::Value *Address) const {
8114  // This is calculated from the LLVM and GCC tables and verified
8115  // against gcc output. AFAIK all ABIs use the same encoding.
8116 
8117  CodeGen::CGBuilderTy &Builder = CGF.Builder;
8118 
8119  llvm::IntegerType *i8 = CGF.Int8Ty;
8120  llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
8121  llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
8122 
8123  // 0-31: the 8-byte general-purpose registers
8124  AssignToArrayRange(Builder, Address, Eight8, 0, 31);
8125 
8126  // 32-63: f0-31, the 4-byte floating-point registers
8127  AssignToArrayRange(Builder, Address, Four8, 32, 63);
8128 
8129  // Y = 64
8130  // PSR = 65
8131  // WIM = 66
8132  // TBR = 67
8133  // PC = 68
8134  // NPC = 69
8135  // FSR = 70
8136  // CSR = 71
8137  AssignToArrayRange(Builder, Address, Eight8, 64, 71);
8138 
8139  // 72-87: d0-15, the 8-byte floating-point registers
8140  AssignToArrayRange(Builder, Address, Eight8, 72, 87);
8141 
8142  return false;
8143 }
8144 
8145 
8146 //===----------------------------------------------------------------------===//
8147 // XCore ABI Implementation
8148 //===----------------------------------------------------------------------===//
8149 
8150 namespace {
8151 
8152 /// A SmallStringEnc instance is used to build up the TypeString by passing
8153 /// it by reference between functions that append to it.
8154 typedef llvm::SmallString<128> SmallStringEnc;
8155 
8156 /// TypeStringCache caches the meta encodings of Types.
8157 ///
8158 /// The reason for caching TypeStrings is two fold:
8159 /// 1. To cache a type's encoding for later uses;
8160 /// 2. As a means to break recursive member type inclusion.
8161 ///
8162 /// A cache Entry can have a Status of:
8163 /// NonRecursive: The type encoding is not recursive;
8164 /// Recursive: The type encoding is recursive;
8165 /// Incomplete: An incomplete TypeString;
8166 /// IncompleteUsed: An incomplete TypeString that has been used in a
8167 /// Recursive type encoding.
8168 ///
8169 /// A NonRecursive entry will have all of its sub-members expanded as fully
8170 /// as possible. Whilst it may contain types which are recursive, the type
8171 /// itself is not recursive and thus its encoding may be safely used whenever
8172 /// the type is encountered.
8173 ///
8174 /// A Recursive entry will have all of its sub-members expanded as fully as
8175 /// possible. The type itself is recursive and it may contain other types which
8176 /// are recursive. The Recursive encoding must not be used during the expansion
8177 /// of a recursive type's recursive branch. For simplicity the code uses
8178 /// IncompleteCount to reject all usage of Recursive encodings for member types.
8179 ///
8180 /// An Incomplete entry is always a RecordType and only encodes its
8181 /// identifier e.g. "s(S){}". Incomplete 'StubEnc' entries are ephemeral and
8182 /// are placed into the cache during type expansion as a means to identify and
8183 /// handle recursive inclusion of types as sub-members. If there is recursion
8184 /// the entry becomes IncompleteUsed.
8185 ///
8186 /// During the expansion of a RecordType's members:
8187 ///
8188 /// If the cache contains a NonRecursive encoding for the member type, the
8189 /// cached encoding is used;
8190 ///
8191 /// If the cache contains a Recursive encoding for the member type, the
8192 /// cached encoding is 'Swapped' out, as it may be incorrect, and...
8193 ///
8194 /// If the member is a RecordType, an Incomplete encoding is placed into the
8195 /// cache to break potential recursive inclusion of itself as a sub-member;
8196 ///
8197 /// Once a member RecordType has been expanded, its temporary incomplete
8198 /// entry is removed from the cache. If a Recursive encoding was swapped out
8199 /// it is swapped back in;
8200 ///
8201 /// If an incomplete entry is used to expand a sub-member, the incomplete
8202 /// entry is marked as IncompleteUsed. The cache keeps count of how many
8203 /// IncompleteUsed entries it currently contains in IncompleteUsedCount;
8204 ///
8205 /// If a member's encoding is found to be a NonRecursive or Recursive viz:
8206 /// IncompleteUsedCount==0, the member's encoding is added to the cache.
8207 /// Else the member is part of a recursive type and thus the recursion has
8208 /// been exited too soon for the encoding to be correct for the member.
8209 ///
8210 class TypeStringCache {
8211  enum Status {NonRecursive, Recursive, Incomplete, IncompleteUsed};
8212  struct Entry {
8213  std::string Str; // The encoded TypeString for the type.
8214  enum Status State; // Information about the encoding in 'Str'.
8215  std::string Swapped; // A temporary place holder for a Recursive encoding
8216  // during the expansion of RecordType's members.
8217  };
8218  std::map<const IdentifierInfo *, struct Entry> Map;
8219  unsigned IncompleteCount; // Number of Incomplete entries in the Map.
8220  unsigned IncompleteUsedCount; // Number of IncompleteUsed entries in the Map.
8221 public:
8222  TypeStringCache() : IncompleteCount(0), IncompleteUsedCount(0) {}
8223  void addIncomplete(const IdentifierInfo *ID, std::string StubEnc);
8224  bool removeIncomplete(const IdentifierInfo *ID);
8225  void addIfComplete(const IdentifierInfo *ID, StringRef Str,
8226  bool IsRecursive);
8227  StringRef lookupStr(const IdentifierInfo *ID);
8228 };
8229 
8230 /// TypeString encodings for enum & union fields must be order.
8231 /// FieldEncoding is a helper for this ordering process.
8232 class FieldEncoding {
8233  bool HasName;
8234  std::string Enc;
8235 public:
8236  FieldEncoding(bool b, SmallStringEnc &e) : HasName(b), Enc(e.c_str()) {}
8237  StringRef str() { return Enc; }
8238  bool operator<(const FieldEncoding &rhs) const {
8239  if (HasName != rhs.HasName) return HasName;
8240  return Enc < rhs.Enc;
8241  }
8242 };
8243 
8244 class XCoreABIInfo : public DefaultABIInfo {
8245 public:
8246  XCoreABIInfo(CodeGen::CodeGenTypes &CGT) : DefaultABIInfo(CGT) {}
8247  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8248  QualType Ty) const override;
8249 };
8250 
8251 class XCoreTargetCodeGenInfo : public TargetCodeGenInfo {
8252  mutable TypeStringCache TSC;
8253 public:
8254  XCoreTargetCodeGenInfo(CodeGenTypes &CGT)
8255  :TargetCodeGenInfo(new XCoreABIInfo(CGT)) {}
8256  void emitTargetMD(const Decl *D, llvm::GlobalValue *GV,
8257  CodeGen::CodeGenModule &M) const override;
8258 };
8259 
8260 } // End anonymous namespace.
8261 
8262 // TODO: this implementation is likely now redundant with the default
8263 // EmitVAArg.
8264 Address XCoreABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8265  QualType Ty) const {
8266  CGBuilderTy &Builder = CGF.Builder;
8267 
8268  // Get the VAList.
8269  CharUnits SlotSize = CharUnits::fromQuantity(4);
8270  Address AP(Builder.CreateLoad(VAListAddr), SlotSize);
8271 
8272  // Handle the argument.
8274  CharUnits TypeAlign = getContext().getTypeAlignInChars(Ty);
8275  llvm::Type *ArgTy = CGT.ConvertType(Ty);
8276  if (AI.canHaveCoerceToType() && !AI.getCoerceToType())
8277  AI.setCoerceToType(ArgTy);
8278  llvm::Type *ArgPtrTy = llvm::PointerType::getUnqual(ArgTy);
8279 
8280  Address Val = Address::invalid();
8281  CharUnits ArgSize = CharUnits::Zero();
8282  switch (AI.getKind()) {
8283  case ABIArgInfo::Expand:
8285  case ABIArgInfo::InAlloca:
8286  llvm_unreachable("Unsupported ABI kind for va_arg");
8287  case ABIArgInfo::Ignore:
8288  Val = Address(llvm::UndefValue::get(ArgPtrTy), TypeAlign);
8289  ArgSize = CharUnits::Zero();
8290  break;
8291  case ABIArgInfo::Extend:
8292  case ABIArgInfo::Direct:
8293  Val = Builder.CreateBitCast(AP, ArgPtrTy);
8294  ArgSize = CharUnits::fromQuantity(
8295  getDataLayout().getTypeAllocSize(AI.getCoerceToType()));
8296  ArgSize = ArgSize.alignTo(SlotSize);
8297  break;
8298  case ABIArgInfo::Indirect:
8299  Val = Builder.CreateElementBitCast(AP, ArgPtrTy);
8300  Val = Address(Builder.CreateLoad(Val), TypeAlign);
8301  ArgSize = SlotSize;
8302  break;
8303  }
8304 
8305  // Increment the VAList.
8306  if (!ArgSize.isZero()) {
8307  llvm::Value *APN =
8308  Builder.CreateConstInBoundsByteGEP(AP.getPointer(), ArgSize);
8309  Builder.CreateStore(APN, VAListAddr);
8310  }
8311 
8312  return Val;
8313 }
8314 
8315 /// During the expansion of a RecordType, an incomplete TypeString is placed
8316 /// into the cache as a means to identify and break recursion.
8317 /// If there is a Recursive encoding in the cache, it is swapped out and will
8318 /// be reinserted by removeIncomplete().
8319 /// All other types of encoding should have been used rather than arriving here.
8320 void TypeStringCache::addIncomplete(const IdentifierInfo *ID,
8321  std::string StubEnc) {
8322  if (!ID)
8323  return;
8324  Entry &E = Map[ID];
8325  assert( (E.Str.empty() || E.State == Recursive) &&
8326  "Incorrectly use of addIncomplete");
8327  assert(!StubEnc.empty() && "Passing an empty string to addIncomplete()");
8328  E.Swapped.swap(E.Str); // swap out the Recursive
8329  E.Str.swap(StubEnc);
8330  E.State = Incomplete;
8331  ++IncompleteCount;
8332 }
8333 
8334 /// Once the RecordType has been expanded, the temporary incomplete TypeString
8335 /// must be removed from the cache.
8336 /// If a Recursive was swapped out by addIncomplete(), it will be replaced.
8337 /// Returns true if the RecordType was defined recursively.
8338 bool TypeStringCache::removeIncomplete(const IdentifierInfo *ID) {
8339  if (!ID)
8340  return false;
8341  auto I = Map.find(ID);
8342  assert(I != Map.end() && "Entry not present");
8343  Entry &E = I->second;
8344  assert( (E.State == Incomplete ||
8345  E.State == IncompleteUsed) &&
8346  "Entry must be an incomplete type");
8347  bool IsRecursive = false;
8348  if (E.State == IncompleteUsed) {
8349  // We made use of our Incomplete encoding, thus we are recursive.
8350  IsRecursive = true;
8351  --IncompleteUsedCount;
8352  }
8353  if (E.Swapped.empty())
8354  Map.erase(I);
8355  else {
8356  // Swap the Recursive back.
8357  E.Swapped.swap(E.Str);
8358  E.Swapped.clear();
8359  E.State = Recursive;
8360  }
8361  --IncompleteCount;
8362  return IsRecursive;
8363 }
8364 
8365 /// Add the encoded TypeString to the cache only if it is NonRecursive or
8366 /// Recursive (viz: all sub-members were expanded as fully as possible).
8367 void TypeStringCache::addIfComplete(const IdentifierInfo *ID, StringRef Str,
8368  bool IsRecursive) {
8369  if (!ID || IncompleteUsedCount)
8370  return; // No key or it is is an incomplete sub-type so don't add.
8371  Entry &E = Map[ID];
8372  if (IsRecursive && !E.Str.empty()) {
8373  assert(E.State==Recursive && E.Str.size() == Str.size() &&
8374  "This is not the same Recursive entry");
8375  // The parent container was not recursive after all, so we could have used
8376  // this Recursive sub-member entry after all, but we assumed the worse when
8377  // we started viz: IncompleteCount!=0.
8378  return;
8379  }
8380  assert(E.Str.empty() && "Entry already present");
8381  E.Str = Str.str();
8382  E.State = IsRecursive? Recursive : NonRecursive;
8383 }
8384 
8385 /// Return a cached TypeString encoding for the ID. If there isn't one, or we
8386 /// are recursively expanding a type (IncompleteCount != 0) and the cached
8387 /// encoding is Recursive, return an empty StringRef.
8388 StringRef TypeStringCache::lookupStr(const IdentifierInfo *ID) {
8389  if (!ID)
8390  return StringRef(); // We have no key.
8391  auto I = Map.find(ID);
8392  if (I == Map.end())
8393  return StringRef(); // We have no encoding.
8394  Entry &E = I->second;
8395  if (E.State == Recursive && IncompleteCount)
8396  return StringRef(); // We don't use Recursive encodings for member types.
8397 
8398  if (E.State == Incomplete) {
8399  // The incomplete type is being used to break out of recursion.
8400  E.State = IncompleteUsed;
8401  ++IncompleteUsedCount;
8402  }
8403  return E.Str;
8404 }
8405 
8406 /// The XCore ABI includes a type information section that communicates symbol
8407 /// type information to the linker. The linker uses this information to verify
8408 /// safety/correctness of things such as array bound and pointers et al.
8409 /// The ABI only requires C (and XC) language modules to emit TypeStrings.
8410 /// This type information (TypeString) is emitted into meta data for all global
8411 /// symbols: definitions, declarations, functions & variables.
8412 ///
8413 /// The TypeString carries type, qualifier, name, size & value details.
8414 /// Please see 'Tools Development Guide' section 2.16.2 for format details:
8415 /// https://www.xmos.com/download/public/Tools-Development-Guide%28X9114A%29.pdf
8416 /// The output is tested by test/CodeGen/xcore-stringtype.c.
8417 ///
8418 static bool getTypeString(SmallStringEnc &Enc, const Decl *D,
8419  CodeGen::CodeGenModule &CGM, TypeStringCache &TSC);
8420 
8421 /// XCore uses emitTargetMD to emit TypeString metadata for global symbols.
8422 void XCoreTargetCodeGenInfo::emitTargetMD(const Decl *D, llvm::GlobalValue *GV,
8423  CodeGen::CodeGenModule &CGM) const {
8424  SmallStringEnc Enc;
8425  if (getTypeString(Enc, D, CGM, TSC)) {
8426  llvm::LLVMContext &Ctx = CGM.getModule().getContext();
8427  llvm::Metadata *MDVals[] = {llvm::ConstantAsMetadata::get(GV),
8428  llvm::MDString::get(Ctx, Enc.str())};
8429  llvm::NamedMDNode *MD =
8430  CGM.getModule().getOrInsertNamedMetadata("xcore.typestrings");
8431  MD->addOperand(llvm::MDNode::get(Ctx, MDVals));
8432  }
8433 }
8434 
8435 //===----------------------------------------------------------------------===//
8436 // SPIR ABI Implementation
8437 //===----------------------------------------------------------------------===//
8438 
8439 namespace {
8440 class SPIRTargetCodeGenInfo : public TargetCodeGenInfo {
8441 public:
8442  SPIRTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
8443  : TargetCodeGenInfo(new DefaultABIInfo(CGT)) {}
8444  unsigned getOpenCLKernelCallingConv() const override;
8445 };
8446 
8447 } // End anonymous namespace.
8448 
8449 namespace clang {
8450 namespace CodeGen {
8452  DefaultABIInfo SPIRABI(CGM.getTypes());
8453  SPIRABI.computeInfo(FI);
8454 }
8455 }
8456 }
8457 
8458 unsigned SPIRTargetCodeGenInfo::getOpenCLKernelCallingConv() const {
8459  return llvm::CallingConv::SPIR_KERNEL;
8460 }
8461 
8462 static bool appendType(SmallStringEnc &Enc, QualType QType,
8463  const CodeGen::CodeGenModule &CGM,
8464  TypeStringCache &TSC);
8465 
8466 /// Helper function for appendRecordType().
8467 /// Builds a SmallVector containing the encoded field types in declaration
8468 /// order.
8470  const RecordDecl *RD,
8471  const CodeGen::CodeGenModule &CGM,
8472  TypeStringCache &TSC) {
8473  for (const auto *Field : RD->fields()) {
8474  SmallStringEnc Enc;
8475  Enc += "m(";
8476  Enc += Field->getName();
8477  Enc += "){";
8478  if (Field->isBitField()) {
8479  Enc += "b(";
8480  llvm::raw_svector_ostream OS(Enc);
8481  OS << Field->getBitWidthValue(CGM.getContext());
8482  Enc += ':';
8483  }
8484  if (!appendType(Enc, Field->getType(), CGM, TSC))
8485  return false;
8486  if (Field->isBitField())
8487  Enc += ')';
8488  Enc += '}';
8489  FE.emplace_back(!Field->getName().empty(), Enc);
8490  }
8491  return true;
8492 }
8493 
8494 /// Appends structure and union types to Enc and adds encoding to cache.
8495 /// Recursively calls appendType (via extractFieldType) for each field.
8496 /// Union types have their fields ordered according to the ABI.
8497 static bool appendRecordType(SmallStringEnc &Enc, const RecordType *RT,
8498  const CodeGen::CodeGenModule &CGM,
8499  TypeStringCache &TSC, const IdentifierInfo *ID) {
8500  // Append the cached TypeString if we have one.
8501  StringRef TypeString = TSC.lookupStr(ID);
8502  if (!TypeString.empty()) {
8503  Enc += TypeString;
8504  return true;
8505  }
8506 
8507  // Start to emit an incomplete TypeString.
8508  size_t Start = Enc.size();
8509  Enc += (RT->isUnionType()? 'u' : 's');
8510  Enc += '(';
8511  if (ID)
8512  Enc += ID->getName();
8513  Enc += "){";
8514 
8515  // We collect all encoded fields and order as necessary.
8516  bool IsRecursive = false;
8517  const RecordDecl *RD = RT->getDecl()->getDefinition();
8518  if (RD && !RD->field_empty()) {
8519  // An incomplete TypeString stub is placed in the cache for this RecordType
8520  // so that recursive calls to this RecordType will use it whilst building a
8521  // complete TypeString for this RecordType.
8523  std::string StubEnc(Enc.substr(Start).str());
8524  StubEnc += '}'; // StubEnc now holds a valid incomplete TypeString.
8525  TSC.addIncomplete(ID, std::move(StubEnc));
8526  if (!extractFieldType(FE, RD, CGM, TSC)) {
8527  (void) TSC.removeIncomplete(ID);
8528  return false;
8529  }
8530  IsRecursive = TSC.removeIncomplete(ID);
8531  // The ABI requires unions to be sorted but not structures.
8532  // See FieldEncoding::operator< for sort algorithm.
8533  if (RT->isUnionType())
8534  std::sort(FE.begin(), FE.end());
8535  // We can now complete the TypeString.
8536  unsigned E = FE.size();
8537  for (unsigned I = 0; I != E; ++I) {
8538  if (I)
8539  Enc += ',';
8540  Enc += FE[I].str();
8541  }
8542  }
8543  Enc += '}';
8544  TSC.addIfComplete(ID, Enc.substr(Start), IsRecursive);
8545  return true;
8546 }
8547 
8548 /// Appends enum types to Enc and adds the encoding to the cache.
8549 static bool appendEnumType(SmallStringEnc &Enc, const EnumType *ET,
8550  TypeStringCache &TSC,
8551  const IdentifierInfo *ID) {
8552  // Append the cached TypeString if we have one.
8553  StringRef TypeString = TSC.lookupStr(ID);
8554  if (!TypeString.empty()) {
8555  Enc += TypeString;
8556  return true;
8557  }
8558 
8559  size_t Start = Enc.size();
8560  Enc += "e(";
8561  if (ID)
8562  Enc += ID->getName();
8563  Enc += "){";
8564 
8565  // We collect all encoded enumerations and order them alphanumerically.
8566  if (const EnumDecl *ED = ET->getDecl()->getDefinition()) {
8568  for (auto I = ED->enumerator_begin(), E = ED->enumerator_end(); I != E;
8569  ++I) {
8570  SmallStringEnc EnumEnc;
8571  EnumEnc += "m(";
8572  EnumEnc += I->getName();
8573  EnumEnc += "){";
8574  I->getInitVal().toString(EnumEnc);
8575  EnumEnc += '}';
8576  FE.push_back(FieldEncoding(!I->getName().empty(), EnumEnc));
8577  }
8578  std::sort(FE.begin(), FE.end());
8579  unsigned E = FE.size();
8580  for (unsigned I = 0; I != E; ++I) {
8581  if (I)
8582  Enc += ',';
8583  Enc += FE[I].str();
8584  }
8585  }
8586  Enc += '}';
8587  TSC.addIfComplete(ID, Enc.substr(Start), false);
8588  return true;
8589 }
8590 
8591 /// Appends type's qualifier to Enc.
8592 /// This is done prior to appending the type's encoding.
8593 static void appendQualifier(SmallStringEnc &Enc, QualType QT) {
8594  // Qualifiers are emitted in alphabetical order.
8595  static const char *const Table[]={"","c:","r:","cr:","v:","cv:","rv:","crv:"};
8596  int Lookup = 0;
8597  if (QT.isConstQualified())
8598  Lookup += 1<<0;
8599  if (QT.isRestrictQualified())
8600  Lookup += 1<<1;
8601  if (QT.isVolatileQualified())
8602  Lookup += 1<<2;
8603  Enc += Table[Lookup];
8604 }
8605 
8606 /// Appends built-in types to Enc.
8607 static bool appendBuiltinType(SmallStringEnc &Enc, const BuiltinType *BT) {
8608  const char *EncType;
8609  switch (BT->getKind()) {
8610  case BuiltinType::Void:
8611  EncType = "0";
8612  break;
8613  case BuiltinType::Bool:
8614  EncType = "b";
8615  break;
8616  case BuiltinType::Char_U:
8617  EncType = "uc";
8618  break;
8619  case BuiltinType::UChar:
8620  EncType = "uc";
8621  break;
8622  case BuiltinType::SChar:
8623  EncType = "sc";
8624  break;
8625  case BuiltinType::UShort:
8626  EncType = "us";
8627  break;
8628  case BuiltinType::Short:
8629  EncType = "ss";
8630  break;
8631  case BuiltinType::UInt:
8632  EncType = "ui";
8633  break;
8634  case BuiltinType::Int:
8635  EncType = "si";
8636  break;
8637  case BuiltinType::ULong:
8638  EncType = "ul";
8639  break;
8640  case BuiltinType::Long:
8641  EncType = "sl";
8642  break;
8643  case BuiltinType::ULongLong:
8644  EncType = "ull";
8645  break;
8646  case BuiltinType::LongLong:
8647  EncType = "sll";
8648  break;
8649  case BuiltinType::Float:
8650  EncType = "ft";
8651  break;
8652  case BuiltinType::Double:
8653  EncType = "d";
8654  break;
8655  case BuiltinType::LongDouble:
8656  EncType = "ld";
8657  break;
8658  default:
8659  return false;
8660  }
8661  Enc += EncType;
8662  return true;
8663 }
8664 
8665 /// Appends a pointer encoding to Enc before calling appendType for the pointee.
8666 static bool appendPointerType(SmallStringEnc &Enc, const PointerType *PT,
8667  const CodeGen::CodeGenModule &CGM,
8668  TypeStringCache &TSC) {
8669  Enc += "p(";
8670  if (!appendType(Enc, PT->getPointeeType(), CGM, TSC))
8671  return false;
8672  Enc += ')';
8673  return true;
8674 }
8675 
8676 /// Appends array encoding to Enc before calling appendType for the element.
8677 static bool appendArrayType(SmallStringEnc &Enc, QualType QT,
8678  const ArrayType *AT,
8679  const CodeGen::CodeGenModule &CGM,
8680  TypeStringCache &TSC, StringRef NoSizeEnc) {
8681  if (AT->getSizeModifier() != ArrayType::Normal)
8682  return false;
8683  Enc += "a(";
8684  if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
8685  CAT->getSize().toStringUnsigned(Enc);
8686  else
8687  Enc += NoSizeEnc; // Global arrays use "*", otherwise it is "".
8688  Enc += ':';
8689  // The Qualifiers should be attached to the type rather than the array.
8690  appendQualifier(Enc, QT);
8691  if (!appendType(Enc, AT->getElementType(), CGM, TSC))
8692  return false;
8693  Enc += ')';
8694  return true;
8695 }
8696 
8697 /// Appends a function encoding to Enc, calling appendType for the return type
8698 /// and the arguments.
8699 static bool appendFunctionType(SmallStringEnc &Enc, const FunctionType *FT,
8700  const CodeGen::CodeGenModule &CGM,
8701  TypeStringCache &TSC) {
8702  Enc += "f{";
8703  if (!appendType(Enc, FT->getReturnType(), CGM, TSC))
8704  return false;
8705  Enc += "}(";
8706  if (const FunctionProtoType *FPT = FT->getAs<FunctionProtoType>()) {
8707  // N.B. we are only interested in the adjusted param types.
8708  auto I = FPT->param_type_begin();
8709  auto E = FPT->param_type_end();
8710  if (I != E) {
8711  do {
8712  if (!appendType(Enc, *I, CGM, TSC))
8713  return false;
8714  ++I;
8715  if (I != E)
8716  Enc += ',';
8717  } while (I != E);
8718  if (FPT->isVariadic())
8719  Enc += ",va";
8720  } else {
8721  if (FPT->isVariadic())
8722  Enc += "va";
8723  else
8724  Enc += '0';
8725  }
8726  }
8727  Enc += ')';
8728  return true;
8729 }
8730 
8731 /// Handles the type's qualifier before dispatching a call to handle specific
8732 /// type encodings.
8733 static bool appendType(SmallStringEnc &Enc, QualType QType,
8734  const CodeGen::CodeGenModule &CGM,
8735  TypeStringCache &TSC) {
8736 
8737  QualType QT = QType.getCanonicalType();
8738 
8739  if (const ArrayType *AT = QT->getAsArrayTypeUnsafe())
8740  // The Qualifiers should be attached to the type rather than the array.
8741  // Thus we don't call appendQualifier() here.
8742  return appendArrayType(Enc, QT, AT, CGM, TSC, "");
8743 
8744  appendQualifier(Enc, QT);
8745 
8746  if (const BuiltinType *BT = QT->getAs<BuiltinType>())
8747  return appendBuiltinType(Enc, BT);
8748 
8749  if (const PointerType *PT = QT->getAs<PointerType>())
8750  return appendPointerType(Enc, PT, CGM, TSC);
8751 
8752  if (const EnumType *ET = QT->getAs<EnumType>())
8753  return appendEnumType(Enc, ET, TSC, QT.getBaseTypeIdentifier());
8754 
8755  if (const RecordType *RT = QT->getAsStructureType())
8756  return appendRecordType(Enc, RT, CGM, TSC, QT.getBaseTypeIdentifier());
8757 
8758  if (const RecordType *RT = QT->getAsUnionType())
8759  return appendRecordType(Enc, RT, CGM, TSC, QT.getBaseTypeIdentifier());
8760 
8761  if (const FunctionType *FT = QT->getAs<FunctionType>())
8762  return appendFunctionType(Enc, FT, CGM, TSC);
8763 
8764  return false;
8765 }
8766 
8767 static bool getTypeString(SmallStringEnc &Enc, const Decl *D,
8768  CodeGen::CodeGenModule &CGM, TypeStringCache &TSC) {
8769  if (!D)
8770  return false;
8771 
8772  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
8773  if (FD->getLanguageLinkage() != CLanguageLinkage)
8774  return false;
8775  return appendType(Enc, FD->getType(), CGM, TSC);
8776  }
8777 
8778  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
8779  if (VD->getLanguageLinkage() != CLanguageLinkage)
8780  return false;
8781  QualType QT = VD->getType().getCanonicalType();
8782  if (const ArrayType *AT = QT->getAsArrayTypeUnsafe()) {
8783  // Global ArrayTypes are given a size of '*' if the size is unknown.
8784  // The Qualifiers should be attached to the type rather than the array.
8785  // Thus we don't call appendQualifier() here.
8786  return appendArrayType(Enc, QT, AT, CGM, TSC, "*");
8787  }
8788  return appendType(Enc, QT, CGM, TSC);
8789  }
8790  return false;
8791 }
8792 
8793 
8794 //===----------------------------------------------------------------------===//
8795 // Driver code
8796 //===----------------------------------------------------------------------===//
8797 
8799  return getTriple().supportsCOMDAT();
8800 }
8801 
8803  if (TheTargetCodeGenInfo)
8804  return *TheTargetCodeGenInfo;
8805 
8806  // Helper to set the unique_ptr while still keeping the return value.
8807  auto SetCGInfo = [&](TargetCodeGenInfo *P) -> const TargetCodeGenInfo & {
8808  this->TheTargetCodeGenInfo.reset(P);
8809  return *P;
8810  };
8811 
8812  const llvm::Triple &Triple = getTarget().getTriple();
8813  switch (Triple.getArch()) {
8814  default:
8815  return SetCGInfo(new DefaultTargetCodeGenInfo(Types));
8816 
8817  case llvm::Triple::le32:
8818  return SetCGInfo(new PNaClTargetCodeGenInfo(Types));
8819  case llvm::Triple::mips:
8820  case llvm::Triple::mipsel:
8821  if (Triple.getOS() == llvm::Triple::NaCl)
8822  return SetCGInfo(new PNaClTargetCodeGenInfo(Types));
8823  return SetCGInfo(new MIPSTargetCodeGenInfo(Types, true));
8824 
8825  case llvm::Triple::mips64:
8826  case llvm::Triple::mips64el:
8827  return SetCGInfo(new MIPSTargetCodeGenInfo(Types, false));
8828 
8829  case llvm::Triple::avr:
8830  return SetCGInfo(new AVRTargetCodeGenInfo(Types));
8831 
8832  case llvm::Triple::aarch64:
8833  case llvm::Triple::aarch64_be: {
8834  AArch64ABIInfo::ABIKind Kind = AArch64ABIInfo::AAPCS;
8835  if (getTarget().getABI() == "darwinpcs")
8836  Kind = AArch64ABIInfo::DarwinPCS;
8837  else if (Triple.isOSWindows())
8838  return SetCGInfo(
8839  new WindowsAArch64TargetCodeGenInfo(Types, AArch64ABIInfo::Win64));
8840 
8841  return SetCGInfo(new AArch64TargetCodeGenInfo(Types, Kind));
8842  }
8843 
8844  case llvm::Triple::wasm32:
8845  case llvm::Triple::wasm64:
8846  return SetCGInfo(new WebAssemblyTargetCodeGenInfo(Types));
8847 
8848  case llvm::Triple::arm:
8849  case llvm::Triple::armeb:
8850  case llvm::Triple::thumb:
8851  case llvm::Triple::thumbeb: {
8852  if (Triple.getOS() == llvm::Triple::Win32) {
8853  return SetCGInfo(
8854  new WindowsARMTargetCodeGenInfo(Types, ARMABIInfo::AAPCS_VFP));
8855  }
8856 
8857  ARMABIInfo::ABIKind Kind = ARMABIInfo::AAPCS;
8858  StringRef ABIStr = getTarget().getABI();
8859  if (ABIStr == "apcs-gnu")
8860  Kind = ARMABIInfo::APCS;
8861  else if (ABIStr == "aapcs16")
8862  Kind = ARMABIInfo::AAPCS16_VFP;
8863  else if (CodeGenOpts.FloatABI == "hard" ||
8864  (CodeGenOpts.FloatABI != "soft" &&
8865  (Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
8866  Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
8867  Triple.getEnvironment() == llvm::Triple::EABIHF)))
8868  Kind = ARMABIInfo::AAPCS_VFP;
8869 
8870  return SetCGInfo(new ARMTargetCodeGenInfo(Types, Kind));
8871  }
8872 
8873  case llvm::Triple::ppc:
8874  return SetCGInfo(
8875  new PPC32TargetCodeGenInfo(Types, CodeGenOpts.FloatABI == "soft"));
8876  case llvm::Triple::ppc64:
8877  if (Triple.isOSBinFormatELF()) {
8878  PPC64_SVR4_ABIInfo::ABIKind Kind = PPC64_SVR4_ABIInfo::ELFv1;
8879  if (getTarget().getABI() == "elfv2")
8880  Kind = PPC64_SVR4_ABIInfo::ELFv2;
8881  bool HasQPX = getTarget().getABI() == "elfv1-qpx";
8882  bool IsSoftFloat = CodeGenOpts.FloatABI == "soft";
8883 
8884  return SetCGInfo(new PPC64_SVR4_TargetCodeGenInfo(Types, Kind, HasQPX,
8885  IsSoftFloat));
8886  } else
8887  return SetCGInfo(new PPC64TargetCodeGenInfo(Types));
8888  case llvm::Triple::ppc64le: {
8889  assert(Triple.isOSBinFormatELF() && "PPC64 LE non-ELF not supported!");
8890  PPC64_SVR4_ABIInfo::ABIKind Kind = PPC64_SVR4_ABIInfo::ELFv2;
8891  if (getTarget().getABI() == "elfv1" || getTarget().getABI() == "elfv1-qpx")
8892  Kind = PPC64_SVR4_ABIInfo::ELFv1;
8893  bool HasQPX = getTarget().getABI() == "elfv1-qpx";
8894  bool IsSoftFloat = CodeGenOpts.FloatABI == "soft";
8895 
8896  return SetCGInfo(new PPC64_SVR4_TargetCodeGenInfo(Types, Kind, HasQPX,
8897  IsSoftFloat));
8898  }
8899 
8900  case llvm::Triple::nvptx:
8901  case llvm::Triple::nvptx64:
8902  return SetCGInfo(new NVPTXTargetCodeGenInfo(Types));
8903 
8904  case llvm::Triple::msp430:
8905  return SetCGInfo(new MSP430TargetCodeGenInfo(Types));
8906 
8907  case llvm::Triple::systemz: {
8908  bool HasVector = getTarget().getABI() == "vector";
8909  return SetCGInfo(new SystemZTargetCodeGenInfo(Types, HasVector));
8910  }
8911 
8912  case llvm::Triple::tce:
8913  case llvm::Triple::tcele:
8914  return SetCGInfo(new TCETargetCodeGenInfo(Types));
8915 
8916  case llvm::Triple::x86: {
8917  bool IsDarwinVectorABI = Triple.isOSDarwin();
8918  bool RetSmallStructInRegABI =
8919  X86_32TargetCodeGenInfo::isStructReturnInRegABI(Triple, CodeGenOpts);
8920  bool IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();
8921 
8922  if (Triple.getOS() == llvm::Triple::Win32) {
8923  return SetCGInfo(new WinX86_32TargetCodeGenInfo(
8924  Types, IsDarwinVectorABI, RetSmallStructInRegABI,
8925  IsWin32FloatStructABI, CodeGenOpts.NumRegisterParameters));
8926  } else {
8927  return SetCGInfo(new X86_32TargetCodeGenInfo(
8928  Types, IsDarwinVectorABI, RetSmallStructInRegABI,
8929  IsWin32FloatStructABI, CodeGenOpts.NumRegisterParameters,
8930  CodeGenOpts.FloatABI == "soft"));
8931  }
8932  }
8933 
8934  case llvm::Triple::x86_64: {
8935  StringRef ABI = getTarget().getABI();
8936  X86AVXABILevel AVXLevel =
8937  (ABI == "avx512"
8938  ? X86AVXABILevel::AVX512
8939  : ABI == "avx" ? X86AVXABILevel::AVX : X86AVXABILevel::None);
8940 
8941  switch (Triple.getOS()) {
8942  case llvm::Triple::Win32:
8943  return SetCGInfo(new WinX86_64TargetCodeGenInfo(Types, AVXLevel));
8944  case llvm::Triple::PS4:
8945  return SetCGInfo(new PS4TargetCodeGenInfo(Types, AVXLevel));
8946  default:
8947  return SetCGInfo(new X86_64TargetCodeGenInfo(Types, AVXLevel));
8948  }
8949  }
8950  case llvm::Triple::hexagon:
8951  return SetCGInfo(new HexagonTargetCodeGenInfo(Types));
8952  case llvm::Triple::lanai:
8953  return SetCGInfo(new LanaiTargetCodeGenInfo(Types));
8954  case llvm::Triple::r600:
8955  return SetCGInfo(new AMDGPUTargetCodeGenInfo(Types));
8956  case llvm::Triple::amdgcn:
8957  return SetCGInfo(new AMDGPUTargetCodeGenInfo(Types));
8958  case llvm::Triple::sparc:
8959  return SetCGInfo(new SparcV8TargetCodeGenInfo(Types));
8960  case llvm::Triple::sparcv9:
8961  return SetCGInfo(new SparcV9TargetCodeGenInfo(Types));
8962  case llvm::Triple::xcore:
8963  return SetCGInfo(new XCoreTargetCodeGenInfo(Types));
8964  case llvm::Triple::spir:
8965  case llvm::Triple::spir64:
8966  return SetCGInfo(new SPIRTargetCodeGenInfo(Types));
8967  }
8968 }
8969 
8970 /// Create an OpenCL kernel for an enqueued block.
8971 ///
8972 /// The kernel has the same function type as the block invoke function. Its
8973 /// name is the name of the block invoke function postfixed with "_kernel".
8974 /// It simply calls the block invoke function then returns.
8975 llvm::Function *
8977  llvm::Function *Invoke,
8978  llvm::Value *BlockLiteral) const {
8979  auto *InvokeFT = Invoke->getFunctionType();
8981  for (auto &P : InvokeFT->params())
8982  ArgTys.push_back(P);
8983  auto &C = CGF.getLLVMContext();
8984  std::string Name = Invoke->getName().str() + "_kernel";
8985  auto *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(C), ArgTys, false);
8987  &CGF.CGM.getModule());
8988  auto IP = CGF.Builder.saveIP();
8989  auto *BB = llvm::BasicBlock::Create(C, "entry", F);
8990  auto &Builder = CGF.Builder;
8991  Builder.SetInsertPoint(BB);
8993  for (auto &A : F->args())
8994  Args.push_back(&A);
8995  Builder.CreateCall(Invoke, Args);
8996  Builder.CreateRetVoid();
8997  Builder.restoreIP(IP);
8998  return F;
8999 }
9000 
9001 /// Create an OpenCL kernel for an enqueued block.
9002 ///
9003 /// The type of the first argument (the block literal) is the struct type
9004 /// of the block literal instead of a pointer type. The first argument
9005 /// (block literal) is passed directly by value to the kernel. The kernel
9006 /// allocates the same type of struct on stack and stores the block literal
9007 /// to it and passes its pointer to the block invoke function. The kernel
9008 /// has "enqueued-block" function attribute and kernel argument metadata.
9009 llvm::Function *AMDGPUTargetCodeGenInfo::createEnqueuedBlockKernel(
9010  CodeGenFunction &CGF, llvm::Function *Invoke,
9011  llvm::Value *BlockLiteral) const {
9012  auto &Builder = CGF.Builder;
9013  auto &C = CGF.getLLVMContext();
9014 
9015  auto *BlockTy = BlockLiteral->getType()->getPointerElementType();
9016  auto *InvokeFT = Invoke->getFunctionType();
9021  llvm::SmallVector<llvm::Metadata *, 8> ArgBaseTypeNames;
9024 
9025  ArgTys.push_back(BlockTy);
9026  ArgTypeNames.push_back(llvm::MDString::get(C, "__block_literal"));
9027  AddressQuals.push_back(llvm::ConstantAsMetadata::get(Builder.getInt32(0)));
9028  ArgBaseTypeNames.push_back(llvm::MDString::get(C, "__block_literal"));
9029  ArgTypeQuals.push_back(llvm::MDString::get(C, ""));
9030  AccessQuals.push_back(llvm::MDString::get(C, "none"));
9031  ArgNames.push_back(llvm::MDString::get(C, "block_literal"));
9032  for (unsigned I = 1, E = InvokeFT->getNumParams(); I < E; ++I) {
9033  ArgTys.push_back(InvokeFT->getParamType(I));
9034  ArgTypeNames.push_back(llvm::MDString::get(C, "void*"));
9035  AddressQuals.push_back(llvm::ConstantAsMetadata::get(Builder.getInt32(3)));
9036  AccessQuals.push_back(llvm::MDString::get(C, "none"));
9037  ArgBaseTypeNames.push_back(llvm::MDString::get(C, "void*"));
9038  ArgTypeQuals.push_back(llvm::MDString::get(C, ""));
9039  ArgNames.push_back(
9040  llvm::MDString::get(C, (Twine("local_arg") + Twine(I)).str()));
9041  }
9042  std::string Name = Invoke->getName().str() + "_kernel";
9043  auto *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(C), ArgTys, false);
9045  &CGF.CGM.getModule());
9046  F->addFnAttr("enqueued-block");
9047  auto IP = CGF.Builder.saveIP();
9048  auto *BB = llvm::BasicBlock::Create(C, "entry", F);
9049  Builder.SetInsertPoint(BB);
9050  unsigned BlockAlign = CGF.CGM.getDataLayout().getPrefTypeAlignment(BlockTy);
9051  auto *BlockPtr = Builder.CreateAlloca(BlockTy, nullptr);
9052  BlockPtr->setAlignment(BlockAlign);
9053  Builder.CreateAlignedStore(F->arg_begin(), BlockPtr, BlockAlign);
9054  auto *Cast = Builder.CreatePointerCast(BlockPtr, InvokeFT->getParamType(0));
9056  Args.push_back(Cast);
9057  for (auto I = F->arg_begin() + 1, E = F->arg_end(); I != E; ++I)
9058  Args.push_back(I);
9059  Builder.CreateCall(Invoke, Args);
9060  Builder.CreateRetVoid();
9061  Builder.restoreIP(IP);
9062 
9063  F->setMetadata("kernel_arg_addr_space", llvm::MDNode::get(C, AddressQuals));
9064  F->setMetadata("kernel_arg_access_qual", llvm::MDNode::get(C, AccessQuals));
9065  F->setMetadata("kernel_arg_type", llvm::MDNode::get(C, ArgTypeNames));
9066  F->setMetadata("kernel_arg_base_type",
9067  llvm::MDNode::get(C, ArgBaseTypeNames));
9068  F->setMetadata("kernel_arg_type_qual", llvm::MDNode::get(C, ArgTypeQuals));
9069  if (CGF.CGM.getCodeGenOpts().EmitOpenCLArgMetadata)
9070  F->setMetadata("kernel_arg_name", llvm::MDNode::get(C, ArgNames));
9071 
9072  return F;
9073 }
const llvm::DataLayout & getDataLayout() const
CGCXXABI & getCXXABI() const
Definition: CodeGenTypes.h:177
Ignore - Ignore the argument (treat as void).
bool isFloatingPoint() const
Definition: Type.h:2189
CharUnits alignTo(const CharUnits &Align) const
alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...
Definition: CharUnits.h:184
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
void setEffectiveCallingConvention(unsigned Value)
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:61
static ABIArgInfo getExtend(llvm::Type *T=nullptr)
static bool addFieldSizes(ASTContext &Context, const RecordDecl *RD, uint64_t &Size)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2283
QualType getPointeeType() const
Definition: Type.h:2296
A (possibly-)qualified type.
Definition: Type.h:653
bool isBlockPointerType() const
Definition: Type.h:5950
base_class_range bases()
Definition: DeclCXX.h:773
bool isMemberPointerType() const
Definition: Type.h:5973
llvm::Type * ConvertTypeForMem(QualType T)
const CodeGenOptions & getCodeGenOpts() const
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1856
bool isHomogeneousAggregate(QualType Ty, const Type *&Base, uint64_t &Members) const
isHomogeneousAggregate - Return true if a type is an ELFv2 homogeneous aggregate. ...
static ABIArgInfo classifyType(CodeGenModule &CGM, CanQualType type, bool forReturn)
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
Kind getKind() const
Definition: Type.h:2164
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3056
llvm::ConstantInt * getSize(CharUnits N)
Definition: CGBuilder.h:61
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:790
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:223
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1893
Extend - Valid only for integer argument types.
bool isRecordType() const
Definition: Type.h:6015
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
static bool appendEnumType(SmallStringEnc &Enc, const EnumType *ET, TypeStringCache &TSC, const IdentifierInfo *ID)
Appends enum types to Enc and adds the encoding to the cache.
const RecordType * getAsStructureType() const
Definition: Type.cpp:472
Direct - Pass the argument directly using the normal converted LLVM type, or by coercing to another s...
const llvm::DataLayout & getDataLayout() const
Definition: CodeGenTypes.h:171
StringRef P
static const Type * isSingleElementStruct(QualType T, ASTContext &Context)
isSingleElementStruct - Determine if a structure is a "single element struct", i.e.
Definition: TargetInfo.cpp:523
The base class of the type hierarchy.
Definition: Type.h:1351
const ABIInfo & getABIInfo() const
getABIInfo() - Returns ABI info helper for the target.
Definition: TargetInfo.h:55
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2558
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition: Type.h:5782
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:671
static bool appendType(SmallStringEnc &Enc, QualType QType, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
Handles the type&#39;s qualifier before dispatching a call to handle specific type encodings.
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
void setCanBeFlattened(bool Flatten)
QualType getElementType() const
Definition: Type.h:2593
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:491
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
Definition: ASTContext.h:2028
virtual bool shouldSignExtUnsignedType(QualType Ty) const
Definition: TargetInfo.cpp:204
ASTContext & getContext() const
Definition: TargetInfo.cpp:173
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
LangAS getLangASFromTargetAS(unsigned TargetAS)
Definition: AddressSpaces.h:67
bool isEnumeralType() const
Definition: Type.h:6019
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6305
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
Definition: Type.h:6254
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:26
llvm::LLVMContext & getVMContext() const
Definition: TargetInfo.cpp:177
void setCoerceToType(llvm::Type *T)
bool field_empty() const
Definition: Decl.h:3628
Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Given a pointer to i8, adjust it by a given constant offset.
Definition: CGBuilder.h:234
llvm::Value * getPointer() const
Definition: Address.h:38
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
static ABIArgInfo getIgnore()
static bool isAggregateTypeForABI(QualType T)
Definition: TargetInfo.cpp:75
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g., it is a floating-point type or a vector thereof.
Definition: Type.cpp:1886
virtual unsigned getOpenCLKernelCallingConv() const
Get LLVM calling convention for OpenCL kernel.
Definition: TargetInfo.cpp:407
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:311
static ABIArgInfo coerceToIntArray(QualType Ty, ASTContext &Context, llvm::LLVMContext &LLVMContext)
Definition: TargetInfo.cpp:51
CodeGen::CodeGenTypes & CGT
Definition: ABIInfo.h:53
One of these records is kept for each identifier that is lexed.
Address getAddress() const
Definition: CGValue.h:324
Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
LineState State
ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type)
Classify the rules for how to pass a particular type.
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3609
static llvm::Type * GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi, const llvm::DataLayout &TD)
GetX86_64ByValArgumentPair - Given a high and low type that can ideally be used as elements of a two ...
static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type)
field_range fields() const
Definition: Decl.h:3619
static Address EmitX86_64VAArgFromMemory(CodeGenFunction &CGF, Address VAListAddr, QualType Ty)
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
static ABIArgInfo getExtendInReg(llvm::Type *T=nullptr)
ABIArgInfo classifyReturnType(CodeGenModule &CGM, CanQualType type)
Classify the rules for how to return a particular type.
bool isReferenceType() const
Definition: Type.h:5954
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6136
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
static bool occupiesMoreThan(CodeGenTypes &cgt, ArrayRef< llvm::Type *> scalarTypes, unsigned maxAllRegisters)
Does the given lowering require more than the given number of registers when expanded?
Definition: TargetInfo.cpp:113
ABIInfo(CodeGen::CodeGenTypes &cgt)
Definition: ABIInfo.h:58
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6219
static ABIArgInfo getIndirectInReg(CharUnits Alignment, bool ByVal=true, bool Realign=false)
virtual StringRef getABI() const
Get the ABI currently in use.
Definition: TargetInfo.h:856
static ABIArgInfo getDirect(llvm::Type *T=nullptr, unsigned Offset=0, llvm::Type *Padding=nullptr, bool CanBeFlattened=true)
static bool hasScalarEvaluationKind(QualType T)
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2545
static ABIArgInfo getExpandWithPadding(bool PaddingInReg, llvm::Type *Padding)
static bool appendRecordType(SmallStringEnc &Enc, const RecordType *RT, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC, const IdentifierInfo *ID)
Appends structure and union types to Enc and adds encoding to cache.
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:157
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
uint32_t Offset
Definition: CacheTokens.cpp:43
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type...
Definition: Type.h:6354
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:67
static void rewriteInputConstraintReferences(unsigned FirstIn, unsigned NumNewOuts, std::string &AsmString)
Rewrite input constraint references after adding some output constraints.
static bool isRecordWithSSEVectorType(ASTContext &Context, QualType Ty)
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5788
const_arg_iterator arg_begin() const
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:259
ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...
CanQualType LongDoubleTy
Definition: ASTContext.h:1007
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5718
unsigned Align
Definition: ASTContext.h:139
field_iterator field_begin() const
Definition: Decl.cpp:3960
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
static bool BitsContainNoUserData(QualType Ty, unsigned StartBit, unsigned EndBit, ASTContext &Context)
BitsContainNoUserData - Return true if the specified [start,end) bit range is known to either be off ...
static ABIArgInfo getExpand()
bool isScalarType() const
Definition: Type.h:6204
#define UINT_MAX
Definition: limits.h:72
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:94
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:84
static QualType useFirstFieldIfTransparentUnion(QualType Ty)
Pass transparent unions as if they were the type of the first element.
Definition: TargetInfo.cpp:158
virtual llvm::Value * performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, llvm::Value *V, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
Perform address space cast of an expression of pointer type.
Definition: TargetInfo.cpp:434
bool isTypeConstant(QualType QTy, bool ExcludeCtorDtor)
isTypeConstant - Determine whether an object of this type can be emitted as a constant.
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3233
static bool ContainsFloatAtOffset(llvm::Type *IRType, unsigned IROffset, const llvm::DataLayout &TD)
ContainsFloatAtOffset - Return true if the specified LLVM IR type has a float member at the specified...
bool isHalfType() const
Definition: Type.h:6175
bool hasAttr() const
Definition: DeclBase.h:535
CanQualType getReturnType() const
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2381
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3268
virtual CodeGen::Address EmitMSVAArg(CodeGen::CodeGenFunction &CGF, CodeGen::Address VAListAddr, QualType Ty) const
Emit the target dependent code to load a value of.
Definition: TargetInfo.cpp:93
const TargetCodeGenInfo & getTargetCodeGenInfo()
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:438
static bool extractFieldType(SmallVectorImpl< FieldEncoding > &FE, const RecordDecl *RD, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
Helper function for appendRecordType().
virtual void getDependentLibraryOption(llvm::StringRef Lib, llvm::SmallString< 24 > &Opt) const
Gets the linker options necessary to link a dependent library on this platform.
Definition: TargetInfo.cpp:398
static void AssignToArrayRange(CodeGen::CGBuilderTy &Builder, llvm::Value *Array, llvm::Value *Value, unsigned FirstIndex, unsigned LastIndex)
Definition: TargetInfo.cpp:62
static bool is32Or64BitBasicType(QualType Ty, ASTContext &Context)
void setAddress(Address address)
Definition: CGValue.h:325
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M, ForDefinition_t IsForDefinition) const
setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...
Definition: TargetInfo.h:59
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
const llvm::fltSemantics & getLongDoubleFormat() const
Definition: TargetInfo.h:422
Exposes information about the current target.
Definition: TargetInfo.h:54
CodeGen::ABIArgInfo getNaturalAlignIndirect(QualType Ty, bool ByRef=true, bool Realign=false, llvm::Type *Padding=nullptr) const
A convenience method to return an indirect ABIArgInfo with an expected alignment equal to the ABI ali...
Definition: TargetInfo.cpp:81
QualType getElementType() const
Definition: Type.h:2236
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
static Address invalid()
Definition: Address.h:35
const FunctionProtoType * T
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
Definition: Type.cpp:70
static bool appendBuiltinType(SmallStringEnc &Enc, const BuiltinType *BT)
Appends built-in types to Enc.
field_iterator field_end() const
Definition: Decl.h:3622
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:44
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
bool isAnyComplexType() const
Definition: Type.h:6023
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
static bool getTypeString(SmallStringEnc &Enc, const Decl *D, CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
The XCore ABI includes a type information section that communicates symbol type information to the li...
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
Definition: RecordLayout.h:177
EnumDecl * getDefinition() const
Definition: Decl.h:3309
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
llvm::CallingConv::ID RuntimeCC
Definition: ABIInfo.h:55
llvm::LLVMContext & getLLVMContext()
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1800
CodeGen::ABIArgInfo getNaturalAlignIndirectInReg(QualType Ty, bool Realign=false) const
Definition: TargetInfo.cpp:88
const CodeGenOptions & getCodeGenOpts() const
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
Definition: CharUnits.h:197
static Address emitVoidPtrDirectVAArg(CodeGenFunction &CGF, Address VAListAddr, llvm::Type *DirectTy, CharUnits DirectSize, CharUnits DirectAlign, CharUnits SlotSize, bool AllowHigherAlign)
Emit va_arg for a platform using the common void* representation, where arguments are simply emitted ...
Definition: TargetInfo.cpp:275
Represents a GCC generic vector type.
Definition: Type.h:2914
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2595
virtual unsigned getSizeOfUnwindException() const
Determines the size of struct _Unwind_Exception on this platform, in 8-bit units. ...
Definition: TargetInfo.cpp:378
Implements C++ ABI-specific semantic analysis functions.
Definition: CXXABI.h:30
const TargetInfo & getTarget() const
bool isUnionType() const
Definition: Type.cpp:432
const LangOptions & getLangOpts() const
ASTContext & getContext() const
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
virtual llvm::Constant * getNullPointer(const CodeGen::CodeGenModule &CGM, llvm::PointerType *T, QualType QT) const
Get target specific null pointer.
Definition: TargetInfo.cpp:421
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:233
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5777
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
Definition: Type.h:3986
Pass it as a pointer to temporary memory.
Definition: CGCXXABI.h:137
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:181
bool isStructureOrClassType() const
Definition: Type.cpp:418
static void appendQualifier(SmallStringEnc &Enc, QualType QT)
Appends type&#39;s qualifier to Enc.
static Address emitMergePHI(CodeGenFunction &CGF, Address Addr1, llvm::BasicBlock *Block1, Address Addr2, llvm::BasicBlock *Block2, const llvm::Twine &Name="")
Definition: TargetInfo.cpp:362
static bool isEmptyField(ASTContext &Context, const FieldDecl *FD, bool AllowArrays)
isEmptyField - Return true iff a the field is "empty", that is it is an unnamed bit-field or an (arra...
Definition: TargetInfo.cpp:462
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:142
Kind
QualType getCanonicalType() const
Definition: Type.h:5757
bool isBuiltinType() const
Helper methods to distinguish type categories.
Definition: Type.h:6011
QualType getReturnType() const
Definition: Type.h:3201
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4002
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5834
const TargetInfo & getTarget() const
Definition: TargetInfo.cpp:185
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2548
static bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays)
isEmptyRecord - Return true iff a structure contains only empty fields.
Definition: TargetInfo.cpp:495
static bool appendFunctionType(SmallStringEnc &Enc, const FunctionType *FT, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
Appends a function encoding to Enc, calling appendType for the return type and the arguments...
SyncScope
Defines synch scope values used internally by clang.
Definition: SyncScope.h:43
const llvm::DataLayout & getDataLayout() const
Definition: TargetInfo.cpp:181
void setArgStruct(llvm::StructType *Ty, CharUnits Align)
virtual void computeInfo(CodeGen::CGFunctionInfo &FI) const =0
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2321
const_arg_iterator arg_end() const
CanQualType FloatTy
Definition: ASTContext.h:1007
CoerceAndExpand - Only valid for aggregate argument types.
bool isMemberFunctionPointerType() const
Definition: Type.h:5977
An aligned address.
Definition: Address.h:25
llvm::LLVMContext & getLLVMContext()
Definition: CodeGenTypes.h:178
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
bool isTargetAddressSpace(LangAS AS)
Definition: AddressSpaces.h:58
EnumDecl * getDecl() const
Definition: Type.h:4009
bool isVectorType() const
Definition: Type.h:6027
TargetCodeGenInfo - This class organizes various target-specific codegeneration issues, like target-specific attributes, builtins and so on.
Definition: TargetInfo.h:46
InAlloca - Pass the argument directly using the LLVM inalloca attribute.
X86AVXABILevel
The AVX ABI level for X86 targets.
QualType getType() const
Definition: CGValue.h:261
llvm::CallingConv::ID getRuntimeCC() const
Return the calling convention to use for system runtime functions.
Definition: ABIInfo.h:76
bool hasFlexibleArrayMember() const
Definition: Decl.h:3541
static llvm::Value * emitRoundPointerUpToAlignment(CodeGenFunction &CGF, llvm::Value *Ptr, CharUnits Align)
Definition: TargetInfo.cpp:245
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
llvm::Type * getPaddingType() const
llvm::CallingConv::ID BuiltinCC
Definition: ABIInfo.h:56
StringRef getName() const
Return the actual identifier string.
const TargetInfo & getTarget() const
Definition: CodeGenTypes.h:176
virtual CodeGen::Address EmitVAArg(CodeGen::CodeGenFunction &CGF, CodeGen::Address VAListAddr, QualType Ty) const =0
EmitVAArg - Emit the target dependent code to load a value of.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
Dataflow Directional Tag Classes.
virtual LangAS getGlobalVarAddressSpace(CodeGenModule &CGM, const VarDecl *D) const
Get target favored AST address space of a global variable for languages other than OpenCL and CUDA...
Definition: TargetInfo.cpp:426
A refining implementation of ABIInfo for targets that support swiftcall.
Definition: ABIInfo.h:134
static bool addBaseAndFieldSizes(ASTContext &Context, const CXXRecordDecl *RD, uint64_t &Size)
virtual llvm::Function * createEnqueuedBlockKernel(CodeGenFunction &CGF, llvm::Function *BlockInvokeFunc, llvm::Value *BlockLiteral) const
Create an OpenCL kernel for an enqueued block.
static ABIArgInfo getDirectInReg(llvm::Type *T=nullptr)
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:172
virtual bool isHomogeneousAggregateSmallEnough(const Type *Base, uint64_t Members) const
Definition: TargetInfo.cpp:199
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:91
static bool appendArrayType(SmallStringEnc &Enc, QualType QT, const ArrayType *AT, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC, StringRef NoSizeEnc)
Appends array encoding to Enc before calling appendType for the element.
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:70
EnumDecl - Represents an enum.
Definition: Decl.h:3239
virtual bool isNoProtoCallVariadic(const CodeGen::CallArgList &args, const FunctionNoProtoType *fnType) const
Determine whether a call to an unprototyped functions under the given calling convention should use t...
Definition: TargetInfo.cpp:388
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:108
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1962
llvm::Module & getModule() const
virtual bool isLegalVectorTypeForSwift(CharUnits totalSize, llvm::Type *eltTy, unsigned elts) const
Definition: TargetInfo.cpp:132
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1600
unsigned getIntWidth(QualType T) const
virtual llvm::Optional< LangAS > getConstantAddressSpace() const
Return an AST address space which can be used opportunistically for constant global memory...
Definition: TargetInfo.h:989
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3976
Complex values, per C99 6.2.5p11.
Definition: Type.h:2223
Pass it using the normal C aggregate rules for the ABI, potentially introducing extra copies and pass...
Definition: CGCXXABI.h:129
Address CreateConstArrayGEP(Address Addr, uint64_t Index, CharUnits EltSize, const llvm::Twine &Name="")
Given addr = [n x T]* ...
Definition: CGBuilder.h:195
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6191
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
Implements C++ ABI-specific code generation functions.
Definition: CGCXXABI.h:44
T * getAttr() const
Definition: DeclBase.h:531
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:120
CodeGen::CGCXXABI & getCXXABI() const
Definition: TargetInfo.cpp:169
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
Expand - Only valid for aggregate argument types.
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:445
static bool isArgInAlloca(const ABIArgInfo &Info)
static ABIArgInfo getInAlloca(unsigned FieldIndex)
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2007
ASTContext & getContext() const
Definition: CodeGenTypes.h:174
Pass it on the stack using its defined layout.
Definition: CGCXXABI.h:134
static CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT, CGCXXABI &CXXABI)
Definition: TargetInfo.cpp:140
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
bool isMultipleOf(CharUnits N) const
Test whether this is a multiple of the other value.
Definition: CharUnits.h:137
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
virtual llvm::SyncScope::ID getLLVMSyncScopeID(SyncScope S, llvm::LLVMContext &C) const
Get the syncscope used in LLVM IR.
Definition: TargetInfo.cpp:454
CallingConv getCallConv() const
Definition: Type.h:3211
unsigned getCallingConvention() const
getCallingConvention - Return the user specified calling convention, which has been translated into a...
Address CreateConstByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:240
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block, taking care to avoid creation of branches from dummy blocks.
Definition: CGStmt.cpp:465
bool isVoidType() const
Definition: Type.h:6169
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
llvm::Type * ConvertType(QualType T)
virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const =0
Returns how an argument of the given record type should be passed.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2143
static Address emitVoidPtrVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType ValueTy, bool IsIndirect, std::pair< CharUnits, CharUnits > ValueInfo, CharUnits SlotSizeAndAlign, bool AllowHigherAlign)
Emit va_arg for a platform using the common void* representation, where arguments are simply emitted ...
Definition: TargetInfo.cpp:329
ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions...
Definition: ABIInfo.h:51
uint64_t Width
Definition: ASTContext.h:138
static bool appendPointerType(SmallStringEnc &Enc, const PointerType *PT, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
Appends a pointer encoding to Enc before calling appendType for the pointee.
uint64_t getTargetNullPointerValue(QualType QT) const
Get target-dependent integer value for null pointer which is used for constant folding.
virtual bool isHomogeneousAggregateBaseType(QualType Ty) const
Definition: TargetInfo.cpp:195
bool isUnion() const
Definition: Decl.h:3165
bool isPointerType() const
Definition: Type.h:5942
unsigned getNumRequiredArgs() const
unsigned getDirectOffset() const
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
llvm::StoreInst * CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr, CharUnits Align, bool IsVolatile=false)
Definition: CGBuilder.h:115
void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI)
QualType getType() const
Definition: Decl.h:638
bool isFloatingType() const
Definition: Type.cpp:1877
LValue - This represents an lvalue references.
Definition: CGValue.h:167
llvm::Type * getCoerceToType() const
void setInAllocaSRet(bool SRet)
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2407
CanQualType DoubleTy
Definition: ASTContext.h:1007
RecordArgABI
Specify how one should pass an argument of a record type.
Definition: CGCXXABI.h:126
Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:164
static bool isIntegerLikeType(QualType Ty, ASTContext &Context, llvm::LLVMContext &VMContext)
static bool isSSEVectorType(ASTContext &Context, QualType Ty)
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:182
Address CreateMemTemp(QualType T, const Twine &Name="tmp", bool CastToDefaultAddrSpace=true)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignment...
Definition: CGExpr.cpp:127
const LangOptions & getLangOpts() const
Definition: ASTContext.h:688
static bool PPC64_initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, llvm::Value *Address)
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2618
static ABIArgInfo getIndirect(CharUnits Alignment, bool ByVal=true, bool Realign=false, llvm::Type *Padding=nullptr)
Attr - This represents one attribute.
Definition: Attr.h:43
Attempt to be ABI-compatible with code generated by Clang 3.8.x (SVN r257626).
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth, signed/unsigned.
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
const CodeGenOptions & getCodeGenOpts() const
Definition: TargetInfo.cpp:189