CGFunctionInfo.h Source File (original) (raw)

15#ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H

16#define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H

22#include "llvm/IR/DerivedTypes.h"

23#include "llvm/ADT/FoldingSet.h"

24#include "llvm/Support/TrailingObjects.h"

25#include

33public:

93 };

95private:

96 llvm::Type *TypeData;

97 union {

100 };

101 struct DirectAttrInfo {

102 unsigned Offset;

103 unsigned Align;

104 };

105 struct IndirectAttrInfo {

106 unsigned Align;

107 unsigned AddrSpace;

108 };

109 union {

110 DirectAttrInfo DirectAttr;

113 };

114 Kind TheKind;

115 bool PaddingInReg : 1;

116 bool InAllocaSRet : 1;

117 bool InAllocaIndirect : 1;

118 bool IndirectByVal : 1;

119 bool IndirectRealign : 1;

120 bool SRetAfterThis : 1;

121 bool InReg : 1;

122 bool CanBeFlattened: 1;

123 bool SignExt : 1;

124 bool ZeroExt : 1;

125

126 bool canHavePaddingType() const {

129 }

130 void setPaddingType(llvm::Type *T) {

131 assert(canHavePaddingType());

133 }

134

135 void setUnpaddedCoerceToType(llvm::Type *T) {

138 }

139

140public:

147

149 llvm::Type *Padding = nullptr,

150 bool CanBeFlattened = true, unsigned Align = 0) {

152 AI.setCoerceToType(T);

153 AI.setPaddingType(Padding);

154 AI.setDirectOffset(Offset);

155 AI.setDirectAlign(Align);

156 AI.setCanBeFlattened(CanBeFlattened);

157 return AI;

158 }

161 AI.setInReg(true);

162 return AI;

163 }

164

168 AI.setCoerceToType(T);

169 AI.setPaddingType(nullptr);

170 AI.setDirectOffset(0);

171 AI.setDirectAlign(0);

172 AI.setSignExt(true);

173 return AI;

174 }

175

179 AI.setCoerceToType(T);

180 AI.setPaddingType(nullptr);

181 AI.setDirectOffset(0);

182 AI.setDirectAlign(0);

183 AI.setZeroExt(true);

184 return AI;

185 }

186

187

188

195

196

199 AI.setCoerceToType(T);

200 AI.setPaddingType(nullptr);

201 AI.setDirectOffset(0);

202 AI.setDirectAlign(0);

203 return AI;

204 }

205

208 AI.setInReg(true);

209 return AI;

210 }

215 bool ByVal = true, bool Realign = false,

216 llvm::Type *Padding = nullptr) {

218 AI.setIndirectAlign(Alignment);

219 AI.setIndirectByVal(ByVal);

220 AI.setIndirectRealign(Realign);

221 AI.setSRetAfterThis(false);

222 AI.setPaddingType(Padding);

223 AI.setIndirectAddrSpace(AddrSpace);

224 return AI;

225 }

226

227

229 bool Realign = false,

230 llvm::Type *Padding = nullptr) {

232 AI.setIndirectAlign(Alignment);

233 AI.setIndirectRealign(Realign);

234 AI.setPaddingType(Padding);

235 AI.setIndirectAddrSpace(AddrSpace);

236 return AI;

237 }

238

240 bool Realign = false) {

241 auto AI = getIndirect(Alignment, 0, ByVal, Realign);

242 AI.setInReg(true);

243 return AI;

244 }

247 AI.setInAllocaFieldIndex(FieldIndex);

248 AI.setInAllocaIndirect(Indirect);

249 return AI;

250 }

253 AI.setPaddingType(nullptr);

254 return AI;

255 }

257 llvm::Type *Padding) {

259 AI.setPaddingInReg(PaddingInReg);

260 AI.setPaddingType(Padding);

261 return AI;

262 }

263

264

265

266

