TypePromotion.cpp Source File (original) (raw)

42#define DEBUG_TYPE "type-promotion"

43#define PASS_NAME "Type Promotion"

45using namespace llvm;

49 cl::desc("Disable type promotion pass"));

100

101

102

103namespace {

104class IRPromoter {

106 unsigned PromotedWidth = 0;

116

117 void ReplaceAllUsersOfWith(Value *From, Value *To);

118 void ExtendSources();

119 void ConvertTruncs();

120 void PromoteTree();

121 void TruncateSinks();

123

124public:

129 : Ctx(C), PromotedWidth(Width), Visited(visited), Sources(sources),

130 Sinks(sinks), SafeWrap(wrap), InstsToRemove(instsToRemove) {

132 }

133

134 void Mutate();

135};

136

137class TypePromotionImpl {

138 unsigned TypeSize = 0;

139 const TargetLowering *TLI = nullptr;

140 LLVMContext *Ctx = nullptr;

141 unsigned RegisterBitWidth = 0;

142 SmallPtrSet<Value *, 16> AllVisited;

143 SmallPtrSet<Instruction *, 8> SafeToPromote;

144 SmallPtrSet<Instruction *, 4> SafeWrap;

145 SmallPtrSet<Instruction *, 4> InstsToRemove;

146

147

148 bool EqualTypeSize(Value *V);

149

150 bool LessOrEqualTypeSize(Value *V);

151

152 bool GreaterThanTypeSize(Value *V);

153

154 bool LessThanTypeSize(Value *V);

155

156 bool isSource(Value *V);

157

158 bool isSink(Value *V);

159

160

161 bool shouldPromote(Value *V);

162

163

164 bool isSafeWrap(Instruction *I);

165

167

168

169 bool isSupportedValue(Value *V);

170

171

173 bool TryToPromote(Value *V, unsigned PromotedWidth, const LoopInfo &LI);

174

175public:

176 bool run(Function &F, const TargetMachine *TM,

177 const TargetTransformInfo &TTI, const LoopInfo &LI);

178};

179

180class TypePromotionLegacy : public FunctionPass {

181public:

182 static char ID;

183

184 TypePromotionLegacy() : FunctionPass(ID) {}

185

186 void getAnalysisUsage(AnalysisUsage &AU) const override {

188 AU.addRequired();

192 }

193

194 StringRef getPassName() const override { return PASS_NAME; }

195

197};

198

199}

200

202 unsigned Opc = I->getOpcode();

203 return Opc == Instruction::AShr || Opc == Instruction::SDiv ||

204 Opc == Instruction::SRem || Opc == Instruction::SExt;

205}

206

207bool TypePromotionImpl::EqualTypeSize(Value *V) {

208 return V->getType()->getScalarSizeInBits() == TypeSize;

209}

210

211bool TypePromotionImpl::LessOrEqualTypeSize(Value *V) {

212 return V->getType()->getScalarSizeInBits() <= TypeSize;

213}

214

215bool TypePromotionImpl::GreaterThanTypeSize(Value *V) {

216 return V->getType()->getScalarSizeInBits() > TypeSize;

217}

218

219bool TypePromotionImpl::LessThanTypeSize(Value *V) {

220 return V->getType()->getScalarSizeInBits() < TypeSize;

221}

222

223

224

225

226

227

228

229

230bool TypePromotionImpl::isSource(Value *V) {

232 return false;

233

234

236 return true;

238 return true;

242 return EqualTypeSize(Trunc);

243 return false;

244}

245

246

247

248

249bool TypePromotionImpl::isSink(Value *V) {

250

251

252

253

254

255

256

257

258

259

261 return LessOrEqualTypeSize(Store->getValueOperand());

263 return LessOrEqualTypeSize(Return->getReturnValue());

265 return GreaterThanTypeSize(ZExt);

267 return LessThanTypeSize(Switch->getCondition());

269 return ICmp->isSigned() || LessThanTypeSize(ICmp->getOperand(0));

270

272}

