1//==-- CGFunctionInfo.h - Representation of function argument/return types -==// 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// Defines CGFunctionInfo and associated types used in representing the 10// LLVM source types and ABI-coerced types for function arguments and 11// return values. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H 16#define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H 17 18#include "clang/AST/CanonicalType.h" 19#include "clang/AST/CharUnits.h" 20#include "clang/AST/Decl.h" 21#include "clang/AST/Type.h" 22#include "llvm/IR/DerivedTypes.h" 23#include "llvm/ADT/FoldingSet.h" 24#include "llvm/Support/TrailingObjects.h" 25#include <cassert> 26 27namespace clang { 28namespace CodeGen { 29 30/// ABIArgInfo - Helper class to encapsulate information about how a 31/// specific C type should be passed to or returned from a function. 32class ABIArgInfo { 33public: 34 enum Kind : uint8_t { 35 /// Direct - Pass the argument directly using the normal converted LLVM 36 /// type, or by coercing to another specified type stored in 37 /// 'CoerceToType'). If an offset is specified (in UIntData), then the 38 /// argument passed is offset by some number of bytes in the memory 39 /// representation. A dummy argument is emitted before the real argument 40 /// if the specified type stored in "PaddingType" is not zero. 41 Direct, 42 43 /// Extend - Valid only for integer argument types. Same as 'direct' 44 /// but also emit a zero/sign extension attribute. 45 Extend, 46 47 /// Indirect - Pass the argument indirectly via a hidden pointer with the 48 /// specified alignment (0 indicates default alignment) and address space. 49 Indirect, 50 51 /// IndirectAliased - Similar to Indirect, but the pointer may be to an 52 /// object that is otherwise referenced. The object is known to not be 53 /// modified through any other references for the duration of the call, and 54 /// the callee must not itself modify the object. Because C allows 55 /// parameter variables to be modified and guarantees that they have unique 56 /// addresses, the callee must defensively copy the object into a local 57 /// variable if it might be modified or its address might be compared. 58 /// Since those are uncommon, in principle this convention allows programs 59 /// to avoid copies in more situations. However, it may introduce *extra* 60 /// copies if the callee fails to prove that a copy is unnecessary and the 61 /// caller naturally produces an unaliased object for the argument. 62 IndirectAliased, 63 64 /// Ignore - Ignore the argument (treat as void). Useful for void and 65 /// empty structs. 66 Ignore, 67 68 /// Expand - Only valid for aggregate argument types. The structure should 69 /// be expanded into consecutive arguments for its constituent fields. 70 /// Currently expand is only allowed on structures whose fields 71 /// are all scalar types or are themselves expandable types. 72 Expand, 73 74 /// CoerceAndExpand - Only valid for aggregate argument types. The 75 /// structure should be expanded into consecutive arguments corresponding 76 /// to the non-array elements of the type stored in CoerceToType. 77 /// Array elements in the type are assumed to be padding and skipped. 78 CoerceAndExpand, 79 80 /// InAlloca - Pass the argument directly using the LLVM inalloca attribute. 81 /// This is similar to indirect with byval, except it only applies to 82 /// arguments stored in memory and forbids any implicit copies. When 83 /// applied to a return type, it means the value is returned indirectly via 84 /// an implicit sret parameter stored in the argument struct. 85 InAlloca, 86 KindFirst = Direct, 87 KindLast = InAlloca 88 }; 89 90private: 91 llvm::Type *TypeData; // canHaveCoerceToType() 92 union { 93 llvm::Type *PaddingType; // canHavePaddingType() 94 llvm::Type *UnpaddedCoerceAndExpandType; // isCoerceAndExpand() 95 }; 96 struct DirectAttrInfo { 97 unsigned Offset; 98 unsigned Align; 99 }; 100 struct IndirectAttrInfo { 101 unsigned Align; 102 unsigned AddrSpace; 103 }; 104 union { 105 DirectAttrInfo DirectAttr; // isDirect() || isExtend() 106 IndirectAttrInfo IndirectAttr; // isIndirect() 107 unsigned AllocaFieldIndex; // isInAlloca() 108 }; 109 Kind TheKind; 110 bool PaddingInReg : 1; 111 bool InAllocaSRet : 1; // isInAlloca() 112 bool InAllocaIndirect : 1;// isInAlloca() 113 bool IndirectByVal : 1; // isIndirect() 114 bool IndirectRealign : 1; // isIndirect() 115 bool SRetAfterThis : 1; // isIndirect() 116 bool InReg : 1; // isDirect() || isExtend() || isIndirect() 117 bool CanBeFlattened: 1; // isDirect() 118 bool SignExt : 1; // isExtend() 119 120 bool canHavePaddingType() const { 121 return isDirect() || isExtend() || isIndirect() || isIndirectAliased() || 122 isExpand(); 123 } 124 void setPaddingType(llvm::Type *T) { 125 assert(canHavePaddingType()); 126 PaddingType = T; 127 } 128 129 void setUnpaddedCoerceToType(llvm::Type *T) { 130 assert(isCoerceAndExpand()); 131 UnpaddedCoerceAndExpandType = T; 132 } 133 134public: 135 ABIArgInfo(Kind K = Direct) 136 : TypeData(nullptr), PaddingType(nullptr), DirectAttr{0, 0}, TheKind(K), 137 PaddingInReg(false), InAllocaSRet(false), 138 InAllocaIndirect(false), IndirectByVal(false), IndirectRealign(false), 139 SRetAfterThis(false), InReg(false), CanBeFlattened(false), 140 SignExt(false) {} 141 142 static ABIArgInfo getDirect(llvm::Type *T = nullptr, unsigned Offset = 0, 143 llvm::Type *Padding = nullptr, 144 bool CanBeFlattened = true, unsigned Align = 0) { 145 auto AI = ABIArgInfo(Direct); 146 AI.setCoerceToType(T); 147 AI.setPaddingType(Padding); 148 AI.setDirectOffset(Offset); 149 AI.setDirectAlign(Align); 150 AI.setCanBeFlattened(CanBeFlattened); 151 return AI; 152 } 153 static ABIArgInfo getDirectInReg(llvm::Type *T = nullptr) { 154 auto AI = getDirect(T); 155 AI.setInReg(true); 156 return AI; 157 } 158 159 static ABIArgInfo getSignExtend(QualType Ty, llvm::Type *T = nullptr) { 160 assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType"); 161 auto AI = ABIArgInfo(Extend); 162 AI.setCoerceToType(T); 163 AI.setPaddingType(nullptr); 164 AI.setDirectOffset(0); 165 AI.setDirectAlign(0); 166 AI.setSignExt(true); 167 return AI; 168 } 169 170 static ABIArgInfo getZeroExtend(QualType Ty, llvm::Type *T = nullptr) { 171 assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType"); 172 auto AI = ABIArgInfo(Extend); 173 AI.setCoerceToType(T); 174 AI.setPaddingType(nullptr); 175 AI.setDirectOffset(0); 176 AI.setDirectAlign(0); 177 AI.setSignExt(false); 178 return AI; 179 } 180 181 // ABIArgInfo will record the argument as being extended based on the sign 182 // of its type. 183 static ABIArgInfo getExtend(QualType Ty, llvm::Type *T = nullptr) { 184 assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType"); 185 if (Ty->hasSignedIntegerRepresentation()) 186 return getSignExtend(Ty, T); 187 return getZeroExtend(Ty, T); 188 } 189 190 static ABIArgInfo getExtendInReg(QualType Ty, llvm::Type *T = nullptr) { 191 auto AI = getExtend(Ty, T); 192 AI.setInReg(true); 193 return AI; 194 } 195 static ABIArgInfo getIgnore() { 196 return ABIArgInfo(Ignore); 197 } 198 static ABIArgInfo getIndirect(CharUnits Alignment, bool ByVal = true, 199 bool Realign = false, 200 llvm::Type *Padding = nullptr) { 201 auto AI = ABIArgInfo(Indirect); 202 AI.setIndirectAlign(Alignment); 203 AI.setIndirectByVal(ByVal); 204 AI.setIndirectRealign(Realign); 205 AI.setSRetAfterThis(false); 206 AI.setPaddingType(Padding); 207 return AI; 208 } 209 210 /// Pass this in memory using the IR byref attribute. 211 static ABIArgInfo getIndirectAliased(CharUnits Alignment, unsigned AddrSpace, 212 bool Realign = false, 213 llvm::Type *Padding = nullptr) { 214 auto AI = ABIArgInfo(IndirectAliased); 215 AI.setIndirectAlign(Alignment); 216 AI.setIndirectRealign(Realign); 217 AI.setPaddingType(Padding); 218 AI.setIndirectAddrSpace(AddrSpace); 219 return AI; 220 } 221 222 static ABIArgInfo getIndirectInReg(CharUnits Alignment, bool ByVal = true, 223 bool Realign = false) { 224 auto AI = getIndirect(Alignment, ByVal, Realign); 225 AI.setInReg(true); 226 return AI; 227 } 228 static ABIArgInfo getInAlloca(unsigned FieldIndex, bool Indirect = false) { 229 auto AI = ABIArgInfo(InAlloca); 230 AI.setInAllocaFieldIndex(FieldIndex); 231 AI.setInAllocaIndirect(Indirect); 232 return AI; 233 } 234 static ABIArgInfo getExpand() { 235 auto AI = ABIArgInfo(Expand); 236 AI.setPaddingType(nullptr); 237 return AI; 238 } 239 static ABIArgInfo getExpandWithPadding(bool PaddingInReg, 240 llvm::Type *Padding) { 241 auto AI = getExpand(); 242 AI.setPaddingInReg(PaddingInReg); 243 AI.setPaddingType(Padding); 244 return AI; 245 } 246 247 /// \param unpaddedCoerceToType The coerce-to type with padding elements 248 /// removed, canonicalized to a single element if it would otherwise 249 /// have exactly one element. 250 static ABIArgInfo getCoerceAndExpand(llvm::StructType *coerceToType, 251 llvm::Type *unpaddedCoerceToType) { 252#ifndef NDEBUG 253 // Check that unpaddedCoerceToType has roughly the right shape. 254 255 // Assert that we only have a struct type if there are multiple elements. 256 auto unpaddedStruct = dyn_cast<llvm::StructType>(unpaddedCoerceToType); 257 assert(!unpaddedStruct || unpaddedStruct->getNumElements() != 1); 258 259 // Assert that all the non-padding elements have a corresponding element 260 // in the unpadded type. 261 unsigned unpaddedIndex = 0; 262 for (auto eltType : coerceToType->elements()) { 263 if (isPaddingForCoerceAndExpand(eltType)) continue; 264 if (unpaddedStruct) { 265 assert(unpaddedStruct->getElementType(unpaddedIndex) == eltType); 266 } else { 267 assert(unpaddedIndex == 0 && unpaddedCoerceToType == eltType); 268 } 269 unpaddedIndex++; 270 } 271 272 // Assert that there aren't extra elements in the unpadded type. 273 if (unpaddedStruct) { 274 assert(unpaddedStruct->getNumElements() == unpaddedIndex); 275 } else { 276 assert(unpaddedIndex == 1); 277 } 278#endif 279 280 auto AI = ABIArgInfo(CoerceAndExpand); 281 AI.setCoerceToType(coerceToType); 282 AI.setUnpaddedCoerceToType(unpaddedCoerceToType); 283 return AI; 284 } 285 286 static bool isPaddingForCoerceAndExpand(llvm::Type *eltType) { 287 if (eltType->isArrayTy()) { 288 assert(eltType->getArrayElementType()->isIntegerTy(8)); 289 return true; 290 } else { 291 return false; 292 } 293 } 294 295 Kind getKind() const { return TheKind; } 296 bool isDirect() const { return TheKind == Direct; } 297 bool isInAlloca() const { return TheKind == InAlloca; } 298 bool isExtend() const { return TheKind == Extend; } 299 bool isIgnore() const { return TheKind == Ignore; } 300 bool isIndirect() const { return TheKind == Indirect; } 301 bool isIndirectAliased() const { return TheKind == IndirectAliased; } 302 bool isExpand() const { return TheKind == Expand; } 303 bool isCoerceAndExpand() const { return TheKind == CoerceAndExpand; } 304 305 bool canHaveCoerceToType() const { 306 return isDirect() || isExtend() || isCoerceAndExpand(); 307 } 308 309 // Direct/Extend accessors 310 unsigned getDirectOffset() const { 311 assert((isDirect() || isExtend()) && "Not a direct or extend kind"); 312 return DirectAttr.Offset; 313 } 314 void setDirectOffset(unsigned Offset) { 315 assert((isDirect() || isExtend()) && "Not a direct or extend kind"); 316 DirectAttr.Offset = Offset; 317 } 318 319 unsigned getDirectAlign() const { 320 assert((isDirect() || isExtend()) && "Not a direct or extend kind"); 321 return DirectAttr.Align; 322 } 323 void setDirectAlign(unsigned Align) { 324 assert((isDirect() || isExtend()) && "Not a direct or extend kind"); 325 DirectAttr.Align = Align; 326 } 327 328 bool isSignExt() const { 329 assert(isExtend() && "Invalid kind!"); 330 return SignExt; 331 } 332 void setSignExt(bool SExt) { 333 assert(isExtend() && "Invalid kind!"); 334 SignExt = SExt; 335 } 336 337 llvm::Type *getPaddingType() const { 338 return (canHavePaddingType() ? PaddingType : nullptr); 339 } 340 341 bool getPaddingInReg() const { 342 return PaddingInReg; 343 } 344 void setPaddingInReg(bool PIR) { 345 PaddingInReg = PIR; 346 } 347 348 llvm::Type *getCoerceToType() const { 349 assert(canHaveCoerceToType() && "Invalid kind!"); 350 return TypeData; 351 } 352 353 void setCoerceToType(llvm::Type *T) { 354 assert(canHaveCoerceToType() && "Invalid kind!"); 355 TypeData = T; 356 } 357 358 llvm::StructType *getCoerceAndExpandType() const { 359 assert(isCoerceAndExpand()); 360 return cast<llvm::StructType>(TypeData); 361 } 362 363 llvm::Type *getUnpaddedCoerceAndExpandType() const { 364 assert(isCoerceAndExpand()); 365 return UnpaddedCoerceAndExpandType; 366 } 367 368 ArrayRef<llvm::Type *>getCoerceAndExpandTypeSequence() const { 369 assert(isCoerceAndExpand()); 370 if (auto structTy = 371 dyn_cast<llvm::StructType>(UnpaddedCoerceAndExpandType)) { 372 return structTy->elements(); 373 } else { 374 return llvm::ArrayRef(&UnpaddedCoerceAndExpandType, 1); 375 } 376 } 377 378 bool getInReg() const { 379 assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!"); 380 return InReg; 381 } 382 383 void setInReg(bool IR) { 384 assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!"); 385 InReg = IR; 386 } 387 388 // Indirect accessors 389 CharUnits getIndirectAlign() const { 390 assert((isIndirect() || isIndirectAliased()) && "Invalid kind!"); 391 return CharUnits::fromQuantity(IndirectAttr.Align); 392 } 393 void setIndirectAlign(CharUnits IA) { 394 assert((isIndirect() || isIndirectAliased()) && "Invalid kind!"); 395 IndirectAttr.Align = IA.getQuantity(); 396 } 397 398 bool getIndirectByVal() const { 399 assert(isIndirect() && "Invalid kind!"); 400 return IndirectByVal; 401 } 402 void setIndirectByVal(bool IBV) { 403 assert(isIndirect() && "Invalid kind!"); 404 IndirectByVal = IBV; 405 } 406 407 unsigned getIndirectAddrSpace() const { 408 assert(isIndirectAliased() && "Invalid kind!"); 409 return IndirectAttr.AddrSpace; 410 } 411 412 void setIndirectAddrSpace(unsigned AddrSpace) { 413 assert(isIndirectAliased() && "Invalid kind!"); 414 IndirectAttr.AddrSpace = AddrSpace; 415 } 416 417 bool getIndirectRealign() const { 418 assert((isIndirect() || isIndirectAliased()) && "Invalid kind!"); 419 return IndirectRealign; 420 } 421 void setIndirectRealign(bool IR) { 422 assert((isIndirect() || isIndirectAliased()) && "Invalid kind!"); 423 IndirectRealign = IR; 424 } 425 426 bool isSRetAfterThis() const { 427 assert(isIndirect() && "Invalid kind!"); 428 return SRetAfterThis; 429 } 430 void setSRetAfterThis(bool AfterThis) { 431 assert(isIndirect() && "Invalid kind!"); 432 SRetAfterThis = AfterThis; 433 } 434 435 unsigned getInAllocaFieldIndex() const { 436 assert(isInAlloca() && "Invalid kind!"); 437 return AllocaFieldIndex; 438 } 439 void setInAllocaFieldIndex(unsigned FieldIndex) { 440 assert(isInAlloca() && "Invalid kind!"); 441 AllocaFieldIndex = FieldIndex; 442 } 443 444 unsigned getInAllocaIndirect() const { 445 assert(isInAlloca() && "Invalid kind!"); 446 return InAllocaIndirect; 447 } 448 void setInAllocaIndirect(bool Indirect) { 449 assert(isInAlloca() && "Invalid kind!"); 450 InAllocaIndirect = Indirect; 451 } 452 453 /// Return true if this field of an inalloca struct should be returned 454 /// to implement a struct return calling convention. 455 bool getInAllocaSRet() const { 456 assert(isInAlloca() && "Invalid kind!"); 457 return InAllocaSRet; 458 } 459 460 void setInAllocaSRet(bool SRet) { 461 assert(isInAlloca() && "Invalid kind!"); 462 InAllocaSRet = SRet; 463 } 464 465 bool getCanBeFlattened() const { 466 assert(isDirect() && "Invalid kind!"); 467 return CanBeFlattened; 468 } 469 470 void setCanBeFlattened(bool Flatten) { 471 assert(isDirect() && "Invalid kind!"); 472 CanBeFlattened = Flatten; 473 } 474 475 void dump() const; 476}; 477 478/// A class for recording the number of arguments that a function 479/// signature requires. 480class RequiredArgs { 481 /// The number of required arguments, or ~0 if the signature does 482 /// not permit optional arguments. 483 unsigned NumRequired; 484public: 485 enum All_t { All }; 486 487 RequiredArgs(All_t _) : NumRequired(~0U) {} 488 explicit RequiredArgs(unsigned n) : NumRequired(n) { 489 assert(n != ~0U); 490 } 491 492 /// Compute the arguments required by the given formal prototype, 493 /// given that there may be some additional, non-formal arguments 494 /// in play. 495 /// 496 /// If FD is not null, this will consider pass_object_size params in FD. 497 static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, 498 unsigned additional) { 499 if (!prototype->isVariadic()) return All; 500 501 if (prototype->hasExtParameterInfos()) 502 additional += llvm::count_if( 503 prototype->getExtParameterInfos(), 504 [](const FunctionProtoType::ExtParameterInfo &ExtInfo) { 505 return ExtInfo.hasPassObjectSize(); 506 }); 507 508 return RequiredArgs(prototype->getNumParams() + additional); 509 } 510 511 static RequiredArgs forPrototypePlus(CanQual<FunctionProtoType> prototype, 512 unsigned additional) { 513 return forPrototypePlus(prototype.getTypePtr(), additional); 514 } 515 516 static RequiredArgs forPrototype(const FunctionProtoType *prototype) { 517 return forPrototypePlus(prototype, 0); 518 } 519 520 static RequiredArgs forPrototype(CanQual<FunctionProtoType> prototype) { 521 return forPrototypePlus(prototype.getTypePtr(), 0); 522 } 523 524 bool allowsOptionalArgs() const { return NumRequired != ~0U; } 525 unsigned getNumRequiredArgs() const { 526 assert(allowsOptionalArgs()); 527 return NumRequired; 528 } 529 530 /// Return true if the argument at a given index is required. 531 bool isRequiredArg(unsigned argIdx) const { 532 return argIdx == ~0U || argIdx < NumRequired; 533 } 534 535 unsigned getOpaqueData() const { return NumRequired; } 536 static RequiredArgs getFromOpaqueData(unsigned value) { 537 if (value == ~0U) return All; 538 return RequiredArgs(value); 539 } 540}; 541 542// Implementation detail of CGFunctionInfo, factored out so it can be named 543// in the TrailingObjects base class of CGFunctionInfo. 544struct CGFunctionInfoArgInfo { 545 CanQualType type; 546 ABIArgInfo info; 547}; 548 549/// CGFunctionInfo - Class to encapsulate the information about a 550/// function definition. 551class CGFunctionInfo final 552 : public llvm::FoldingSetNode, 553 private llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo, 554 FunctionProtoType::ExtParameterInfo> { 555 typedef CGFunctionInfoArgInfo ArgInfo; 556 typedef FunctionProtoType::ExtParameterInfo ExtParameterInfo; 557 558 /// The LLVM::CallingConv to use for this function (as specified by the 559 /// user). 560 unsigned CallingConvention : 8; 561 562 /// The LLVM::CallingConv to actually use for this function, which may 563 /// depend on the ABI. 564 unsigned EffectiveCallingConvention : 8; 565 566 /// The clang::CallingConv that this was originally created with. 567 unsigned ASTCallingConvention : 6; 568 569 /// Whether this is an instance method. 570 unsigned InstanceMethod : 1; 571 572 /// Whether this is a chain call. 573 unsigned ChainCall : 1; 574 575 /// Whether this function is called by forwarding arguments. 576 /// This doesn't support inalloca or varargs. 577 unsigned DelegateCall : 1; 578 579 /// Whether this function is a CMSE nonsecure call 580 unsigned CmseNSCall : 1; 581 582 /// Whether this function is noreturn. 583 unsigned NoReturn : 1; 584 585 /// Whether this function is returns-retained. 586 unsigned ReturnsRetained : 1; 587 588 /// Whether this function saved caller registers. 589 unsigned NoCallerSavedRegs : 1; 590 591 /// How many arguments to pass inreg. 592 unsigned HasRegParm : 1; 593 unsigned RegParm : 3; 594 595 /// Whether this function has nocf_check attribute. 596 unsigned NoCfCheck : 1; 597 598 /// Log 2 of the maximum vector width. 599 unsigned MaxVectorWidth : 4; 600 601 RequiredArgs Required; 602 603 /// The struct representing all arguments passed in memory. Only used when 604 /// passing non-trivial types with inalloca. Not part of the profile. 605 llvm::StructType *ArgStruct; 606 unsigned ArgStructAlign : 31; 607 unsigned HasExtParameterInfos : 1; 608 609 unsigned NumArgs; 610 611 ArgInfo *getArgsBuffer() { 612 return getTrailingObjects<ArgInfo>(); 613 } 614 const ArgInfo *getArgsBuffer() const { 615 return getTrailingObjects<ArgInfo>(); 616 } 617 618 ExtParameterInfo *getExtParameterInfosBuffer() { 619 return getTrailingObjects<ExtParameterInfo>(); 620 } 621 const ExtParameterInfo *getExtParameterInfosBuffer() const{ 622 return getTrailingObjects<ExtParameterInfo>(); 623 } 624 625 CGFunctionInfo() : Required(RequiredArgs::All) {} 626 627public: 628 static CGFunctionInfo * 629 create(unsigned llvmCC, bool instanceMethod, bool chainCall, 630 bool delegateCall, const FunctionType::ExtInfo &extInfo, 631 ArrayRef<ExtParameterInfo> paramInfos, CanQualType resultType, 632 ArrayRef<CanQualType> argTypes, RequiredArgs required); 633 void operator delete(void *p) { ::operator delete(p); } 634 635 // Friending class TrailingObjects is apparently not good enough for MSVC, 636 // so these have to be public. 637 friend class TrailingObjects; 638 size_t numTrailingObjects(OverloadToken<ArgInfo>) const { 639 return NumArgs + 1; 640 } 641 size_t numTrailingObjects(OverloadToken<ExtParameterInfo>) const { 642 return (HasExtParameterInfos ? NumArgs : 0); 643 } 644 645 typedef const ArgInfo *const_arg_iterator; 646 typedef ArgInfo *arg_iterator; 647 648 MutableArrayRef<ArgInfo> arguments() { 649 return MutableArrayRef<ArgInfo>(arg_begin(), NumArgs); 650 } 651 ArrayRef<ArgInfo> arguments() const { 652 return ArrayRef<ArgInfo>(arg_begin(), NumArgs); 653 } 654 655 const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; } 656 const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + NumArgs; } 657 arg_iterator arg_begin() { return getArgsBuffer() + 1; } 658 arg_iterator arg_end() { return getArgsBuffer() + 1 + NumArgs; } 659 660 unsigned arg_size() const { return NumArgs; } 661 662 bool isVariadic() const { return Required.allowsOptionalArgs(); } 663 RequiredArgs getRequiredArgs() const { return Required; } 664 unsigned getNumRequiredArgs() const { 665 return isVariadic() ? getRequiredArgs().getNumRequiredArgs() : arg_size(); 666 } 667 668 bool isInstanceMethod() const { return InstanceMethod; } 669 670 bool isChainCall() const { return ChainCall; } 671 672 bool isDelegateCall() const { return DelegateCall; } 673 674 bool isCmseNSCall() const { return CmseNSCall; } 675 676 bool isNoReturn() const { return NoReturn; } 677 678 /// In ARC, whether this function retains its return value. This 679 /// is not always reliable for call sites. 680 bool isReturnsRetained() const { return ReturnsRetained; } 681 682 /// Whether this function no longer saves caller registers. 683 bool isNoCallerSavedRegs() const { return NoCallerSavedRegs; } 684 685 /// Whether this function has nocf_check attribute. 686 bool isNoCfCheck() const { return NoCfCheck; } 687 688 /// getASTCallingConvention() - Return the AST-specified calling 689 /// convention. 690 CallingConv getASTCallingConvention() const { 691 return CallingConv(ASTCallingConvention); 692 } 693 694 /// getCallingConvention - Return the user specified calling 695 /// convention, which has been translated into an LLVM CC. 696 unsigned getCallingConvention() const { return CallingConvention; } 697 698 /// getEffectiveCallingConvention - Return the actual calling convention to 699 /// use, which may depend on the ABI. 700 unsigned getEffectiveCallingConvention() const { 701 return EffectiveCallingConvention; 702 } 703 void setEffectiveCallingConvention(unsigned Value) { 704 EffectiveCallingConvention = Value; 705 } 706 707 bool getHasRegParm() const { return HasRegParm; } 708 unsigned getRegParm() const { return RegParm; } 709 710 FunctionType::ExtInfo getExtInfo() const { 711 return FunctionType::ExtInfo(isNoReturn(), getHasRegParm(), getRegParm(), 712 getASTCallingConvention(), isReturnsRetained(), 713 isNoCallerSavedRegs(), isNoCfCheck(), 714 isCmseNSCall()); 715 } 716 717 CanQualType getReturnType() const { return getArgsBuffer()[0].type; } 718 719 ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; } 720 const ABIArgInfo &getReturnInfo() const { return getArgsBuffer()[0].info; } 721 722 ArrayRef<ExtParameterInfo> getExtParameterInfos() const { 723 if (!HasExtParameterInfos) return {}; 724 return llvm::ArrayRef(getExtParameterInfosBuffer(), NumArgs); 725 } 726 ExtParameterInfo getExtParameterInfo(unsigned argIndex) const { 727 assert(argIndex <= NumArgs); 728 if (!HasExtParameterInfos) return ExtParameterInfo(); 729 return getExtParameterInfos()[argIndex]; 730 } 731 732 /// Return true if this function uses inalloca arguments. 733 bool usesInAlloca() const { return ArgStruct; } 734 735 /// Get the struct type used to represent all the arguments in memory. 736 llvm::StructType *getArgStruct() const { return ArgStruct; } 737 CharUnits getArgStructAlignment() const { 738 return CharUnits::fromQuantity(ArgStructAlign); 739 } 740 void setArgStruct(llvm::StructType *Ty, CharUnits Align) { 741 ArgStruct = Ty; 742 ArgStructAlign = Align.getQuantity(); 743 } 744 745 /// Return the maximum vector width in the arguments. 746 unsigned getMaxVectorWidth() const { 747 return MaxVectorWidth ? 1U << (MaxVectorWidth - 1) : 0; 748 } 749 750 /// Set the maximum vector width in the arguments. 751 void setMaxVectorWidth(unsigned Width) { 752 assert(llvm::isPowerOf2_32(Width) && "Expected power of 2 vector"); 753 MaxVectorWidth = llvm::countr_zero(Width) + 1; 754 } 755 756 void Profile(llvm::FoldingSetNodeID &ID) { 757 ID.AddInteger(getASTCallingConvention()); 758 ID.AddBoolean(InstanceMethod); 759 ID.AddBoolean(ChainCall); 760 ID.AddBoolean(DelegateCall); 761 ID.AddBoolean(NoReturn); 762 ID.AddBoolean(ReturnsRetained); 763 ID.AddBoolean(NoCallerSavedRegs); 764 ID.AddBoolean(HasRegParm); 765 ID.AddInteger(RegParm); 766 ID.AddBoolean(NoCfCheck); 767 ID.AddBoolean(CmseNSCall); 768 ID.AddInteger(Required.getOpaqueData()); 769 ID.AddBoolean(HasExtParameterInfos); 770 if (HasExtParameterInfos) { 771 for (auto paramInfo : getExtParameterInfos()) 772 ID.AddInteger(paramInfo.getOpaqueValue()); 773 } 774 getReturnType().Profile(ID); 775 for (const auto &I : arguments()) 776 I.type.Profile(ID); 777 } 778 static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod, 779 bool ChainCall, bool IsDelegateCall, 780 const FunctionType::ExtInfo &info, 781 ArrayRef<ExtParameterInfo> paramInfos, 782 RequiredArgs required, CanQualType resultType, 783 ArrayRef<CanQualType> argTypes) { 784 ID.AddInteger(info.getCC()); 785 ID.AddBoolean(InstanceMethod); 786 ID.AddBoolean(ChainCall); 787 ID.AddBoolean(IsDelegateCall); 788 ID.AddBoolean(info.getNoReturn()); 789 ID.AddBoolean(info.getProducesResult()); 790 ID.AddBoolean(info.getNoCallerSavedRegs()); 791 ID.AddBoolean(info.getHasRegParm()); 792 ID.AddInteger(info.getRegParm()); 793 ID.AddBoolean(info.getNoCfCheck()); 794 ID.AddBoolean(info.getCmseNSCall()); 795 ID.AddInteger(required.getOpaqueData()); 796 ID.AddBoolean(!paramInfos.empty()); 797 if (!paramInfos.empty()) { 798 for (auto paramInfo : paramInfos) 799 ID.AddInteger(paramInfo.getOpaqueValue()); 800 } 801 resultType.Profile(ID); 802 for (ArrayRef<CanQualType>::iterator 803 i = argTypes.begin(), e = argTypes.end(); i != e; ++i) { 804 i->Profile(ID); 805 } 806 } 807}; 808 809} // end namespace CodeGen 810} // end namespace clang 811 812#endif 813