268 llvm::Type *unpaddedCoerceToType) {

269#ifndef NDEBUG

270

271

272

273 auto unpaddedStruct = dyn_castllvm::StructType(unpaddedCoerceToType);

274 assert(!unpaddedStruct || unpaddedStruct->getNumElements() != 1);

275

276

277

278 unsigned unpaddedIndex = 0;

279 for (auto eltType : coerceToType->elements()) {

281 continue;

282 unpaddedIndex++;

283 }

284

285

286 if (unpaddedStruct) {

287 assert(unpaddedStruct->getNumElements() == unpaddedIndex);

288 } else {

289 assert(unpaddedIndex == 1);

290 }

291#endif

292

294 AI.setCoerceToType(coerceToType);

295 AI.setUnpaddedCoerceToType(unpaddedCoerceToType);

296 return AI;

297 }

298

300 unsigned Offset = 0,

301 llvm::Type *Padding = nullptr,

302 bool CanBeFlattened = true,

303 unsigned Align = 0) {

305 AI.setCoerceToType(T);

306 AI.setPaddingType(Padding);

307 AI.setDirectOffset(Offset);

308 AI.setDirectAlign(Align);

309 AI.setCanBeFlattened(CanBeFlattened);

310 return AI;

311 }

312

314 return eltType->isArrayTy() &&

315 eltType->getArrayElementType()->isIntegerTy(8);

316 }

317

328

333

334

337 "Not a direct or extend or target specific kind");

339 }

342 "Not a direct or extend or target specific kind");

344 }

345

348 "Not a direct or extend or target specific kind");

350 }

353 "Not a direct or extend or target specific kind");

355 }

356

358 assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");

359 return SignExt;

360 }

362 assert(isExtend() && "Invalid kind!");

363 SignExt = SExt;

364 }

365

367 assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");

368 return ZeroExt;

369 }

371 assert(isExtend() && "Invalid kind!");

372 ZeroExt = ZExt;

373 }

374

376 assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");

377 return !SignExt && !ZeroExt;

378 }

379

381 return (canHavePaddingType() ? PaddingType : nullptr);

382 }

383

385 return PaddingInReg;

386 }

388 PaddingInReg = PIR;

389 }

390

393 return TypeData;

394 }

395

400

405

410

413 if (auto structTy =

415 return structTy->elements();

416 } else {

418 }

419 }

420

423 "Invalid kind!");

424 return InReg;

425 }

426

429 "Invalid kind!");

430 InReg = IR;

431 }

432

433

442

444 assert(isIndirect() && "Invalid kind!");

445 return IndirectByVal;

446 }

448 assert(isIndirect() && "Invalid kind!");

449 IndirectByVal = IBV;

450 }

451

456

461

464 return IndirectRealign;

465 }

468 IndirectRealign = IR;

469 }

470

472 assert(isIndirect() && "Invalid kind!");

473 return SRetAfterThis;

474 }

476 assert(isIndirect() && "Invalid kind!");

477 SRetAfterThis = AfterThis;

478 }

479

481 assert(isInAlloca() && "Invalid kind!");

483 }

485 assert(isInAlloca() && "Invalid kind!");

487 }

488

490 assert(isInAlloca() && "Invalid kind!");

491 return InAllocaIndirect;

492 }

494 assert(isInAlloca() && "Invalid kind!");

496 }

497

498

499

501 assert(isInAlloca() && "Invalid kind!");

502 return InAllocaSRet;

503 }

504

506 assert(isInAlloca() && "Invalid kind!");

507 InAllocaSRet = SRet;

508 }

509

512 return CanBeFlattened;

513 }

514

517 CanBeFlattened = Flatten;

518 }

519

520 void dump() const;

521};

522

523

524

526

527

528 unsigned NumRequired;

529public:

531

534 assert(n != ~0U);

535 }

536

537

538

539

540

541

543 unsigned additional) {

545

547 additional += llvm::count_if(

550 return ExtInfo.hasPassObjectSize();

551 });

552

554 }

555

557 unsigned additional) {

559 }

560

564

568

572 return NumRequired;

573 }

574

575

577 return argIdx == ~0U || argIdx < NumRequired;

578 }

579

582 if (value == ~0U) return All;

584 }

585};

586

587

588

593

594

595

596class CGFunctionInfo final

597 : public llvm::FoldingSetNode,

598 private llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo,