273

274

275bool TypePromotionImpl::isSafeWrap(Instruction *I) {

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329 unsigned Opc = I->getOpcode();

330 if (Opc != Instruction::Add && Opc != Instruction::Sub)

331 return false;

332

333 if (->hasOneUse() || isa<ICmpInst> (*I->user_begin()) ||

335 return false;

336

337

339 if (CI->isSigned() || CI->isEquality())

340 return false;

341

342 ConstantInt *ICmpConstant = nullptr;

344 ICmpConstant = Const;

346 ICmpConstant = Const;

347 else

348 return false;

349

350 const APInt &ICmpConst = ICmpConstant->getValue();

351 APInt OverflowConst = cast(I->getOperand(1))->getValue();

352 if (Opc == Instruction::Sub)

353 OverflowConst = -OverflowConst;

354

355

356

358

359

361 return false;

362

363 APInt NewConst = -((-OverflowConst).zext(64));

365 return false;

366 }

367

369

370 if (OverflowConst == 0 || OverflowConst.ugt(ICmpConst)) {

371 LLVM_DEBUG(dbgs() << "IR Promotion: Allowing safe overflow for "

372 << "const of " << *I << "\n");

373 return true;

374 }

375

376 LLVM_DEBUG(dbgs() << "IR Promotion: Allowing safe overflow for "

377 << "const of " << *I << " and " << *CI << "\n");

379 return true;

380}

381

382bool TypePromotionImpl::shouldPromote(Value *V) {

384 return false;

385

386 if (isSource(V))

387 return true;

388

390 if ()

391 return false;

392

394 return false;

395

396 return true;

397}

398

399

400

403 return false;

404

406 return true;

407

408 return I->hasNoUnsignedWrap();

409}

410

411void IRPromoter::ReplaceAllUsersOfWith(Value *From, Value *To) {

412 SmallVector<Instruction *, 4> Users;

414 bool ReplacedAll = true;

415

416 LLVM_DEBUG(dbgs() << "IR Promotion: Replacing " << *From << " with " << *To

417 << "\n");

418

419 for (Use &U : From->uses()) {

421 if (InstTo && User->isIdenticalTo(InstTo)) {

422 ReplacedAll = false;

423 continue;

424 }

425 Users.push_back(User);

426 }

427

428 for (auto *U : Users)

429 U->replaceUsesOfWith(From, To);

430

431 if (ReplacedAll)

434}

435

436void IRPromoter::ExtendSources() {

438

440 assert(V->getType() != ExtTy && "zext already extends to i32");

441 LLVM_DEBUG(dbgs() << "IR Promotion: Inserting ZExt for " << *V << "\n");

445

449 I->moveBefore(InsertPt);

450 else

451 I->moveAfter(&*InsertPt);

452 NewInsts.insert(I);

453 }

454

455 ReplaceAllUsersOfWith(V, ZExt);

456 };

457

458

459 LLVM_DEBUG(dbgs() << "IR Promotion: Promoting sources:\n");

460 for (auto *V : Sources) {

463 InsertZExt(I, I->getIterator());

465 BasicBlock &BB = Arg->getParent()->front();

467 } else {

469 }

470 Promoted.insert(V);

471 }

472}

473

