1 //===- Hexagon.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 12 using namespace clang; 13 using namespace clang::CodeGen; 14 15 //===----------------------------------------------------------------------===// 16 // Hexagon ABI Implementation 17 //===----------------------------------------------------------------------===// 18 19 namespace { 20 21 class HexagonABIInfo : public DefaultABIInfo { 22 public: HexagonABIInfo(CodeGenTypes & CGT)23 HexagonABIInfo(CodeGenTypes &CGT) : DefaultABIInfo(CGT) {} 24 25 private: 26 ABIArgInfo classifyReturnType(QualType RetTy) const; 27 ABIArgInfo classifyArgumentType(QualType RetTy) const; 28 ABIArgInfo classifyArgumentType(QualType RetTy, unsigned *RegsLeft) const; 29 30 void computeInfo(CGFunctionInfo &FI) const override; 31 32 RValue EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty, 33 AggValueSlot Slot) const override; 34 Address EmitVAArgFromMemory(CodeGenFunction &CFG, Address VAListAddr, 35 QualType Ty) const; 36 Address EmitVAArgForHexagon(CodeGenFunction &CFG, Address VAListAddr, 37 QualType Ty) const; 38 Address EmitVAArgForHexagonLinux(CodeGenFunction &CFG, Address VAListAddr, 39 QualType Ty) const; 40 }; 41 42 class HexagonTargetCodeGenInfo : public TargetCodeGenInfo { 43 public: HexagonTargetCodeGenInfo(CodeGenTypes & CGT)44 HexagonTargetCodeGenInfo(CodeGenTypes &CGT) 45 : TargetCodeGenInfo(std::make_unique<HexagonABIInfo>(CGT)) {} 46 getDwarfEHStackPointer(CodeGen::CodeGenModule & M) const47 int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { 48 return 29; 49 } 50 setTargetAttributes(const Decl * D,llvm::GlobalValue * GV,CodeGen::CodeGenModule & GCM) const51 void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, 52 CodeGen::CodeGenModule &GCM) const override { 53 if (GV->isDeclaration()) 54 return; 55 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D); 56 if (!FD) 57 return; 58 } 59 }; 60 61 } // namespace 62 computeInfo(CGFunctionInfo & FI) const63 void HexagonABIInfo::computeInfo(CGFunctionInfo &FI) const { 64 unsigned RegsLeft = 6; 65 if (!getCXXABI().classifyReturnType(FI)) 66 FI.getReturnInfo() = classifyReturnType(FI.getReturnType()); 67 for (auto &I : FI.arguments()) 68 I.info = classifyArgumentType(I.type, &RegsLeft); 69 } 70 HexagonAdjustRegsLeft(uint64_t Size,unsigned * RegsLeft)71 static bool HexagonAdjustRegsLeft(uint64_t Size, unsigned *RegsLeft) { 72 assert(Size <= 64 && "Not expecting to pass arguments larger than 64 bits" 73 " through registers"); 74 75 if (*RegsLeft == 0) 76 return false; 77 78 if (Size <= 32) { 79 (*RegsLeft)--; 80 return true; 81 } 82 83 if (2 <= (*RegsLeft & (~1U))) { 84 *RegsLeft = (*RegsLeft & (~1U)) - 2; 85 return true; 86 } 87 88 // Next available register was r5 but candidate was greater than 32-bits so it 89 // has to go on the stack. However we still consume r5 90 if (*RegsLeft == 1) 91 *RegsLeft = 0; 92 93 return false; 94 } 95 classifyArgumentType(QualType Ty,unsigned * RegsLeft) const96 ABIArgInfo HexagonABIInfo::classifyArgumentType(QualType Ty, 97 unsigned *RegsLeft) const { 98 if (!isAggregateTypeForABI(Ty)) { 99 // Treat an enum type as its underlying type. 100 if (const EnumType *EnumTy = Ty->getAs<EnumType>()) 101 Ty = EnumTy->getDecl()->getIntegerType(); 102 103 uint64_t Size = getContext().getTypeSize(Ty); 104 if (Size <= 64) 105 HexagonAdjustRegsLeft(Size, RegsLeft); 106 107 if (Size > 64 && Ty->isBitIntType()) 108 return getNaturalAlignIndirect(Ty, /*ByVal=*/true); 109 110 return isPromotableIntegerTypeForABI(Ty) ? ABIArgInfo::getExtend(Ty) 111 : ABIArgInfo::getDirect(); 112 } 113 114 if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(Ty, getCXXABI())) 115 return getNaturalAlignIndirect(Ty, RAA == CGCXXABI::RAA_DirectInMemory); 116 117 // Ignore empty records. 118 if (isEmptyRecord(getContext(), Ty, true)) 119 return ABIArgInfo::getIgnore(); 120 121 uint64_t Size = getContext().getTypeSize(Ty); 122 unsigned Align = getContext().getTypeAlign(Ty); 123 124 if (Size > 64) 125 return getNaturalAlignIndirect(Ty, /*ByVal=*/true); 126 127 if (HexagonAdjustRegsLeft(Size, RegsLeft)) 128 Align = Size <= 32 ? 32 : 64; 129 if (Size <= Align) { 130 // Pass in the smallest viable integer type. 131 Size = llvm::bit_ceil(Size); 132 return ABIArgInfo::getDirect(llvm::Type::getIntNTy(getVMContext(), Size)); 133 } 134 return DefaultABIInfo::classifyArgumentType(Ty); 135 } 136 classifyReturnType(QualType RetTy) const137 ABIArgInfo HexagonABIInfo::classifyReturnType(QualType RetTy) const { 138 if (RetTy->isVoidType()) 139 return ABIArgInfo::getIgnore(); 140 141 const TargetInfo &T = CGT.getTarget(); 142 uint64_t Size = getContext().getTypeSize(RetTy); 143 144 if (RetTy->getAs<VectorType>()) { 145 // HVX vectors are returned in vector registers or register pairs. 146 if (T.hasFeature("hvx")) { 147 assert(T.hasFeature("hvx-length64b") || T.hasFeature("hvx-length128b")); 148 uint64_t VecSize = T.hasFeature("hvx-length64b") ? 64*8 : 128*8; 149 if (Size == VecSize || Size == 2*VecSize) 150 return ABIArgInfo::getDirectInReg(); 151 } 152 // Large vector types should be returned via memory. 153 if (Size > 64) 154 return getNaturalAlignIndirect(RetTy); 155 } 156 157 if (!isAggregateTypeForABI(RetTy)) { 158 // Treat an enum type as its underlying type. 159 if (const EnumType *EnumTy = RetTy->getAs<EnumType>()) 160 RetTy = EnumTy->getDecl()->getIntegerType(); 161 162 if (Size > 64 && RetTy->isBitIntType()) 163 return getNaturalAlignIndirect(RetTy, /*ByVal=*/false); 164 165 return isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy) 166 : ABIArgInfo::getDirect(); 167 } 168 169 if (isEmptyRecord(getContext(), RetTy, true)) 170 return ABIArgInfo::getIgnore(); 171 172 // Aggregates <= 8 bytes are returned in registers, other aggregates 173 // are returned indirectly. 174 if (Size <= 64) { 175 // Return in the smallest viable integer type. 176 Size = llvm::bit_ceil(Size); 177 return ABIArgInfo::getDirect(llvm::Type::getIntNTy(getVMContext(), Size)); 178 } 179 return getNaturalAlignIndirect(RetTy, /*ByVal=*/true); 180 } 181 EmitVAArgFromMemory(CodeGenFunction & CGF,Address VAListAddr,QualType Ty) const182 Address HexagonABIInfo::EmitVAArgFromMemory(CodeGenFunction &CGF, 183 Address VAListAddr, 184 QualType Ty) const { 185 // Load the overflow area pointer. 186 Address __overflow_area_pointer_p = 187 CGF.Builder.CreateStructGEP(VAListAddr, 2, "__overflow_area_pointer_p"); 188 llvm::Value *__overflow_area_pointer = CGF.Builder.CreateLoad( 189 __overflow_area_pointer_p, "__overflow_area_pointer"); 190 191 uint64_t Align = CGF.getContext().getTypeAlign(Ty) / 8; 192 if (Align > 4) { 193 // Alignment should be a power of 2. 194 assert((Align & (Align - 1)) == 0 && "Alignment is not power of 2!"); 195 196 // overflow_arg_area = (overflow_arg_area + align - 1) & -align; 197 llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int64Ty, Align - 1); 198 199 // Add offset to the current pointer to access the argument. 200 __overflow_area_pointer = 201 CGF.Builder.CreateGEP(CGF.Int8Ty, __overflow_area_pointer, Offset); 202 llvm::Value *AsInt = 203 CGF.Builder.CreatePtrToInt(__overflow_area_pointer, CGF.Int32Ty); 204 205 // Create a mask which should be "AND"ed 206 // with (overflow_arg_area + align - 1) 207 llvm::Value *Mask = llvm::ConstantInt::get(CGF.Int32Ty, -(int)Align); 208 __overflow_area_pointer = CGF.Builder.CreateIntToPtr( 209 CGF.Builder.CreateAnd(AsInt, Mask), __overflow_area_pointer->getType(), 210 "__overflow_area_pointer.align"); 211 } 212 213 // Get the type of the argument from memory and bitcast 214 // overflow area pointer to the argument type. 215 llvm::Type *PTy = CGF.ConvertTypeForMem(Ty); 216 Address AddrTyped = 217 Address(__overflow_area_pointer, PTy, CharUnits::fromQuantity(Align)); 218 219 // Round up to the minimum stack alignment for varargs which is 4 bytes. 220 uint64_t Offset = llvm::alignTo(CGF.getContext().getTypeSize(Ty) / 8, 4); 221 222 __overflow_area_pointer = CGF.Builder.CreateGEP( 223 CGF.Int8Ty, __overflow_area_pointer, 224 llvm::ConstantInt::get(CGF.Int32Ty, Offset), 225 "__overflow_area_pointer.next"); 226 CGF.Builder.CreateStore(__overflow_area_pointer, __overflow_area_pointer_p); 227 228 return AddrTyped; 229 } 230 EmitVAArgForHexagon(CodeGenFunction & CGF,Address VAListAddr,QualType Ty) const231 Address HexagonABIInfo::EmitVAArgForHexagon(CodeGenFunction &CGF, 232 Address VAListAddr, 233 QualType Ty) const { 234 // FIXME: Need to handle alignment 235 llvm::Type *BP = CGF.Int8PtrTy; 236 CGBuilderTy &Builder = CGF.Builder; 237 Address VAListAddrAsBPP = VAListAddr.withElementType(BP); 238 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur"); 239 // Handle address alignment for type alignment > 32 bits 240 uint64_t TyAlign = CGF.getContext().getTypeAlign(Ty) / 8; 241 if (TyAlign > 4) { 242 assert((TyAlign & (TyAlign - 1)) == 0 && "Alignment is not power of 2!"); 243 llvm::Value *AddrAsInt = Builder.CreatePtrToInt(Addr, CGF.Int32Ty); 244 AddrAsInt = Builder.CreateAdd(AddrAsInt, Builder.getInt32(TyAlign - 1)); 245 AddrAsInt = Builder.CreateAnd(AddrAsInt, Builder.getInt32(~(TyAlign - 1))); 246 Addr = Builder.CreateIntToPtr(AddrAsInt, BP); 247 } 248 Address AddrTyped = 249 Address(Addr, CGF.ConvertType(Ty), CharUnits::fromQuantity(TyAlign)); 250 251 uint64_t Offset = llvm::alignTo(CGF.getContext().getTypeSize(Ty) / 8, 4); 252 llvm::Value *NextAddr = Builder.CreateGEP( 253 CGF.Int8Ty, Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset), "ap.next"); 254 Builder.CreateStore(NextAddr, VAListAddrAsBPP); 255 256 return AddrTyped; 257 } 258 EmitVAArgForHexagonLinux(CodeGenFunction & CGF,Address VAListAddr,QualType Ty) const259 Address HexagonABIInfo::EmitVAArgForHexagonLinux(CodeGenFunction &CGF, 260 Address VAListAddr, 261 QualType Ty) const { 262 int ArgSize = CGF.getContext().getTypeSize(Ty) / 8; 263 264 if (ArgSize > 8) 265 return EmitVAArgFromMemory(CGF, VAListAddr, Ty); 266 267 // Here we have check if the argument is in register area or 268 // in overflow area. 269 // If the saved register area pointer + argsize rounded up to alignment > 270 // saved register area end pointer, argument is in overflow area. 271 unsigned RegsLeft = 6; 272 Ty = CGF.getContext().getCanonicalType(Ty); 273 (void)classifyArgumentType(Ty, &RegsLeft); 274 275 llvm::BasicBlock *MaybeRegBlock = CGF.createBasicBlock("vaarg.maybe_reg"); 276 llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg"); 277 llvm::BasicBlock *OnStackBlock = CGF.createBasicBlock("vaarg.on_stack"); 278 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end"); 279 280 // Get rounded size of the argument.GCC does not allow vararg of 281 // size < 4 bytes. We follow the same logic here. 282 ArgSize = (CGF.getContext().getTypeSize(Ty) <= 32) ? 4 : 8; 283 int ArgAlign = (CGF.getContext().getTypeSize(Ty) <= 32) ? 4 : 8; 284 285 // Argument may be in saved register area 286 CGF.EmitBlock(MaybeRegBlock); 287 288 // Load the current saved register area pointer. 289 Address __current_saved_reg_area_pointer_p = CGF.Builder.CreateStructGEP( 290 VAListAddr, 0, "__current_saved_reg_area_pointer_p"); 291 llvm::Value *__current_saved_reg_area_pointer = CGF.Builder.CreateLoad( 292 __current_saved_reg_area_pointer_p, "__current_saved_reg_area_pointer"); 293 294 // Load the saved register area end pointer. 295 Address __saved_reg_area_end_pointer_p = CGF.Builder.CreateStructGEP( 296 VAListAddr, 1, "__saved_reg_area_end_pointer_p"); 297 llvm::Value *__saved_reg_area_end_pointer = CGF.Builder.CreateLoad( 298 __saved_reg_area_end_pointer_p, "__saved_reg_area_end_pointer"); 299 300 // If the size of argument is > 4 bytes, check if the stack 301 // location is aligned to 8 bytes 302 if (ArgAlign > 4) { 303 304 llvm::Value *__current_saved_reg_area_pointer_int = 305 CGF.Builder.CreatePtrToInt(__current_saved_reg_area_pointer, 306 CGF.Int32Ty); 307 308 __current_saved_reg_area_pointer_int = CGF.Builder.CreateAdd( 309 __current_saved_reg_area_pointer_int, 310 llvm::ConstantInt::get(CGF.Int32Ty, (ArgAlign - 1)), 311 "align_current_saved_reg_area_pointer"); 312 313 __current_saved_reg_area_pointer_int = 314 CGF.Builder.CreateAnd(__current_saved_reg_area_pointer_int, 315 llvm::ConstantInt::get(CGF.Int32Ty, -ArgAlign), 316 "align_current_saved_reg_area_pointer"); 317 318 __current_saved_reg_area_pointer = 319 CGF.Builder.CreateIntToPtr(__current_saved_reg_area_pointer_int, 320 __current_saved_reg_area_pointer->getType(), 321 "align_current_saved_reg_area_pointer"); 322 } 323 324 llvm::Value *__new_saved_reg_area_pointer = 325 CGF.Builder.CreateGEP(CGF.Int8Ty, __current_saved_reg_area_pointer, 326 llvm::ConstantInt::get(CGF.Int32Ty, ArgSize), 327 "__new_saved_reg_area_pointer"); 328 329 llvm::Value *UsingStack = nullptr; 330 UsingStack = CGF.Builder.CreateICmpSGT(__new_saved_reg_area_pointer, 331 __saved_reg_area_end_pointer); 332 333 CGF.Builder.CreateCondBr(UsingStack, OnStackBlock, InRegBlock); 334 335 // Argument in saved register area 336 // Implement the block where argument is in register saved area 337 CGF.EmitBlock(InRegBlock); 338 339 llvm::Type *PTy = CGF.ConvertType(Ty); 340 llvm::Value *__saved_reg_area_p = CGF.Builder.CreateBitCast( 341 __current_saved_reg_area_pointer, llvm::PointerType::getUnqual(PTy)); 342 343 CGF.Builder.CreateStore(__new_saved_reg_area_pointer, 344 __current_saved_reg_area_pointer_p); 345 346 CGF.EmitBranch(ContBlock); 347 348 // Argument in overflow area 349 // Implement the block where the argument is in overflow area. 350 CGF.EmitBlock(OnStackBlock); 351 352 // Load the overflow area pointer 353 Address __overflow_area_pointer_p = 354 CGF.Builder.CreateStructGEP(VAListAddr, 2, "__overflow_area_pointer_p"); 355 llvm::Value *__overflow_area_pointer = CGF.Builder.CreateLoad( 356 __overflow_area_pointer_p, "__overflow_area_pointer"); 357 358 // Align the overflow area pointer according to the alignment of the argument 359 if (ArgAlign > 4) { 360 llvm::Value *__overflow_area_pointer_int = 361 CGF.Builder.CreatePtrToInt(__overflow_area_pointer, CGF.Int32Ty); 362 363 __overflow_area_pointer_int = 364 CGF.Builder.CreateAdd(__overflow_area_pointer_int, 365 llvm::ConstantInt::get(CGF.Int32Ty, ArgAlign - 1), 366 "align_overflow_area_pointer"); 367 368 __overflow_area_pointer_int = 369 CGF.Builder.CreateAnd(__overflow_area_pointer_int, 370 llvm::ConstantInt::get(CGF.Int32Ty, -ArgAlign), 371 "align_overflow_area_pointer"); 372 373 __overflow_area_pointer = CGF.Builder.CreateIntToPtr( 374 __overflow_area_pointer_int, __overflow_area_pointer->getType(), 375 "align_overflow_area_pointer"); 376 } 377 378 // Get the pointer for next argument in overflow area and store it 379 // to overflow area pointer. 380 llvm::Value *__new_overflow_area_pointer = CGF.Builder.CreateGEP( 381 CGF.Int8Ty, __overflow_area_pointer, 382 llvm::ConstantInt::get(CGF.Int32Ty, ArgSize), 383 "__overflow_area_pointer.next"); 384 385 CGF.Builder.CreateStore(__new_overflow_area_pointer, 386 __overflow_area_pointer_p); 387 388 CGF.Builder.CreateStore(__new_overflow_area_pointer, 389 __current_saved_reg_area_pointer_p); 390 391 // Bitcast the overflow area pointer to the type of argument. 392 llvm::Type *OverflowPTy = CGF.ConvertTypeForMem(Ty); 393 llvm::Value *__overflow_area_p = CGF.Builder.CreateBitCast( 394 __overflow_area_pointer, llvm::PointerType::getUnqual(OverflowPTy)); 395 396 CGF.EmitBranch(ContBlock); 397 398 // Get the correct pointer to load the variable argument 399 // Implement the ContBlock 400 CGF.EmitBlock(ContBlock); 401 402 llvm::Type *MemTy = CGF.ConvertTypeForMem(Ty); 403 llvm::Type *MemPTy = llvm::PointerType::getUnqual(MemTy); 404 llvm::PHINode *ArgAddr = CGF.Builder.CreatePHI(MemPTy, 2, "vaarg.addr"); 405 ArgAddr->addIncoming(__saved_reg_area_p, InRegBlock); 406 ArgAddr->addIncoming(__overflow_area_p, OnStackBlock); 407 408 return Address(ArgAddr, MemTy, CharUnits::fromQuantity(ArgAlign)); 409 } 410 EmitVAArg(CodeGenFunction & CGF,Address VAListAddr,QualType Ty,AggValueSlot Slot) const411 RValue HexagonABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, 412 QualType Ty, AggValueSlot Slot) const { 413 414 if (getTarget().getTriple().isMusl()) 415 return CGF.EmitLoadOfAnyValue( 416 CGF.MakeAddrLValue(EmitVAArgForHexagonLinux(CGF, VAListAddr, Ty), Ty), 417 Slot); 418 419 return CGF.EmitLoadOfAnyValue( 420 CGF.MakeAddrLValue(EmitVAArgForHexagon(CGF, VAListAddr, Ty), Ty), Slot); 421 } 422 423 std::unique_ptr<TargetCodeGenInfo> createHexagonTargetCodeGenInfo(CodeGenModule & CGM)424 CodeGen::createHexagonTargetCodeGenInfo(CodeGenModule &CGM) { 425 return std::make_unique<HexagonTargetCodeGenInfo>(CGM.getTypes()); 426 } 427