599 FunctionProtoType::ExtParameterInfo> {

602

603

604

605 unsigned CallingConvention : 8;

606

607

608

609 unsigned EffectiveCallingConvention : 8;

610

611

613 unsigned ASTCallingConvention : 6;

614

615

616 LLVM_PREFERRED_TYPE(bool)

617 unsigned InstanceMethod : 1;

618

619

620 LLVM_PREFERRED_TYPE(bool)

621 unsigned ChainCall : 1;

622

623

624

625 LLVM_PREFERRED_TYPE(bool)

626 unsigned DelegateCall : 1;

627

628

629 LLVM_PREFERRED_TYPE(bool)

630 unsigned CmseNSCall : 1;

631

632

633 LLVM_PREFERRED_TYPE(bool)

634 unsigned NoReturn : 1;

635

636

637 LLVM_PREFERRED_TYPE(bool)

638 unsigned ReturnsRetained : 1;

639

640

641 LLVM_PREFERRED_TYPE(bool)

642 unsigned NoCallerSavedRegs : 1;

643

644

645 LLVM_PREFERRED_TYPE(bool)

646 unsigned HasRegParm : 1;

647 unsigned RegParm : 3;

648

649

650 LLVM_PREFERRED_TYPE(bool)

651 unsigned NoCfCheck : 1;

652

653

654 unsigned MaxVectorWidth : 4;

655

657

658

659

660 llvm::StructType *ArgStruct;

661 unsigned ArgStructAlign : 31;

662 LLVM_PREFERRED_TYPE(bool)

663 unsigned HasExtParameterInfos : 1;

664

665 unsigned NumArgs;

666

667 ArgInfo *getArgsBuffer() {

668 return getTrailingObjects();

669 }

670 const ArgInfo *getArgsBuffer() const {

671 return getTrailingObjects();

672 }

673

674 ExtParameterInfo *getExtParameterInfosBuffer() {

675 return getTrailingObjects();

676 }

677 const ExtParameterInfo *getExtParameterInfosBuffer() const{

678 return getTrailingObjects();

679 }

680

682

683public:

684 static CGFunctionInfo *

685 create(unsigned llvmCC, bool instanceMethod, bool chainCall,

689 void operator delete(void *p) { ::operator delete(p); }

690

691

692

695 return NumArgs + 1;

696 }

698 return (HasExtParameterInfos ? NumArgs : 0);

699 }

700

703

710

715

716 unsigned arg_size() const { return NumArgs; }

717

718 bool isVariadic() const { return Required.allowsOptionalArgs(); }

723

725

727

729

731

733

734

735

737

738

740

741

743

744

745

749

750

751

753

754

755

757 return EffectiveCallingConvention;

758 }

760 EffectiveCallingConvention = Value;

761 }

762

765

772

774

777

779 if (!HasExtParameterInfos) return {};

780 return llvm::ArrayRef(getExtParameterInfosBuffer(), NumArgs);

781 }

783 assert(argIndex <= NumArgs);

784 if (!HasExtParameterInfos) return ExtParameterInfo();

786 }

787

788

790

791

792 llvm::StructType *getArgStruct() const { return ArgStruct; }

797 ArgStruct = Ty;

799 }

800

801

803 return MaxVectorWidth ? 1U << (MaxVectorWidth - 1) : 0;

804 }

805

806

808 assert(llvm::isPowerOf2_32(Width) && "Expected power of 2 vector");

809 MaxVectorWidth = llvm::countr_zero(Width) + 1;

810 }

811

812 void Profile(llvm::FoldingSetNodeID &ID) {

814 ID.AddBoolean(InstanceMethod);

815 ID.AddBoolean(ChainCall);

816 ID.AddBoolean(DelegateCall);

817 ID.AddBoolean(NoReturn);

818 ID.AddBoolean(ReturnsRetained);

819 ID.AddBoolean(NoCallerSavedRegs);

820 ID.AddBoolean(HasRegParm);

821 ID.AddInteger(RegParm);

822 ID.AddBoolean(NoCfCheck);

823 ID.AddBoolean(CmseNSCall);

824 ID.AddInteger(Required.getOpaqueData());

825 ID.AddBoolean(HasExtParameterInfos);

826 if (HasExtParameterInfos) {

828 ID.AddInteger(paramInfo.getOpaqueValue());

829 }

831 for (const auto &I : arguments())

832 I.type.Profile(ID);

833 }

834 static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod,

