ConstantFold.cpp Source File (original) (raw)

32using namespace llvm;

43static unsigned

45 unsigned opc,

46 ConstantExpr *Op,

47 Type *DstTy

{

49 assert(Op && Op->isCast() && "Can't fold cast of cast without a cast!");

54 Type *SrcTy = Op->getOperand(0)->getType();

55 Type *MidTy = Op->getType();

59 nullptr);

60}

63 Type *SrcTy = V->getType();

64 if (SrcTy == DestTy)

65 return V;

67 if (V->isAllOnesValue())

82 return nullptr;

84 return ConstantFP::get(

85 DestTy,

87 }

100

101

102

103 if (SrcTy->isPPC_FP128Ty())

104 return nullptr;

105

106

109 return nullptr;

110

111 return ConstantInt::get(DestTy, FP->getValueAPF().bitcastToAPInt());

112 }

113

114 return nullptr;

115}

116

123

125 Type *DestTy) {

128

130

131

132

133 if (opc == Instruction::ZExt || opc == Instruction::SExt ||

134 opc == Instruction::UIToFP || opc == Instruction::SIToFP)

137 }

138

139 if (V->isNullValue() && !DestTy->isX86_AMXTy() &&

140 opc != Instruction::AddrSpaceCast)

142

143

144

146 if (CE->isCast()) {

147

150 }

151 }

152

153

154

155

156 if (DestTy->isVectorTy() && V->getType()->isVectorTy() &&

161

164 if (!Res)

165 return nullptr;

168 }

170 return nullptr;

173 for (unsigned i = 0,

175 i != e; ++i) {

178 if (!Casted)

179 return nullptr;

181 }

183 }

184

185

186

187 switch (opc) {

188 default:

190 case Instruction::FPTrunc:

191 case Instruction::FPExt:

193 bool ignored;

194 APFloat Val = FPC->getValueAPF();

197 return ConstantFP::get(DestTy, Val);

198 }

199 return nullptr;

200 case Instruction::FPToUI:

201 case Instruction::FPToSI:

203 const APFloat &V = FPC->getValueAPF();

204 bool ignored;

208

209

211 }

212 return ConstantInt::get(DestTy, IntVal);

213 }

214 return nullptr;

215 case Instruction::UIToFP:

216 case Instruction::SIToFP:

218 const APInt &api = CI->getValue();

223 return ConstantFP::get(DestTy, apf);

224 }

225 return nullptr;

226 case Instruction::ZExt:

229 return ConstantInt::get(DestTy, CI->getValue().zext(BitWidth));

230 }

231 return nullptr;

232 case Instruction::SExt:

235 return ConstantInt::get(DestTy, CI->getValue().sext(BitWidth));

236 }

237 return nullptr;

238 case Instruction::Trunc: {

241 return ConstantInt::get(DestTy, CI->getValue().trunc(BitWidth));

242 }

243

244 return nullptr;

245 }

246 case Instruction::BitCast:

248 case Instruction::AddrSpaceCast:

249 case Instruction::IntToPtr:

250 case Instruction::PtrToAddr:

251 case Instruction::PtrToInt:

252 return nullptr;

253 }

254}

255

258

259 if (Cond->isNullValue()) return V2;

260 if (Cond->isAllOnesValue()) return V1;

261

262

264 auto *V1VTy = CondV->getType();

267 for (unsigned i = 0, e = V1VTy->getNumElements(); i != e; ++i) {

270 ConstantInt::get(Ty, i));

272 ConstantInt::get(Ty, i));

276 } else if (V1Element == V2Element) {

277 V = V1Element;

280 } else {

282 V = Cond->isNullValue() ? V2Element : V1Element;

283 }

284 Result.push_back(V);

285 }

286

287

288 if (Result.size() == V1VTy->getNumElements())

290 }

291

294

297 return V2;

298 }

299

300 if (V1 == V2) return V1;

