<div dir="ltr">I'm seeing a warning:<div><br></div><div><div>/Users/Sean/pg/llvm/tools/clang/lib/CodeGen/SwiftCallingConv.cpp:236:12: warning: unused variable 'eltTy' [-Wunused-variable]</div><div> auto eltTy = split.first;</div><div> ^</div><div>1 warning generated.</div></div><div><br></div><div><br></div><div>-- Sean Silva</div></div><div class="gmail_extra"><br><div class="gmail_quote">On Mon, Apr 4, 2016 at 11:33 AM, John McCall via cfe-commits <span dir="ltr"><<a href="mailto:cfe-commits@lists.llvm.org" target="_blank">cfe-commits@lists.llvm.org</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Author: rjmccall<br>
Date: Mon Apr 4 13:33:08 2016<br>
New Revision: 265324<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=265324&view=rev" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project?rev=265324&view=rev</a><br>
Log:<br>
IRGen-level lowering for the Swift calling convention.<br>
<br>
Added:<br>
cfe/trunk/include/clang/CodeGen/SwiftCallingConv.h<br>
cfe/trunk/lib/CodeGen/SwiftCallingConv.cpp<br>
cfe/trunk/test/CodeGen/arm-swiftcall.c<br>
cfe/trunk/test/CodeGenCXX/arm-swiftcall.cpp<br>
Modified:<br>
cfe/trunk/lib/CodeGen/ABIInfo.h<br>
cfe/trunk/lib/CodeGen/CGCall.cpp<br>
cfe/trunk/lib/CodeGen/CMakeLists.txt<br>
cfe/trunk/lib/CodeGen/CodeGenFunction.h<br>
cfe/trunk/lib/CodeGen/CodeGenModule.h<br>
cfe/trunk/lib/CodeGen/CodeGenTypes.h<br>
cfe/trunk/lib/CodeGen/TargetInfo.cpp<br>
cfe/trunk/lib/CodeGen/TargetInfo.h<br>
<br>
Added: cfe/trunk/include/clang/CodeGen/SwiftCallingConv.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/CodeGen/SwiftCallingConv.h?rev=265324&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/CodeGen/SwiftCallingConv.h?rev=265324&view=auto</a><br>
==============================================================================<br>
--- cfe/trunk/include/clang/CodeGen/SwiftCallingConv.h (added)<br>
+++ cfe/trunk/include/clang/CodeGen/SwiftCallingConv.h Mon Apr 4 13:33:08 2016<br>
@@ -0,0 +1,168 @@<br>
+//==-- SwiftCallingConv.h - Swift ABI lowering -----------------------------==//<br>
+//<br>
+// The LLVM Compiler Infrastructure<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+//<br>
+// Defines constants and types related to Swift ABI lowering.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#ifndef LLVM_CLANG_CODEGEN_SWIFTCALLINGCONV_H<br>
+#define LLVM_CLANG_CODEGEN_SWIFTCALLINGCONV_H<br>
+<br>
+#include "clang/AST/CanonicalType.h"<br>
+#include "clang/AST/CharUnits.h"<br>
+#include "clang/AST/Type.h"<br>
+#include "llvm/ADT/FoldingSet.h"<br>
+#include "llvm/Support/TrailingObjects.h"<br>
+#include <cassert><br>
+<br>
+namespace llvm {<br>
+ class IntegerType;<br>
+ class Type;<br>
+ class StructType;<br>
+ class VectorType;<br>
+}<br>
+<br>
+namespace clang {<br>
+class Decl;<br>
+class FieldDecl;<br>
+class ASTRecordLayout;<br>
+<br>
+namespace CodeGen {<br>
+class ABIArgInfo;<br>
+class CodeGenModule;<br>
+class CGFunctionInfo;<br>
+<br>
+namespace swiftcall {<br>
+<br>
+class SwiftAggLowering {<br>
+ CodeGenModule &CGM;<br>
+<br>
+ struct StorageEntry {<br>
+ CharUnits Begin;<br>
+ CharUnits End;<br>
+ llvm::Type *Type;<br>
+<br>
+ CharUnits getWidth() const {<br>
+ return End - Begin;<br>
+ }<br>
+ };<br>
+ SmallVector<StorageEntry, 4> Entries;<br>
+ bool Finished = false;<br>
+<br>
+public:<br>
+ SwiftAggLowering(CodeGenModule &CGM) : CGM(CGM) {}<br>
+<br>
+ void addOpaqueData(CharUnits begin, CharUnits end) {<br>
+ addEntry(nullptr, begin, end);<br>
+ }<br>
+<br>
+ void addTypedData(QualType type, CharUnits begin);<br>
+ void addTypedData(const RecordDecl *record, CharUnits begin);<br>
+ void addTypedData(const RecordDecl *record, CharUnits begin,<br>
+ const ASTRecordLayout &layout);<br>
+ void addTypedData(llvm::Type *type, CharUnits begin);<br>
+ void addTypedData(llvm::Type *type, CharUnits begin, CharUnits end);<br>
+<br>
+ void finish();<br>
+<br>
+ /// Does this lowering require passing any data?<br>
+ bool empty() const {<br>
+ assert(Finished && "didn't finish lowering before calling empty()");<br>
+ return Entries.empty();<br>
+ }<br>
+<br>
+ /// According to the target Swift ABI, should a value with this lowering<br>
+ /// be passed indirectly?<br>
+ ///<br>
+ /// Note that this decision is based purely on the data layout of the<br>
+ /// value and does not consider whether the type is address-only,<br>
+ /// must be passed indirectly to match a function abstraction pattern, or<br>
+ /// anything else that is expected to be handled by high-level lowering.<br>
+ ///<br>
+ /// \param asReturnValue - if true, answer whether it should be passed<br>
+ /// indirectly as a return value; if false, answer whether it should be<br>
+ /// passed indirectly as an argument<br>
+ bool shouldPassIndirectly(bool asReturnValue) const;<br>
+<br>
+ using EnumerationCallback =<br>
+ llvm::function_ref<void(CharUnits offset, llvm::Type *type)>;<br>
+<br>
+ /// Enumerate the expanded components of this type.<br>
+ ///<br>
+ /// The component types will always be legal vector, floating-point,<br>
+ /// integer, or pointer types.<br>
+ void enumerateComponents(EnumerationCallback callback) const;<br>
+<br>
+ /// Return the types for a coerce-and-expand operation.<br>
+ ///<br>
+ /// The first type matches the memory layout of the data that's been<br>
+ /// added to this structure, including explicit [N x i8] arrays for any<br>
+ /// internal padding.<br>
+ ///<br>
+ /// The second type removes any internal padding members and, if only<br>
+ /// one element remains, is simply that element type.<br>
+ std::pair<llvm::StructType*, llvm::Type*> getCoerceAndExpandTypes() const;<br>
+<br>
+private:<br>
+ void addBitFieldData(const FieldDecl *field, CharUnits begin,<br>
+ uint64_t bitOffset);<br>
+ void addLegalTypedData(llvm::Type *type, CharUnits begin, CharUnits end);<br>
+ void addEntry(llvm::Type *type, CharUnits begin, CharUnits end);<br>
+ void splitVectorEntry(unsigned index);<br>
+};<br>
+<br>
+/// Return the maximum voluntary integer size for the current target.<br>
+CharUnits getMaximumVoluntaryIntegerSize(CodeGenModule &CGM);<br>
+<br>
+/// Return the Swift CC's notion of the natural alignment of a type.<br>
+CharUnits getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type);<br>
+<br>
+/// Is the given integer type "legal" for Swift's perspective on the<br>
+/// current platform?<br>
+bool isLegalIntegerType(CodeGenModule &CGM, llvm::IntegerType *type);<br>
+<br>
+/// Is the given vector type "legal" for Swift's perspective on the<br>
+/// current platform?<br>
+bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,<br>
+ llvm::VectorType *vectorTy);<br>
+bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,<br>
+ llvm::Type *eltTy, unsigned numElts);<br>
+<br>
+/// Minimally split a legal vector type.<br>
+std::pair<llvm::Type*, unsigned><br>
+splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,<br>
+ llvm::VectorType *vectorTy);<br>
+<br>
+/// Turn a vector type in a sequence of legal component vector types.<br>
+///<br>
+/// The caller may assume that the sum of the data sizes of the resulting<br>
+/// types will equal the data size of the vector type.<br>
+void legalizeVectorType(CodeGenModule &CGM, CharUnits vectorSize,<br>
+ llvm::VectorType *vectorTy,<br>
+ llvm::SmallVectorImpl<llvm::Type*> &types);<br>
+<br>
+/// Should a C++ record type be passed and returned indirectly?<br>
+bool shouldPassCXXRecordIndirectly(CodeGenModule &CGM,<br>
+ const CXXRecordDecl *record);<br>
+<br>
+/// Classify the rules for how to return a particular type.<br>
+ABIArgInfo classifyReturnType(CodeGenModule &CGM, CanQualType type);<br>
+<br>
+/// Classify the rules for how to pass a particular type.<br>
+ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type);<br>
+<br>
+/// Compute the ABI information of a swiftcall function. This is a<br>
+/// private interface for Clang.<br>
+void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);<br>
+<br>
+} // end namespace swiftcall<br>
+} // end namespace CodeGen<br>
+} // end namespace clang<br>
+<br>
+#endif<br>
<br>
Modified: cfe/trunk/lib/CodeGen/ABIInfo.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/ABIInfo.h?rev=265324&r1=265323&r2=265324&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/ABIInfo.h?rev=265324&r1=265323&r2=265324&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/ABIInfo.h (original)<br>
+++ cfe/trunk/lib/CodeGen/ABIInfo.h Mon Apr 4 13:33:08 2016<br>
@@ -18,20 +18,25 @@ namespace llvm {<br>
class Value;<br>
class LLVMContext;<br>
class DataLayout;<br>
+ class Type;<br>
}<br>
<br>
namespace clang {<br>
class ASTContext;<br>
class TargetInfo;<br>
<br>
- namespace CodeGen {<br>
- class ABIArgInfo;<br>
- class Address;<br>
- class CGCXXABI;<br>
- class CGFunctionInfo;<br>
- class CodeGenFunction;<br>
- class CodeGenTypes;<br>
- }<br>
+namespace CodeGen {<br>
+ class ABIArgInfo;<br>
+ class Address;<br>
+ class CGCXXABI;<br>
+ class CGFunctionInfo;<br>
+ class CodeGenFunction;<br>
+ class CodeGenTypes;<br>
+ class SwiftABIInfo;<br>
+<br>
+namespace swiftcall {<br>
+ class SwiftAggLowering;<br>
+}<br>
<br>
// FIXME: All of this stuff should be part of the target interface<br>
// somehow. It is currently here because it is not clear how to factor<br>
@@ -55,6 +60,8 @@ namespace clang {<br>
<br>
virtual ~ABIInfo();<br>
<br>
+ virtual bool supportsSwift() const { return false; }<br>
+<br>
CodeGen::CGCXXABI &getCXXABI() const;<br>
ASTContext &getContext() const;<br>
llvm::LLVMContext &getVMContext() const;<br>
@@ -112,7 +119,35 @@ namespace clang {<br>
<br>
CodeGen::ABIArgInfo<br>
getNaturalAlignIndirectInReg(QualType Ty, bool Realign = false) const;<br>
+<br>
+<br>
+ };<br>
+<br>
+ /// A refining implementation of ABIInfo for targets that support swiftcall.<br>
+ ///<br>
+ /// If we find ourselves wanting multiple such refinements, they'll probably<br>
+ /// be independent refinements, and we should probably find another way<br>
+ /// to do it than simple inheritance.<br>
+ class SwiftABIInfo : public ABIInfo {<br>
+ public:<br>
+ SwiftABIInfo(CodeGen::CodeGenTypes &cgt) : ABIInfo(cgt) {}<br>
+<br>
+ bool supportsSwift() const final override { return true; }<br>
+<br>
+ virtual bool shouldPassIndirectlyForSwift(CharUnits totalSize,<br>
+ ArrayRef<llvm::Type*> types,<br>
+ bool asReturnValue) const = 0;<br>
+<br>
+ virtual bool isLegalVectorTypeForSwift(CharUnits totalSize,<br>
+ llvm::Type *eltTy,<br>
+ unsigned elts) const;<br>
+<br>
+ static bool classof(const ABIInfo *info) {<br>
+ return info->supportsSwift();<br>
+ }<br>
};<br>
+<br>
+} // end namespace CodeGen<br>
} // end namespace clang<br>
<br>
#endif<br>
<br>
Modified: cfe/trunk/lib/CodeGen/CGCall.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGCall.cpp?rev=265324&r1=265323&r2=265324&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGCall.cpp?rev=265324&r1=265323&r2=265324&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/CGCall.cpp (original)<br>
+++ cfe/trunk/lib/CodeGen/CGCall.cpp Mon Apr 4 13:33:08 2016<br>
@@ -26,6 +26,7 @@<br>
#include "clang/Basic/TargetBuiltins.h"<br>
#include "clang/Basic/TargetInfo.h"<br>
#include "clang/CodeGen/CGFunctionInfo.h"<br>
+#include "clang/CodeGen/SwiftCallingConv.h"<br>
#include "clang/Frontend/CodeGenOptions.h"<br>
#include "llvm/ADT/StringExtras.h"<br>
#include "llvm/IR/Attributes.h"<br>
@@ -59,6 +60,7 @@ static unsigned ClangCallConvToLLVMCallC<br>
case CC_SpirKernel: return llvm::CallingConv::SPIR_KERNEL;<br>
case CC_PreserveMost: return llvm::CallingConv::PreserveMost;<br>
case CC_PreserveAll: return llvm::CallingConv::PreserveAll;<br>
+ case CC_Swift: return llvm::CallingConv::Swift;<br>
}<br>
}<br>
<br>
@@ -109,7 +111,7 @@ static void appendParameterTypes(const C<br>
auto protoParamInfos = FPT->getExtParameterInfos();<br>
paramInfos.reserve(prefix.size() + protoParamInfos.size());<br>
paramInfos.resize(prefix.size());<br>
- paramInfos.append(paramInfos.begin(), paramInfos.end());<br>
+ paramInfos.append(protoParamInfos.begin(), protoParamInfos.end());<br>
}<br>
<br>
// Fast path: unknown target.<br>
@@ -590,7 +592,6 @@ CodeGenTypes::arrangeBuiltinFunctionDecl<br>
argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);<br>
}<br>
<br>
-<br>
/// Arrange a call to a C++ method, passing the given arguments.<br>
const CGFunctionInfo &<br>
CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args,<br>
@@ -679,7 +680,11 @@ CodeGenTypes::arrangeLLVMFunctionInfo(Ca<br>
assert(inserted && "Recursively being processed?");<br>
<br>
// Compute ABI information.<br>
- getABIInfo().computeInfo(*FI);<br>
+ if (info.getCC() != CC_Swift) {<br>
+ getABIInfo().computeInfo(*FI);<br>
+ } else {<br>
+ swiftcall::computeABIInfo(CGM, *FI);<br>
+ }<br>
<br>
// Loop over all of the computed argument and return value info. If any of<br>
// them are direct or extend without a specified coerce type, specify the<br>
@@ -918,7 +923,7 @@ static void forConstantArrayExpansion(Co<br>
}<br>
<br>
void CodeGenFunction::ExpandTypeFromArgs(<br>
- QualType Ty, LValue LV, SmallVectorImpl<llvm::Argument *>::iterator &AI) {<br>
+ QualType Ty, LValue LV, SmallVectorImpl<llvm::Value *>::iterator &AI) {<br>
assert(LV.isSimple() &&<br>
"Unexpected non-simple lvalue during struct expansion.");<br>
<br>
@@ -1813,10 +1818,13 @@ void CodeGenModule::ConstructAttributeLi<br>
getLLVMContext(), llvm::AttributeSet::ReturnIndex, RetAttrs));<br>
}<br>
<br>
+ bool hasUsedSRet = false;<br>
+<br>
// Attach attributes to sret.<br>
if (IRFunctionArgs.hasSRetArg()) {<br>
llvm::AttrBuilder SRETAttrs;<br>
SRETAttrs.addAttribute(llvm::Attribute::StructRet);<br>
+ hasUsedSRet = true;<br>
if (RetAI.getInReg())<br>
SRETAttrs.addAttribute(llvm::Attribute::InReg);<br>
PAL.push_back(llvm::AttributeSet::get(<br>
@@ -1920,6 +1928,41 @@ void CodeGenModule::ConstructAttributeLi<br>
Attrs.addAttribute(llvm::Attribute::NonNull);<br>
}<br>
<br>
+ switch (FI.getExtParameterInfo(ArgNo).getABI()) {<br>
+ case ParameterABI::Ordinary:<br>
+ break;<br>
+<br>
+ case ParameterABI::SwiftIndirectResult: {<br>
+ // Add 'sret' if we haven't already used it for something, but<br>
+ // only if the result is void.<br>
+ if (!hasUsedSRet && RetTy->isVoidType()) {<br>
+ Attrs.addAttribute(llvm::Attribute::StructRet);<br>
+ hasUsedSRet = true;<br>
+ }<br>
+<br>
+ // Add 'noalias' in either case.<br>
+ Attrs.addAttribute(llvm::Attribute::NoAlias);<br>
+<br>
+ // Add 'dereferenceable' and 'alignment'.<br>
+ auto PTy = ParamType->getPointeeType();<br>
+ if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) {<br>
+ auto info = getContext().getTypeInfoInChars(PTy);<br>
+ Attrs.addDereferenceableAttr(info.first.getQuantity());<br>
+ Attrs.addAttribute(llvm::Attribute::getWithAlignment(getLLVMContext(),<br>
+ info.second.getQuantity()));<br>
+ }<br>
+ break;<br>
+ }<br>
+<br>
+ case ParameterABI::SwiftErrorResult:<br>
+ Attrs.addAttribute(llvm::Attribute::SwiftError);<br>
+ break;<br>
+<br>
+ case ParameterABI::SwiftContext:<br>
+ Attrs.addAttribute(llvm::Attribute::SwiftSelf);<br>
+ break;<br>
+ }<br>
+<br>
if (Attrs.hasAttributes()) {<br>
unsigned FirstIRArg, NumIRArgs;<br>
std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);<br>
@@ -1985,6 +2028,18 @@ static const NonNullAttr *getNonNullAttr<br>
return nullptr;<br>
}<br>
<br>
+namespace {<br>
+ struct CopyBackSwiftError final : EHScopeStack::Cleanup {<br>
+ Address Temp;<br>
+ Address Arg;<br>
+ CopyBackSwiftError(Address temp, Address arg) : Temp(temp), Arg(arg) {}<br>
+ void Emit(CodeGenFunction &CGF, Flags flags) override {<br>
+ llvm::Value *errorValue = CGF.Builder.CreateLoad(Temp);<br>
+ CGF.Builder.CreateStore(errorValue, Arg);<br>
+ }<br>
+ };<br>
+}<br>
+<br>
void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,<br>
llvm::Function *Fn,<br>
const FunctionArgList &Args) {<br>
@@ -2010,7 +2065,7 @@ void CodeGenFunction::EmitFunctionProlog<br>
<br>
ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), FI);<br>
// Flattened function arguments.<br>
- SmallVector<llvm::Argument *, 16> FnArgs;<br>
+ SmallVector<llvm::Value *, 16> FnArgs;<br>
FnArgs.reserve(IRFunctionArgs.totalIRArgs());<br>
for (auto &Arg : Fn->args()) {<br>
FnArgs.push_back(&Arg);<br>
@@ -2031,7 +2086,7 @@ void CodeGenFunction::EmitFunctionProlog<br>
<br>
// Name the struct return parameter.<br>
if (IRFunctionArgs.hasSRetArg()) {<br>
- auto AI = FnArgs[IRFunctionArgs.getSRetArgNo()];<br>
+ auto AI = cast<llvm::Argument>(FnArgs[IRFunctionArgs.getSRetArgNo()]);<br>
AI->setName("agg.result");<br>
AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1,<br>
llvm::Attribute::NoAlias));<br>
@@ -2119,8 +2174,8 @@ void CodeGenFunction::EmitFunctionProlog<br>
ArgI.getCoerceToType() == ConvertType(Ty) &&<br>
ArgI.getDirectOffset() == 0) {<br>
assert(NumIRArgs == 1);<br>
- auto AI = FnArgs[FirstIRArg];<br>
- llvm::Value *V = AI;<br>
+ llvm::Value *V = FnArgs[FirstIRArg];<br>
+ auto AI = cast<llvm::Argument>(V);<br>
<br>
if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(Arg)) {<br>
if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(),<br>
@@ -2189,6 +2244,25 @@ void CodeGenFunction::EmitFunctionProlog<br>
AI->getArgNo() + 1,<br>
llvm::Attribute::NoAlias));<br>
<br>
+ // LLVM expects swifterror parameters to be used in very restricted<br>
+ // ways. Copy the value into a less-restricted temporary.<br>
+ if (FI.getExtParameterInfo(ArgNo).getABI()<br>
+ == ParameterABI::SwiftErrorResult) {<br>
+ QualType pointeeTy = Ty->getPointeeType();<br>
+ assert(pointeeTy->isPointerType());<br>
+ Address temp =<br>
+ CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp");<br>
+ Address arg = Address(V, getContext().getTypeAlignInChars(pointeeTy));<br>
+ llvm::Value *incomingErrorValue = Builder.CreateLoad(arg);<br>
+ Builder.CreateStore(incomingErrorValue, temp);<br>
+ V = temp.getPointer();<br>
+<br>
+ // Push a cleanup to copy the value back at the end of the function.<br>
+ // The convention does not guarantee that the value will be written<br>
+ // back if the function exits with an unwind exception.<br>
+ EHStack.pushCleanup<CopyBackSwiftError>(NormalCleanup, temp, arg);<br>
+ }<br>
+<br>
// Ensure the argument is the correct type.<br>
if (V->getType() != ArgI.getCoerceToType())<br>
V = Builder.CreateBitCast(V, ArgI.getCoerceToType());<br>
@@ -3481,6 +3555,9 @@ RValue CodeGenFunction::EmitCall(const C<br>
}<br>
}<br>
<br>
+ Address swiftErrorTemp = Address::invalid();<br>
+ Address swiftErrorArg = Address::invalid();<br>
+<br>
assert(CallInfo.arg_size() == CallArgs.size() &&<br>
"Mismatch between function signature & arguments.");<br>
unsigned ArgNo = 0;<br>
@@ -3587,6 +3664,25 @@ RValue CodeGenFunction::EmitCall(const C<br>
else<br>
V = Builder.CreateLoad(RV.getAggregateAddress());<br>
<br>
+ // Implement swifterror by copying into a new swifterror argument.<br>
+ // We'll write back in the normal path out of the call.<br>
+ if (CallInfo.getExtParameterInfo(ArgNo).getABI()<br>
+ == ParameterABI::SwiftErrorResult) {<br>
+ assert(!swiftErrorTemp.isValid() && "multiple swifterror args");<br>
+<br>
+ QualType pointeeTy = I->Ty->getPointeeType();<br>
+ swiftErrorArg =<br>
+ Address(V, getContext().getTypeAlignInChars(pointeeTy));<br>
+<br>
+ swiftErrorTemp =<br>
+ CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp");<br>
+ V = swiftErrorTemp.getPointer();<br>
+ cast<llvm::AllocaInst>(V)->setSwiftError(true);<br>
+<br>
+ llvm::Value *errorValue = Builder.CreateLoad(swiftErrorArg);<br>
+ Builder.CreateStore(errorValue, swiftErrorTemp);<br>
+ }<br>
+<br>
// We might have to widen integers, but we should never truncate.<br>
if (ArgInfo.getCoerceToType() != V->getType() &&<br>
V->getType()->isIntegerTy())<br>
@@ -3597,6 +3693,7 @@ RValue CodeGenFunction::EmitCall(const C<br>
if (FirstIRArg < IRFuncTy->getNumParams() &&<br>
V->getType() != IRFuncTy->getParamType(FirstIRArg))<br>
V = Builder.CreateBitCast(V, IRFuncTy->getParamType(FirstIRArg));<br>
+<br>
IRCallArgs[FirstIRArg] = V;<br>
break;<br>
}<br>
@@ -3656,13 +3753,31 @@ RValue CodeGenFunction::EmitCall(const C<br>
}<br>
<br>
case ABIArgInfo::CoerceAndExpand: {<br>
- assert(RV.isAggregate() &&<br>
- "CoerceAndExpand does not support non-aggregate types yet");<br>
-<br>
auto coercionType = ArgInfo.getCoerceAndExpandType();<br>
auto layout = CGM.getDataLayout().getStructLayout(coercionType);<br>
<br>
- Address addr = RV.getAggregateAddress();<br>
+ llvm::Value *tempSize = nullptr;<br>
+ Address addr = Address::invalid();<br>
+ if (RV.isAggregate()) {<br>
+ addr = RV.getAggregateAddress();<br>
+ } else {<br>
+ assert(RV.isScalar()); // complex should always just be direct<br>
+<br>
+ llvm::Type *scalarType = RV.getScalarVal()->getType();<br>
+ auto scalarSize = CGM.getDataLayout().getTypeAllocSize(scalarType);<br>
+ auto scalarAlign = CGM.getDataLayout().getPrefTypeAlignment(scalarType);<br>
+<br>
+ tempSize = llvm::ConstantInt::get(CGM.Int64Ty, scalarSize);<br>
+<br>
+ // Materialize to a temporary.<br>
+ addr = CreateTempAlloca(RV.getScalarVal()->getType(),<br>
+ CharUnits::fromQuantity(std::max(layout->getAlignment(),<br>
+ scalarAlign)));<br>
+ EmitLifetimeStart(scalarSize, addr.getPointer());<br>
+<br>
+ Builder.CreateStore(RV.getScalarVal(), addr);<br>
+ }<br>
+<br>
addr = Builder.CreateElementBitCast(addr, coercionType);<br>
<br>
unsigned IRArgPos = FirstIRArg;<br>
@@ -3675,6 +3790,10 @@ RValue CodeGenFunction::EmitCall(const C<br>
}<br>
assert(IRArgPos == FirstIRArg + NumIRArgs);<br>
<br>
+ if (tempSize) {<br>
+ EmitLifetimeEnd(tempSize, addr.getPointer());<br>
+ }<br>
+<br>
break;<br>
}<br>
<br>
@@ -3853,6 +3972,12 @@ RValue CodeGenFunction::EmitCall(const C<br>
if (!CI->getType()->isVoidTy())<br>
CI->setName("call");<br>
<br>
+ // Perform the swifterror writeback.<br>
+ if (swiftErrorTemp.isValid()) {<br>
+ llvm::Value *errorResult = Builder.CreateLoad(swiftErrorTemp);<br>
+ Builder.CreateStore(errorResult, swiftErrorArg);<br>
+ }<br>
+<br>
// Emit any writebacks immediately. Arguably this should happen<br>
// after any return-value munging.<br>
if (CallArgs.hasWritebacks())<br>
@@ -3870,15 +3995,6 @@ RValue CodeGenFunction::EmitCall(const C<br>
<br>
RValue Ret = [&] {<br>
switch (RetAI.getKind()) {<br>
- case ABIArgInfo::InAlloca:<br>
- case ABIArgInfo::Indirect: {<br>
- RValue ret = convertTempToRValue(SRetPtr, RetTy, SourceLocation());<br>
- if (UnusedReturnSize)<br>
- EmitLifetimeEnd(llvm::ConstantInt::get(Int64Ty, UnusedReturnSize),<br>
- SRetPtr.getPointer());<br>
- return ret;<br>
- }<br>
-<br>
case ABIArgInfo::CoerceAndExpand: {<br>
auto coercionType = RetAI.getCoerceAndExpandType();<br>
auto layout = CGM.getDataLayout().getStructLayout(coercionType);<br>
@@ -3886,15 +4002,31 @@ RValue CodeGenFunction::EmitCall(const C<br>
Address addr = SRetPtr;<br>
addr = Builder.CreateElementBitCast(addr, coercionType);<br>
<br>
+ assert(CI->getType() == RetAI.getUnpaddedCoerceAndExpandType());<br>
+ bool requiresExtract = isa<llvm::StructType>(CI->getType());<br>
+<br>
unsigned unpaddedIndex = 0;<br>
for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {<br>
llvm::Type *eltType = coercionType->getElementType(i);<br>
if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue;<br>
Address eltAddr = Builder.CreateStructGEP(addr, i, layout);<br>
- llvm::Value *elt = Builder.CreateExtractValue(CI, unpaddedIndex++);<br>
+ llvm::Value *elt = CI;<br>
+ if (requiresExtract)<br>
+ elt = Builder.CreateExtractValue(elt, unpaddedIndex++);<br>
+ else<br>
+ assert(unpaddedIndex == 0);<br>
Builder.CreateStore(elt, eltAddr);<br>
}<br>
- break;<br>
+ // FALLTHROUGH<br>
+ }<br>
+<br>
+ case ABIArgInfo::InAlloca:<br>
+ case ABIArgInfo::Indirect: {<br>
+ RValue ret = convertTempToRValue(SRetPtr, RetTy, SourceLocation());<br>
+ if (UnusedReturnSize)<br>
+ EmitLifetimeEnd(llvm::ConstantInt::get(Int64Ty, UnusedReturnSize),<br>
+ SRetPtr.getPointer());<br>
+ return ret;<br>
}<br>
<br>
case ABIArgInfo::Ignore:<br>
<br>
Modified: cfe/trunk/lib/CodeGen/CMakeLists.txt<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CMakeLists.txt?rev=265324&r1=265323&r2=265324&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CMakeLists.txt?rev=265324&r1=265323&r2=265324&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/CMakeLists.txt (original)<br>
+++ cfe/trunk/lib/CodeGen/CMakeLists.txt Mon Apr 4 13:33:08 2016<br>
@@ -76,6 +76,7 @@ add_clang_library(clangCodeGen<br>
ModuleBuilder.cpp<br>
ObjectFilePCHContainerOperations.cpp<br>
SanitizerMetadata.cpp<br>
+ SwiftCallingConv.cpp<br>
TargetInfo.cpp<br>
<br>
DEPENDS<br>
<br>
Modified: cfe/trunk/lib/CodeGen/CodeGenFunction.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.h?rev=265324&r1=265323&r2=265324&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.h?rev=265324&r1=265323&r2=265324&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/CodeGenFunction.h (original)<br>
+++ cfe/trunk/lib/CodeGen/CodeGenFunction.h Mon Apr 4 13:33:08 2016<br>
@@ -68,7 +68,6 @@ class ObjCMethodDecl;<br>
class ObjCImplementationDecl;<br>
class ObjCPropertyImplDecl;<br>
class TargetInfo;<br>
-class TargetCodeGenInfo;<br>
class VarDecl;<br>
class ObjCForCollectionStmt;<br>
class ObjCAtTryStmt;<br>
@@ -86,6 +85,7 @@ class BlockByrefHelpers;<br>
class BlockByrefInfo;<br>
class BlockFlags;<br>
class BlockFieldFlags;<br>
+class TargetCodeGenInfo;<br>
<br>
/// The kind of evaluation to perform on values of a particular<br>
/// type. Basically, is the code in CGExprScalar, CGExprComplex, or<br>
@@ -3110,7 +3110,7 @@ private:<br>
///<br>
/// \param AI - The first function argument of the expansion.<br>
void ExpandTypeFromArgs(QualType Ty, LValue Dst,<br>
- SmallVectorImpl<llvm::Argument *>::iterator &AI);<br>
+ SmallVectorImpl<llvm::Value *>::iterator &AI);<br>
<br>
/// ExpandTypeToArgs - Expand an RValue \arg RV, with the LLVM type for \arg<br>
/// Ty, into individual arguments on the provided vector \arg IRCallArgs,<br>
<br>
Modified: cfe/trunk/lib/CodeGen/CodeGenModule.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenModule.h?rev=265324&r1=265323&r2=265324&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenModule.h?rev=265324&r1=265323&r2=265324&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/CodeGenModule.h (original)<br>
+++ cfe/trunk/lib/CodeGen/CodeGenModule.h Mon Apr 4 13:33:08 2016<br>
@@ -49,7 +49,6 @@ class IndexedInstrProfReader;<br>
}<br>
<br>
namespace clang {<br>
-class TargetCodeGenInfo;<br>
class ASTContext;<br>
class AtomicType;<br>
class FunctionDecl;<br>
@@ -93,6 +92,7 @@ class CGCUDARuntime;<br>
class BlockFieldFlags;<br>
class FunctionArgList;<br>
class CoverageMappingModuleGen;<br>
+class TargetCodeGenInfo;<br>
<br>
struct OrderGlobalInits {<br>
unsigned int priority;<br>
<br>
Modified: cfe/trunk/lib/CodeGen/CodeGenTypes.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenTypes.h?rev=265324&r1=265323&r2=265324&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenTypes.h?rev=265324&r1=265323&r2=265324&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/CodeGenTypes.h (original)<br>
+++ cfe/trunk/lib/CodeGen/CodeGenTypes.h Mon Apr 4 13:33:08 2016<br>
@@ -31,7 +31,6 @@ class StructType;<br>
}<br>
<br>
namespace clang {<br>
-class ABIInfo;<br>
class ASTContext;<br>
template <typename> class CanQual;<br>
class CXXConstructorDecl;<br>
@@ -51,6 +50,7 @@ class Type;<br>
typedef CanQual<Type> CanQualType;<br>
<br>
namespace CodeGen {<br>
+class ABIInfo;<br>
class CGCXXABI;<br>
class CGRecordLayout;<br>
class CodeGenModule;<br>
<br>
Added: cfe/trunk/lib/CodeGen/SwiftCallingConv.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/SwiftCallingConv.cpp?rev=265324&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/SwiftCallingConv.cpp?rev=265324&view=auto</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/SwiftCallingConv.cpp (added)<br>
+++ cfe/trunk/lib/CodeGen/SwiftCallingConv.cpp Mon Apr 4 13:33:08 2016<br>
@@ -0,0 +1,830 @@<br>
+//===--- SwiftCallingConv.cpp - Lowering for the Swift calling convention -===//<br>
+//<br>
+// The LLVM Compiler Infrastructure<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+//<br>
+// Implementation of the abstract lowering for the Swift calling convention.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "clang/CodeGen/SwiftCallingConv.h"<br>
+#include "clang/Basic/TargetInfo.h"<br>
+#include "CodeGenModule.h"<br>
+#include "TargetInfo.h"<br>
+<br>
+using namespace clang;<br>
+using namespace CodeGen;<br>
+using namespace swiftcall;<br>
+<br>
+static const SwiftABIInfo &getSwiftABIInfo(CodeGenModule &CGM) {<br>
+ return cast<SwiftABIInfo>(CGM.getTargetCodeGenInfo().getABIInfo());<br>
+}<br>
+<br>
+static bool isPowerOf2(unsigned n) {<br>
+ return n == (n & -n);<br>
+}<br>
+<br>
+/// Given two types with the same size, try to find a common type.<br>
+static llvm::Type *getCommonType(llvm::Type *first, llvm::Type *second) {<br>
+ assert(first != second);<br>
+<br>
+ // Allow pointers to merge with integers, but prefer the integer type.<br>
+ if (first->isIntegerTy()) {<br>
+ if (second->isPointerTy()) return first;<br>
+ } else if (first->isPointerTy()) {<br>
+ if (second->isIntegerTy()) return second;<br>
+ if (second->isPointerTy()) return first;<br>
+<br>
+ // Allow two vectors to be merged (given that they have the same size).<br>
+ // This assumes that we never have two different vector register sets.<br>
+ } else if (auto firstVecTy = dyn_cast<llvm::VectorType>(first)) {<br>
+ if (auto secondVecTy = dyn_cast<llvm::VectorType>(second)) {<br>
+ if (auto commonTy = getCommonType(firstVecTy->getElementType(),<br>
+ secondVecTy->getElementType())) {<br>
+ return (commonTy == firstVecTy->getElementType() ? first : second);<br>
+ }<br>
+ }<br>
+ }<br>
+<br>
+ return nullptr;<br>
+}<br>
+<br>
+static CharUnits getTypeStoreSize(CodeGenModule &CGM, llvm::Type *type) {<br>
+ return CharUnits::fromQuantity(CGM.getDataLayout().getTypeStoreSize(type));<br>
+}<br>
+<br>
+void SwiftAggLowering::addTypedData(QualType type, CharUnits begin) {<br>
+ // Deal with various aggregate types as special cases:<br>
+<br>
+ // Record types.<br>
+ if (auto recType = type->getAs<RecordType>()) {<br>
+ addTypedData(recType->getDecl(), begin);<br>
+<br>
+ // Array types.<br>
+ } else if (type->isArrayType()) {<br>
+ // Incomplete array types (flexible array members?) don't provide<br>
+ // data to lay out, and the other cases shouldn't be possible.<br>
+ auto arrayType = CGM.getContext().getAsConstantArrayType(type);<br>
+ if (!arrayType) return;<br>
+<br>
+ QualType eltType = arrayType->getElementType();<br>
+ auto eltSize = CGM.getContext().getTypeSizeInChars(eltType);<br>
+ for (uint64_t i = 0, e = arrayType->getSize().getZExtValue(); i != e; ++i) {<br>
+ addTypedData(eltType, begin + i * eltSize);<br>
+ }<br>
+<br>
+ // Complex types.<br>
+ } else if (auto complexType = type->getAs<ComplexType>()) {<br>
+ auto eltType = complexType->getElementType();<br>
+ auto eltSize = CGM.getContext().getTypeSizeInChars(eltType);<br>
+ auto eltLLVMType = CGM.getTypes().ConvertType(eltType);<br>
+ addTypedData(eltLLVMType, begin, begin + eltSize);<br>
+ addTypedData(eltLLVMType, begin + eltSize, begin + 2 * eltSize);<br>
+<br>
+ // Member pointer types.<br>
+ } else if (type->getAs<MemberPointerType>()) {<br>
+ // Just add it all as opaque.<br>
+ addOpaqueData(begin, begin + CGM.getContext().getTypeSizeInChars(type));<br>
+<br>
+ // Everything else is scalar and should not convert as an LLVM aggregate.<br>
+ } else {<br>
+ // We intentionally convert as !ForMem because we want to preserve<br>
+ // that a type was an i1.<br>
+ auto llvmType = CGM.getTypes().ConvertType(type);<br>
+ addTypedData(llvmType, begin);<br>
+ }<br>
+}<br>
+<br>
+void SwiftAggLowering::addTypedData(const RecordDecl *record, CharUnits begin) {<br>
+ addTypedData(record, begin, CGM.getContext().getASTRecordLayout(record));<br>
+}<br>
+<br>
+void SwiftAggLowering::addTypedData(const RecordDecl *record, CharUnits begin,<br>
+ const ASTRecordLayout &layout) {<br>
+ // Unions are a special case.<br>
+ if (record->isUnion()) {<br>
+ for (auto field : record->fields()) {<br>
+ if (field->isBitField()) {<br>
+ addBitFieldData(field, begin, 0);<br>
+ } else {<br>
+ addTypedData(field->getType(), begin);<br>
+ }<br>
+ }<br>
+ return;<br>
+ }<br>
+<br>
+ // Note that correctness does not rely on us adding things in<br>
+ // their actual order of layout; it's just somewhat more efficient<br>
+ // for the builder.<br>
+<br>
+ // With that in mind, add "early" C++ data.<br>
+ auto cxxRecord = dyn_cast<CXXRecordDecl>(record);<br>
+ if (cxxRecord) {<br>
+ // - a v-table pointer, if the class adds its own<br>
+ if (layout.hasOwnVFPtr()) {<br>
+ addTypedData(CGM.Int8PtrTy, begin);<br>
+ }<br>
+<br>
+ // - non-virtual bases<br>
+ for (auto &baseSpecifier : cxxRecord->bases()) {<br>
+ if (baseSpecifier.isVirtual()) continue;<br>
+<br>
+ auto baseRecord = baseSpecifier.getType()->getAsCXXRecordDecl();<br>
+ addTypedData(baseRecord, begin + layout.getBaseClassOffset(baseRecord));<br>
+ }<br>
+<br>
+ // - a vbptr if the class adds its own<br>
+ if (layout.hasOwnVBPtr()) {<br>
+ addTypedData(CGM.Int8PtrTy, begin + layout.getVBPtrOffset());<br>
+ }<br>
+ }<br>
+<br>
+ // Add fields.<br>
+ for (auto field : record->fields()) {<br>
+ auto fieldOffsetInBits = layout.getFieldOffset(field->getFieldIndex());<br>
+ if (field->isBitField()) {<br>
+ addBitFieldData(field, begin, fieldOffsetInBits);<br>
+ } else {<br>
+ addTypedData(field->getType(),<br>
+ begin + CGM.getContext().toCharUnitsFromBits(fieldOffsetInBits));<br>
+ }<br>
+ }<br>
+<br>
+ // Add "late" C++ data:<br>
+ if (cxxRecord) {<br>
+ // - virtual bases<br>
+ for (auto &vbaseSpecifier : cxxRecord->vbases()) {<br>
+ auto baseRecord = vbaseSpecifier.getType()->getAsCXXRecordDecl();<br>
+ addTypedData(baseRecord, begin + layout.getVBaseClassOffset(baseRecord));<br>
+ }<br>
+ }<br>
+}<br>
+<br>
+void SwiftAggLowering::addBitFieldData(const FieldDecl *bitfield,<br>
+ CharUnits recordBegin,<br>
+ uint64_t bitfieldBitBegin) {<br>
+ assert(bitfield->isBitField());<br>
+ auto &ctx = CGM.getContext();<br>
+ auto width = bitfield->getBitWidthValue(ctx);<br>
+<br>
+ // We can ignore zero-width bit-fields.<br>
+ if (width == 0) return;<br>
+<br>
+ // toCharUnitsFromBits rounds down.<br>
+ CharUnits bitfieldByteBegin = ctx.toCharUnitsFromBits(bitfieldBitBegin);<br>
+<br>
+ // Find the offset of the last byte that is partially occupied by the<br>
+ // bit-field; since we otherwise expect exclusive ends, the end is the<br>
+ // next byte.<br>
+ uint64_t bitfieldBitLast = bitfieldBitBegin + width - 1;<br>
+ CharUnits bitfieldByteEnd =<br>
+ ctx.toCharUnitsFromBits(bitfieldBitLast) + CharUnits::One();<br>
+ addOpaqueData(recordBegin + bitfieldByteBegin,<br>
+ recordBegin + bitfieldByteEnd);<br>
+}<br>
+<br>
+void SwiftAggLowering::addTypedData(llvm::Type *type, CharUnits begin) {<br>
+ assert(type && "didn't provide type for typed data");<br>
+ addTypedData(type, begin, begin + getTypeStoreSize(CGM, type));<br>
+}<br>
+<br>
+void SwiftAggLowering::addTypedData(llvm::Type *type,<br>
+ CharUnits begin, CharUnits end) {<br>
+ assert(type && "didn't provide type for typed data");<br>
+ assert(getTypeStoreSize(CGM, type) == end - begin);<br>
+<br>
+ // Legalize vector types.<br>
+ if (auto vecTy = dyn_cast<llvm::VectorType>(type)) {<br>
+ SmallVector<llvm::Type*, 4> componentTys;<br>
+ legalizeVectorType(CGM, end - begin, vecTy, componentTys);<br>
+ assert(componentTys.size() >= 1);<br>
+<br>
+ // Walk the initial components.<br>
+ for (size_t i = 0, e = componentTys.size(); i != e - 1; ++i) {<br>
+ llvm::Type *componentTy = componentTys[i];<br>
+ auto componentSize = getTypeStoreSize(CGM, componentTy);<br>
+ assert(componentSize < end - begin);<br>
+ addLegalTypedData(componentTy, begin, begin + componentSize);<br>
+ begin += componentSize;<br>
+ }<br>
+<br>
+ return addLegalTypedData(componentTys.back(), begin, end);<br>
+ }<br>
+<br>
+ // Legalize integer types.<br>
+ if (auto intTy = dyn_cast<llvm::IntegerType>(type)) {<br>
+ if (!isLegalIntegerType(CGM, intTy))<br>
+ return addOpaqueData(begin, end);<br>
+ }<br>
+<br>
+ // All other types should be legal.<br>
+ return addLegalTypedData(type, begin, end);<br>
+}<br>
+<br>
+void SwiftAggLowering::addLegalTypedData(llvm::Type *type,<br>
+ CharUnits begin, CharUnits end) {<br>
+ // Require the type to be naturally aligned.<br>
+ if (!begin.isZero() && !begin.isMultipleOf(getNaturalAlignment(CGM, type))) {<br>
+<br>
+ // Try splitting vector types.<br>
+ if (auto vecTy = dyn_cast<llvm::VectorType>(type)) {<br>
+ auto split = splitLegalVectorType(CGM, end - begin, vecTy);<br>
+ auto eltTy = split.first;<br>
+ auto numElts = split.second;<br>
+<br>
+ auto eltSize = (end - begin) / numElts;<br>
+ assert(eltSize == getTypeStoreSize(CGM, eltTy));<br>
+ for (size_t i = 0, e = numElts; i != e; ++i) {<br>
+ addLegalTypedData(type, begin, begin + eltSize);<br>
+ begin += eltSize;<br>
+ }<br>
+ assert(begin == end);<br>
+ return;<br>
+ }<br>
+<br>
+ return addOpaqueData(begin, end);<br>
+ }<br>
+<br>
+ addEntry(type, begin, end);<br>
+}<br>
+<br>
+void SwiftAggLowering::addEntry(llvm::Type *type,<br>
+ CharUnits begin, CharUnits end) {<br>
+ assert(!type ||<br>
+ (!isa<llvm::StructType>(type) && !isa<llvm::ArrayType>(type)) &&<br>
+ "cannot add aggregate-typed data");<br>
+ assert(!type || begin.isMultipleOf(getNaturalAlignment(CGM, type)));<br>
+<br>
+ // Fast path: we can just add entries to the end.<br>
+ if (Entries.empty() || Entries.back().End <= begin) {<br>
+ Entries.push_back({begin, end, type});<br>
+ return;<br>
+ }<br>
+<br>
+ // Find the first existing entry that ends after the start of the new data.<br>
+ // TODO: do a binary search if Entries is big enough for it to matter.<br>
+ size_t index = Entries.size() - 1;<br>
+ while (index != 0) {<br>
+ if (Entries[index - 1].End <= begin) break;<br>
+ --index;<br>
+ }<br>
+<br>
+ // The entry ends after the start of the new data.<br>
+ // If the entry starts after the end of the new data, there's no conflict.<br>
+ if (Entries[index].Begin >= end) {<br>
+ // This insertion is potentially O(n), but the way we generally build<br>
+ // these layouts makes that unlikely to matter: we'd need a union of<br>
+ // several very large types.<br>
+ Entries.insert(Entries.begin() + index, {begin, end, type});<br>
+ return;<br>
+ }<br>
+<br>
+ // Otherwise, the ranges overlap. The new range might also overlap<br>
+ // with later ranges.<br>
+restartAfterSplit:<br>
+<br>
+ // Simplest case: an exact overlap.<br>
+ if (Entries[index].Begin == begin && Entries[index].End == end) {<br>
+ // If the types match exactly, great.<br>
+ if (Entries[index].Type == type) return;<br>
+<br>
+ // If either type is opaque, make the entry opaque and return.<br>
+ if (Entries[index].Type == nullptr) {<br>
+ return;<br>
+ } else if (type == nullptr) {<br>
+ Entries[index].Type = nullptr;<br>
+ return;<br>
+ }<br>
+<br>
+ // If they disagree in an ABI-agnostic way, just resolve the conflict<br>
+ // arbitrarily.<br>
+ if (auto entryType = getCommonType(Entries[index].Type, type)) {<br>
+ Entries[index].Type = entryType;<br>
+ return;<br>
+ }<br>
+<br>
+ // Otherwise, make the entry opaque.<br>
+ Entries[index].Type = nullptr;<br>
+ return;<br>
+ }<br>
+<br>
+ // Okay, we have an overlapping conflict of some sort.<br>
+<br>
+ // If we have a vector type, split it.<br>
+ if (auto vecTy = dyn_cast_or_null<llvm::VectorType>(type)) {<br>
+ auto eltTy = vecTy->getElementType();<br>
+ CharUnits eltSize = (end - begin) / vecTy->getNumElements();<br>
+ assert(eltSize == getTypeStoreSize(CGM, eltTy));<br>
+ for (unsigned i = 0, e = vecTy->getNumElements(); i != e; ++i) {<br>
+ addEntry(eltTy, begin, begin + eltSize);<br>
+ begin += eltSize;<br>
+ }<br>
+ assert(begin == end);<br>
+ return;<br>
+ }<br>
+<br>
+ // If the entry is a vector type, split it and try again.<br>
+ if (Entries[index].Type && Entries[index].Type->isVectorTy()) {<br>
+ splitVectorEntry(index);<br>
+ goto restartAfterSplit;<br>
+ }<br>
+<br>
+ // Okay, we have no choice but to make the existing entry opaque.<br>
+<br>
+ Entries[index].Type = nullptr;<br>
+<br>
+ // Stretch the start of the entry to the beginning of the range.<br>
+ if (begin < Entries[index].Begin) {<br>
+ Entries[index].Begin = begin;<br>
+ assert(index == 0 || begin >= Entries[index - 1].End);<br>
+ }<br>
+<br>
+ // Stretch the end of the entry to the end of the range; but if we run<br>
+ // into the start of the next entry, just leave the range there and repeat.<br>
+ while (end > Entries[index].End) {<br>
+ assert(Entries[index].Type == nullptr);<br>
+<br>
+ // If the range doesn't overlap the next entry, we're done.<br>
+ if (index == Entries.size() - 1 || end <= Entries[index + 1].Begin) {<br>
+ Entries[index].End = end;<br>
+ break;<br>
+ }<br>
+<br>
+ // Otherwise, stretch to the start of the next entry.<br>
+ Entries[index].End = Entries[index + 1].Begin;<br>
+<br>
+ // Continue with the next entry.<br>
+ index++;<br>
+<br>
+ // This entry needs to be made opaque if it is not already.<br>
+ if (Entries[index].Type == nullptr)<br>
+ continue;<br>
+<br>
+ // Split vector entries unless we completely subsume them.<br>
+ if (Entries[index].Type->isVectorTy() &&<br>
+ end < Entries[index].End) {<br>
+ splitVectorEntry(index);<br>
+ }<br>
+<br>
+ // Make the entry opaque.<br>
+ Entries[index].Type = nullptr;<br>
+ }<br>
+}<br>
+<br>
+/// Replace the entry of vector type at offset 'index' with a sequence<br>
+/// of its component vectors.<br>
+void SwiftAggLowering::splitVectorEntry(unsigned index) {<br>
+ auto vecTy = cast<llvm::VectorType>(Entries[index].Type);<br>
+ auto split = splitLegalVectorType(CGM, Entries[index].getWidth(), vecTy);<br>
+<br>
+ auto eltTy = split.first;<br>
+ CharUnits eltSize = getTypeStoreSize(CGM, eltTy);<br>
+ auto numElts = split.second;<br>
+ Entries.insert(&Entries[index + 1], numElts - 1, StorageEntry());<br>
+<br>
+ CharUnits begin = Entries[index].Begin;<br>
+ for (unsigned i = 0; i != numElts; ++i) {<br>
+ Entries[index].Type = eltTy;<br>
+ Entries[index].Begin = begin;<br>
+ Entries[index].End = begin + eltSize;<br>
+ begin += eltSize;<br>
+ }<br>
+}<br>
+<br>
+/// Given a power-of-two unit size, return the offset of the aligned unit<br>
+/// of that size which contains the given offset.<br>
+///<br>
+/// In other words, round down to the nearest multiple of the unit size.<br>
+static CharUnits getOffsetAtStartOfUnit(CharUnits offset, CharUnits unitSize) {<br>
+ assert(isPowerOf2(unitSize.getQuantity()));<br>
+ auto unitMask = ~(unitSize.getQuantity() - 1);<br>
+ return CharUnits::fromQuantity(offset.getQuantity() & unitMask);<br>
+}<br>
+<br>
+static bool areBytesInSameUnit(CharUnits first, CharUnits second,<br>
+ CharUnits chunkSize) {<br>
+ return getOffsetAtStartOfUnit(first, chunkSize)<br>
+ == getOffsetAtStartOfUnit(second, chunkSize);<br>
+}<br>
+<br>
+void SwiftAggLowering::finish() {<br>
+ if (Entries.empty()) {<br>
+ Finished = true;<br>
+ return;<br>
+ }<br>
+<br>
+ // We logically split the layout down into a series of chunks of this size,<br>
+ // which is generally the size of a pointer.<br>
+ const CharUnits chunkSize = getMaximumVoluntaryIntegerSize(CGM);<br>
+<br>
+ // First pass: if two entries share a chunk, make them both opaque<br>
+ // and stretch one to meet the next.<br>
+ bool hasOpaqueEntries = (Entries[0].Type == nullptr);<br>
+ for (size_t i = 1, e = Entries.size(); i != e; ++i) {<br>
+ if (areBytesInSameUnit(Entries[i - 1].End - CharUnits::One(),<br>
+ Entries[i].Begin, chunkSize)) {<br>
+ Entries[i - 1].Type = nullptr;<br>
+ Entries[i].Type = nullptr;<br>
+ Entries[i - 1].End = Entries[i].Begin;<br>
+ hasOpaqueEntries = true;<br>
+<br>
+ } else if (Entries[i].Type == nullptr) {<br>
+ hasOpaqueEntries = true;<br>
+ }<br>
+ }<br>
+<br>
+ // The rest of the algorithm leaves non-opaque entries alone, so if we<br>
+ // have no opaque entries, we're done.<br>
+ if (!hasOpaqueEntries) {<br>
+ Finished = true;<br>
+ return;<br>
+ }<br>
+<br>
+ // Okay, move the entries to a temporary and rebuild Entries.<br>
+ auto orig = std::move(Entries);<br>
+ assert(Entries.empty());<br>
+<br>
+ for (size_t i = 0, e = orig.size(); i != e; ++i) {<br>
+ // Just copy over non-opaque entries.<br>
+ if (orig[i].Type != nullptr) {<br>
+ Entries.push_back(orig[i]);<br>
+ continue;<br>
+ }<br>
+<br>
+ // Scan forward to determine the full extent of the next opaque range.<br>
+ // We know from the first pass that only contiguous ranges will overlap<br>
+ // the same aligned chunk.<br>
+ auto begin = orig[i].Begin;<br>
+ auto end = orig[i].End;<br>
+ while (i + 1 != e &&<br>
+ orig[i + 1].Type == nullptr &&<br>
+ end == orig[i + 1].Begin) {<br>
+ end = orig[i + 1].End;<br>
+ i++;<br>
+ }<br>
+<br>
+ // Add an entry per intersected chunk.<br>
+ do {<br>
+ // Find the smallest aligned storage unit in the maximal aligned<br>
+ // storage unit containing 'begin' that contains all the bytes in<br>
+ // the intersection between the range and this chunk.<br>
+ CharUnits localBegin = begin;<br>
+ CharUnits chunkBegin = getOffsetAtStartOfUnit(localBegin, chunkSize);<br>
+ CharUnits chunkEnd = chunkBegin + chunkSize;<br>
+ CharUnits localEnd = std::min(end, chunkEnd);<br>
+<br>
+ // Just do a simple loop over ever-increasing unit sizes.<br>
+ CharUnits unitSize = CharUnits::One();<br>
+ CharUnits unitBegin, unitEnd;<br>
+ for (; ; unitSize *= 2) {<br>
+ assert(unitSize <= chunkSize);<br>
+ unitBegin = getOffsetAtStartOfUnit(localBegin, unitSize);<br>
+ unitEnd = unitBegin + unitSize;<br>
+ if (unitEnd >= localEnd) break;<br>
+ }<br>
+<br>
+ // Add an entry for this unit.<br>
+ auto entryTy =<br>
+ llvm::IntegerType::get(CGM.getLLVMContext(),<br>
+ CGM.getContext().toBits(unitSize));<br>
+ Entries.push_back({unitBegin, unitEnd, entryTy});<br>
+<br>
+ // The next chunk starts where this chunk left off.<br>
+ begin = localEnd;<br>
+ } while (begin != end);<br>
+ }<br>
+<br>
+ // Okay, finally finished.<br>
+ Finished = true;<br>
+}<br>
+<br>
+void SwiftAggLowering::enumerateComponents(EnumerationCallback callback) const {<br>
+ assert(Finished && "haven't yet finished lowering");<br>
+<br>
+ for (auto &entry : Entries) {<br>
+ callback(entry.Begin, entry.Type);<br>
+ }<br>
+}<br>
+<br>
+std::pair<llvm::StructType*, llvm::Type*><br>
+SwiftAggLowering::getCoerceAndExpandTypes() const {<br>
+ assert(Finished && "haven't yet finished lowering");<br>
+<br>
+ auto &ctx = CGM.getLLVMContext();<br>
+<br>
+ if (Entries.empty()) {<br>
+ auto type = llvm::StructType::get(ctx);<br>
+ return { type, type };<br>
+ }<br>
+<br>
+ SmallVector<llvm::Type*, 8> elts;<br>
+ CharUnits lastEnd = CharUnits::Zero();<br>
+ bool hasPadding = false;<br>
+ bool packed = false;<br>
+ for (auto &entry : Entries) {<br>
+ if (entry.Begin != lastEnd) {<br>
+ auto paddingSize = entry.Begin - lastEnd;<br>
+ assert(!paddingSize.isNegative());<br>
+<br>
+ auto padding = llvm::ArrayType::get(llvm::Type::getInt8Ty(ctx),<br>
+ paddingSize.getQuantity());<br>
+ elts.push_back(padding);<br>
+ hasPadding = true;<br>
+ }<br>
+<br>
+ if (!packed && !entry.Begin.isMultipleOf(<br>
+ CharUnits::fromQuantity(<br>
+ CGM.getDataLayout().getABITypeAlignment(entry.Type))))<br>
+ packed = true;<br>
+<br>
+ elts.push_back(entry.Type);<br>
+ lastEnd = entry.End;<br>
+ }<br>
+<br>
+ // We don't need to adjust 'packed' to deal with possible tail padding<br>
+ // because we never do that kind of access through the coercion type.<br>
+ auto coercionType = llvm::StructType::get(ctx, elts, packed);<br>
+<br>
+ llvm::Type *unpaddedType = coercionType;<br>
+ if (hasPadding) {<br>
+ elts.clear();<br>
+ for (auto &entry : Entries) {<br>
+ elts.push_back(entry.Type);<br>
+ }<br>
+ if (elts.size() == 1) {<br>
+ unpaddedType = elts[0];<br>
+ } else {<br>
+ unpaddedType = llvm::StructType::get(ctx, elts, /*packed*/ false);<br>
+ }<br>
+ } else if (Entries.size() == 1) {<br>
+ unpaddedType = Entries[0].Type;<br>
+ }<br>
+<br>
+ return { coercionType, unpaddedType };<br>
+}<br>
+<br>
+bool SwiftAggLowering::shouldPassIndirectly(bool asReturnValue) const {<br>
+ assert(Finished && "haven't yet finished lowering");<br>
+<br>
+ // Empty types don't need to be passed indirectly.<br>
+ if (Entries.empty()) return false;<br>
+<br>
+ CharUnits totalSize = Entries.back().End;<br>
+<br>
+ // Avoid copying the array of types when there's just a single element.<br>
+ if (Entries.size() == 1) {<br>
+ return getSwiftABIInfo(CGM).shouldPassIndirectlyForSwift(totalSize,<br>
+ Entries.back().Type,<br>
+ asReturnValue);<br>
+ }<br>
+<br>
+ SmallVector<llvm::Type*, 8> componentTys;<br>
+ componentTys.reserve(Entries.size());<br>
+ for (auto &entry : Entries) {<br>
+ componentTys.push_back(entry.Type);<br>
+ }<br>
+ return getSwiftABIInfo(CGM).shouldPassIndirectlyForSwift(totalSize,<br>
+ componentTys,<br>
+ asReturnValue);<br>
+}<br>
+<br>
+CharUnits swiftcall::getMaximumVoluntaryIntegerSize(CodeGenModule &CGM) {<br>
+ // Currently always the size of an ordinary pointer.<br>
+ return CGM.getContext().toCharUnitsFromBits(<br>
+ CGM.getContext().getTargetInfo().getPointerWidth(0));<br>
+}<br>
+<br>
+CharUnits swiftcall::getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type) {<br>
+ // For Swift's purposes, this is always just the store size of the type<br>
+ // rounded up to a power of 2.<br>
+ auto size = (unsigned long long) getTypeStoreSize(CGM, type).getQuantity();<br>
+ if (!isPowerOf2(size)) {<br>
+ size = 1U << (llvm::findLastSet(size, llvm::ZB_Undefined) + 1);<br>
+ }<br>
+ assert(size >= CGM.getDataLayout().getABITypeAlignment(type));<br>
+ return CharUnits::fromQuantity(size);<br>
+}<br>
+<br>
+bool swiftcall::isLegalIntegerType(CodeGenModule &CGM,<br>
+ llvm::IntegerType *intTy) {<br>
+ auto size = intTy->getBitWidth();<br>
+ switch (size) {<br>
+ case 1:<br>
+ case 8:<br>
+ case 16:<br>
+ case 32:<br>
+ case 64:<br>
+ // Just assume that the above are always legal.<br>
+ return true;<br>
+<br>
+ case 128:<br>
+ return CGM.getContext().getTargetInfo().hasInt128Type();<br>
+<br>
+ default:<br>
+ return false;<br>
+ }<br>
+}<br>
+<br>
+bool swiftcall::isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,<br>
+ llvm::VectorType *vectorTy) {<br>
+ return isLegalVectorType(CGM, vectorSize, vectorTy->getElementType(),<br>
+ vectorTy->getNumElements());<br>
+}<br>
+<br>
+bool swiftcall::isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,<br>
+ llvm::Type *eltTy, unsigned numElts) {<br>
+ assert(numElts > 1 && "illegal vector length");<br>
+ return getSwiftABIInfo(CGM)<br>
+ .isLegalVectorTypeForSwift(vectorSize, eltTy, numElts);<br>
+}<br>
+<br>
+std::pair<llvm::Type*, unsigned><br>
+swiftcall::splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,<br>
+ llvm::VectorType *vectorTy) {<br>
+ auto numElts = vectorTy->getNumElements();<br>
+ auto eltTy = vectorTy->getElementType();<br>
+<br>
+ // Try to split the vector type in half.<br>
+ if (numElts >= 4 && isPowerOf2(numElts)) {<br>
+ if (isLegalVectorType(CGM, vectorSize / 2, eltTy, numElts / 2))<br>
+ return {llvm::VectorType::get(eltTy, numElts / 2), 2};<br>
+ }<br>
+<br>
+ return {eltTy, numElts};<br>
+}<br>
+<br>
+void swiftcall::legalizeVectorType(CodeGenModule &CGM, CharUnits origVectorSize,<br>
+ llvm::VectorType *origVectorTy,<br>
+ llvm::SmallVectorImpl<llvm::Type*> &components) {<br>
+ // If it's already a legal vector type, use it.<br>
+ if (isLegalVectorType(CGM, origVectorSize, origVectorTy)) {<br>
+ components.push_back(origVectorTy);<br>
+ return;<br>
+ }<br>
+<br>
+ // Try to split the vector into legal subvectors.<br>
+ auto numElts = origVectorTy->getNumElements();<br>
+ auto eltTy = origVectorTy->getElementType();<br>
+ assert(numElts != 1);<br>
+<br>
+ // The largest size that we're still considering making subvectors of.<br>
+ // Always a power of 2.<br>
+ unsigned logCandidateNumElts = llvm::findLastSet(numElts, llvm::ZB_Undefined);<br>
+ unsigned candidateNumElts = 1U << logCandidateNumElts;<br>
+ assert(candidateNumElts <= numElts && candidateNumElts * 2 > numElts);<br>
+<br>
+ // Minor optimization: don't check the legality of this exact size twice.<br>
+ if (candidateNumElts == numElts) {<br>
+ logCandidateNumElts--;<br>
+ candidateNumElts >>= 1;<br>
+ }<br>
+<br>
+ CharUnits eltSize = (origVectorSize / numElts);<br>
+ CharUnits candidateSize = eltSize * candidateNumElts;<br>
+<br>
+ // The sensibility of this algorithm relies on the fact that we never<br>
+ // have a legal non-power-of-2 vector size without having the power of 2<br>
+ // also be legal.<br>
+ while (logCandidateNumElts > 0) {<br>
+ assert(candidateNumElts == 1U << logCandidateNumElts);<br>
+ assert(candidateNumElts <= numElts);<br>
+ assert(candidateSize == eltSize * candidateNumElts);<br>
+<br>
+ // Skip illegal vector sizes.<br>
+ if (!isLegalVectorType(CGM, candidateSize, eltTy, candidateNumElts)) {<br>
+ logCandidateNumElts--;<br>
+ candidateNumElts /= 2;<br>
+ candidateSize /= 2;<br>
+ continue;<br>
+ }<br>
+<br>
+ // Add the right number of vectors of this size.<br>
+ auto numVecs = numElts >> logCandidateNumElts;<br>
+ components.append(numVecs, llvm::VectorType::get(eltTy, candidateNumElts));<br>
+ numElts -= (numVecs << logCandidateNumElts);<br>
+<br>
+ if (numElts == 0) return;<br>
+<br>
+ // It's possible that the number of elements remaining will be legal.<br>
+ // This can happen with e.g. <7 x float> when <3 x float> is legal.<br>
+ // This only needs to be separately checked if it's not a power of 2.<br>
+ if (numElts > 2 && !isPowerOf2(numElts) &&<br>
+ isLegalVectorType(CGM, eltSize * numElts, eltTy, numElts)) {<br>
+ components.push_back(llvm::VectorType::get(eltTy, numElts));<br>
+ return;<br>
+ }<br>
+<br>
+ // Bring vecSize down to something no larger than numElts.<br>
+ do {<br>
+ logCandidateNumElts--;<br>
+ candidateNumElts /= 2;<br>
+ candidateSize /= 2;<br>
+ } while (candidateNumElts > numElts);<br>
+ }<br>
+<br>
+ // Otherwise, just append a bunch of individual elements.<br>
+ components.append(numElts, eltTy);<br>
+}<br>
+<br>
+bool swiftcall::shouldPassCXXRecordIndirectly(CodeGenModule &CGM,<br>
+ const CXXRecordDecl *record) {<br>
+ // Following a recommendation from Richard Smith, pass a C++ type<br>
+ // indirectly only if the destructor is non-trivial or *all* of the<br>
+ // copy/move constructors are deleted or non-trivial.<br>
+<br>
+ if (record->hasNonTrivialDestructor())<br>
+ return true;<br>
+<br>
+ // It would be nice if this were summarized on the CXXRecordDecl.<br>
+ for (auto ctor : record->ctors()) {<br>
+ if (ctor->isCopyOrMoveConstructor() && !ctor->isDeleted() &&<br>
+ ctor->isTrivial()) {<br>
+ return false;<br>
+ }<br>
+ }<br>
+<br>
+ return true;<br>
+}<br>
+<br>
+static ABIArgInfo classifyExpandedType(SwiftAggLowering &lowering,<br>
+ bool forReturn,<br>
+ CharUnits alignmentForIndirect) {<br>
+ if (lowering.empty()) {<br>
+ return ABIArgInfo::getIgnore();<br>
+ } else if (lowering.shouldPassIndirectly(forReturn)) {<br>
+ return ABIArgInfo::getIndirect(alignmentForIndirect, /*byval*/ false);<br>
+ } else {<br>
+ auto types = lowering.getCoerceAndExpandTypes();<br>
+ return ABIArgInfo::getCoerceAndExpand(types.first, types.second);<br>
+ }<br>
+}<br>
+<br>
+static ABIArgInfo classifyType(CodeGenModule &CGM, CanQualType type,<br>
+ bool forReturn) {<br>
+ if (auto recordType = dyn_cast<RecordType>(type)) {<br>
+ auto record = recordType->getDecl();<br>
+ auto &layout = CGM.getContext().getASTRecordLayout(record);<br>
+<br>
+ if (auto cxxRecord = dyn_cast<CXXRecordDecl>(record)) {<br>
+ if (shouldPassCXXRecordIndirectly(CGM, cxxRecord))<br>
+ return ABIArgInfo::getIndirect(layout.getAlignment(), /*byval*/ false);<br>
+ }<br>
+<br>
+ SwiftAggLowering lowering(CGM);<br>
+ lowering.addTypedData(recordType->getDecl(), CharUnits::Zero(), layout);<br>
+ lowering.finish();<br>
+<br>
+ return classifyExpandedType(lowering, forReturn, layout.getAlignment());<br>
+ }<br>
+<br>
+ // Just assume that all of our target ABIs can support returning at least<br>
+ // two integer or floating-point values.<br>
+ if (isa<ComplexType>(type)) {<br>
+ return (forReturn ? ABIArgInfo::getDirect() : ABIArgInfo::getExpand());<br>
+ }<br>
+<br>
+ // Vector types may need to be legalized.<br>
+ if (isa<VectorType>(type)) {<br>
+ SwiftAggLowering lowering(CGM);<br>
+ lowering.addTypedData(type, CharUnits::Zero());<br>
+ lowering.finish();<br>
+<br>
+ CharUnits alignment = CGM.getContext().getTypeAlignInChars(type);<br>
+ return classifyExpandedType(lowering, forReturn, alignment);<br>
+ }<br>
+<br>
+ // Member pointer types need to be expanded, but it's a simple form of<br>
+ // expansion that 'Direct' can handle. Note that CanBeFlattened should be<br>
+ // true for this to work.<br>
+<br>
+ // 'void' needs to be ignored.<br>
+ if (type->isVoidType()) {<br>
+ return ABIArgInfo::getIgnore();<br>
+ }<br>
+<br>
+ // Everything else can be passed directly.<br>
+ return ABIArgInfo::getDirect();<br>
+}<br>
+<br>
+ABIArgInfo swiftcall::classifyReturnType(CodeGenModule &CGM, CanQualType type) {<br>
+ return classifyType(CGM, type, /*forReturn*/ true);<br>
+}<br>
+<br>
+ABIArgInfo swiftcall::classifyArgumentType(CodeGenModule &CGM,<br>
+ CanQualType type) {<br>
+ return classifyType(CGM, type, /*forReturn*/ false);<br>
+}<br>
+<br>
+void swiftcall::computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI) {<br>
+ auto &retInfo = FI.getReturnInfo();<br>
+ retInfo = classifyReturnType(CGM, FI.getReturnType());<br>
+<br>
+ for (unsigned i = 0, e = FI.arg_size(); i != e; ++i) {<br>
+ auto &argInfo = FI.arg_begin()[i];<br>
+ argInfo.info = classifyArgumentType(CGM, argInfo.type);<br>
+ }<br>
+}<br>
\ No newline at end of file<br>
<br>
Modified: cfe/trunk/lib/CodeGen/TargetInfo.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/TargetInfo.cpp?rev=265324&r1=265323&r2=265324&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/TargetInfo.cpp?rev=265324&r1=265323&r2=265324&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/TargetInfo.cpp (original)<br>
+++ cfe/trunk/lib/CodeGen/TargetInfo.cpp Mon Apr 4 13:33:08 2016<br>
@@ -19,6 +19,7 @@<br>
#include "CodeGenFunction.h"<br>
#include "clang/AST/RecordLayout.h"<br>
#include "clang/CodeGen/CGFunctionInfo.h"<br>
+#include "clang/CodeGen/SwiftCallingConv.h"<br>
#include "clang/Frontend/CodeGenOptions.h"<br>
#include "llvm/ADT/StringExtras.h"<br>
#include "llvm/ADT/Triple.h"<br>
@@ -68,6 +69,46 @@ Address ABIInfo::EmitMSVAArg(CodeGenFunc<br>
<br>
ABIInfo::~ABIInfo() {}<br>
<br>
+/// Does the given lowering require more than the given number of<br>
+/// registers when expanded?<br>
+///<br>
+/// This is intended to be the basis of a reasonable basic implementation<br>
+/// of should{Pass,Return}IndirectlyForSwift.<br>
+///<br>
+/// For most targets, a limit of four total registers is reasonable; this<br>
+/// limits the amount of code required in order to move around the value<br>
+/// in case it wasn't produced immediately prior to the call by the caller<br>
+/// (or wasn't produced in exactly the right registers) or isn't used<br>
+/// immediately within the callee. But some targets may need to further<br>
+/// limit the register count due to an inability to support that many<br>
+/// return registers.<br>
+static bool occupiesMoreThan(CodeGenTypes &cgt,<br>
+ ArrayRef<llvm::Type*> scalarTypes,<br>
+ unsigned maxAllRegisters) {<br>
+ unsigned intCount = 0, fpCount = 0;<br>
+ for (llvm::Type *type : scalarTypes) {<br>
+ if (type->isPointerTy()) {<br>
+ intCount++;<br>
+ } else if (auto intTy = dyn_cast<llvm::IntegerType>(type)) {<br>
+ auto ptrWidth = cgt.getTarget().getPointerWidth(0);<br>
+ intCount += (intTy->getBitWidth() + ptrWidth - 1) / ptrWidth;<br>
+ } else {<br>
+ assert(type->isVectorTy() || type->isFloatingPointTy());<br>
+ fpCount++;<br>
+ }<br>
+ }<br>
+<br>
+ return (intCount + fpCount > maxAllRegisters);<br>
+}<br>
+<br>
+bool SwiftABIInfo::isLegalVectorTypeForSwift(CharUnits vectorSize,<br>
+ llvm::Type *eltTy,<br>
+ unsigned numElts) const {<br>
+ // The default implementation of this assumes that the target guarantees<br>
+ // 128-bit SIMD support but nothing more.<br>
+ return (vectorSize.getQuantity() > 8 && vectorSize.getQuantity() <= 16);<br>
+}<br>
+<br>
static CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT,<br>
CGCXXABI &CXXABI) {<br>
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());<br>
@@ -866,7 +907,7 @@ struct CCState {<br>
};<br>
<br>
/// X86_32ABIInfo - The X86-32 ABI information.<br>
-class X86_32ABIInfo : public ABIInfo {<br>
+class X86_32ABIInfo : public SwiftABIInfo {<br>
enum Class {<br>
Integer,<br>
Float<br>
@@ -935,12 +976,22 @@ public:<br>
X86_32ABIInfo(CodeGen::CodeGenTypes &CGT, bool DarwinVectorABI,<br>
bool RetSmallStructInRegABI, bool Win32StructABI,<br>
unsigned NumRegisterParameters, bool SoftFloatABI)<br>
- : ABIInfo(CGT), IsDarwinVectorABI(DarwinVectorABI),<br>
+ : SwiftABIInfo(CGT), IsDarwinVectorABI(DarwinVectorABI),<br>
IsRetSmallStructInRegABI(RetSmallStructInRegABI),<br>
IsWin32StructABI(Win32StructABI),<br>
IsSoftFloatABI(SoftFloatABI),<br>
IsMCUABI(CGT.getTarget().getTriple().isOSIAMCU()),<br>
DefaultNumRegisterParameters(NumRegisterParameters) {}<br>
+<br>
+ bool shouldPassIndirectlyForSwift(CharUnits totalSize,<br>
+ ArrayRef<llvm::Type*> scalars,<br>
+ bool asReturnValue) const override {<br>
+ // LLVM's x86-32 lowering currently only assigns up to three<br>
+ // integer registers and three fp registers. Oddly, it'll use up to<br>
+ // four vector registers for vectors, but those can overlap with the<br>
+ // scalar registers.<br>
+ return occupiesMoreThan(CGT, scalars, /*total*/ 3);<br>
+ }<br>
};<br>
<br>
class X86_32TargetCodeGenInfo : public TargetCodeGenInfo {<br>
@@ -1758,7 +1809,7 @@ static unsigned getNativeVectorSizeForAV<br>
}<br>
<br>
/// X86_64ABIInfo - The X86_64 ABI information.<br>
-class X86_64ABIInfo : public ABIInfo {<br>
+class X86_64ABIInfo : public SwiftABIInfo {<br>
enum Class {<br>
Integer = 0,<br>
SSE,<br>
@@ -1880,7 +1931,7 @@ class X86_64ABIInfo : public ABIInfo {<br>
<br>
public:<br>
X86_64ABIInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel) :<br>
- ABIInfo(CGT), AVXLevel(AVXLevel),<br>
+ SwiftABIInfo(CGT), AVXLevel(AVXLevel),<br>
Has64BitPointers(CGT.getDataLayout().getPointerSize(0) == 8) {<br>
}<br>
<br>
@@ -1907,6 +1958,12 @@ public:<br>
bool has64BitPointers() const {<br>
return Has64BitPointers;<br>
}<br>
+<br>
+ bool shouldPassIndirectlyForSwift(CharUnits totalSize,<br>
+ ArrayRef<llvm::Type*> scalars,<br>
+ bool asReturnValue) const override {<br>
+ return occupiesMoreThan(CGT, scalars, /*total*/ 4);<br>
+ }<br>
};<br>
<br>
/// WinX86_64ABIInfo - The Windows X86_64 ABI information.<br>
@@ -4338,7 +4395,7 @@ PPC64TargetCodeGenInfo::initDwarfEHRegSi<br>
<br>
namespace {<br>
<br>
-class AArch64ABIInfo : public ABIInfo {<br>
+class AArch64ABIInfo : public SwiftABIInfo {<br>
public:<br>
enum ABIKind {<br>
AAPCS = 0,<br>
@@ -4349,7 +4406,8 @@ private:<br>
ABIKind Kind;<br>
<br>
public:<br>
- AArch64ABIInfo(CodeGenTypes &CGT, ABIKind Kind) : ABIInfo(CGT), Kind(Kind) {}<br>
+ AArch64ABIInfo(CodeGenTypes &CGT, ABIKind Kind)<br>
+ : SwiftABIInfo(CGT), Kind(Kind) {}<br>
<br>
private:<br>
ABIKind getABIKind() const { return Kind; }<br>
@@ -4382,6 +4440,12 @@ private:<br>
return isDarwinPCS() ? EmitDarwinVAArg(VAListAddr, Ty, CGF)<br>
: EmitAAPCSVAArg(VAListAddr, Ty, CGF);<br>
}<br>
+<br>
+ bool shouldPassIndirectlyForSwift(CharUnits totalSize,<br>
+ ArrayRef<llvm::Type*> scalars,<br>
+ bool asReturnValue) const override {<br>
+ return occupiesMoreThan(CGT, scalars, /*total*/ 4);<br>
+ }<br>
};<br>
<br>
class AArch64TargetCodeGenInfo : public TargetCodeGenInfo {<br>
@@ -4856,7 +4920,7 @@ Address AArch64ABIInfo::EmitDarwinVAArg(<br>
<br>
namespace {<br>
<br>
-class ARMABIInfo : public ABIInfo {<br>
+class ARMABIInfo : public SwiftABIInfo {<br>
public:<br>
enum ABIKind {<br>
APCS = 0,<br>
@@ -4869,7 +4933,8 @@ private:<br>
ABIKind Kind;<br>
<br>
public:<br>
- ARMABIInfo(CodeGenTypes &CGT, ABIKind _Kind) : ABIInfo(CGT), Kind(_Kind) {<br>
+ ARMABIInfo(CodeGenTypes &CGT, ABIKind _Kind)<br>
+ : SwiftABIInfo(CGT), Kind(_Kind) {<br>
setCCs();<br>
}<br>
<br>
@@ -4915,6 +4980,12 @@ private:<br>
llvm::CallingConv::ID getLLVMDefaultCC() const;<br>
llvm::CallingConv::ID getABIDefaultCC() const;<br>
void setCCs();<br>
+<br>
+ bool shouldPassIndirectlyForSwift(CharUnits totalSize,<br>
+ ArrayRef<llvm::Type*> scalars,<br>
+ bool asReturnValue) const override {<br>
+ return occupiesMoreThan(CGT, scalars, /*total*/ 4);<br>
+ }<br>
};<br>
<br>
class ARMTargetCodeGenInfo : public TargetCodeGenInfo {<br>
<br>
Modified: cfe/trunk/lib/CodeGen/TargetInfo.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/TargetInfo.h?rev=265324&r1=265323&r2=265324&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/TargetInfo.h?rev=265324&r1=265323&r2=265324&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/TargetInfo.h (original)<br>
+++ cfe/trunk/lib/CodeGen/TargetInfo.h Mon Apr 4 13:33:08 2016<br>
@@ -29,15 +29,14 @@ class Value;<br>
}<br>
<br>
namespace clang {<br>
-class ABIInfo;<br>
class Decl;<br>
<br>
namespace CodeGen {<br>
+class ABIInfo;<br>
class CallArgList;<br>
class CodeGenModule;<br>
class CodeGenFunction;<br>
class CGFunctionInfo;<br>
-}<br>
<br>
/// TargetCodeGenInfo - This class organizes various target-specific<br>
/// codegeneration issues, like target-specific attributes, builtins and so<br>
@@ -219,6 +218,8 @@ public:<br>
llvm::StringRef Value,<br>
llvm::SmallString<32> &Opt) const {}<br>
};<br>
+<br>
+} // namespace CodeGen<br>
} // namespace clang<br>
<br>
#endif // LLVM_CLANG_LIB_CODEGEN_TARGETINFO_H<br>
<br>
Added: cfe/trunk/test/CodeGen/arm-swiftcall.c<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/arm-swiftcall.c?rev=265324&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/arm-swiftcall.c?rev=265324&view=auto</a><br>
==============================================================================<br>
--- cfe/trunk/test/CodeGen/arm-swiftcall.c (added)<br>
+++ cfe/trunk/test/CodeGen/arm-swiftcall.c Mon Apr 4 13:33:08 2016<br>
@@ -0,0 +1,496 @@<br>
+// RUN: %clang_cc1 -triple armv7-apple-darwin9 -emit-llvm -o - %s | FileCheck %s<br>
+<br>
+// This isn't really testing anything ARM-specific; it's just a convenient<br>
+// 32-bit platform.<br>
+<br>
+#define SWIFTCALL __attribute__((swiftcall))<br>
+#define OUT __attribute__((swift_indirect_result))<br>
+#define ERROR __attribute__((swift_error_result))<br>
+#define CONTEXT __attribute__((swift_context))<br>
+<br>
+/*****************************************************************************/<br>
+/****************************** PARAMETER ABIS *******************************/<br>
+/*****************************************************************************/<br>
+<br>
+SWIFTCALL void indirect_result_1(OUT int *arg0, OUT float *arg1) {}<br>
+// CHECK-LABEL: define {{.*}} void @indirect_result_1(i32* noalias sret align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}})<br>
+<br>
+// TODO: maybe this shouldn't suppress sret.<br>
+SWIFTCALL int indirect_result_2(OUT int *arg0, OUT float *arg1) { __builtin_unreachable(); }<br>
+// CHECK-LABEL: define {{.*}} i32 @indirect_result_2(i32* noalias align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}})<br>
+<br>
+typedef struct { char array[1024]; } struct_reallybig;<br>
+SWIFTCALL struct_reallybig indirect_result_3(OUT int *arg0, OUT float *arg1) { __builtin_unreachable(); }<br>
+// CHECK-LABEL: define {{.*}} void @indirect_result_3({{.*}}* noalias sret {{.*}}, i32* noalias align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}})<br>
+<br>
+SWIFTCALL void context_1(CONTEXT void *self) {}<br>
+// CHECK-LABEL: define {{.*}} void @context_1(i8* swiftself<br>
+<br>
+SWIFTCALL void context_2(void *arg0, CONTEXT void *self) {}<br>
+// CHECK-LABEL: define {{.*}} void @context_2(i8*{{.*}}, i8* swiftself<br>
+<br>
+SWIFTCALL void context_error_1(CONTEXT int *self, ERROR float **error) {}<br>
+// CHECK-LABEL: define {{.*}} void @context_error_1(i32* swiftself{{.*}}, float** swifterror)<br>
+// CHECK: [[TEMP:%.*]] = alloca float*, align 4<br>
+// CHECK: [[T0:%.*]] = load float*, float** [[ERRORARG:%.*]], align 4<br>
+// CHECK: store float* [[T0]], float** [[TEMP]], align 4<br>
+// CHECK: [[T0:%.*]] = load float*, float** [[TEMP]], align 4<br>
+// CHECK: store float* [[T0]], float** [[ERRORARG]], align 4<br>
+void test_context_error_1() {<br>
+ int x;<br>
+ float *error;<br>
+ context_error_1(&x, &error);<br>
+}<br>
+// CHECK-LABEL: define void @test_context_error_1()<br>
+// CHECK: [[X:%.*]] = alloca i32, align 4<br>
+// CHECK: [[ERROR:%.*]] = alloca float*, align 4<br>
+// CHECK: [[TEMP:%.*]] = alloca swifterror float*, align 4<br>
+// CHECK: [[T0:%.*]] = load float*, float** [[ERROR]], align 4<br>
+// CHECK: store float* [[T0]], float** [[TEMP]], align 4<br>
+// CHECK: call [[SWIFTCC:cc16]] void @context_error_1(i32* swiftself [[X]], float** swifterror [[TEMP]])<br>
+// CHECK: [[T0:%.*]] = load float*, float** [[TEMP]], align 4<br>
+// CHECK: store float* [[T0]], float** [[ERROR]], align 4<br>
+<br>
+SWIFTCALL void context_error_2(short s, CONTEXT int *self, ERROR float **error) {}<br>
+// CHECK-LABEL: define {{.*}} void @context_error_2(i16{{.*}}, i32* swiftself{{.*}}, float** swifterror)<br>
+<br>
+/*****************************************************************************/<br>
+/********************************** LOWERING *********************************/<br>
+/*****************************************************************************/<br>
+<br>
+typedef float float4 __attribute__((ext_vector_type(4)));<br>
+typedef float float8 __attribute__((ext_vector_type(8)));<br>
+typedef double double2 __attribute__((ext_vector_type(2)));<br>
+typedef double double4 __attribute__((ext_vector_type(4)));<br>
+typedef int int4 __attribute__((ext_vector_type(4)));<br>
+typedef int int5 __attribute__((ext_vector_type(5)));<br>
+typedef int int8 __attribute__((ext_vector_type(8)));<br>
+<br>
+#define TEST(TYPE) \<br>
+ SWIFTCALL TYPE return_##TYPE(void) { \<br>
+ TYPE result = {}; \<br>
+ return result; \<br>
+ } \<br>
+ SWIFTCALL void take_##TYPE(TYPE v) { \<br>
+ } \<br>
+ void test_##TYPE() { \<br>
+ take_##TYPE(return_##TYPE()); \<br>
+ }<br>
+<br>
+/*****************************************************************************/<br>
+/*********************************** STRUCTS *********************************/<br>
+/*****************************************************************************/<br>
+<br>
+typedef struct {<br>
+} struct_empty;<br>
+TEST(struct_empty);<br>
+// CHECK-LABEL: define {{.*}} @return_struct_empty()<br>
+// CHECK: ret void<br>
+// CHECK-LABEL: define {{.*}} @take_struct_empty()<br>
+// CHECK: ret void<br>
+<br>
+typedef struct {<br>
+ int x;<br>
+ char c0;<br>
+ char c1;<br>
+ float f0;<br>
+ float f1;<br>
+} struct_1;<br>
+TEST(struct_1);<br>
+// CHECK-LABEL: define {{.*}} @return_struct_1()<br>
+// CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align 4<br>
+// CHECK: [[VAR:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: @llvm.memset<br>
+// CHECK: @llvm.memcpy<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, i16, \[2 x i8\], float, float }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i16, i16* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 4<br>
+// CHECK: [[FOURTH:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ i32, i16, float, float }]] undef, i32 [[FIRST]], 0<br>
+// CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i16 [[SECOND]], 1<br>
+// CHECK: [[T2:%.*]] = insertvalue [[UAGG]] [[T1]], float [[THIRD]], 2<br>
+// CHECK: [[T3:%.*]] = insertvalue [[UAGG]] [[T2]], float [[FOURTH]], 3<br>
+// CHECK: ret [[UAGG]] [[T3]]<br>
+// CHECK-LABEL: define {{.*}} @take_struct_1(i32, i16, float, float)<br>
+// CHECK: [[V:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: store i32 %0, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: store i16 %1, i16* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: store float %2, float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 4<br>
+// CHECK: store float %3, float* [[T0]], align 4<br>
+// CHECK: ret void<br>
+// CHECK-LABEL: define void @test_struct_1()<br>
+// CHECK: [[TMP:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_struct_1()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1<br>
+// CHECK: store i16 [[T1]], i16* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 2<br>
+// CHECK: store float [[T1]], float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 4<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 3<br>
+// CHECK: store float [[T1]], float* [[T0]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i16, i16* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 4<br>
+// CHECK: [[FOURTH:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: call [[SWIFTCC]] void @take_struct_1(i32 [[FIRST]], i16 [[SECOND]], float [[THIRD]], float [[FOURTH]])<br>
+// CHECK: ret void<br>
+<br>
+typedef struct {<br>
+ int x;<br>
+ char c0;<br>
+ __attribute__((aligned(2))) char c1;<br>
+ float f0;<br>
+ float f1;<br>
+} struct_2;<br>
+TEST(struct_2);<br>
+// CHECK-LABEL: define {{.*}} @return_struct_2()<br>
+// CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align 4<br>
+// CHECK: [[VAR:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: @llvm.memcpy<br>
+// CHECK: @llvm.memcpy<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, i32, float, float }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[FOURTH:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ i32, i32, float, float }]] undef, i32 [[FIRST]], 0<br>
+// CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i32 [[SECOND]], 1<br>
+// CHECK: [[T2:%.*]] = insertvalue [[UAGG]] [[T1]], float [[THIRD]], 2<br>
+// CHECK: [[T3:%.*]] = insertvalue [[UAGG]] [[T2]], float [[FOURTH]], 3<br>
+// CHECK: ret [[UAGG]] [[T3]]<br>
+// CHECK-LABEL: define {{.*}} @take_struct_2(i32, i32, float, float)<br>
+// CHECK: [[V:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: store i32 %0, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: store i32 %1, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: store float %2, float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: store float %3, float* [[T0]], align 4<br>
+// CHECK: ret void<br>
+// CHECK-LABEL: define void @test_struct_2()<br>
+// CHECK: [[TMP:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_struct_2()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 2<br>
+// CHECK: store float [[T1]], float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 3<br>
+// CHECK: store float [[T1]], float* [[T0]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[FOURTH:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: call [[SWIFTCC]] void @take_struct_2(i32 [[FIRST]], i32 [[SECOND]], float [[THIRD]], float [[FOURTH]])<br>
+// CHECK: ret void<br>
+<br>
+// There's no way to put a field randomly in the middle of an otherwise<br>
+// empty storage unit in C, so that case has to be tested in C++, which<br>
+// can use empty structs to introduce arbitrary padding. (In C, they end up<br>
+// with size 0 and so don't affect layout.)<br>
+<br>
+// Misaligned data rule.<br>
+typedef struct {<br>
+ char c0;<br>
+ __attribute__((packed)) float f;<br>
+} struct_misaligned_1;<br>
+TEST(struct_misaligned_1)<br>
+// CHECK-LABEL: define {{.*}} @return_struct_misaligned_1()<br>
+// CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align<br>
+// CHECK: [[VAR:%.*]] = alloca [[REC]], align<br>
+// CHECK: @llvm.memset<br>
+// CHECK: @llvm.memcpy<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, i8 }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i8, i8* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ i32, i8 }]] undef, i32 [[FIRST]], 0<br>
+// CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i8 [[SECOND]], 1<br>
+// CHECK: ret [[UAGG]] [[T1]]<br>
+// CHECK-LABEL: define {{.*}} @take_struct_misaligned_1(i32, i8)<br>
+// CHECK: [[V:%.*]] = alloca [[REC]], align<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: store i32 %0, i32* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: store i8 %1, i8* [[T0]], align<br>
+// CHECK: ret void<br>
+<br>
+// Too many scalars.<br>
+typedef struct {<br>
+ int x[5];<br>
+} struct_big_1;<br>
+TEST(struct_big_1)<br>
+<br>
+// CHECK-LABEL: define {{.*}} void @return_struct_big_1({{.*}} noalias sret<br>
+<br>
+// Should not be byval.<br>
+// CHECK-LABEL: define {{.*}} void @take_struct_big_1({{.*}}*{{( %.*)?}})<br>
+<br>
+/*****************************************************************************/<br>
+/********************************* TYPE MERGING ******************************/<br>
+/*****************************************************************************/<br>
+<br>
+typedef union {<br>
+ float f;<br>
+ double d;<br>
+} union_het_fp;<br>
+TEST(union_het_fp)<br>
+// CHECK-LABEL: define {{.*}} @return_union_het_fp()<br>
+// CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align 4<br>
+// CHECK: [[VAR:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: @llvm.memcpy<br>
+// CHECK: @llvm.memcpy<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, i32 }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ i32, i32 }]] undef, i32 [[FIRST]], 0<br>
+// CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i32 [[SECOND]], 1<br>
+// CHECK: ret [[UAGG]] [[T1]]<br>
+// CHECK-LABEL: define {{.*}} @take_union_het_fp(i32, i32)<br>
+// CHECK: [[V:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: store i32 %0, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: store i32 %1, i32* [[T0]], align 4<br>
+// CHECK: ret void<br>
+// CHECK-LABEL: define void @test_union_het_fp()<br>
+// CHECK: [[TMP:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_union_het_fp()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: call [[SWIFTCC]] void @take_union_het_fp(i32 [[FIRST]], i32 [[SECOND]])<br>
+// CHECK: ret void<br>
+<br>
+<br>
+typedef union {<br>
+ float f1;<br>
+ float f2;<br>
+} union_hom_fp;<br>
+TEST(union_hom_fp)<br>
+// CHECK-LABEL: define void @test_union_hom_fp()<br>
+// CHECK: [[TMP:%.*]] = alloca [[REC:%.*]], align 4<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] float @return_union_hom_fp()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG:{ float }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: store float [[CALL]], float* [[T0]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: call [[SWIFTCC]] void @take_union_hom_fp(float [[FIRST]])<br>
+// CHECK: ret void<br>
+<br>
+typedef union {<br>
+ float f1;<br>
+ float4 fv2;<br>
+} union_hom_fp_partial;<br>
+TEST(union_hom_fp_partial)<br>
+// CHECK-LABEL: define void @test_union_hom_fp_partial()<br>
+// CHECK: [[TMP:%.*]] = alloca [[REC:%.*]], align 16<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG:{ float, float, float, float }]] @return_union_hom_fp_partial()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG:{ float, float, float, float }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0<br>
+// CHECK: store float [[T1]], float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1<br>
+// CHECK: store float [[T1]], float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 2<br>
+// CHECK: store float [[T1]], float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 3<br>
+// CHECK: store float [[T1]], float* [[T0]], align<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[FOURTH:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: call [[SWIFTCC]] void @take_union_hom_fp_partial(float [[FIRST]], float [[SECOND]], float [[THIRD]], float [[FOURTH]])<br>
+// CHECK: ret void<br>
+<br>
+typedef union {<br>
+ struct { int x, y; } f1;<br>
+ float4 fv2;<br>
+} union_het_fpv_partial;<br>
+TEST(union_het_fpv_partial)<br>
+// CHECK-LABEL: define void @test_union_het_fpv_partial()<br>
+// CHECK: [[TMP:%.*]] = alloca [[REC:%.*]], align 16<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG:{ i32, i32, float, float }]] @return_union_het_fpv_partial()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG:{ i32, i32, float, float }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 2<br>
+// CHECK: store float [[T1]], float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 3<br>
+// CHECK: store float [[T1]], float* [[T0]], align<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3<br>
+// CHECK: [[FOURTH:%.*]] = load float, float* [[T0]], align<br>
+// CHECK: call [[SWIFTCC]] void @take_union_het_fpv_partial(i32 [[FIRST]], i32 [[SECOND]], float [[THIRD]], float [[FOURTH]])<br>
+// CHECK: ret void<br>
+<br>
+/*****************************************************************************/<br>
+/****************************** VECTOR LEGALIZATION **************************/<br>
+/*****************************************************************************/<br>
+<br>
+TEST(int4)<br>
+// CHECK-LABEL: define {{.*}} <4 x i32> @return_int4()<br>
+// CHECK-LABEL: define {{.*}} @take_int4(<4 x i32><br>
+<br>
+TEST(int8)<br>
+// CHECK-LABEL: define {{.*}} @return_int8()<br>
+// CHECK: [[RET:%.*]] = alloca [[REC:<8 x i32>]], align 32<br>
+// CHECK: [[VAR:%.*]] = alloca [[REC]], align<br>
+// CHECK: store<br>
+// CHECK: load<br>
+// CHECK: store<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ <4 x i32>, <4 x i32> }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ <4 x i32>, <4 x i32> }]] undef, <4 x i32> [[FIRST]], 0<br>
+// CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], <4 x i32> [[SECOND]], 1<br>
+// CHECK: ret [[UAGG]] [[T1]]<br>
+// CHECK-LABEL: define {{.*}} @take_int8(<4 x i32>, <4 x i32>)<br>
+// CHECK: [[V:%.*]] = alloca [[REC]], align<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: store <4 x i32> %0, <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: store <4 x i32> %1, <4 x i32>* [[T0]], align<br>
+// CHECK: ret void<br>
+// CHECK-LABEL: define void @test_int8()<br>
+// CHECK: [[TMP1:%.*]] = alloca [[REC]], align<br>
+// CHECK: [[TMP2:%.*]] = alloca [[REC]], align<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_int8()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP1]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0<br>
+// CHECK: store <4 x i32> [[T1]], <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1<br>
+// CHECK: store <4 x i32> [[T1]], <4 x i32>* [[T0]], align<br>
+// CHECK: [[V:%.*]] = load [[REC]], [[REC]]* [[TMP1]], align<br>
+// CHECK: store [[REC]] [[V]], [[REC]]* [[TMP2]], align<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP2]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align<br>
+// CHECK: call [[SWIFTCC]] void @take_int8(<4 x i32> [[FIRST]], <4 x i32> [[SECOND]])<br>
+// CHECK: ret void<br>
+<br>
+TEST(int5)<br>
+// CHECK-LABEL: define {{.*}} @return_int5()<br>
+// CHECK: [[RET:%.*]] = alloca [[REC:<5 x i32>]], align 32<br>
+// CHECK: [[VAR:%.*]] = alloca [[REC]], align<br>
+// CHECK: store<br>
+// CHECK: load<br>
+// CHECK: store<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ <4 x i32>, i32 }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ <4 x i32>, i32 }]] undef, <4 x i32> [[FIRST]], 0<br>
+// CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i32 [[SECOND]], 1<br>
+// CHECK: ret [[UAGG]] [[T1]]<br>
+// CHECK-LABEL: define {{.*}} @take_int5(<4 x i32>, i32)<br>
+// CHECK: [[V:%.*]] = alloca [[REC]], align<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: store <4 x i32> %0, <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: store i32 %1, i32* [[T0]], align<br>
+// CHECK: ret void<br>
+// CHECK-LABEL: define void @test_int5()<br>
+// CHECK: [[TMP1:%.*]] = alloca [[REC]], align<br>
+// CHECK: [[TMP2:%.*]] = alloca [[REC]], align<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_int5()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP1]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0<br>
+// CHECK: store <4 x i32> [[T1]], <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align<br>
+// CHECK: [[V:%.*]] = load [[REC]], [[REC]]* [[TMP1]], align<br>
+// CHECK: store [[REC]] [[V]], [[REC]]* [[TMP2]], align<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP2]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1<br>
+// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align<br>
+// CHECK: call [[SWIFTCC]] void @take_int5(<4 x i32> [[FIRST]], i32 [[SECOND]])<br>
+// CHECK: ret void<br>
<br>
Added: cfe/trunk/test/CodeGenCXX/arm-swiftcall.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/arm-swiftcall.cpp?rev=265324&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/arm-swiftcall.cpp?rev=265324&view=auto</a><br>
==============================================================================<br>
--- cfe/trunk/test/CodeGenCXX/arm-swiftcall.cpp (added)<br>
+++ cfe/trunk/test/CodeGenCXX/arm-swiftcall.cpp Mon Apr 4 13:33:08 2016<br>
@@ -0,0 +1,115 @@<br>
+// RUN: %clang_cc1 -triple armv7-apple-darwin9 -emit-llvm -o - %s -Wno-return-type-c-linkage | FileCheck %s<br>
+<br>
+// This isn't really testing anything ARM-specific; it's just a convenient<br>
+// 32-bit platform.<br>
+<br>
+#define SWIFTCALL __attribute__((swiftcall))<br>
+#define OUT __attribute__((swift_indirect_result))<br>
+#define ERROR __attribute__((swift_error_result))<br>
+#define CONTEXT __attribute__((swift_context))<br>
+<br>
+/*****************************************************************************/<br>
+/********************************** LOWERING *********************************/<br>
+/*****************************************************************************/<br>
+<br>
+#define TEST(TYPE) \<br>
+ extern "C" SWIFTCALL TYPE return_##TYPE(void) { \<br>
+ TYPE result = {}; \<br>
+ return result; \<br>
+ } \<br>
+ extern "C" SWIFTCALL void take_##TYPE(TYPE v) { \<br>
+ } \<br>
+ extern "C" void test_##TYPE() { \<br>
+ take_##TYPE(return_##TYPE()); \<br>
+ }<br>
+<br>
+/*****************************************************************************/<br>
+/*********************************** STRUCTS *********************************/<br>
+/*****************************************************************************/<br>
+<br>
+typedef struct {<br>
+} struct_empty;<br>
+TEST(struct_empty);<br>
+// CHECK-LABEL: define {{.*}} @return_struct_empty()<br>
+// CHECK: ret void<br>
+// CHECK-LABEL: define {{.*}} @take_struct_empty()<br>
+// CHECK: ret void<br>
+<br>
+// This is only properly testable in C++ because it relies on empty structs<br>
+// actually taking up space in a structure without requiring any extra data<br>
+// to be passed.<br>
+typedef struct {<br>
+ int x;<br>
+ struct_empty padding[2];<br>
+ char c1;<br>
+ float f0;<br>
+ float f1;<br>
+} struct_1;<br>
+TEST(struct_1);<br>
+// CHECK-LABEL: define {{.*}} @return_struct_1()<br>
+// CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align 4<br>
+// CHECK: @llvm.memset<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, \[2 x i8\], i8, \[1 x i8\], float, float }]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[SECOND:%.*]] = load i8, i8* [[T0]], align 2<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 4<br>
+// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 5<br>
+// CHECK: [[FOURTH:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ i32, i8, float, float }]] undef, i32 [[FIRST]], 0<br>
+// CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i8 [[SECOND]], 1<br>
+// CHECK: [[T2:%.*]] = insertvalue [[UAGG]] [[T1]], float [[THIRD]], 2<br>
+// CHECK: [[T3:%.*]] = insertvalue [[UAGG]] [[T2]], float [[FOURTH]], 3<br>
+// CHECK: ret [[UAGG]] [[T3]]<br>
+// CHECK-LABEL: define {{.*}} @take_struct_1(i32, i8, float, float)<br>
+// CHECK: [[V:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: store i32 %0, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: store i8 %1, i8* [[T0]], align 2<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 4<br>
+// CHECK: store float %2, float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 5<br>
+// CHECK: store float %3, float* [[T0]], align 4<br>
+// CHECK: ret void<br>
+// CHECK-LABEL: define void @test_struct_1()<br>
+// CHECK: [[TMP:%.*]] = alloca [[REC]], align 4<br>
+// CHECK: [[CALL:%.*]] = call [[SWIFTCC:cc16]] [[UAGG]] @return_struct_1()<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0<br>
+// CHECK: store i32 [[T1]], i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1<br>
+// CHECK: store i8 [[T1]], i8* [[T0]], align 2<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 4<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 2<br>
+// CHECK: store float [[T1]], float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 5<br>
+// CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 3<br>
+// CHECK: store float [[T1]], float* [[T0]], align 4<br>
+// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0<br>
+// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2<br>
+// CHECK: [[SECOND:%.*]] = load i8, i8* [[T0]], align 2<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 4<br>
+// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 5<br>
+// CHECK: [[FOURTH:%.*]] = load float, float* [[T0]], align 4<br>
+// CHECK: call [[SWIFTCC]] void @take_struct_1(i32 [[FIRST]], i8 [[SECOND]], float [[THIRD]], float [[FOURTH]])<br>
+// CHECK: ret void<br>
+<br>
+struct struct_indirect_1 {<br>
+ int x;<br>
+ ~struct_indirect_1();<br>
+};<br>
+TEST(struct_indirect_1)<br>
+<br>
+// CHECK-LABEL: define {{.*}} void @return_struct_indirect_1({{.*}} noalias sret<br>
+<br>
+// Should not be byval.<br>
+// CHECK-LABEL: define {{.*}} void @take_struct_indirect_1({{.*}}*{{( %.*)?}})<br>
<br>
<br>
_______________________________________________<br>
cfe-commits mailing list<br>
<a href="mailto:cfe-commits@lists.llvm.org">cfe-commits@lists.llvm.org</a><br>
<a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits" rel="noreferrer" target="_blank">http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits</a><br>
</blockquote></div><br></div>