474void IRPromoter::PromoteTree() {

475 LLVM_DEBUG(dbgs() << "IR Promotion: Mutating the tree..\n");

476

477

478

479 for (auto *V : Visited) {

480 if (Sources.count(V))

481 continue;

482

485 continue;

486

487 for (unsigned i = 0, e = I->getNumOperands(); i < e; ++i) {

488 Value *Op = I->getOperand(i);

490 continue;

491

493

494

495

496

497

498

499 APInt NewConst;

501 if (I->getOpcode() == Instruction::ICmp)

502 NewConst = -((-Const->getValue()).zext(PromotedWidth));

503 else if (I->getOpcode() == Instruction::Add && i == 1)

504 NewConst = -((-Const->getValue()).zext(PromotedWidth));

505 else

506 NewConst = Const->getValue().zext(PromotedWidth);

507 } else

508 NewConst = Const->getValue().zext(PromotedWidth);

509

510 I->setOperand(i, ConstantInt::get(Const->getContext(), NewConst));

512 I->setOperand(i, ConstantInt::get(ExtTy, 0));

513 }

514

515

517 for (auto Case : SI->cases()) {

518 APInt NewConst = Case.getCaseValue()->getValue().zext(PromotedWidth);

519 Case.setValue(ConstantInt::get(SI->getContext(), NewConst));

520 }

521 }

522

523

525 I->mutateType(ExtTy);

526 Promoted.insert(I);

527 }

528 }

529}

530

531void IRPromoter::TruncateSinks() {

532 LLVM_DEBUG(dbgs() << "IR Promotion: Fixing up the sinks:\n");

533

535

536 auto InsertTrunc = [&](Value *V, Type *TruncTy) -> Instruction * {

538 return nullptr;

539

540 if ((!Promoted.count(V) && !NewInsts.count(V)) || Sources.count(V))

541 return nullptr;

542

543 LLVM_DEBUG(dbgs() << "IR Promotion: Creating " << *TruncTy << " Trunc for "

544 << *V << "\n");

547 if (Trunc)

548 NewInsts.insert(Trunc);

549 return Trunc;

550 };

551

552

553

554 for (auto *I : Sinks) {

555 LLVM_DEBUG(dbgs() << "IR Promotion: For Sink: " << *I << "\n");

556

557

559 for (unsigned i = 0; i < Call->arg_size(); ++i) {

561 Type *Ty = TruncTysMap[Call][i];

562 if (Instruction *Trunc = InsertTrunc(Arg, Ty)) {

565 }

566 }

567 continue;

568 }

569

570

573 if (Instruction *Trunc = InsertTrunc(Switch->getCondition(), Ty)) {

574 Trunc->moveBefore(Switch->getIterator());

575 Switch->setCondition(Trunc);

576 }

577 continue;

578 }

579

580

581

582

583

584

585

588 continue;

589

590

591 for (unsigned i = 0; i < I->getNumOperands(); ++i) {

592 Type *Ty = TruncTysMap[I][i];

593 if (Instruction *Trunc = InsertTrunc(I->getOperand(i), Ty)) {

594 Trunc->moveBefore(I->getIterator());

595 I->setOperand(i, Trunc);

596 }

597 }

598 }

599}

600

601void IRPromoter::Cleanup() {

603

604

605 for (auto *V : Visited) {

607 continue;

608

610 if (ZExt->getDestTy() != ExtTy)

611 continue;

612

613 Value *Src = ZExt->getOperand(0);

614 if (ZExt->getSrcTy() == ZExt->getDestTy()) {

615 LLVM_DEBUG(dbgs() << "IR Promotion: Removing unnecessary cast: " << *ZExt

616 << "\n");

617 ReplaceAllUsersOfWith(ZExt, Src);

618 continue;

619 }

620

621

622

625 assert(Trunc->getOperand(0)->getType() == ExtTy &&

626 "expected inserted trunc to be operating on i32");

627 ReplaceAllUsersOfWith(ZExt, Trunc->getOperand(0));

628 }

629 }

630

631 for (auto *I : InstsToRemove) {

632 LLVM_DEBUG(dbgs() << "IR Promotion: Removing " << *I << "\n");

633 I->dropAllReferences();

634 }

635}

636

637void IRPromoter::ConvertTruncs() {

638 LLVM_DEBUG(dbgs() << "IR Promotion: Converting truncs..\n");

640

641 for (auto *V : Visited) {

643 continue;

644

647 IntegerType *SrcTy = cast(Trunc->getOperand(0)->getType());

649

651 ConstantInt *Mask =

656

658 NewInsts.insert(I);

659

660 ReplaceAllUsersOfWith(Trunc, Masked);

661 }

662}