301

303 return V2;

305 return V1;

306

307

308

309 auto NotPoison = [](Constant *C) {

311 return false;

312

313

314

316 return false;

317

320 return true;

321

322 if (C->getType()->isVectorTy())

323 return ->containsPoisonElement() && ->containsConstantExpression();

324

325

326 return false;

327 };

330

331 return nullptr;

332}

333

337

338

339

342

343

346

348 if (!CIdx)

349 return nullptr;

350

352

353 if (CIdx->uge(ValFVTy->getNumElements()))

355 }

356

357

361 Ops.reserve(CE->getNumOperands());

362 for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {

364 if (Op->getType()->isVectorTy()) {

366 if (!ScalarOp)

367 return nullptr;

368 Ops.push_back(ScalarOp);

369 } else

370 Ops.push_back(Op);

371 }

372 return CE->getWithOperands(Ops, ValVTy->getElementType(), false,

373 GEP->getSourceElementType());

374 } else if (CE->getOpcode() == Instruction::InsertElement) {

377 APSInt(CIdx->getValue()))) {

378 return CE->getOperand(1);

379 } else {

381 }

382 }

383 }

384 }

385

387 return C;

388

389

390 if (CIdx->getValue().ult(ValVTy->getElementCount().getKnownMinValue())) {

392 return SplatVal;

393 }

394

395 return nullptr;

396}

397

403

404

405

407 return Val;

408

410 if (!CIdx) return nullptr;

411

412

413

415 return nullptr;

416

418

419 unsigned NumElts = ValTy->getNumElements();

420 if (CIdx->uge(NumElts))

422

424 Result.reserve(NumElts);

427 for (unsigned i = 0; i != NumElts; ++i) {

428 if (i == IdxVal) {

429 Result.push_back(Elt);

430 continue;

431 }

432

434 Result.push_back(C);

435 }

436

438}

439

443 unsigned MaskNumElts = Mask.size();

444 auto MaskEltCount =

446 Type *EltTy = V1VTy->getElementType();

447

448

451 }

452

453

454

455 if (all_of(Mask, [](int Elt) { return Elt == 0; })) {

459

460

461

464 }

465

466

467

469 return nullptr;

470

471 unsigned SrcNumElts = V1VTy->getElementCount().getKnownMinValue();

472

473

475 for (unsigned i = 0; i != MaskNumElts; ++i) {

476 int Elt = Mask[i];

477 if (Elt == -1) {

479 continue;

480 }

482 if (unsigned(Elt) >= SrcNumElts*2)

484 else if (unsigned(Elt) >= SrcNumElts) {

486 InElt =

488 ConstantInt::get(Ty, Elt - SrcNumElts));

489 } else {

492 }

493 Result.push_back(InElt);

494 }

495

497}

498

501

502 if (Idxs.empty())

503 return Agg;

504

507

508 return nullptr;

509}

510

514

515 if (Idxs.empty())

516 return Val;

517

518 unsigned NumElts;

520 NumElts = ST->getNumElements();

521 else

523

525 for (unsigned i = 0; i != NumElts; ++i) {

527 if () return nullptr;

528

529 if (Idxs[0] == i)

531

532 Result.push_back(C);

533 }

534

538}

539

542

543

544

546 bool HasScalarUndefOrScalableVectorUndef =

547 (->getType()->isVectorTy() || IsScalableVector) && isa(C);

548

549 if (HasScalarUndefOrScalableVectorUndef) {

551 case Instruction::FNeg:

552 return C;

553 case Instruction::UnaryOpsEnd:

555 }

556 }

557

558

559 assert(!HasScalarUndefOrScalableVectorUndef && "Unexpected UndefValue");

560

562

564 const APFloat &CV = CFP->getValueAPF();

565 switch (Opcode) {

566 default:

567 break;

568 case Instruction::FNeg:

569 return ConstantFP::get(C->getType(), neg(CV));

570 }

