1//===- Xtensa.cpp ---------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "ABIInfoImpl.h"
10#include "TargetInfo.h"
11
12using namespace clang;
13using namespace clang::CodeGen;
14//===----------------------------------------------------------------------===//
15// Xtensa ABI Implementation
16//===----------------------------------------------------------------------===//
17
18namespace {
19class XtensaABIInfo : public DefaultABIInfo {
20private:
21 static const int MaxNumArgGPRs = 6;
22 static const int MaxNumRetGPRs = 4;
23
24public:
25 XtensaABIInfo(CodeGen::CodeGenTypes &CGT) : DefaultABIInfo(CGT) {}
26
27 void computeInfo(CGFunctionInfo &FI) const override;
28
29 ABIArgInfo classifyArgumentType(QualType Ty, int &ArgGPRsLeft) const;
30
31 ABIArgInfo classifyReturnType(QualType RetTy) const;
32
33 RValue EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
34 AggValueSlot Slot) const override;
35
36 ABIArgInfo extendType(QualType Ty) const;
37};
38} // end anonymous namespace
39
40void XtensaABIInfo::computeInfo(CGFunctionInfo &FI) const {
41 QualType RetTy = FI.getReturnType();
42 if (!getCXXABI().classifyReturnType(FI))
43 FI.getReturnInfo() = classifyReturnType(RetTy);
44
45 int ArgGPRsLeft = MaxNumArgGPRs;
46 for (auto &[Type, Info] : FI.arguments()) {
47 Info = classifyArgumentType(Ty: Type, ArgGPRsLeft);
48 }
49}
50
51ABIArgInfo XtensaABIInfo::classifyArgumentType(QualType Ty,
52 int &ArgGPRsLeft) const {
53 assert(ArgGPRsLeft <= MaxNumArgGPRs && "Arg GPR tracking underflow");
54 Ty = useFirstFieldIfTransparentUnion(Ty);
55 // Structures with either a non-trivial destructor or a non-trivial
56 // copy constructor are always passed indirectly.
57 if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(T: Ty, CXXABI&: getCXXABI())) {
58 if (ArgGPRsLeft)
59 ArgGPRsLeft -= 1;
60 return getNaturalAlignIndirect(Ty, AddrSpace: getDataLayout().getAllocaAddrSpace(),
61 /*ByVal=*/RAA ==
62 CGCXXABI::RAA_DirectInMemory);
63 }
64
65 // Ignore empty structs/unions.
66 if (isEmptyRecord(Context&: getContext(), T: Ty, AllowArrays: true))
67 return ABIArgInfo::getIgnore();
68
69 uint64_t Size = getContext().getTypeSize(T: Ty);
70 uint64_t NeededAlign = getContext().getTypeAlign(T: Ty);
71 int NeededArgGPRs = (Size + 31) / 32;
72
73 if (NeededAlign == (2 * 32))
74 NeededArgGPRs += (ArgGPRsLeft % 2);
75
76 // Push onto the stack objects that do not fit into 6 registers,
77 // also push onto the stack an object with alignment greater than 16 bytes,
78 // and an object with alignment of 16 bytes if it is not the first argument.
79 if ((NeededArgGPRs > ArgGPRsLeft) || (NeededAlign > (4 * 32)) ||
80 ((ArgGPRsLeft < 6) && (NeededAlign == (4 * 32)))) {
81 ArgGPRsLeft = 0;
82 return getNaturalAlignIndirect(Ty, AddrSpace: getDataLayout().getAllocaAddrSpace(),
83 /*ByVal=*/true);
84 }
85 ArgGPRsLeft -= NeededArgGPRs;
86
87 if (!isAggregateTypeForABI(T: Ty) && !Ty->isVectorType()) {
88 // Treat an enum type as its underlying type.
89 if (const auto *ED = Ty->getAsEnumDecl())
90 Ty = ED->getIntegerType();
91 // All integral types less then 32-bit width are promoted to 32-bit width.
92 if (Size < 32 && Ty->isIntegralOrEnumerationType()) {
93 return extendType(Ty);
94 }
95 // Assume that type has 32, 64 or 128 bits
96 return ABIArgInfo::getDirect(T: llvm::IntegerType::get(C&: getVMContext(), NumBits: Size));
97 }
98
99 // Aggregates which are <= 6*32 will be passed in registers if possible,
100 // so coerce to integers.
101 if (Size <= (MaxNumArgGPRs * 32)) {
102 if (Size <= 32) {
103 return ABIArgInfo::getDirect(T: llvm::IntegerType::get(C&: getVMContext(), NumBits: 32));
104 } else if (NeededAlign == (2 * 32)) {
105 return ABIArgInfo::getDirect(T: llvm::ArrayType::get(
106 ElementType: llvm::IntegerType::get(C&: getVMContext(), NumBits: 64), NumElements: NeededArgGPRs / 2));
107 } else if (NeededAlign == (4 * 32)) {
108 return ABIArgInfo::getDirect(T: llvm::IntegerType::get(C&: getVMContext(), NumBits: 128));
109 }
110
111 return ABIArgInfo::getDirect(T: llvm::ArrayType::get(
112 ElementType: llvm::IntegerType::get(C&: getVMContext(), NumBits: 32), NumElements: NeededArgGPRs));
113 }
114
115 return getNaturalAlignIndirect(Ty, AddrSpace: getDataLayout().getAllocaAddrSpace(),
116 /*ByVal=*/true);
117}
118
119ABIArgInfo XtensaABIInfo::classifyReturnType(QualType RetTy) const {
120 if (RetTy->isVoidType())
121 return ABIArgInfo::getIgnore();
122
123 int ArgGPRsLeft = MaxNumRetGPRs;
124 auto RetSize = llvm::alignTo(Value: getContext().getTypeSize(T: RetTy), Align: 32) / 32;
125
126 // The rules for return value and for argument with type size more
127 // then 4 bytes are the same, so defer to classifyArgumentType.
128 if (RetSize > 1)
129 return classifyArgumentType(Ty: RetTy, ArgGPRsLeft);
130
131 return DefaultABIInfo::classifyReturnType(RetTy);
132}
133
134RValue XtensaABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
135 QualType Ty, AggValueSlot Slot) const {
136 // The va_list structure memory layout:
137 // struct __va_list_tag {
138 // int32_t *va_stk;
139 // int32_t *va_reg;
140 // int32_t va_ndx;
141 // };
142 CGBuilderTy &Builder = CGF.Builder;
143
144 Address OverflowAreaPtr = Builder.CreateStructGEP(Addr: VAListAddr, Index: 0, Name: "__va_stk");
145 Address OverflowArea = Address(Builder.CreateLoad(Addr: OverflowAreaPtr, Name: ""),
146 CGF.Int32Ty, CharUnits::fromQuantity(Quantity: 4));
147 Address RegSaveAreaPtr = Builder.CreateStructGEP(Addr: VAListAddr, Index: 1, Name: "__va_reg");
148 Address RegSaveArea = Address(Builder.CreateLoad(Addr: RegSaveAreaPtr, Name: ""),
149 CGF.Int32Ty, CharUnits::fromQuantity(Quantity: 4));
150 Address ARAreaPtr = Builder.CreateStructGEP(Addr: VAListAddr, Index: 2, Name: "__va_ndx");
151 llvm::Value *ARIndex = Builder.CreateLoad(Addr: ARAreaPtr, Name: "");
152
153 ARIndex = Builder.CreateLShr(LHS: ARIndex, RHS: Builder.getInt32(C: 2));
154
155 unsigned Align = getContext().getTypeAlign(T: Ty) / 32;
156 unsigned Size = (getContext().getTypeSize(T: Ty) + 31) / 32;
157
158 if (Align > 1) {
159 ARIndex = Builder.CreateAdd(LHS: ARIndex, RHS: Builder.getInt32(C: Align - 1));
160 ARIndex =
161 Builder.CreateAnd(LHS: ARIndex, RHS: Builder.getInt32(C: (uint32_t)~(Align - 1)));
162 }
163
164 llvm::Value *ARIndexNext = Builder.CreateAdd(LHS: ARIndex, RHS: Builder.getInt32(C: Size));
165 Builder.CreateStore(Val: Builder.CreateShl(LHS: ARIndexNext, RHS: Builder.getInt32(C: 2)),
166 Addr: ARAreaPtr);
167
168 const unsigned OverflowLimit = 6;
169 llvm::Value *CC = Builder.CreateICmpULE(
170 LHS: ARIndexNext, RHS: Builder.getInt32(C: OverflowLimit), Name: "cond");
171
172 llvm::BasicBlock *UsingRegSaveArea =
173 CGF.createBasicBlock(name: "using_regsavearea");
174 llvm::BasicBlock *UsingOverflow = CGF.createBasicBlock(name: "using_overflow");
175 llvm::BasicBlock *Cont = CGF.createBasicBlock(name: "cont");
176
177 Builder.CreateCondBr(Cond: CC, True: UsingRegSaveArea, False: UsingOverflow);
178
179 llvm::Type *DirectTy = CGF.ConvertType(T: Ty);
180
181 // Case 1: consume registers.
182 Address RegAddr = Address::invalid();
183 {
184 CGF.EmitBlock(BB: UsingRegSaveArea);
185
186 CharUnits RegSize = CharUnits::fromQuantity(Quantity: 4);
187 RegSaveArea =
188 Address(Builder.CreateInBoundsGEP(
189 Ty: CGF.Int32Ty, Ptr: RegSaveArea.emitRawPointer(CGF), IdxList: ARIndex),
190 CGF.Int32Ty,
191 RegSaveArea.getAlignment().alignmentOfArrayElement(elementSize: RegSize));
192 RegAddr = RegSaveArea.withElementType(ElemTy: DirectTy);
193 CGF.EmitBranch(Block: Cont);
194 }
195
196 // Case 2: consume space in the overflow area.
197 Address MemAddr = Address::invalid();
198 {
199 CGF.EmitBlock(BB: UsingOverflow);
200 llvm::Value *CC1 = Builder.CreateICmpULE(
201 LHS: ARIndex, RHS: Builder.getInt32(C: OverflowLimit), Name: "cond_overflow");
202
203 llvm::Value *ARIndexOff = Builder.CreateSelect(
204 C: CC1, True: Builder.CreateSub(LHS: Builder.getInt32(C: 8), RHS: ARIndex),
205 False: Builder.getInt32(C: 0));
206
207 llvm::Value *ARIndexCorr = Builder.CreateAdd(LHS: ARIndex, RHS: ARIndexOff);
208 llvm::Value *ARIndexNextCorr = Builder.CreateAdd(LHS: ARIndexNext, RHS: ARIndexOff);
209 Builder.CreateStore(Val: Builder.CreateShl(LHS: ARIndexNextCorr, RHS: Builder.getInt32(C: 2)),
210 Addr: ARAreaPtr);
211
212 CharUnits RegSize = CharUnits::fromQuantity(Quantity: 4);
213 OverflowArea =
214 Address(Builder.CreateInBoundsGEP(
215 Ty: CGF.Int32Ty, Ptr: OverflowArea.emitRawPointer(CGF), IdxList: ARIndexCorr),
216 CGF.Int32Ty,
217 OverflowArea.getAlignment().alignmentOfArrayElement(elementSize: RegSize));
218 MemAddr = OverflowArea.withElementType(ElemTy: DirectTy);
219 CGF.EmitBranch(Block: Cont);
220 }
221
222 CGF.EmitBlock(BB: Cont);
223
224 // Merge the cases with a phi.
225 Address Result =
226 emitMergePHI(CGF, Addr1: RegAddr, Block1: UsingRegSaveArea, Addr2: MemAddr, Block2: UsingOverflow, Name: "");
227
228 return CGF.EmitLoadOfAnyValue(V: CGF.MakeAddrLValue(Addr: Result, T: Ty), Slot);
229}
230
231ABIArgInfo XtensaABIInfo::extendType(QualType Ty) const {
232 return ABIArgInfo::getExtend(Ty);
233}
234
235namespace {
236class XtensaTargetCodeGenInfo : public TargetCodeGenInfo {
237public:
238 XtensaTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
239 : TargetCodeGenInfo(std::make_unique<XtensaABIInfo>(args&: CGT)) {}
240};
241} // namespace
242
243std::unique_ptr<TargetCodeGenInfo>
244CodeGen::createXtensaTargetCodeGenInfo(CodeGenModule &CGM) {
245 return std::make_unique<XtensaTargetCodeGenInfo>(args&: CGM.getTypes());
246}
247