663

664void IRPromoter::Mutate() {

665 LLVM_DEBUG(dbgs() << "IR Promotion: Promoting use-def chains to "

666 << PromotedWidth << "-bits\n");

667

668

669 for (auto *I : Sinks) {

672 TruncTysMap[Call].push_back(Arg->getType());

674 TruncTysMap[I].push_back(Switch->getCondition()->getType());

675 else {

676 for (const Value *Op : I->operands())

677 TruncTysMap[I].push_back(Op->getType());

678 }

679 }

680 for (auto *V : Visited) {

682 continue;

684 TruncTysMap[Trunc].push_back(Trunc->getDestTy());

685 }

686

687

688 ExtendSources();

689

690

691 PromoteTree();

692

693

694 ConvertTruncs();

695

696

697 TruncateSinks();

698

699

700

702

703 LLVM_DEBUG(dbgs() << "IR Promotion: Mutation complete\n");

704}

705

706

707

708

709bool TypePromotionImpl::isSupportedType(Value *V) {

710 Type *Ty = V->getType();

711

712

714 return true;

715

718 return false;

719

720 return LessOrEqualTypeSize(V);

721}

722

723

724

725

726

727bool TypePromotionImpl::isSupportedValue(Value *V) {

729 switch (I->getOpcode()) {

730 default:

733 case Instruction::GetElementPtr:

734 case Instruction::Store:

735 case Instruction::Br:

736 case Instruction::Switch:

737 return true;

738 case Instruction::PHI:

739 case Instruction::Select:

740 case Instruction::Ret:

741 case Instruction::Load:

742 case Instruction::Trunc:

744 case Instruction::BitCast:

745 return I->getOperand(0)->getType() == I->getType();

746 case Instruction::ZExt:

748 case Instruction::ICmp:

749

750

751

752

754 return true;

755 return EqualTypeSize(I->getOperand(0));

756 case Instruction::Call: {

757

758

759

763 }

764 }

769

771}

772

773

774

775

776bool TypePromotionImpl::isLegalToPromote(Value *V) {

778 if ()

779 return true;

780

781 if (SafeToPromote.count(I))

782 return true;

783

785 SafeToPromote.insert(I);

786 return true;

787 }

788 return false;

789}

790

791bool TypePromotionImpl::TryToPromote(Value *V, unsigned PromotedWidth,

792 const LoopInfo &LI) {

793 Type *OrigTy = V->getType();

795 SafeToPromote.clear();

796 SafeWrap.clear();

797

798 if (!isSupportedValue(V) || !shouldPromote(V) || isLegalToPromote (V))

799 return false;

800

801 LLVM_DEBUG(dbgs() << "IR Promotion: TryToPromote: " << *V << ", from "

802 << TypeSize << " bits to " << PromotedWidth << "\n");

803

804 SetVector<Value *> WorkList;

805 SetVector<Value *> Sources;

806 SetVector<Instruction *> Sinks;

807 SetVector<Value *> CurrentVisited;

809

810

811

812

813 auto AddLegalInst = [&](Value *V) {

814 if (CurrentVisited.count(V))

815 return true;

816

817

818

820 return false;

821

822 if (!isSupportedValue(V) || (shouldPromote(V) && isLegalToPromote (V))) {

823 LLVM_DEBUG(dbgs() << "IR Promotion: Can't handle: " << *V << "\n");

824 return false;

825 }

826

828 return true;

829 };

830

831

832 while (!WorkList.empty()) {

834 if (CurrentVisited.count(V))

835 continue;

836

837

839 continue;

840

841

842

843

844

845 if (!AllVisited.insert(V).second)

846 return false;

847

848 CurrentVisited.insert(V);

849

850

851 if (isSink(V))

853

854 if (isSource(V))

856

857 if (!isSink(V) && !isSource(V)) {

859

860 for (auto &U : I->operands()) {

861 if (!AddLegalInst(U))

862 return false;

863 }

864 }

865 }

866

867

868

869 if (isSource(V) || shouldPromote(V)) {

870 for (Use &U : V->uses()) {

871 if (!AddLegalInst(U.getUser()))

872 return false;

873 }

874 }

875 }