572

576

578

581 for (unsigned i = 0, e = FVTy->getNumElements(); i != e; ++i) {

582 Constant *ExtractIdx = ConstantInt::get(Ty, i);

585 if (!Res)

586 return nullptr;

587 Result.push_back(Res);

588 }

589

591 }

592 }

593

594

595 return nullptr;

596}

597

601

602

603

605 Opcode, C1->getType(), false)) {

606 if (C1 == Identity)

607 return C2;

608 if (C2 == Identity)

609 return C1;

611 Opcode, C1->getType(), true)) {

612 if (C2 == Identity)

613 return C1;

614 }

615

616

619

620

621

623 bool HasScalarUndefOrScalableVectorUndef =

624 (!C1->getType()->isVectorTy() || IsScalableVector) &&

626 if (HasScalarUndefOrScalableVectorUndef) {

628 case Instruction::Xor:

630

631

633 [[fallthrough]];

634 case Instruction::Add:

635 case Instruction::Sub:

637 case Instruction::And:

639 return C1;

641 case Instruction::Mul: {

642

644 return C1;

646

648 if ((*CV)[0])

650

651

653 }

654 case Instruction::SDiv:

655 case Instruction::UDiv:

656

657

660

662 case Instruction::URem:

663 case Instruction::SRem:

664

665

668

670 case Instruction::Or:

672 return C1;

674 case Instruction::LShr:

675

678

680 case Instruction::AShr:

681

684

685

687 case Instruction::Shl:

688

691

693 case Instruction::FSub:

694

696 return C2;

697 [[fallthrough]];

698 case Instruction::FAdd:

699 case Instruction::FMul:

700 case Instruction::FDiv:

701 case Instruction::FRem:

702

704 return C1;

705

706

707

708

709

710

711

713 case Instruction::BinaryOpsEnd:

715 }

716 }

717

718

719 assert((!HasScalarUndefOrScalableVectorUndef) && "Unexpected UndefValue");

720

721

724 false))

725 return C2;

726

727 switch (Opcode) {

728 case Instruction::UDiv:

729 case Instruction::SDiv:

730 if (CI2->isZero())

732 break;

733 case Instruction::URem:

734 case Instruction::SRem:

735 if (CI2->isOne())

737 if (CI2->isZero())

739 break;

740 case Instruction::And:

741 assert(!CI2->isZero() && "And zero handled above");

743

744 if ((CE1->getOpcode() == Instruction::PtrToInt ||

745 CE1->getOpcode() == Instruction::PtrToAddr) &&

748

749 Align GVAlign;

750

752 const DataLayout &DL = TheModule->getDataLayout();

754

755

756

757

758

759

760

761

762

763

765 GVAlign = Align(4);

768 }

769

770 if (GVAlign > 1) {

771 unsigned DstWidth = CI2->getBitWidth();

772 unsigned SrcWidth = std::min(DstWidth, Log2(GVAlign));

774

775

776 if ((CI2->getValue() & BitsNotSet) == CI2->getValue())

778 }

779 }

780 }

781 break;

782 }

784

789 }

790

793 const APInt &C1V = CI1->getValue();

794 const APInt &C2V = CI2->getValue();