840 ID.AddInteger(info.getCC());

841 ID.AddBoolean(InstanceMethod);

842 ID.AddBoolean(ChainCall);

852 ID.AddBoolean(!paramInfos.empty());

853 if (!paramInfos.empty()) {

854 for (auto paramInfo : paramInfos)

855 ID.AddInteger(paramInfo.getOpaqueValue());

856 }

858 for (const CanQualType &argType : argTypes)

859 argType.Profile(ID);

860 }

861};

862

863}

864}

865

866#endif

C Language Family Type Representation.

Represents a canonical, potentially-qualified type.

void Profile(llvm::FoldingSetNodeID &ID) const

const T * getTypePtr() const

Retrieve the underlying type pointer, which refers to a canonical type.

CharUnits - This is an opaque type for sizes expressed in character units.

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

static CharUnits fromQuantity(QuantityType Quantity)

fromQuantity - Construct a CharUnits quantity from a raw integer type.

ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...

Definition CGFunctionInfo.h:32

bool isIndirect() const

Definition CGFunctionInfo.h:323

void setZeroExt(bool ZExt)

Definition CGFunctionInfo.h:370

unsigned getInAllocaFieldIndex() const

Definition CGFunctionInfo.h:480

void setIndirectAddrSpace(unsigned AddrSpace)

Definition CGFunctionInfo.h:457

bool isExpand() const

Definition CGFunctionInfo.h:325

static ABIArgInfo getNoExtend(llvm::IntegerType *T)

Definition CGFunctionInfo.h:197

bool getIndirectByVal() const

Definition CGFunctionInfo.h:443

llvm::StructType * getCoerceAndExpandType() const

Definition CGFunctionInfo.h:401

bool getIndirectRealign() const

Definition CGFunctionInfo.h:462

static ABIArgInfo getInAlloca(unsigned FieldIndex, bool Indirect=false)

Definition CGFunctionInfo.h:245

static ABIArgInfo getIgnore()

Definition CGFunctionInfo.h:211

static ABIArgInfo getExpand()

Definition CGFunctionInfo.h:251

Kind getKind() const

Definition CGFunctionInfo.h:318

void setCoerceToType(llvm::Type *T)

Definition CGFunctionInfo.h:396

llvm::Type * getUnpaddedCoerceAndExpandType() const

Definition CGFunctionInfo.h:406

bool isNoExt() const

Definition CGFunctionInfo.h:375

bool getCanBeFlattened() const

Definition CGFunctionInfo.h:510

unsigned getDirectOffset() const

Definition CGFunctionInfo.h:335

static bool isPaddingForCoerceAndExpand(llvm::Type *eltType)

Definition CGFunctionInfo.h:313

void setDirectOffset(unsigned Offset)

Definition CGFunctionInfo.h:340

static ABIArgInfo getTargetSpecific(llvm::Type *T=nullptr, unsigned Offset=0, llvm::Type *Padding=nullptr, bool CanBeFlattened=true, unsigned Align=0)

Definition CGFunctionInfo.h:299

void setPaddingInReg(bool PIR)

Definition CGFunctionInfo.h:387

bool getInAllocaSRet() const

Return true if this field of an inalloca struct should be returned to implement a struct return calli...

Definition CGFunctionInfo.h:500

void setIndirectAlign(CharUnits IA)

Definition CGFunctionInfo.h:438

llvm::Type * getPaddingType() const

Definition CGFunctionInfo.h:380

void setIndirectByVal(bool IBV)

Definition CGFunctionInfo.h:447

static ABIArgInfo getExtendInReg(QualType Ty, llvm::Type *T=nullptr)

Definition CGFunctionInfo.h:206

bool getPaddingInReg() const

Definition CGFunctionInfo.h:384

static ABIArgInfo getExpandWithPadding(bool PaddingInReg, llvm::Type *Padding)

Definition CGFunctionInfo.h:256

unsigned getDirectAlign() const

Definition CGFunctionInfo.h:346

unsigned getIndirectAddrSpace() const

Definition CGFunctionInfo.h:452

ABIArgInfo(Kind K=Direct)

Definition CGFunctionInfo.h:141

bool isDirect() const

Definition CGFunctionInfo.h:319