876

878 dbgs() << "IR Promotion: Visited nodes:\n";

879 for (auto *I : CurrentVisited)

880 I->dump();

881 });

882

883 unsigned ToPromote = 0;

884 unsigned NonFreeArgs = 0;

885 unsigned NonLoopSources = 0, LoopSinks = 0;

886 SmallPtrSet<BasicBlock *, 4> Blocks;

887 for (auto *CV : CurrentVisited) {

889 Blocks.insert(I->getParent());

890

891 if (Sources.count(CV)) {

893 if (!Arg->hasZExtAttr() && !Arg->hasSExtAttr())

894 ++NonFreeArgs;

897 ++NonLoopSources;

898 continue;

899 }

900

902 continue;

904 ++LoopSinks;

906 continue;

907 ++ToPromote;

908 }

909

910

911

912 if ( isa<PHINode> (V) && !(LoopSinks && NonLoopSources) &&

913 (ToPromote < 2 || (Blocks.size() == 1 && NonFreeArgs > SafeWrap.size())))

914 return false;

915

916 IRPromoter Promoter(*Ctx, PromotedWidth, CurrentVisited, Sources, Sinks,

917 SafeWrap, InstsToRemove);

918 Promoter.Mutate();

919 return true;

920}

921

922bool TypePromotionImpl::run(Function &F, const TargetMachine *TM,

923 const TargetTransformInfo &TTI,

924 const LoopInfo &LI) {

926 return false;

927

928 LLVM_DEBUG(dbgs() << "IR Promotion: Running on " << F.getName() << "\n");

929

930 AllVisited.clear();

931 SafeToPromote.clear();

932 SafeWrap.clear();

933 bool MadeChange = false;

934 const DataLayout &DL = F.getDataLayout();

935 const TargetSubtargetInfo *SubtargetInfo = TM->getSubtargetImpl(F);

937 RegisterBitWidth =

939 Ctx = &F.getContext();

940

941

942

943 auto GetPromoteWidth = [&](Instruction *I) -> uint32_t {

945 return 0;

946

949 return 0;

950

951 if (TLI->getTypeAction(*Ctx, SrcVT) != TargetLowering::TypePromoteInteger)

952 return 0;

953

956 return 0;

958 LLVM_DEBUG(dbgs() << "IR Promotion: Couldn't find target register "

959 << "for promoted type\n");

960 return 0;

961 }

962

963

965 };

966

967 auto BBIsInLoop = [&](BasicBlock *BB) -> bool {

968 for (auto *L : LI)

969 if (L->contains(BB))

970 return true;

971 return false;

972 };

973

974 for (BasicBlock &BB : F) {

975 for (Instruction &I : BB) {

976 if (AllVisited.count(&I))

977 continue;

978

981 LLVM_DEBUG(dbgs() << "IR Promotion: Searching from: "

982 << *I.getOperand(0) << "\n");

986 if (RegisterBitWidth < PromoteWidth) {

987 LLVM_DEBUG(dbgs() << "IR Promotion: Couldn't find target "

988 << "register for ZExt type\n");

989 continue;

990 }

991 MadeChange |= TryToPromote(Phi, PromoteWidth, LI);

993

994

995 if (ICmp->isSigned())

996 continue;

997

998 LLVM_DEBUG(dbgs() << "IR Promotion: Searching from: " << *ICmp << "\n");

999

1000 for (auto &Op : ICmp->operands()) {

1002 if (auto PromotedWidth = GetPromoteWidth(OpI)) {

1003 MadeChange |= TryToPromote(OpI, PromotedWidth, LI);

1004 break;

1005 }

1006 }

1007 }

1008 }