795 switch (Opcode) {

796 default:

797 break;

798 case Instruction::Add:

799 return ConstantInt::get(C1->getType(), C1V + C2V);

800 case Instruction::Sub:

801 return ConstantInt::get(C1->getType(), C1V - C2V);

802 case Instruction::Mul:

803 return ConstantInt::get(C1->getType(), C1V * C2V);

804 case Instruction::UDiv:

805 assert(!CI2->isZero() && "Div by zero handled above");

806 return ConstantInt::get(CI1->getType(), C1V.udiv(C2V));

807 case Instruction::SDiv:

808 assert(!CI2->isZero() && "Div by zero handled above");

810 return PoisonValue::get(CI1->getType());

811 return ConstantInt::get(CI1->getType(), C1V.sdiv(C2V));

812 case Instruction::URem:

813 assert(!CI2->isZero() && "Div by zero handled above");

814 return ConstantInt::get(C1->getType(), C1V.urem(C2V));

815 case Instruction::SRem:

816 assert(!CI2->isZero() && "Div by zero handled above");

819 return ConstantInt::get(C1->getType(), C1V.srem(C2V));

820 case Instruction::And:

821 return ConstantInt::get(C1->getType(), C1V & C2V);

822 case Instruction::Or:

823 return ConstantInt::get(C1->getType(), C1V | C2V);

824 case Instruction::Xor:

825 return ConstantInt::get(C1->getType(), C1V ^ C2V);

826 case Instruction::Shl:

828 return ConstantInt::get(C1->getType(), C1V.shl(C2V));

830 case Instruction::LShr:

832 return ConstantInt::get(C1->getType(), C1V.lshr(C2V));

834 case Instruction::AShr:

836 return ConstantInt::get(C1->getType(), C1V.ashr(C2V));

838 }

839 }

840

842 true))

843 return C1;

846 const APFloat &C1V = CFP1->getValueAPF();

847 const APFloat &C2V = CFP2->getValueAPF();

848 APFloat C3V = C1V;

849 switch (Opcode) {

850 default:

851 break;

852 case Instruction::FAdd:

854 return ConstantFP::get(C1->getType(), C3V);

855 case Instruction::FSub:

857 return ConstantFP::get(C1->getType(), C3V);

858 case Instruction::FMul:

860 return ConstantFP::get(C1->getType(), C3V);

861 case Instruction::FDiv:

863 return ConstantFP::get(C1->getType(), C3V);

864 case Instruction::FRem:

865 (void)C3V.mod(C2V);

866 return ConstantFP::get(C1->getType(), C3V);

867 }

868 }

869 }

870

872

881 if (!Res)

882 return nullptr;

884 }

885 }

886

888

891 for (unsigned i = 0, e = FVTy->getNumElements(); i != e; ++i) {

892 Constant *ExtractIdx = ConstantInt::get(Ty, i);

898 if (!Res)

899 return nullptr;

900 Result.push_back(Res);

901 }

902

904 }

905 }

906

908

909

910

911

912

913

918 }

920

921

924 }

925

926

928 switch (Opcode) {

929 case Instruction::Add:

930 case Instruction::Sub:

932 case Instruction::Shl:

933 case Instruction::LShr:

934 case Instruction::AShr:

935

936

937 return C1;

938 case Instruction::SDiv:

939 case Instruction::UDiv:

940

941

942 return C1;

943 case Instruction::URem:

944 case Instruction::SRem:

945

946

948 default:

949 break;

950 }

951 }

952

953

954 return nullptr;

955}

956

959 auto isGlobalUnsafeForEquality = [](const GlobalValue *GV) {

960 if (GV->isInterposable() || GV->hasGlobalUnnamedAddr())

961 return true;

963 Type *Ty = GVar->getValueType();

964

965 if (!Ty->isSized())

966 return true;

967

968

969 if (Ty->isEmptyTy())

970 return true;

971 }

972 return false;

973 };

974

976 if (!isGlobalUnsafeForEquality(GV1) && !isGlobalUnsafeForEquality(GV2))

979}

980

981

982

983

984

985

986

989 "Cannot compare different types of values!");

991

992

995

996

997

998

999

1000 auto GetComplexity = [](Constant *V) {

1002 return 3;

1004 return 2;

1006 return 1;

1007 return 0;

1008 };

1009 if (GetComplexity(V1) < GetComplexity(V2)) {

1014 }

1015

1017

1019

1020

1021

1022 if (BA2->getFunction() != BA->getFunction())

1026 }

1028

1029