static ABIArgInfo getIndirectInReg(CharUnits Alignment, bool ByVal=true, bool Realign=false)

Definition CGFunctionInfo.h:239

void setIndirectRealign(bool IR)

Definition CGFunctionInfo.h:466

static ABIArgInfo getDirect(llvm::Type *T=nullptr, unsigned Offset=0, llvm::Type *Padding=nullptr, bool CanBeFlattened=true, unsigned Align=0)

Definition CGFunctionInfo.h:148

void setInReg(bool IR)

Definition CGFunctionInfo.h:427

Kind

Definition CGFunctionInfo.h:34

@ Extend

Extend - Valid only for integer argument types.

Definition CGFunctionInfo.h:45

@ Ignore

Ignore - Ignore the argument (treat as void).

Definition CGFunctionInfo.h:66

@ IndirectAliased

IndirectAliased - Similar to Indirect, but the pointer may be to an object that is otherwise referenc...

Definition CGFunctionInfo.h:62

@ KindFirst

Definition CGFunctionInfo.h:91

@ Expand

Expand - Only valid for aggregate argument types.

Definition CGFunctionInfo.h:72

@ TargetSpecific

TargetSpecific - Some argument types are passed as target specific types such as RISC-V's tuple type,...

Definition CGFunctionInfo.h:83

@ InAlloca

InAlloca - Pass the argument directly using the LLVM inalloca attribute.

Definition CGFunctionInfo.h:90

@ Indirect

Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...

Definition CGFunctionInfo.h:49

@ CoerceAndExpand

CoerceAndExpand - Only valid for aggregate argument types.

Definition CGFunctionInfo.h:78

@ KindLast

Definition CGFunctionInfo.h:92

@ Direct

Direct - Pass the argument directly using the normal converted LLVM type, or by coercing to another s...

Definition CGFunctionInfo.h:41

static ABIArgInfo getIndirect(CharUnits Alignment, unsigned AddrSpace, bool ByVal=true, bool Realign=false, llvm::Type *Padding=nullptr)

Definition CGFunctionInfo.h:214

ArrayRef< llvm::Type * > getCoerceAndExpandTypeSequence() const

Definition CGFunctionInfo.h:411

static ABIArgInfo getIndirectAliased(CharUnits Alignment, unsigned AddrSpace, bool Realign=false, llvm::Type *Padding=nullptr)

Pass this in memory using the IR byref attribute.

Definition CGFunctionInfo.h:228

void setSRetAfterThis(bool AfterThis)

Definition CGFunctionInfo.h:475

llvm::Type * PaddingType

Definition CGFunctionInfo.h:98

bool isTargetSpecific() const

Definition CGFunctionInfo.h:327

void setInAllocaIndirect(bool Indirect)

Definition CGFunctionInfo.h:493

void setInAllocaSRet(bool SRet)

Definition CGFunctionInfo.h:505

bool isCoerceAndExpand() const

Definition CGFunctionInfo.h:326

static ABIArgInfo getZeroExtend(QualType Ty, llvm::Type *T=nullptr)

Definition CGFunctionInfo.h:176

static ABIArgInfo getExtend(QualType Ty, llvm::Type *T=nullptr)

Definition CGFunctionInfo.h:189

DirectAttrInfo DirectAttr

Definition CGFunctionInfo.h:110

static ABIArgInfo getCoerceAndExpand(llvm::StructType *coerceToType, llvm::Type *unpaddedCoerceToType)

Definition CGFunctionInfo.h:267

unsigned AllocaFieldIndex

Definition CGFunctionInfo.h:112

unsigned getInAllocaIndirect() const

Definition CGFunctionInfo.h:489

bool isExtend() const

Definition CGFunctionInfo.h:321

llvm::Type * getCoerceToType() const

Definition CGFunctionInfo.h:391

bool isIndirectAliased() const

Definition CGFunctionInfo.h:324

void setInAllocaFieldIndex(unsigned FieldIndex)

Definition CGFunctionInfo.h:484

bool isSRetAfterThis() const

Definition CGFunctionInfo.h:471

IndirectAttrInfo IndirectAttr

Definition CGFunctionInfo.h:111

bool isInAlloca() const

Definition CGFunctionInfo.h:320

bool canHaveCoerceToType() const