1009 }

1010 if (!InstsToRemove.empty()) {

1011 for (auto *I : InstsToRemove)

1012 I->eraseFromParent();

1013 InstsToRemove.clear();

1014 }

1015 }

1016

1017 AllVisited.clear();

1018 SafeToPromote.clear();

1019 SafeWrap.clear();

1020

1021 return MadeChange;

1022}

1023

1029

1030char TypePromotionLegacy::ID = 0;

1031

1032bool TypePromotionLegacy::runOnFunction(Function &F) {

1033 if (skipFunction(F))

1034 return false;

1035

1036 auto &TPC = getAnalysis();

1037 auto *TM = &TPC.getTM();

1038 auto &TTI = getAnalysis().getTTI(F);

1039 auto &LI = getAnalysis().getLoopInfo();

1040

1041 TypePromotionImpl TP;

1042 return TP.run(F, TM, TTI, LI);

1043}

1044

1046 return new TypePromotionLegacy();

1047}

1048

1053 TypePromotionImpl TP;

1054

1058

1062 return PA;

1063}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static bool isSupportedType(const DataLayout &DL, const ARMTargetLowering &TLI, Type *T)

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

This file contains the simple types necessary to represent the attributes associated with functions a...

This file contains the declarations for the subclasses of Constant, which represent the different fla...

static bool runOnFunction(Function &F, bool PostInlining)

static const HTTPClientCleanup Cleanup

iv Induction Variable Users

#define INITIALIZE_PASS_DEPENDENCY(depName)

#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)

#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)

This file implements a set that has insertion order iteration characteristics.

This file describes how to lower LLVM code to machine code.

Target-Independent Code Generator Pass Configuration Options pass.

This pass exposes codegen information to IR-level passes.

static unsigned getBitWidth(Type *Ty, const DataLayout &DL)

Returns the bitwidth of the given scalar or pointer type.

LLVM_ABI APInt zext(unsigned width) const

Zero extend to a new width.

static APInt getMaxValue(unsigned numBits)

Gets maximum unsigned value of APInt for specific bit width.

bool ugt(const APInt &RHS) const

Unsigned greater than comparison.

unsigned getBitWidth() const

Return the number of bits in the APInt.

bool isNonPositive() const

Determine if this APInt Value is non-positive (<= 0).

int64_t getSExtValue() const

Get sign extended value.

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

AnalysisUsage & addRequired()

AnalysisUsage & addPreserved()

Add the specified Pass class to the set of analyses preserved by this pass.

LLVM_ABI void setPreservesCFG()

This function should be called by the pass, iff they do not:

LLVM_ABI const_iterator getFirstInsertionPt() const

Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...

InstListType::iterator iterator

Instruction iterators...

Represents analyses that only rely on functions' control flow.

bool hasRetAttr(Attribute::AttrKind Kind) const

Determine whether the return value has the given attribute.

Value * getArgOperand(unsigned i) const

void setArgOperand(unsigned i, Value *v)

iterator_range< User::op_iterator > args()

Iteration adapter for range-for loops.

unsigned arg_size() const

const APInt & getValue() const

Return the constant as an APInt value reference.

FunctionPass class - This class is used to implement most global optimizations.

void SetCurrentDebugLocation(DebugLoc L)

Set location information used by debugging information.

Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)

Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")

Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="", bool IsNUW=false, bool IsNSW=false)

void SetInsertPoint(BasicBlock *TheBB)

This specifies that created instructions should be appended to the end of the specified block.

Class to represent integer types.

static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)

This static method is the primary way of constructing an IntegerType.

unsigned getBitWidth() const

Get the number of bits in this IntegerType.

This is an important class for using LLVM in a threaded context.

Analysis pass that exposes the LoopInfo for a function.

LoopT * getLoopFor(const BlockT *BB) const

Return the inner most loop that BB lives in.

A set of analyses that are preserved following a run of a transformation pass.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