1035

1036

1037

1038

1039

1040 if (!GV->hasExternalWeakLinkage() && isa<GlobalAlias> (GV) &&

1042 GV->getType()->getAddressSpace()))

1044 }

1046

1047

1049

1050 switch (CE1->getOpcode()) {

1051 case Instruction::GetElementPtr: {

1053

1054

1056

1057

1059

1060

1061 if (!GV->hasExternalWeakLinkage() && CE1GEP->isInBounds())

1063 }

1066 if (GV != GV2) {

1070 }

1071 }

1073

1074

1077

1078 if (CE1Op0 != CE2Op0) {

1083 }

1084 }

1085 }

1086 break;

1087 }

1088 default:

1089 break;

1090 }

1091 }

1092

1094}

1095

1098 Type *ResultTy;

1101 VT->getElementCount());

1102 else

1104

1105

1108

1111

1112

1115

1118

1119

1120

1123

1124

1125

1126 if (isIntegerPredicate)

1128

1129

1130

1132 }

1133

1135

1136

1137

1140

1143 }

1144

1145

1147 switch (Predicate) {

1154 default:

1155 break;

1156 }

1157 }

1158

1162 return ConstantInt::get(ResultTy, ICmpInst::compare(V1, V2, Predicate));

1166 return ConstantInt::get(ResultTy, FCmpInst::compare(C1V, C2V, Predicate));

1168

1169

1175

1176

1177

1179 return nullptr;

1180

1181

1182

1185

1186 for (unsigned I = 0, E = C1VTy->getElementCount().getKnownMinValue();

1187 I != E; ++I) {

1193 if (!Elt)

1194 return nullptr;

1195

1197 }

1198

1200 }

1201

1203 if (C1 == C2) {

1204

1209 }

1210 } else {

1211

1212 int Result = -1;

1216 break;

1218

1219

1221 break;

1223 switch (Predicate) {

1225 Result = 1; break;

1227 Result = 0; break;

1228 default:

1229 break;

1230 }

1231 break;

1233 switch (Predicate) {

1235 Result = 1; break;

1237 Result = 0; break;

1238 default:

1239 break;

1240 }

1241 break;

1243 switch (Predicate) {

1245 Result = 1; break;

1247 Result = 0; break;

1248 default:

1249 break;

1250 }

1251 break;

1253 switch (Predicate) {

1255 Result = 1; break;

1257 Result = 0; break;

1258 default:

1259 break;

1260 }

1261 break;

1264 Result = 0;

1266 Result = 1;

1267 break;

1270 Result = 0;

1272 Result = 1;

1273 break;

1276 Result = 0;

1278 Result = 1;

1279 break;

1282 Result = 0;

1284 Result = 1;

1285 break;

1288 Result = 0;

1290 Result = 1;

1291 break;

1292 }

1293

1294

1295 if (Result != -1)

1296 return ConstantInt::get(ResultTy, Result);

1297

1300

1301

1302

1305 }

1306 }

1307 return nullptr;

1308}

1309

1311 std::optional InRange,

1313 if (Idxs.empty()) return C;

1314

1317

1320

1323

1324 auto IsNoOp = [&]() {

1325

1327 return false;

1328

1332 });

1333 };

1334 if (IsNoOp())

1335 return GEPTy->isVectorTy() && ->getType()->isVectorTy()

1338 : C;

1339

1340 return nullptr;

1341}

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

This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static unsigned foldConstantCastPair(unsigned opc, ConstantExpr *Op, Type *DstTy)

This function determines which opcode to use to fold two constant cast expressions together.

Definition ConstantFold.cpp:44

static Constant * foldMaybeUndesirableCast(unsigned opc, Constant *V, Type *DestTy)

Definition ConstantFold.cpp:117

static ICmpInst::Predicate areGlobalsPotentiallyEqual(const GlobalValue *GV1, const GlobalValue *GV2)