Definition CGFunctionInfo.h:329

llvm::Type * UnpaddedCoerceAndExpandType

Definition CGFunctionInfo.h:99

void setSignExt(bool SExt)

Definition CGFunctionInfo.h:361

bool isZeroExt() const

Definition CGFunctionInfo.h:366

void setCanBeFlattened(bool Flatten)

Definition CGFunctionInfo.h:515

void setDirectAlign(unsigned Align)

Definition CGFunctionInfo.h:351

static ABIArgInfo getSignExtend(QualType Ty, llvm::Type *T=nullptr)

Definition CGFunctionInfo.h:165

bool getInReg() const

Definition CGFunctionInfo.h:421

CharUnits getIndirectAlign() const

Definition CGFunctionInfo.h:434

bool isSignExt() const

Definition CGFunctionInfo.h:357

static ABIArgInfo getDirectInReg(llvm::Type *T=nullptr)

Definition CGFunctionInfo.h:159

bool isIgnore() const

Definition CGFunctionInfo.h:322

bool usesInAlloca() const

Return true if this function uses inalloca arguments.

Definition CGFunctionInfo.h:789

FunctionType::ExtInfo getExtInfo() const

Definition CGFunctionInfo.h:766

bool isInstanceMethod() const

Definition CGFunctionInfo.h:724

bool isChainCall() const

Definition CGFunctionInfo.h:726

ABIArgInfo & getReturnInfo()

Definition CGFunctionInfo.h:775

bool isReturnsRetained() const

In ARC, whether this function retains its return value.

Definition CGFunctionInfo.h:736

unsigned getCallingConvention() const

getCallingConvention - Return the user specified calling convention, which has been translated into a...

Definition CGFunctionInfo.h:752

void Profile(llvm::FoldingSetNodeID &ID)

Definition CGFunctionInfo.h:812

const_arg_iterator arg_begin() const

Definition CGFunctionInfo.h:711

bool isNoCallerSavedRegs() const

Whether this function no longer saves caller registers.

Definition CGFunctionInfo.h:739

bool isNoReturn() const

Definition CGFunctionInfo.h:732

unsigned getRegParm() const

Definition CGFunctionInfo.h:764

ArrayRef< ExtParameterInfo > getExtParameterInfos() const

Definition CGFunctionInfo.h:778

CanQualType getReturnType() const

Definition CGFunctionInfo.h:773

bool isNoCfCheck() const

Whether this function has nocf_check attribute.

Definition CGFunctionInfo.h:742

CallingConv getASTCallingConvention() const

getASTCallingConvention() - Return the AST-specified calling convention.

Definition CGFunctionInfo.h:746

const ABIArgInfo & getReturnInfo() const

Definition CGFunctionInfo.h:776

bool getHasRegParm() const

Definition CGFunctionInfo.h:763

ArrayRef< ArgInfo > arguments() const

Definition CGFunctionInfo.h:707

const ArgInfo * const_arg_iterator

Definition CGFunctionInfo.h:701

static CGFunctionInfo * create(unsigned llvmCC, bool instanceMethod, bool chainCall, bool delegateCall, const FunctionType::ExtInfo &extInfo, ArrayRef< ExtParameterInfo > paramInfos, CanQualType resultType, ArrayRef< CanQualType > argTypes, RequiredArgs required)

static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod, bool ChainCall, bool IsDelegateCall, const FunctionType::ExtInfo &info, ArrayRef< ExtParameterInfo > paramInfos, RequiredArgs required, CanQualType resultType, ArrayRef< CanQualType > argTypes)

Definition CGFunctionInfo.h:834

friend class TrailingObjects

Definition CGFunctionInfo.h:693

bool isCmseNSCall() const

Definition CGFunctionInfo.h:730

bool isDelegateCall() const

Definition CGFunctionInfo.h:728

MutableArrayRef< ArgInfo > arguments()

Definition CGFunctionInfo.h:704

const_arg_iterator arg_end() const

Definition CGFunctionInfo.h:712

unsigned getEffectiveCallingConvention() const

getEffectiveCallingConvention - Return the actual calling convention to use, which may depend on the ...

Definition CGFunctionInfo.h:756

bool isVariadic() const