PreservedAnalyses & preserveSet()

Mark an analysis set as preserved.

PreservedAnalyses & preserve()

Mark an analysis as preserved.

A vector that has set insertion semantics.

size_type count(const_arg_type key) const

Count the number of elements of a given key in the SetVector.

bool empty() const

Determine if the SetVector is empty or not.

bool insert(const value_type &X)

Insert a new element into the SetVector.

value_type pop_back_val()

A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...

size_type count(ConstPtrType Ptr) const

count - Return 1 if the specified pointer is in the set, 0 otherwise.

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

bool contains(ConstPtrType Ptr) const

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

Analysis pass providing the TargetTransformInfo.

EVT getValueType(const DataLayout &DL, Type *Ty, bool AllowUnknown=false) const

Return the EVT corresponding to this LLVM type.

virtual bool isSExtCheaperThanZExt(EVT FromTy, EVT ToTy) const

Return true if sign-extension from FromTy to ToTy is cheaper than zero-extension.

virtual EVT getTypeToTransformTo(LLVMContext &Context, EVT VT) const

For types supported by the target, this is an identity function.

bool isTypeLegal(EVT VT) const

Return true if the target has native support for the specified value type.

virtual bool isLegalAddImmediate(int64_t) const

Return true if the specified immediate is legal add immediate, that is the target has add instruction...

LegalizeTypeAction getTypeAction(LLVMContext &Context, EVT VT) const

Return how we should legalize values of this type, either it is already legal (return 'Legal') or we ...

virtual const TargetSubtargetInfo * getSubtargetImpl(const Function &) const

Virtual method implemented by subclasses that returns a reference to that target's TargetSubtargetInf...

virtual const TargetLowering * getTargetLowering() const

LLVM_ABI TypeSize getRegisterBitWidth(RegisterKind K) const

bool isPointerTy() const

True if this is an instance of PointerType.

LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY

Return the basic size of this type if it is a primitive type.

LLVM_ABI unsigned getScalarSizeInBits() const LLVM_READONLY

If this is a vector type, return the getPrimitiveSizeInBits value for the element type.

bool isVoidTy() const

Return true if this is 'void'.

LLVM Value Representation.

Type * getType() const

All values are typed, get the type of this value.

iterator_range< use_iterator > uses()

constexpr ScalarTy getFixedValue() const

self_iterator getIterator()

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

constexpr std::underlying_type_t< E > Mask()

Get a bitmask with 1s in all places up to the high-order bit of E's largest value.

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

@ C

The default llvm calling convention, compatible with C.

@ BasicBlock

Various leaf nodes.

initializer< Ty > init(const Ty &Val)

@ Switch

The "resume-switch" lowering, where there are separate resume and destroy functions that are shared b...

PointerTypeMap run(const Module &M)

Compute the PointerTypeMap for the module M.

@ User

could "use" a pointer

NodeAddr< PhiNode * > Phi

friend class Instruction

Iterator for Instructions in a `BasicBlock.

This is an optimization pass for GlobalISel generic memory operations.

FunctionAddr VTableAddr Value

LLVM_ABI bool isLegalToPromote(const CallBase &CB, Function *Callee, const char **FailureReason=nullptr)

Return true if the given indirect call site can be made to call Callee.

LLVM_ABI FunctionPass * createTypePromotionLegacyPass()

Create IR Type Promotion pass.

Definition TypePromotion.cpp:1045

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

IRBuilder(LLVMContext &, FolderTy, InserterTy, MDNode *, ArrayRef< OperandBundleDef >) -> IRBuilder< FolderTy, InserterTy >

DWARFExpression::Operation Op

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

LLVMAttributeRef wrap(Attribute Attr)

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

bool isSimple() const

Test if the given EVT is simple (as opposed to being extended).

MVT getSimpleVT() const

Return the SimpleValueType held in the specified simple EVT.

uint64_t getFixedSizeInBits() const

Return the size of the specified fixed width value type in bits.