Definition ConstantFold.cpp:957

static Constant * FoldBitCast(Constant *V, Type *DestTy)

Definition ConstantFold.cpp:62

static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2)

This function determines if there is anything we can decide about the two constants provided.

Definition ConstantFold.cpp:987

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

Module.h This file contains the declarations for the Module class.

const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]

static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)

const SmallVectorImpl< MachineOperand > & Cond

This file defines the SmallVector class.

static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)

Returns the opcode of Values or ~0 if they do not all agree.

static constexpr roundingMode rmTowardZero

static constexpr roundingMode rmNearestTiesToEven

opStatus divide(const APFloat &RHS, roundingMode RM)

LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)

opStatus subtract(const APFloat &RHS, roundingMode RM)

opStatus add(const APFloat &RHS, roundingMode RM)

opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)

opStatus multiply(const APFloat &RHS, roundingMode RM)

opStatus mod(const APFloat &RHS)

Class for arbitrary precision integers.

LLVM_ABI APInt udiv(const APInt &RHS) const

Unsigned division operation.

bool isMinSignedValue() const

Determine if this is the smallest signed value.

LLVM_ABI APInt urem(const APInt &RHS) const

Unsigned remainder operation.

unsigned getBitWidth() const

Return the number of bits in the APInt.

LLVM_ABI APInt sdiv(const APInt &RHS) const

Signed division function for APInt.

APInt ashr(unsigned ShiftAmt) const

Arithmetic right-shift function.

LLVM_ABI APInt srem(const APInt &RHS) const

Function for signed remainder operation.

APInt shl(unsigned shiftAmt) const

Left-shift function.

static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)

Constructs an APInt value that has the bottom loBitsSet bits set.

static APInt getZero(unsigned numBits)

Get the '0' value for the specified bit-width.

APInt lshr(unsigned shiftAmt) const

Logical right-shift function.

An arbitrary precision integer that knows its signedness.

static bool isSameValue(const APSInt &I1, const APSInt &I2)

Determine if two APSInts have the same value, zero- or sign-extending as needed.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

size_t size() const

size - Get the array size.

bool empty() const

empty - Check if the array is empty.

ArrayRef< T > slice(size_t N, size_t M) const

slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.

The address of a basic block.

static LLVM_ABI unsigned isEliminableCastPair(Instruction::CastOps firstOpcode, Instruction::CastOps secondOpcode, Type *SrcTy, Type *MidTy, Type *DstTy, const DataLayout *DL)

Determine how a pair of casts can be eliminated, if they can be at all.

Predicate

This enumeration lists the possible predicates for CmpInst subclasses.

@ FCMP_TRUE

1 1 1 1 Always true (always folded)

@ ICMP_SLT

signed less than

@ ICMP_SLE

signed less or equal

@ ICMP_UGE

unsigned greater or equal

@ ICMP_UGT

unsigned greater than

@ ICMP_SGT

signed greater than

@ FCMP_ONE

0 1 1 0 True if ordered and operands are unequal

@ FCMP_UEQ

1 0 0 1 True if unordered or equal

@ ICMP_ULT

unsigned less than

@ ICMP_SGE

signed greater or equal

@ ICMP_ULE

unsigned less or equal

@ FCMP_FALSE

0 0 0 0 Always false (always folded)

Predicate getSwappedPredicate() const

For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.

bool isTrueWhenEqual() const

This is just a convenience.

static LLVM_ABI bool isUnordered(Predicate predicate)

Determine if the predicate is an unordered operation.

static bool isIntPredicate(Predicate P)

static LLVM_ABI Constant * get(ArrayType *T, ArrayRef< Constant * > V)

A constant value that is initialized with an expression using other constant values.

static LLVM_ABI Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)

static LLVM_ABI bool isDesirableCastOp(unsigned Opcode)

Whether creating a constant expression for this cast is desirable.