Definition CGFunctionInfo.h:718

void setArgStruct(llvm::StructType *Ty, CharUnits Align)

Definition CGFunctionInfo.h:796

size_t numTrailingObjects(OverloadToken< ArgInfo >) const

Definition CGFunctionInfo.h:694

ExtParameterInfo getExtParameterInfo(unsigned argIndex) const

Definition CGFunctionInfo.h:782

unsigned getMaxVectorWidth() const

Return the maximum vector width in the arguments.

Definition CGFunctionInfo.h:802

arg_iterator arg_begin()

Definition CGFunctionInfo.h:713

CharUnits getArgStructAlignment() const

Definition CGFunctionInfo.h:793

size_t numTrailingObjects(OverloadToken< ExtParameterInfo >) const

Definition CGFunctionInfo.h:697

unsigned arg_size() const

Definition CGFunctionInfo.h:716

RequiredArgs getRequiredArgs() const

Definition CGFunctionInfo.h:719

arg_iterator arg_end()

Definition CGFunctionInfo.h:714

ArgInfo * arg_iterator

Definition CGFunctionInfo.h:702

void setEffectiveCallingConvention(unsigned Value)

Definition CGFunctionInfo.h:759

unsigned getNumRequiredArgs() const

Definition CGFunctionInfo.h:720

llvm::StructType * getArgStruct() const

Get the struct type used to represent all the arguments in memory.

Definition CGFunctionInfo.h:792

void setMaxVectorWidth(unsigned Width)

Set the maximum vector width in the arguments.

Definition CGFunctionInfo.h:807

A class for recording the number of arguments that a function signature requires.

Definition CGFunctionInfo.h:525

static RequiredArgs forPrototypePlus(CanQual< FunctionProtoType > prototype, unsigned additional)

Definition CGFunctionInfo.h:556

bool allowsOptionalArgs() const

Definition CGFunctionInfo.h:569

unsigned getNumRequiredArgs() const

Definition CGFunctionInfo.h:570

static RequiredArgs forPrototype(CanQual< FunctionProtoType > prototype)

Definition CGFunctionInfo.h:565

RequiredArgs(unsigned n)

Definition CGFunctionInfo.h:533

static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)

Compute the arguments required by the given formal prototype, given that there may be some additional...

Definition CGFunctionInfo.h:542

All_t

Definition CGFunctionInfo.h:530

@ All

Definition CGFunctionInfo.h:530

static RequiredArgs getFromOpaqueData(unsigned value)

Definition CGFunctionInfo.h:581

RequiredArgs(All_t _)

Definition CGFunctionInfo.h:532

bool isRequiredArg(unsigned argIdx) const

Return true if the argument at a given index is required.

Definition CGFunctionInfo.h:576

static RequiredArgs forPrototype(const FunctionProtoType *prototype)

Definition CGFunctionInfo.h:561

unsigned getOpaqueData() const

Definition CGFunctionInfo.h:580

Represents a prototype with parameter type info, e.g.

unsigned getNumParams() const

bool isVariadic() const

Whether this function prototype is variadic.

ArrayRef< ExtParameterInfo > getExtParameterInfos() const

bool hasExtParameterInfos() const

Is there any interesting extra information for any of the parameters of this function type?

A class which abstracts out some details necessary for making a call.

CallingConv getCC() const

bool getCmseNSCall() const

bool getNoCfCheck() const

unsigned getRegParm() const

bool getNoCallerSavedRegs() const

bool getHasRegParm() const

bool getProducesResult() const

Interesting information about a specific parameter that can't simply be reflected in parameter's type...

A (possibly-)qualified type.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool hasSignedIntegerRepresentation() const

Determine whether this type has an signed integer representation of some sort, e.g....

Definition CGFunctionInfo.h:28

The JSON file list parser is used to communicate input to InstallAPI.

CanQual< Type > CanQualType

Represents a canonical, potentially-qualified type.

nullptr

This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...

const FunctionProtoType * T

CallingConv

CallingConv - Specifies the calling convention that a function uses.

U cast(CodeGen::Address addr)

Definition CGFunctionInfo.h:589

CanQualType type

Definition CGFunctionInfo.h:590

ABIArgInfo info

Definition CGFunctionInfo.h:591