static LLVM_ABI Constant * getBinOpAbsorber(unsigned Opcode, Type *Ty, bool AllowLHSConstant=false)

Return the absorbing element for the given binary operation, i.e.

static LLVM_ABI Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)

Convenience function for getting a Cast operation.

static LLVM_ABI Constant * getNot(Constant *C)

static LLVM_ABI Constant * getXor(Constant *C1, Constant *C2)

static LLVM_ABI Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)

get - Return a binary or shift operator constant expression, folding if possible.

static LLVM_ABI bool isDesirableBinOp(unsigned Opcode)

Whether creating a constant expression for this binary operator is desirable.

static LLVM_ABI Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)

static LLVM_ABI Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false, bool NSZ=false)

Return the identity constant for a binary opcode.

ConstantFP - Floating Point Values [float, double].

static LLVM_ABI Constant * getNaN(Type *Ty, bool Negative=false, uint64_t Payload=0)

This is the shared class of boolean and integer constants.

static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)

static LLVM_ABI ConstantInt * getFalse(LLVMContext &Context)

uint64_t getZExtValue() const

Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...

bool uge(uint64_t Num) const

This function will return true iff this constant represents a value with active bits bigger than 64 b...

static LLVM_ABI Constant * get(StructType *T, ArrayRef< Constant * > V)

Constant Vector Declarations.

static LLVM_ABI Constant * getSplat(ElementCount EC, Constant *Elt)

Return a ConstantVector with the specified constant in each element.

static LLVM_ABI Constant * get(ArrayRef< Constant * > V)

This is an important base class in LLVM.

LLVM_ABI Constant * getSplatValue(bool AllowPoison=false) const

If all elements of the vector constant have the same value, return that value.

static LLVM_ABI Constant * getAllOnesValue(Type *Ty)

static LLVM_ABI Constant * getNullValue(Type *Ty)

Constructor to create a '0' constant of arbitrary type.

LLVM_ABI Constant * getAggregateElement(unsigned Elt) const

For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...

LLVM_ABI bool isNullValue() const

Return true if this is the value that would be returned by getNullValue.

A parsed version of the target data layout string in and methods for querying it.

static constexpr ElementCount get(ScalarTy MinVal, bool Scalable)

static LLVM_ABI bool compare(const APFloat &LHS, const APFloat &RHS, FCmpInst::Predicate Pred)

Return result of LHS Pred RHS comparison.

bool isInBounds() const

Test whether this is an inbounds GEP, as defined by LangRef.html.

bool hasAllZeroIndices() const

Return true if all of the indices of this GEP are zeros.

static Type * getGEPReturnType(Value *Ptr, ArrayRef< Value * > IdxList)

Returns the pointer type returned by the GEP instruction, which may be a vector of pointers.

Module * getParent()

Get the module that this global value is contained inside of...

static LLVM_ABI bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)

Return result of LHS Pred RHS comparison.

static bool isEquality(Predicate P)

Return true if this predicate is either EQ or NE.

LLVM_ABI bool isAssociative() const LLVM_READONLY

Return true if the instruction is associative:

LLVM_ABI bool isCommutative() const LLVM_READONLY

Return true if the instruction is commutative:

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

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

A Module instance is used to store all the information related to an LLVM module.

static LLVM_ABI PoisonValue * get(Type *T)

Static factory methods - Return an 'poison' object of the specified type.

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Class to represent struct types.

The instances of the Type class are immutable: once they are created, they are never changed.

bool isVectorTy() const

True if this is an instance of VectorType.

static LLVM_ABI IntegerType * getInt32Ty(LLVMContext &C)

bool isIntOrIntVectorTy() const

Return true if this is an integer type or a vector of integer types.

bool isPointerTy() const

True if this is an instance of PointerType.

bool isPPC_FP128Ty() const

Return true if this is powerpc long double.

LLVM_ABI bool isFirstClassType() const

Return true if the type is "first class", meaning it is a valid type for a Value.

Type * getScalarType() const

If this is a vector type, return the element type, otherwise return 'this'.

LLVM_ABI unsigned getScalarSizeInBits() const LLVM_READONLY

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

static LLVM_ABI IntegerType * getInt1Ty(LLVMContext &C)

bool isX86_AMXTy() const

Return true if this is X86 AMX.

bool isIntegerTy() const

True if this is an instance of IntegerType.

bool isFPOrFPVectorTy() const

Return true if this is a FP type or a vector of FP.

LLVM_ABI const fltSemantics & getFltSemantics() const

static LLVM_ABI UndefValue * get(Type *T)

Static factory methods - Return an 'undef' object of the specified type.

Value * getOperand(unsigned i) const

LLVM Value Representation.

Type * getType() const

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

LLVM_ABI Align getPointerAlignment(const DataLayout &DL) const

Returns an alignment of the pointer value.

LLVM_ABI LLVMContext & getContext() const

All values hold a context through their type.

Base class of all SIMD vector types.

static LLVM_ABI VectorType * get(Type *ElementType, ElementCount EC)

This static method is the primary way to construct an VectorType.

Type * getElementType() const

#define llvm_unreachable(msg)

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

@ C

The default llvm calling convention, compatible with C.

ap_match< APInt > m_APInt(const APInt *&Res)

Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.

bool match(Val *V, const Pattern &P)

cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()

Match a floating-point negative zero.

auto m_Undef()

Match an arbitrary undef constant.

is_zero m_Zero()

Match any null constant or a vector with all elements equal to 0.

match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)

Combine two pattern matchers matching L || R.

This is an optimization pass for GlobalISel generic memory operations.

bool all_of(R &&range, UnaryPredicate P)

Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.

LLVM_ABI Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)

Attempt to constant fold a select instruction with the specified operands.

Definition ConstantFold.cpp:256

decltype(auto) dyn_cast(const From &Val)

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

LLVM_ABI Constant * ConstantFoldCompareInstruction(CmpInst::Predicate Predicate, Constant *C1, Constant *C2)

Definition ConstantFold.cpp:1096

LLVM_ABI Constant * ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V)

Definition ConstantFold.cpp:540

LLVM_ABI Constant * ConstantFoldGetElementPtr(Type *Ty, Constant *C, std::optional< ConstantRange > InRange, ArrayRef< Value * > Idxs)

Definition ConstantFold.cpp:1310

LLVM_ABI Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)

Attempt to constant fold an extractvalue instruction with the specified operands and indices.

Definition ConstantFold.cpp:499

LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)

Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...

LLVM_ABI Constant * ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt, Constant *Idx)

Attempt to constant fold an insertelement instruction with the specified operands and indices.

Definition ConstantFold.cpp:398

bool isa(const From &Val)

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

constexpr int PoisonMaskElem

LLVM_ABI Constant * ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx)

Attempt to constant fold an extractelement instruction with the specified operands and indices.

Definition ConstantFold.cpp:334

DWARFExpression::Operation Op

ArrayRef(const T &OneElt) -> ArrayRef< T >

constexpr unsigned BitWidth

decltype(auto) cast(const From &Val)

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

APFloat neg(APFloat X)

Returns the negated value of the argument.

LLVM_ABI Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)

Definition ConstantFold.cpp:124

LLVM_ABI Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)

Attempt to constant fold an insertvalue instruction with the specified operands and indices.

Definition ConstantFold.cpp:511

unsigned Log2(Align A)

Returns the log2 of the alignment.

LLVM_ABI Constant * ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, ArrayRef< int > Mask)

Attempt to constant fold a shufflevector instruction with the specified operands and mask.

Definition ConstantFold.cpp:440

LLVM_ABI Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)

Definition ConstantFold.cpp:598

This struct is a compact representation of a valid (non-zero power of two) alignment.