LLVM: lib/Analysis/ConstantFolding.cpp Source File (original) (raw)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

31#include "llvm/Config/config.h"

45#include "llvm/IR/IntrinsicsAArch64.h"

46#include "llvm/IR/IntrinsicsAMDGPU.h"

47#include "llvm/IR/IntrinsicsARM.h"

48#include "llvm/IR/IntrinsicsNVPTX.h"

49#include "llvm/IR/IntrinsicsWebAssembly.h"

50#include "llvm/IR/IntrinsicsX86.h"

59#include

60#include

61#include

62#include

63#include

64

65using namespace llvm;

66

68 "disable-fp-call-folding",

69 cl::desc("Disable constant-folding of FP intrinsics and libcalls."),

71

72namespace {

73

74

75

76

77

78static Constant *foldConstVectorToAPInt(APInt &Result, Type *DestTy,

80 unsigned NumSrcElts,

82

83

84 unsigned BitShift = DL.getTypeSizeInBits(SrcEltTy);

85 for (unsigned i = 0; i != NumSrcElts; ++i) {

87 if (DL.isLittleEndian())

88 Element = C->getAggregateElement(NumSrcElts - i - 1);

89 else

90 Element = C->getAggregateElement(i);

91

93 Result <<= BitShift;

94 continue;

95 }

96

98 if (!ElementCI)

100

102 Result |= ElementCI->getValue().zext(Result.getBitWidth());

103 }

104

105 return nullptr;

106}

107

108

109

110

113 "Invalid constantexpr bitcast!");

114

115

117 return Res;

118

120

123 Type *SrcEltTy = VTy->getElementType();

124

125

126

131

133 }

134

136 if (Constant *CE = foldConstVectorToAPInt(Result, DestTy, C,

137 SrcEltTy, NumSrcElts, DL))

138 return CE;

139

141 return ConstantInt::get(DestTy, Result);

142

144 return ConstantFP::get(DestTy->getContext(), FP);

145 }

146 }

147

148

150 if (!DestVTy)

152

153

154

157 Constant *Ops = C;

159 }

160

161

162

165

166

170

171

174 if (NumDstElt == NumSrcElt)

176

178 Type *DstEltTy = DestVTy->getElementType();

179

180

181

182

183

184

185

186

187

188

189

191

195

197

198

200 }

201

202

203

208

212 "Constant folding cannot fail for plain fp->int bitcast!");

213 }

214

215

216

217

218

219 bool isLittleEndian = DL.isLittleEndian();

220

222 if (NumDstElt < NumSrcElt) {

223

225 unsigned Ratio = NumSrcElt/NumDstElt;

227 unsigned SrcElt = 0;

228 for (unsigned i = 0; i != NumDstElt; ++i) {

229

231 unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize*(Ratio-1);

232 for (unsigned j = 0; j != Ratio; ++j) {

233 Constant *Src = C->getAggregateElement(SrcElt++);

237 else

239 if (!Src)

241

242

245 assert(Src && "Constant folding cannot fail on plain integers");

246

247

249 Instruction::Shl, Src, ConstantInt::get(Src->getType(), ShiftAmt),

251 assert(Src && "Constant folding cannot fail on plain integers");

252

253 ShiftAmt += isLittleEndian ? SrcBitSize : -SrcBitSize;

254

255

257 assert(Elt && "Constant folding cannot fail on plain integers");

258 }

259 Result.push_back(Elt);

260 }

262 }

263

264

265 unsigned Ratio = NumDstElt/NumSrcElt;

266 unsigned DstBitSize = DL.getTypeSizeInBits(DstEltTy);

267

268

269 for (unsigned i = 0; i != NumSrcElt; ++i) {

270 auto *Element = C->getAggregateElement(i);

271

272 if (!Element)

274

276

278 continue;

279 }

280

282 if (!Src)

284

285 unsigned ShiftAmt = isLittleEndian ? 0 : DstBitSize*(Ratio-1);

286 for (unsigned j = 0; j != Ratio; ++j) {

287

288

289 APInt Elt = Src->getValue().lshr(ShiftAmt);

290 ShiftAmt += isLittleEndian ? DstBitSize : -DstBitSize;

291

292

293 Result.push_back(ConstantInt::get(DstEltTy, Elt.trunc(DstBitSize)));

294 }

295 }

296

298}

299

300}

301

302

303

307 if (DSOEquiv)

308 *DSOEquiv = nullptr;

309

310

314 return true;

315 }

316

318 if (DSOEquiv)

319 *DSOEquiv = FoundDSOEquiv;

320 GV = FoundDSOEquiv->getGlobalValue();

323 return true;

324 }

325

326

328 if (!CE) return false;

329

330

331 if (CE->getOpcode() == Instruction::PtrToInt ||

332 CE->getOpcode() == Instruction::PtrToAddr ||

333 CE->getOpcode() == Instruction::BitCast)

335 DSOEquiv);

336

337

339 if ()

340 return false;

341

342 unsigned BitWidth = DL.getIndexTypeSizeInBits(GEP->getType());

344

345

347 DSOEquiv))

348 return false;

349

350

351 if (->accumulateConstantOffset(DL, TmpOffset))

352 return false;

353

355 return true;

356}

357

360 do {

361 Type *SrcTy = C->getType();

362 if (SrcTy == DestTy)

363 return C;

364

365 TypeSize DestSize = DL.getTypeSizeInBits(DestTy);

366 TypeSize SrcSize = DL.getTypeSizeInBits(SrcTy);

368 return nullptr;

369

370

371

373 return Res;

374

375

376

377

378 if (SrcSize == DestSize &&

379 DL.isNonIntegralPointerType(SrcTy->getScalarType()) ==

382

383

384 if (SrcTy->isIntegerTy() && DestTy->isPointerTy())

385 Cast = Instruction::IntToPtr;

386 else if (SrcTy->isPointerTy() && DestTy->isIntegerTy())

387 Cast = Instruction::PtrToInt;

388

391 }

392

393

394

395 if (!SrcTy->isAggregateType() && !SrcTy->isVectorTy())

396 return nullptr;

397

398

399

400

401

402 if (SrcTy->isStructTy()) {

403

404

405 unsigned Elem = 0;

407 do {

408 ElemC = C->getAggregateElement(Elem++);

409 } while (ElemC && DL.getTypeSizeInBits(ElemC->getType()).isZero());

410 C = ElemC;

411 } else {

412

413

415 if (.typeSizeEqualsStoreSize(VT->getElementType()))

416 return nullptr;

417

418 C = C->getAggregateElement(0u);

419 }

420 } while (C);

421

422 return nullptr;

423}

424

425namespace {

426

427

428

429

430

431bool ReadDataFromGlobal(Constant *C, uint64_t ByteOffset, unsigned char *CurPtr,

433 assert(ByteOffset <= DL.getTypeAllocSize(C->getType()) &&

434 "Out of range access");

435

436

437 if (ByteOffset >= DL.getTypeStoreSize(C->getType()))

438 return true;

439

440

441

443 return true;

444

446 if ((CI->getBitWidth() & 7) != 0)

447 return false;

448 const APInt &Val = CI->getValue();

449 unsigned IntBytes = unsigned(CI->getBitWidth()/8);

450

451 for (unsigned i = 0; i != BytesLeft && ByteOffset != IntBytes; ++i) {

452 unsigned n = ByteOffset;

453 if (.isLittleEndian())

454 n = IntBytes - n - 1;

456 ++ByteOffset;

457 }

458 return true;

459 }

460

462 if (CFP->getType()->isDoubleTy()) {

464 return ReadDataFromGlobal(C, ByteOffset, CurPtr, BytesLeft, DL);

465 }

466 if (CFP->getType()->isFloatTy()){

468 return ReadDataFromGlobal(C, ByteOffset, CurPtr, BytesLeft, DL);

469 }

470 if (CFP->getType()->isHalfTy()){

472 return ReadDataFromGlobal(C, ByteOffset, CurPtr, BytesLeft, DL);

473 }

474 return false;

475 }

476

478 const StructLayout *SL = DL.getStructLayout(CS->getType());

481 ByteOffset -= CurEltOffset;

482

483 while (true) {

484

485

486 uint64_t EltSize = DL.getTypeAllocSize(CS->getOperand(Index)->getType());

487

488 if (ByteOffset < EltSize &&

489 !ReadDataFromGlobal(CS->getOperand(Index), ByteOffset, CurPtr,

490 BytesLeft, DL))

491 return false;

492

493 ++Index;

494

495

496 if (Index == CS->getType()->getNumElements())

497 return true;

498

499

501

502 if (BytesLeft <= NextEltOffset - CurEltOffset - ByteOffset)

503 return true;

504

505

506 CurPtr += NextEltOffset - CurEltOffset - ByteOffset;

507 BytesLeft -= NextEltOffset - CurEltOffset - ByteOffset;

508 ByteOffset = 0;

509 CurEltOffset = NextEltOffset;

510 }

511

512 }

513

519 NumElts = AT->getNumElements();

520 EltTy = AT->getElementType();

521 EltSize = DL.getTypeAllocSize(EltTy);

522 } else {

525

526

527 if (.typeSizeEqualsStoreSize(EltTy))

528 return false;

529

530 EltSize = DL.getTypeStoreSize(EltTy);

531 }

532 uint64_t Index = ByteOffset / EltSize;

534

535 for (; Index != NumElts; ++Index) {

536 if (!ReadDataFromGlobal(C->getAggregateElement(Index), Offset, CurPtr,

537 BytesLeft, DL))

538 return false;

539

541 assert(BytesWritten <= EltSize && "Not indexing into this element?");

542 if (BytesWritten >= BytesLeft)

543 return true;

544

546 BytesLeft -= BytesWritten;

547 CurPtr += BytesWritten;

548 }

549 return true;

550 }

551

553 if (CE->getOpcode() == Instruction::IntToPtr &&

554 CE->getOperand(0)->getType() == DL.getIntPtrType(CE->getType())) {

555 return ReadDataFromGlobal(CE->getOperand(0), ByteOffset, CurPtr,

556 BytesLeft, DL);

557 }

558 }

559

560

561 return false;

562}

563

566

568 return nullptr;

569

571

572

573 if (!IntType) {

574

575

576

577

580 return nullptr;

581

583 DL.getTypeSizeInBits(LoadTy).getFixedValue());

584 if (Constant *Res = FoldReinterpretLoadFromConst(C, MapTy, Offset, DL)) {

585 if (Res->isNullValue() && !LoadTy->isX86_AMXTy())

586

591

592 if (Res->isNullValue() && !LoadTy->isX86_AMXTy())

594 if (DL.isNonIntegralPointerType(LoadTy->getScalarType()))

595

596 return nullptr;

598 }

599 return Res;

600 }

601 return nullptr;

602 }

603

604 unsigned BytesLoaded = (IntType->getBitWidth() + 7) / 8;

605 if (BytesLoaded > 32 || BytesLoaded == 0)

606 return nullptr;

607

608

609 if (Offset <= -1 * static_cast<int64_t>(BytesLoaded))

611

612

613 TypeSize InitializerSize = DL.getTypeAllocSize(C->getType());

615 return nullptr;

616

617

620

621 unsigned char RawBytes[32] = {0};

622 unsigned char *CurPtr = RawBytes;

623 unsigned BytesLeft = BytesLoaded;

624

625

630 }

631

632 if (!ReadDataFromGlobal(C, Offset, CurPtr, BytesLeft, DL))

633 return nullptr;

634

635 APInt ResultVal = APInt(IntType->getBitWidth(), 0);

636 if (DL.isLittleEndian()) {

637 ResultVal = RawBytes[BytesLoaded - 1];

638 for (unsigned i = 1; i != BytesLoaded; ++i) {

639 ResultVal <<= 8;

640 ResultVal |= RawBytes[BytesLoaded - 1 - i];

641 }

642 } else {

643 ResultVal = RawBytes[0];

644 for (unsigned i = 1; i != BytesLoaded; ++i) {

645 ResultVal <<= 8;

646 ResultVal |= RawBytes[i];

647 }

648 }

649

650 return ConstantInt::get(IntType->getContext(), ResultVal);

651}

652

653}

654

655

656

657

661 return nullptr;

662

665 TypeSize InitSize = DL.getTypeAllocSize(Init->getType());

666 if (InitSize < Offset)

667 return nullptr;

668

670 if (NBytes > UINT16_MAX)

671

672

673

674

675 return nullptr;

676

678 unsigned char *CurPtr = RawBytes.data();

679

680 if (!ReadDataFromGlobal(Init, Offset, CurPtr, NBytes, DL))

681 return nullptr;

682

684}

685

686

687

692

694 return nullptr;

695

696 Type *ElemTy = Base->getType();

698 if (.isZero() || !Indices[0].isZero())

699 return nullptr;

700

703 if (Index.isNegative() || Index.getActiveBits() >= 32)

704 return nullptr;

705

706 C = C->getAggregateElement(Index.getZExtValue());

707 if ()

708 return nullptr;

709 }

710

711 return C;

712}

713

719 return Result;

720

721

722

724 if (.isScalable() && Offset.sge(Size.getFixedValue()))

726

727

729 return Result;

730

731

732 if (Offset.getSignificantBits() <= 64)

734 FoldReinterpretLoadFromConst(C, Ty, Offset.getSExtValue(), DL))

735 return Result;

736

737 return nullptr;

738}

739

744

748

749

751 if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())

752 return nullptr;

753

755 DL, Offset, true));

756

757 if (C == GV)

760 return Result;

761

762

763

765}

766

772

779

780

781 if (.typeSizeEqualsStoreSize(C->getType()))

782 return nullptr;

783 if (C->isNullValue() && !Ty->isX86_AMXTy())

785 if (C->isAllOnesValue() &&

786 (Ty->isIntOrIntVectorTy() || Ty->isFPOrFPVectorTy()))

788 return nullptr;

789}

790

791namespace {

792

793

794

795

796

799

800

801

802

803

804

805 if (Opc == Instruction::And) {

808 if ((Known1.One | Known0.Zero).isAllOnes()) {

809

810 return Op0;

811 }

812 if ((Known0.One | Known1.Zero).isAllOnes()) {

813

814 return Op1;

815 }

816

817 Known0 &= Known1;

820 }

821

822

823

824 if (Opc == Instruction::Sub) {

826 APInt Offs1, Offs2;

827

830 unsigned OpSize = DL.getTypeSizeInBits(Op0->getType());

831

832

833

834

837 }

838 }

839

840 return nullptr;

841}

842

843

844

847 std::optional InRange,

849 Type *IntIdxTy = DL.getIndexType(ResultTy);

851

852 bool Any = false;

854 for (unsigned i = 1, e = Ops.size(); i != e; ++i) {

855 if ((i == 1 ||

857 SrcElemTy, Ops.slice(1, i - 1)))) &&

858 Ops[i]->getType()->getScalarType() != IntIdxScalarTy) {

859 Any = true;

860 Type *NewType =

861 Ops[i]->getType()->isVectorTy() ? IntIdxTy : IntIdxScalarTy;

865 if (!NewIdx)

866 return nullptr;

868 } else

870 }

871

872 if ()

873 return nullptr;

874

878}

879

880

885 Type *SrcElemTy = GEP->getSourceElementType();

886 Type *ResTy = GEP->getType();

888 return nullptr;

889

890 if (Constant *C = CastGEPIndices(SrcElemTy, Ops, ResTy, GEP->getNoWrapFlags(),

891 GEP->getInRange(), DL, TLI))

892 return C;

893

896 return nullptr;

897

898 Type *IntIdxTy = DL.getIndexType(Ptr->getType());

899

900 for (unsigned i = 1, e = Ops.size(); i != e; ++i)

902 return nullptr;

903

904 unsigned BitWidth = DL.getTypeSizeInBits(IntIdxTy);

907 DL.getIndexedOffsetInType(

909 true, true);

910

911 std::optional InRange = GEP->getInRange();

914

915

917 bool Overflow = false;

919 NW &= GEP->getNoWrapFlags();

920

922

923

924 bool AllConstantInt = true;

925 for (Value *NestedOp : NestedOps)

927 AllConstantInt = false;

928 break;

929 }

930 if (!AllConstantInt)

931 break;

932

933

934 if (auto GEPRange = GEP->getInRange()) {

935 auto AdjustedGEPRange = GEPRange->sextOrTrunc(BitWidth).subtract(Offset);

937 InRange ? InRange->intersectWith(AdjustedGEPRange) : AdjustedGEPRange;

938 }

939

941 SrcElemTy = GEP->getSourceElementType();

943 APInt(BitWidth, DL.getIndexedOffsetInType(SrcElemTy, NestedOps),

944 true, true),

945 Overflow);

946 }

947

948

949

952

953

954

955 APInt BaseIntVal(DL.getPointerTypeSizeInBits(Ptr->getType()), 0);

957 if (CE->getOpcode() == Instruction::IntToPtr) {

959 BaseIntVal = Base->getValue().zextOrTrunc(BaseIntVal.getBitWidth());

960 }

961 }

962

963 if ((Ptr->isNullValue() || BaseIntVal != 0) &&

964 .mustNotIntroduceIntToPtr(Ptr->getType())) {

965

966

967

968 BaseIntVal.insertBits(BaseIntVal.trunc(BitWidth) + Offset, 0);

971 }

972

973

975 bool CanBeNull, CanBeFreed;

978 if (DerefBytes != 0 && !CanBeNull && Offset.sle(DerefBytes))

980 }

981

982

985

986

989 ConstantInt::get(Ctx, Offset), NW,

991}

992

993

994

995

996

997

998Constant *ConstantFoldInstOperandsImpl(const Value *InstOrCE, unsigned Opcode,

1002 bool AllowNonDeterministic) {

1004

1007

1009 switch (Opcode) {

1010 default:

1011 break;

1012 case Instruction::FAdd:

1013 case Instruction::FSub:

1014 case Instruction::FMul:

1015 case Instruction::FDiv:

1016 case Instruction::FRem:

1017

1018

1019

1022 AllowNonDeterministic);

1023 }

1024 }

1026 }

1027

1030

1032 Type *SrcElemTy = GEP->getSourceElementType();

1034 return nullptr;

1035

1037 return C;

1038

1040 GEP->getNoWrapFlags(),

1041 GEP->getInRange());

1042 }

1043

1045 return CE->getWithOperands(Ops);

1046

1047 switch (Opcode) {

1048 default: return nullptr;

1049 case Instruction::ICmp:

1050 case Instruction::FCmp: {

1053 DL, TLI, C);

1054 }

1055 case Instruction::Freeze:

1057 case Instruction::Call:

1062 AllowNonDeterministic);

1063 }

1064 return nullptr;

1065 case Instruction::Select:

1067 case Instruction::ExtractElement:

1069 case Instruction::ExtractValue:

1072 case Instruction::InsertElement:

1074 case Instruction::InsertValue:

1077 case Instruction::ShuffleVector:

1080 case Instruction::Load: {

1082 if (LI->isVolatile())

1083 return nullptr;

1085 }

1086 }

1087}

1088

1089}

1090

1091

1092

1093

1094

1095namespace {

1096

1102 return const_cast<Constant *>(C);

1103

1105 for (const Use &OldU : C->operands()) {

1108

1109

1111 auto It = FoldedOps.find(OldC);

1112 if (It == FoldedOps.end()) {

1113 NewC = ConstantFoldConstantImpl(OldC, DL, TLI, FoldedOps);

1114 FoldedOps.insert({OldC, NewC});

1115 } else {

1116 NewC = It->second;

1117 }

1118 }

1119 Ops.push_back(NewC);

1120 }

1121

1123 if (Constant *Res = ConstantFoldInstOperandsImpl(

1124 CE, CE->getOpcode(), Ops, DL, TLI, true))

1125 return Res;

1126 return const_cast<Constant *>(C);

1127 }

1128

1131}

1132

1133}

1134

1138

1140 Constant *CommonValue = nullptr;

1141

1144

1145

1146

1147

1149 continue;

1150

1152 if ()

1153 return nullptr;

1154

1155 C = ConstantFoldConstantImpl(C, DL, TLI, FoldedOps);

1156

1157

1158 if (CommonValue && C != CommonValue)

1159 return nullptr;

1160 CommonValue = C;

1161 }

1162

1163

1164 return CommonValue ? CommonValue : UndefValue::get(PN->getType());

1165 }

1166

1167

1168

1169 if ((I->operands(), [](const Use &U) { return isa(U); }))

1170 return nullptr;

1171

1174 for (const Use &OpU : I->operands()) {

1176

1177 Op = ConstantFoldConstantImpl(Op, DL, TLI, FoldedOps);

1178 Ops.push_back(Op);

1179 }

1180

1182}

1183

1187 return ConstantFoldConstantImpl(C, DL, TLI, FoldedOps);

1188}

1189

1194 bool AllowNonDeterministic) {

1195 return ConstantFoldInstOperandsImpl(I, I->getOpcode(), Ops, DL, TLI,

1196 AllowNonDeterministic);

1197}

1198

1203

1204

1205

1206

1207

1208

1209

1210

1211

1212

1215 if (CE0->getOpcode() == Instruction::IntToPtr) {

1216 Type *IntPtrTy = DL.getIntPtrType(CE0->getType());

1217

1218

1220 false, DL)) {

1223 }

1224 }

1225

1226

1227

1228 if (CE0->getOpcode() == Instruction::PtrToInt) {

1229 Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType());

1230 if (CE0->getType() == IntPtrTy) {

1231 Constant *C = CE0->getOperand(0);

1234 }

1235 }

1236 }

1237

1239 if (CE0->getOpcode() == CE1->getOpcode()) {

1240 if (CE0->getOpcode() == Instruction::IntToPtr) {

1241 Type *IntPtrTy = DL.getIntPtrType(CE0->getType());

1242

1243

1244

1246 false, DL);

1248 false, DL);

1249 if (C0 && C1)

1251 }

1252

1253

1254

1255 if (CE0->getOpcode() == Instruction::PtrToInt) {

1256 Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType());

1257 if (CE0->getType() == IntPtrTy &&

1258 CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()) {

1260 Predicate, CE0->getOperand(0), CE1->getOperand(0), DL, TLI);

1261 }

1262 }

1263 }

1264 }

1265

1266

1267

1268

1269

1270

1272 unsigned IndexWidth = DL.getIndexTypeSizeInBits(Ops0->getType());

1273 APInt Offset0(IndexWidth, 0);

1276 DL, Offset0, IsEqPred,

1277 false, nullptr,

1278 IsEqPred);

1279 APInt Offset1(IndexWidth, 0);

1281 DL, Offset1, IsEqPred,

1282 false, nullptr,

1283 IsEqPred);

1284 if (Stripped0 == Stripped1)

1289 }

1291

1292

1295 }

1296

1298

1299

1301 if (!Ops0)

1302 return nullptr;

1304 if (!Ops1)

1305 return nullptr;

1306 }

1307

1309}

1310

1317

1323 if (Constant *C = SymbolicallyEvaluateBinop(Opcode, LHS, RHS, DL))

1324 return C;

1325

1329}

1330

1333 switch (Mode) {

1335 return nullptr;

1337 return ConstantFP::get(Ty->getContext(), APF);

1339 return ConstantFP::get(

1340 Ty->getContext(),

1343 return ConstantFP::get(Ty->getContext(),

1345 default:

1346 break;

1347 }

1348

1350}

1351

1352

1353

1359

1362 bool IsOutput) {

1365 return CFP;

1366

1369 IsOutput ? Mode.Output : Mode.Input);

1370}

1371

1373 bool IsOutput) {

1376

1378 return Operand;

1379

1382 if (VecTy) {

1385 if (!Folded)

1386 return nullptr;

1388 }

1389

1391 }

1392

1394 return Operand;

1395

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

1402 continue;

1403 }

1404

1406 if (!CFP)

1407 return nullptr;

1408

1410 if (!Folded)

1411 return nullptr;

1413 }

1414

1416 }

1417

1420 for (unsigned I = 0, E = CDV->getNumElements(); I < E; ++I) {

1421 const APFloat &Elt = CDV->getElementAsAPFloat(I);

1423 NewElts.push_back(ConstantFP::get(Ty, Elt));

1424 } else {

1428 if (!Folded)

1429 return nullptr;

1431 }

1432 }

1433

1435 }

1436

1437 return nullptr;

1438}

1439

1443 bool AllowNonDeterministic) {

1445

1447 if (!Op0)

1448 return nullptr;

1450 if (!Op1)

1451 return nullptr;

1452

1453

1454

1455

1456 if (!AllowNonDeterministic)

1458 if (FP->hasNoSignedZeros() || FP->hasAllowReassoc() ||

1459 FP->hasAllowContract() || FP->hasAllowReciprocal())

1460 return nullptr;

1461

1462

1464 if ()

1465 return nullptr;

1466

1467

1469 if ()

1470 return nullptr;

1471

1472

1473 if (!AllowNonDeterministic && C->isNaN())

1474 return nullptr;

1475

1476 return C;

1477 }

1478

1479

1481}

1482

1486

1488 if (CE->isCast())

1492 C->getType(), DestTy, &DL))

1494

1495 switch (Opcode) {

1496 default:

1498 case Instruction::PtrToAddr:

1499 case Instruction::PtrToInt:

1501 Constant *FoldedValue = nullptr;

1502

1503

1504 if (CE->getOpcode() == Instruction::IntToPtr) {

1505

1506 Type *MidTy = Opcode == Instruction::PtrToInt

1507 ? DL.getAddressType(CE->getType())

1508 : DL.getIntPtrType(CE->getType());

1510 false, DL);

1512

1513

1514

1515 unsigned BitWidth = DL.getIndexTypeSizeInBits(GEP->getType());

1518 DL, BaseOffset, true));

1519 if (Base->isNullValue()) {

1520 FoldedValue = ConstantInt::get(CE->getContext(), BaseOffset);

1521 } else {

1522

1523

1524 if (GEP->getNumIndices() == 1 &&

1525 GEP->getSourceElementType()->isIntegerTy(8)) {

1528 Type *IntIdxTy = DL.getIndexType(Ptr->getType());

1529 if (Sub && Sub->getType() == IntIdxTy &&

1530 Sub->getOpcode() == Instruction::Sub &&

1531 Sub->getOperand(0)->isNullValue())

1534 Sub->getOperand(1));

1535 }

1536 }

1537 }

1538 if (FoldedValue) {

1539

1541 DL);

1542 }

1543 }

1544 break;

1545 case Instruction::IntToPtr:

1546

1547

1548

1549

1551 if (CE->getOpcode() == Instruction::PtrToInt) {

1552 Constant *SrcPtr = CE->getOperand(0);

1553 unsigned SrcPtrSize = DL.getPointerTypeSizeInBits(SrcPtr->getType());

1554 unsigned MidIntSize = CE->getType()->getScalarSizeInBits();

1555

1556 if (MidIntSize >= SrcPtrSize) {

1559 return FoldBitCast(CE->getOperand(0), DestTy, DL);

1560 }

1561 }

1562 }

1563 break;

1564 case Instruction::Trunc:

1565 case Instruction::ZExt:

1566 case Instruction::SExt:

1567 case Instruction::FPTrunc:

1568 case Instruction::FPExt:

1569 case Instruction::UIToFP:

1570 case Instruction::SIToFP:

1571 case Instruction::FPToUI:

1572 case Instruction::FPToSI:

1573 case Instruction::AddrSpaceCast:

1574 break;

1575 case Instruction::BitCast:

1577 }

1578

1582}

1583

1586 Type *SrcTy = C->getType();

1587 if (SrcTy == DestTy)

1588 return C;

1591 if (IsSigned)

1594}

1595

1596

1597

1598

1599

1601 if (Call->isNoBuiltin())

1602 return false;

1603 if (Call->getFunctionType() != F->getFunctionType())

1604 return false;

1605

1606

1607

1608

1609

1612 return Arg.getType()->isFloatingPointTy();

1613 })))

1614 return false;

1615

1616 switch (F->getIntrinsicID()) {

1617

1618

1619 case Intrinsic::bswap:

1620 case Intrinsic::ctpop:

1621 case Intrinsic::ctlz:

1622 case Intrinsic::cttz:

1623 case Intrinsic::fshl:

1624 case Intrinsic::fshr:

1625 case Intrinsic::launder_invariant_group:

1626 case Intrinsic::strip_invariant_group:

1627 case Intrinsic::masked_load:

1628 case Intrinsic::get_active_lane_mask:

1629 case Intrinsic::abs:

1630 case Intrinsic::smax:

1631 case Intrinsic::smin:

1632 case Intrinsic::umax:

1633 case Intrinsic::umin:

1634 case Intrinsic::scmp:

1635 case Intrinsic::ucmp:

1636 case Intrinsic::sadd_with_overflow:

1637 case Intrinsic::uadd_with_overflow:

1638 case Intrinsic::ssub_with_overflow:

1639 case Intrinsic::usub_with_overflow:

1640 case Intrinsic::smul_with_overflow:

1641 case Intrinsic::umul_with_overflow:

1642 case Intrinsic::sadd_sat:

1643 case Intrinsic::uadd_sat:

1644 case Intrinsic::ssub_sat:

1645 case Intrinsic::usub_sat:

1646 case Intrinsic::smul_fix:

1647 case Intrinsic::smul_fix_sat:

1648 case Intrinsic::bitreverse:

1649 case Intrinsic::is_constant:

1650 case Intrinsic::vector_reduce_add:

1651 case Intrinsic::vector_reduce_mul:

1652 case Intrinsic::vector_reduce_and:

1653 case Intrinsic::vector_reduce_or:

1654 case Intrinsic::vector_reduce_xor:

1655 case Intrinsic::vector_reduce_smin:

1656 case Intrinsic::vector_reduce_smax:

1657 case Intrinsic::vector_reduce_umin:

1658 case Intrinsic::vector_reduce_umax:

1659 case Intrinsic::vector_extract:

1660 case Intrinsic::vector_insert:

1661 case Intrinsic::vector_interleave2:

1662 case Intrinsic::vector_interleave3:

1663 case Intrinsic::vector_interleave4:

1664 case Intrinsic::vector_interleave5:

1665 case Intrinsic::vector_interleave6:

1666 case Intrinsic::vector_interleave7:

1667 case Intrinsic::vector_interleave8:

1668 case Intrinsic::vector_deinterleave2:

1669 case Intrinsic::vector_deinterleave3:

1670 case Intrinsic::vector_deinterleave4:

1671 case Intrinsic::vector_deinterleave5:

1672 case Intrinsic::vector_deinterleave6:

1673 case Intrinsic::vector_deinterleave7:

1674 case Intrinsic::vector_deinterleave8:

1675

1676 case Intrinsic::amdgcn_perm:

1677 case Intrinsic::amdgcn_wave_reduce_umin:

1678 case Intrinsic::amdgcn_wave_reduce_umax:

1679 case Intrinsic::amdgcn_wave_reduce_max:

1680 case Intrinsic::amdgcn_wave_reduce_min:

1681 case Intrinsic::amdgcn_wave_reduce_add:

1682 case Intrinsic::amdgcn_wave_reduce_sub:

1683 case Intrinsic::amdgcn_wave_reduce_and:

1684 case Intrinsic::amdgcn_wave_reduce_or:

1685 case Intrinsic::amdgcn_wave_reduce_xor:

1686 case Intrinsic::amdgcn_s_wqm:

1687 case Intrinsic::amdgcn_s_quadmask:

1688 case Intrinsic::amdgcn_s_bitreplicate:

1689 case Intrinsic::arm_mve_vctp8:

1690 case Intrinsic::arm_mve_vctp16:

1691 case Intrinsic::arm_mve_vctp32:

1692 case Intrinsic::arm_mve_vctp64:

1693 case Intrinsic::aarch64_sve_convert_from_svbool:

1694 case Intrinsic::wasm_alltrue:

1695 case Intrinsic::wasm_anytrue:

1696 case Intrinsic::wasm_dot:

1697

1698 case Intrinsic::wasm_trunc_signed:

1699 case Intrinsic::wasm_trunc_unsigned:

1700 return true;

1701

1702

1703

1704 case Intrinsic::minnum:

1705 case Intrinsic::maxnum:

1706 case Intrinsic::minimum:

1707 case Intrinsic::maximum:

1708 case Intrinsic::minimumnum:

1709 case Intrinsic::maximumnum:

1710 case Intrinsic:🪵

1711 case Intrinsic::log2:

1712 case Intrinsic::log10:

1713 case Intrinsic::exp:

1714 case Intrinsic::exp2:

1715 case Intrinsic::exp10:

1716 case Intrinsic::sqrt:

1717 case Intrinsic::sin:

1718 case Intrinsic::cos:

1719 case Intrinsic::sincos:

1720 case Intrinsic::sinh:

1721 case Intrinsic::cosh:

1722 case Intrinsic::atan:

1723 case Intrinsic::pow:

1724 case Intrinsic::powi:

1725 case Intrinsic::ldexp:

1726 case Intrinsic::fma:

1727 case Intrinsic::fmuladd:

1728 case Intrinsic::frexp:

1729 case Intrinsic::fptoui_sat:

1730 case Intrinsic::fptosi_sat:

1731 case Intrinsic::convert_from_fp16:

1732 case Intrinsic::convert_to_fp16:

1733 case Intrinsic::amdgcn_cos:

1734 case Intrinsic::amdgcn_cubeid:

1735 case Intrinsic::amdgcn_cubema:

1736 case Intrinsic::amdgcn_cubesc:

1737 case Intrinsic::amdgcn_cubetc:

1738 case Intrinsic::amdgcn_fmul_legacy:

1739 case Intrinsic::amdgcn_fma_legacy:

1740 case Intrinsic::amdgcn_fract:

1741 case Intrinsic::amdgcn_sin:

1742

1743 case Intrinsic::x86_sse_cvtss2si:

1744 case Intrinsic::x86_sse_cvtss2si64:

1745 case Intrinsic::x86_sse_cvttss2si:

1746 case Intrinsic::x86_sse_cvttss2si64:

1747 case Intrinsic::x86_sse2_cvtsd2si:

1748 case Intrinsic::x86_sse2_cvtsd2si64:

1749 case Intrinsic::x86_sse2_cvttsd2si:

1750 case Intrinsic::x86_sse2_cvttsd2si64:

1751 case Intrinsic::x86_avx512_vcvtss2si32:

1752 case Intrinsic::x86_avx512_vcvtss2si64:

1753 case Intrinsic::x86_avx512_cvttss2si:

1754 case Intrinsic::x86_avx512_cvttss2si64:

1755 case Intrinsic::x86_avx512_vcvtsd2si32:

1756 case Intrinsic::x86_avx512_vcvtsd2si64:

1757 case Intrinsic::x86_avx512_cvttsd2si:

1758 case Intrinsic::x86_avx512_cvttsd2si64:

1759 case Intrinsic::x86_avx512_vcvtss2usi32:

1760 case Intrinsic::x86_avx512_vcvtss2usi64:

1761 case Intrinsic::x86_avx512_cvttss2usi:

1762 case Intrinsic::x86_avx512_cvttss2usi64:

1763 case Intrinsic::x86_avx512_vcvtsd2usi32:

1764 case Intrinsic::x86_avx512_vcvtsd2usi64:

1765 case Intrinsic::x86_avx512_cvttsd2usi:

1766 case Intrinsic::x86_avx512_cvttsd2usi64:

1767

1768

1769 case Intrinsic::nvvm_fmax_d:

1770 case Intrinsic::nvvm_fmax_f:

1771 case Intrinsic::nvvm_fmax_ftz_f:

1772 case Intrinsic::nvvm_fmax_ftz_nan_f:

1773 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:

1774 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:

1775 case Intrinsic::nvvm_fmax_nan_f:

1776 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:

1777 case Intrinsic::nvvm_fmax_xorsign_abs_f:

1778

1779

1780 case Intrinsic::nvvm_fmin_d:

1781 case Intrinsic::nvvm_fmin_f:

1782 case Intrinsic::nvvm_fmin_ftz_f:

1783 case Intrinsic::nvvm_fmin_ftz_nan_f:

1784 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:

1785 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:

1786 case Intrinsic::nvvm_fmin_nan_f:

1787 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:

1788 case Intrinsic::nvvm_fmin_xorsign_abs_f:

1789

1790

1791 case Intrinsic::nvvm_f2i_rm:

1792 case Intrinsic::nvvm_f2i_rn:

1793 case Intrinsic::nvvm_f2i_rp:

1794 case Intrinsic::nvvm_f2i_rz:

1795 case Intrinsic::nvvm_f2i_rm_ftz:

1796 case Intrinsic::nvvm_f2i_rn_ftz:

1797 case Intrinsic::nvvm_f2i_rp_ftz:

1798 case Intrinsic::nvvm_f2i_rz_ftz:

1799 case Intrinsic::nvvm_f2ui_rm:

1800 case Intrinsic::nvvm_f2ui_rn:

1801 case Intrinsic::nvvm_f2ui_rp:

1802 case Intrinsic::nvvm_f2ui_rz:

1803 case Intrinsic::nvvm_f2ui_rm_ftz:

1804 case Intrinsic::nvvm_f2ui_rn_ftz:

1805 case Intrinsic::nvvm_f2ui_rp_ftz:

1806 case Intrinsic::nvvm_f2ui_rz_ftz:

1807 case Intrinsic::nvvm_d2i_rm:

1808 case Intrinsic::nvvm_d2i_rn:

1809 case Intrinsic::nvvm_d2i_rp:

1810 case Intrinsic::nvvm_d2i_rz:

1811 case Intrinsic::nvvm_d2ui_rm:

1812 case Intrinsic::nvvm_d2ui_rn:

1813 case Intrinsic::nvvm_d2ui_rp:

1814 case Intrinsic::nvvm_d2ui_rz:

1815

1816

1817 case Intrinsic::nvvm_f2ll_rm:

1818 case Intrinsic::nvvm_f2ll_rn:

1819 case Intrinsic::nvvm_f2ll_rp:

1820 case Intrinsic::nvvm_f2ll_rz:

1821 case Intrinsic::nvvm_f2ll_rm_ftz:

1822 case Intrinsic::nvvm_f2ll_rn_ftz:

1823 case Intrinsic::nvvm_f2ll_rp_ftz:

1824 case Intrinsic::nvvm_f2ll_rz_ftz:

1825 case Intrinsic::nvvm_f2ull_rm:

1826 case Intrinsic::nvvm_f2ull_rn:

1827 case Intrinsic::nvvm_f2ull_rp:

1828 case Intrinsic::nvvm_f2ull_rz:

1829 case Intrinsic::nvvm_f2ull_rm_ftz:

1830 case Intrinsic::nvvm_f2ull_rn_ftz:

1831 case Intrinsic::nvvm_f2ull_rp_ftz:

1832 case Intrinsic::nvvm_f2ull_rz_ftz:

1833 case Intrinsic::nvvm_d2ll_rm:

1834 case Intrinsic::nvvm_d2ll_rn:

1835 case Intrinsic::nvvm_d2ll_rp:

1836 case Intrinsic::nvvm_d2ll_rz:

1837 case Intrinsic::nvvm_d2ull_rm:

1838 case Intrinsic::nvvm_d2ull_rn:

1839 case Intrinsic::nvvm_d2ull_rp:

1840 case Intrinsic::nvvm_d2ull_rz:

1841

1842

1843 case Intrinsic::nvvm_ceil_d:

1844 case Intrinsic::nvvm_ceil_f:

1845 case Intrinsic::nvvm_ceil_ftz_f:

1846

1847 case Intrinsic::nvvm_fabs:

1848 case Intrinsic::nvvm_fabs_ftz:

1849

1850 case Intrinsic::nvvm_floor_d:

1851 case Intrinsic::nvvm_floor_f:

1852 case Intrinsic::nvvm_floor_ftz_f:

1853

1854 case Intrinsic::nvvm_rcp_rm_d:

1855 case Intrinsic::nvvm_rcp_rm_f:

1856 case Intrinsic::nvvm_rcp_rm_ftz_f:

1857 case Intrinsic::nvvm_rcp_rn_d:

1858 case Intrinsic::nvvm_rcp_rn_f:

1859 case Intrinsic::nvvm_rcp_rn_ftz_f:

1860 case Intrinsic::nvvm_rcp_rp_d:

1861 case Intrinsic::nvvm_rcp_rp_f:

1862 case Intrinsic::nvvm_rcp_rp_ftz_f:

1863 case Intrinsic::nvvm_rcp_rz_d:

1864 case Intrinsic::nvvm_rcp_rz_f:

1865 case Intrinsic::nvvm_rcp_rz_ftz_f:

1866

1867 case Intrinsic::nvvm_round_d:

1868 case Intrinsic::nvvm_round_f:

1869 case Intrinsic::nvvm_round_ftz_f:

1870

1871 case Intrinsic::nvvm_saturate_d:

1872 case Intrinsic::nvvm_saturate_f:

1873 case Intrinsic::nvvm_saturate_ftz_f:

1874

1875 case Intrinsic::nvvm_sqrt_f:

1876 case Intrinsic::nvvm_sqrt_rn_d:

1877 case Intrinsic::nvvm_sqrt_rn_f:

1878 case Intrinsic::nvvm_sqrt_rn_ftz_f:

1879 return ->isStrictFP();

1880

1881

1882 case Intrinsic::nvvm_add_rm_d:

1883 case Intrinsic::nvvm_add_rn_d:

1884 case Intrinsic::nvvm_add_rp_d:

1885 case Intrinsic::nvvm_add_rz_d:

1886 case Intrinsic::nvvm_add_rm_f:

1887 case Intrinsic::nvvm_add_rn_f:

1888 case Intrinsic::nvvm_add_rp_f:

1889 case Intrinsic::nvvm_add_rz_f:

1890 case Intrinsic::nvvm_add_rm_ftz_f:

1891 case Intrinsic::nvvm_add_rn_ftz_f:

1892 case Intrinsic::nvvm_add_rp_ftz_f:

1893 case Intrinsic::nvvm_add_rz_ftz_f:

1894

1895

1896 case Intrinsic::nvvm_div_rm_d:

1897 case Intrinsic::nvvm_div_rn_d:

1898 case Intrinsic::nvvm_div_rp_d:

1899 case Intrinsic::nvvm_div_rz_d:

1900 case Intrinsic::nvvm_div_rm_f:

1901 case Intrinsic::nvvm_div_rn_f:

1902 case Intrinsic::nvvm_div_rp_f:

1903 case Intrinsic::nvvm_div_rz_f:

1904 case Intrinsic::nvvm_div_rm_ftz_f:

1905 case Intrinsic::nvvm_div_rn_ftz_f:

1906 case Intrinsic::nvvm_div_rp_ftz_f:

1907 case Intrinsic::nvvm_div_rz_ftz_f:

1908

1909

1910 case Intrinsic::nvvm_mul_rm_d:

1911 case Intrinsic::nvvm_mul_rn_d:

1912 case Intrinsic::nvvm_mul_rp_d:

1913 case Intrinsic::nvvm_mul_rz_d:

1914 case Intrinsic::nvvm_mul_rm_f:

1915 case Intrinsic::nvvm_mul_rn_f:

1916 case Intrinsic::nvvm_mul_rp_f:

1917 case Intrinsic::nvvm_mul_rz_f:

1918 case Intrinsic::nvvm_mul_rm_ftz_f:

1919 case Intrinsic::nvvm_mul_rn_ftz_f:

1920 case Intrinsic::nvvm_mul_rp_ftz_f:

1921 case Intrinsic::nvvm_mul_rz_ftz_f:

1922

1923

1924 case Intrinsic::nvvm_fma_rm_d:

1925 case Intrinsic::nvvm_fma_rn_d:

1926 case Intrinsic::nvvm_fma_rp_d:

1927 case Intrinsic::nvvm_fma_rz_d:

1928 case Intrinsic::nvvm_fma_rm_f:

1929 case Intrinsic::nvvm_fma_rn_f:

1930 case Intrinsic::nvvm_fma_rp_f:

1931 case Intrinsic::nvvm_fma_rz_f:

1932 case Intrinsic::nvvm_fma_rm_ftz_f:

1933 case Intrinsic::nvvm_fma_rn_ftz_f:

1934 case Intrinsic::nvvm_fma_rp_ftz_f:

1935 case Intrinsic::nvvm_fma_rz_ftz_f:

1936

1937

1938

1939 case Intrinsic::fabs:

1940 case Intrinsic::copysign:

1941 case Intrinsic::is_fpclass:

1942

1943

1944 case Intrinsic::ceil:

1945 case Intrinsic:🤣

1946 case Intrinsic::round:

1947 case Intrinsic::roundeven:

1948 case Intrinsic::trunc:

1949 case Intrinsic::nearbyint:

1950 case Intrinsic::rint:

1951 case Intrinsic::canonicalize:

1952

1953

1954

1955 case Intrinsic::experimental_constrained_fma:

1956 case Intrinsic::experimental_constrained_fmuladd:

1957 case Intrinsic::experimental_constrained_fadd:

1958 case Intrinsic::experimental_constrained_fsub:

1959 case Intrinsic::experimental_constrained_fmul:

1960 case Intrinsic::experimental_constrained_fdiv:

1961 case Intrinsic::experimental_constrained_frem:

1962 case Intrinsic::experimental_constrained_ceil:

1963 case Intrinsic::experimental_constrained_floor:

1964 case Intrinsic::experimental_constrained_round:

1965 case Intrinsic::experimental_constrained_roundeven:

1966 case Intrinsic::experimental_constrained_trunc:

1967 case Intrinsic::experimental_constrained_nearbyint:

1968 case Intrinsic::experimental_constrained_rint:

1969 case Intrinsic::experimental_constrained_fcmp:

1970 case Intrinsic::experimental_constrained_fcmps:

1971 return true;

1972 default:

1973 return false;

1975 }

1976

1977 if (->hasName() || Call->isStrictFP())

1978 return false;

1979

1980

1981

1982

1984 switch (Name[0]) {

1985 default:

1986 return false;

1987

1988 case 'a':

1989 return Name == "acos" || Name == "acosf" ||

1990 Name == "asin" || Name == "asinf" ||

1991 Name == "atan" || Name == "atanf" ||

1992 Name == "atan2" || Name == "atan2f";

1993 case 'c':

1994 return Name == "ceil" || Name == "ceilf" ||

1995 Name == "cos" || Name == "cosf" ||

1996 Name == "cosh" || Name == "coshf";

1997 case 'e':

1998 return Name == "exp" || Name == "expf" || Name == "exp2" ||

1999 Name == "exp2f" || Name == "erf" || Name == "erff";

2000 case 'f':

2001 return Name == "fabs" || Name == "fabsf" ||

2002 Name == "floor" || Name == "floorf" ||

2003 Name == "fmod" || Name == "fmodf";

2004 case 'i':

2005 return Name == "ilogb" || Name == "ilogbf";

2006 case 'l':

2007 return Name == "log" || Name == "logf" || Name == "logl" ||

2008 Name == "log2" || Name == "log2f" || Name == "log10" ||

2009 Name == "log10f" || Name == "logb" || Name == "logbf" ||

2010 Name == "log1p" || Name == "log1pf";

2011 case 'n':

2012 return Name == "nearbyint" || Name == "nearbyintf";

2013 case 'p':

2014 return Name == "pow" || Name == "powf";

2015 case 'r':

2016 return Name == "remainder" || Name == "remainderf" ||

2017 Name == "rint" || Name == "rintf" ||

2018 Name == "round" || Name == "roundf" ||

2019 Name == "roundeven" || Name == "roundevenf";

2020 case 's':

2021 return Name == "sin" || Name == "sinf" ||

2022 Name == "sinh" || Name == "sinhf" ||

2023 Name == "sqrt" || Name == "sqrtf";

2024 case 't':

2025 return Name == "tan" || Name == "tanf" ||

2026 Name == "tanh" || Name == "tanhf" ||

2027 Name == "trunc" || Name == "truncf";

2028 case '_':

2029

2030

2031

2032

2033

2034

2035 if (Name.size() < 12 || Name[1] != '_')

2036 return false;

2037 switch (Name[2]) {

2038 default:

2039 return false;

2040 case 'a':

2041 return Name == "__acos_finite" || Name == "__acosf_finite" ||

2042 Name == "__asin_finite" || Name == "__asinf_finite" ||

2043 Name == "__atan2_finite" || Name == "__atan2f_finite";

2044 case 'c':

2045 return Name == "__cosh_finite" || Name == "__coshf_finite";

2046 case 'e':

2047 return Name == "__exp_finite" || Name == "__expf_finite" ||

2048 Name == "__exp2_finite" || Name == "__exp2f_finite";

2049 case 'l':

2050 return Name == "__log_finite" || Name == "__logf_finite" ||

2051 Name == "__log10_finite" || Name == "__log10f_finite";

2052 case 'p':

2053 return Name == "__pow_finite" || Name == "__powf_finite";

2054 case 's':

2055 return Name == "__sinh_finite" || Name == "__sinhf_finite";

2056 }

2057

2058 }

2059}

2060

2061namespace {

2062

2063Constant *GetConstantFoldFPValue(double V, Type *Ty) {

2064 if (Ty->isHalfTy() || Ty->isFloatTy()) {

2066 bool unused;

2068 return ConstantFP::get(Ty->getContext(), APF);

2069 }

2070 if (Ty->isDoubleTy())

2071 return ConstantFP::get(Ty->getContext(), APFloat(V));

2072 llvm_unreachable("Can only constant fold half/float/double");

2073}

2074

2075#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)

2076Constant *GetConstantFoldFPValue128(float128 V, Type *Ty) {

2077 if (Ty->isFP128Ty())

2078 return ConstantFP::get(Ty, V);

2080}

2081#endif

2082

2083

2084inline void llvm_fenv_clearexcept() {

2085#if HAVE_DECL_FE_ALL_EXCEPT

2086 feclearexcept(FE_ALL_EXCEPT);

2087#endif

2088 errno = 0;

2089}

2090

2091

2092inline bool llvm_fenv_testexcept() {

2093 int errno_val = errno;

2094 if (errno_val == ERANGE || errno_val == EDOM)

2095 return true;

2096#if HAVE_DECL_FE_ALL_EXCEPT && HAVE_DECL_FE_INEXACT

2097 if (fetestexcept(FE_ALL_EXCEPT & ~FE_INEXACT))

2098 return true;

2099#endif

2100 return false;

2101}

2102

2104 if (V.isDenormal())

2106 return V;

2107}

2108

2109static APFloat FlushToPositiveZero(const APFloat &V) {

2110 if (V.isDenormal())

2112 return V;

2113}

2114

2119 switch (DenormKind) {

2121 return V;

2123 return FTZPreserveSign(V);

2125 return FlushToPositiveZero(V);

2126 default:

2128 }

2129}

2130

2131Constant *ConstantFoldFP(double (*NativeFP)(double), const APFloat &V, Type *Ty,

2133 if (!DenormMode.isValid() ||

2136 return nullptr;

2137

2138 llvm_fenv_clearexcept();

2139 auto Input = FlushWithDenormKind(V, DenormMode.Input);

2140 double Result = NativeFP(Input.convertToDouble());

2141 if (llvm_fenv_testexcept()) {

2142 llvm_fenv_clearexcept();

2143 return nullptr;

2144 }

2145

2146 Constant *Output = GetConstantFoldFPValue(Result, Ty);

2148 return Output;

2149 const auto *CFP = static_cast<ConstantFP *>(Output);

2150 const auto Res = FlushWithDenormKind(CFP->getValueAPF(), DenormMode.Output);

2151 return ConstantFP::get(Ty->getContext(), Res);

2152}

2153

2154#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)

2155Constant *ConstantFoldFP128(float128 (*NativeFP)(float128), const APFloat &V,

2157 llvm_fenv_clearexcept();

2158 float128 Result = NativeFP(V.convertToQuad());

2159 if (llvm_fenv_testexcept()) {

2160 llvm_fenv_clearexcept();

2161 return nullptr;

2162 }

2163

2164 return GetConstantFoldFPValue128(Result, Ty);

2165}

2166#endif

2167

2168Constant *ConstantFoldBinaryFP(double (*NativeFP)(double, double),

2170 llvm_fenv_clearexcept();

2171 double Result = NativeFP(V.convertToDouble(), W.convertToDouble());

2172 if (llvm_fenv_testexcept()) {

2173 llvm_fenv_clearexcept();

2174 return nullptr;

2175 }

2176

2177 return GetConstantFoldFPValue(Result, Ty);

2178}

2179

2182

2183

2184 if (Op->containsPoisonElement())

2186

2187

2188 if (Constant *SplatVal = Op->getSplatValue()) {

2189 switch (IID) {

2190 case Intrinsic::vector_reduce_and:

2191 case Intrinsic::vector_reduce_or:

2192 case Intrinsic::vector_reduce_smin:

2193 case Intrinsic::vector_reduce_smax:

2194 case Intrinsic::vector_reduce_umin:

2195 case Intrinsic::vector_reduce_umax:

2196 return SplatVal;

2197 case Intrinsic::vector_reduce_add:

2198 if (SplatVal->isNullValue())

2199 return SplatVal;

2200 break;

2201 case Intrinsic::vector_reduce_mul:

2202 if (SplatVal->isNullValue() || SplatVal->isOneValue())

2203 return SplatVal;

2204 break;

2205 case Intrinsic::vector_reduce_xor:

2206 if (SplatVal->isNullValue())

2207 return SplatVal;

2208 if (OpVT->getElementCount().isKnownMultipleOf(2))

2210 break;

2211 }

2212 }

2213

2215 if (!VT)

2216 return nullptr;

2217

2218

2220 if (!EltC)

2221 return nullptr;

2222

2223 APInt Acc = EltC->getValue();

2226 return nullptr;

2227 const APInt &X = EltC->getValue();

2228 switch (IID) {

2229 case Intrinsic::vector_reduce_add:

2230 Acc = Acc + X;

2231 break;

2232 case Intrinsic::vector_reduce_mul:

2233 Acc = Acc * X;

2234 break;

2235 case Intrinsic::vector_reduce_and:

2236 Acc = Acc & X;

2237 break;

2238 case Intrinsic::vector_reduce_or:

2239 Acc = Acc | X;

2240 break;

2241 case Intrinsic::vector_reduce_xor:

2242 Acc = Acc ^ X;

2243 break;

2244 case Intrinsic::vector_reduce_smin:

2246 break;

2247 case Intrinsic::vector_reduce_smax:

2249 break;

2250 case Intrinsic::vector_reduce_umin:

2252 break;

2253 case Intrinsic::vector_reduce_umax:

2255 break;

2256 }

2257 }

2258

2259 return ConstantInt::get(Op->getContext(), Acc);

2260}

2261

2262

2263

2264

2265

2266

2267

2268

2269Constant *ConstantFoldSSEConvertToInt(const APFloat &Val, bool roundTowardZero,

2270 Type *Ty, bool IsSigned) {

2271

2272 unsigned ResultWidth = Ty->getIntegerBitWidth();

2273 assert(ResultWidth <= 64 &&

2274 "Can only constant fold conversions to 64 and 32 bit ints");

2275

2277 bool isExact = false;

2282 IsSigned, mode, &isExact);

2285 return nullptr;

2286 return ConstantInt::get(Ty, UIntVal, IsSigned);

2287}

2288

2290 Type *Ty = Op->getType();

2291

2292 if (Ty->isBFloatTy() || Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy())

2293 return Op->getValueAPF().convertToDouble();

2294

2295 bool unused;

2296 APFloat APF = Op->getValueAPF();

2299}

2300

2301static bool getConstIntOrUndef(Value *Op, const APInt *&C) {

2303 C = &CI->getValue();

2304 return true;

2305 }

2307 C = nullptr;

2308 return true;

2309 }

2310 return false;

2311}

2312

2313

2314

2315

2316

2317

2320 std::optional ORM = CI->getRoundingMode();

2322

2323

2324

2326 return true;

2327

2328

2329

2331 return false;

2332

2333

2334

2336 return true;

2337

2338

2339

2340 return false;

2341}

2342

2343

2346 std::optional ORM = CI->getRoundingMode();

2348

2349

2350

2351

2353 return *ORM;

2354}

2355

2356

2357static Constant *constantFoldCanonicalize(const Type *Ty, const CallBase *CI,

2359

2360 if (Src.isZero()) {

2361

2362 return ConstantFP::get(

2365 }

2366

2367 if (!Ty->isIEEELikeFPTy())

2368 return nullptr;

2369

2370

2371

2372

2373

2374 if (Src.isNormal() || Src.isInfinity())

2375 return ConstantFP::get(CI->getContext(), Src);

2376

2380

2382 return ConstantFP::get(CI->getContext(), Src);

2383

2385 return nullptr;

2386

2387

2392 return nullptr;

2393

2394 bool IsPositive =

2398

2399 return ConstantFP::get(CI->getContext(),

2401 }

2402

2403 return nullptr;

2404}

2405

2412 assert(Operands.size() == 1 && "Wrong number of operands.");

2413

2414 if (IntrinsicID == Intrinsic::is_constant) {

2415

2416

2417

2418 if (Operands[0]->isManifestConstant())

2420 return nullptr;

2421 }

2422

2424

2425

2426

2427 if (IntrinsicID == Intrinsic::cos ||

2428 IntrinsicID == Intrinsic::ctpop ||

2429 IntrinsicID == Intrinsic::fptoui_sat ||

2430 IntrinsicID == Intrinsic::fptosi_sat ||

2431 IntrinsicID == Intrinsic::canonicalize)

2433 if (IntrinsicID == Intrinsic::bswap ||

2434 IntrinsicID == Intrinsic::bitreverse ||

2435 IntrinsicID == Intrinsic::launder_invariant_group ||

2436 IntrinsicID == Intrinsic::strip_invariant_group)

2437 return Operands[0];

2438 }

2439

2441

2442 if (IntrinsicID == Intrinsic::launder_invariant_group ||

2443 IntrinsicID == Intrinsic::strip_invariant_group) {

2444

2445

2446

2448 Call->getParent() ? Call->getCaller() : nullptr;

2449 if (Caller &&

2452 return Operands[0];

2453 }

2454 return nullptr;

2455 }

2456 }

2457

2459 if (IntrinsicID == Intrinsic::convert_to_fp16) {

2461

2462 bool lost = false;

2464

2465 return ConstantInt::get(Ty->getContext(), Val.bitcastToAPInt());

2466 }

2467

2469

2470 if (IntrinsicID == Intrinsic::wasm_trunc_signed ||

2471 IntrinsicID == Intrinsic::wasm_trunc_unsigned) {

2472 bool Signed = IntrinsicID == Intrinsic::wasm_trunc_signed;

2473

2474 if (U.isNaN())

2475 return nullptr;

2476

2477 unsigned Width = Ty->getIntegerBitWidth();

2479 bool IsExact = false;

2482

2484 return ConstantInt::get(Ty, Int);

2485

2486 return nullptr;

2487 }

2488

2489 if (IntrinsicID == Intrinsic::fptoui_sat ||

2490 IntrinsicID == Intrinsic::fptosi_sat) {

2491

2492 APSInt Int(Ty->getIntegerBitWidth(),

2493 IntrinsicID == Intrinsic::fptoui_sat);

2494 bool IsExact;

2496 return ConstantInt::get(Ty, Int);

2497 }

2498

2499 if (IntrinsicID == Intrinsic::canonicalize)

2500 return constantFoldCanonicalize(Ty, Call, U);

2501

2502#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)

2503 if (Ty->isFP128Ty()) {

2504 if (IntrinsicID == Intrinsic::log) {

2505 float128 Result = logf128(Op->getValueAPF().convertToQuad());

2506 return GetConstantFoldFPValue128(Result, Ty);

2507 }

2508

2509 LibFunc Fp128Func = NotLibFunc;

2510 if (TLI && TLI->getLibFunc(Name, Fp128Func) && TLI->has(Fp128Func) &&

2511 Fp128Func == LibFunc_logl)

2512 return ConstantFoldFP128(logf128, Op->getValueAPF(), Ty);

2513 }

2514#endif

2515

2516 if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy() &&

2517 !Ty->isIntegerTy())

2518 return nullptr;

2519

2520

2521

2522 if (IntrinsicID == Intrinsic::nearbyint || IntrinsicID == Intrinsic::rint ||

2523 IntrinsicID == Intrinsic::roundeven) {

2525 return ConstantFP::get(Ty->getContext(), U);

2526 }

2527

2528 if (IntrinsicID == Intrinsic::round) {

2530 return ConstantFP::get(Ty->getContext(), U);

2531 }

2532

2533 if (IntrinsicID == Intrinsic::roundeven) {

2535 return ConstantFP::get(Ty->getContext(), U);

2536 }

2537

2538 if (IntrinsicID == Intrinsic::ceil) {

2540 return ConstantFP::get(Ty->getContext(), U);

2541 }

2542

2543 if (IntrinsicID == Intrinsic::floor) {

2545 return ConstantFP::get(Ty->getContext(), U);

2546 }

2547

2548 if (IntrinsicID == Intrinsic::trunc) {

2550 return ConstantFP::get(Ty->getContext(), U);

2551 }

2552

2553 if (IntrinsicID == Intrinsic::fabs) {

2554 U.clearSign();

2555 return ConstantFP::get(Ty->getContext(), U);

2556 }

2557

2558 if (IntrinsicID == Intrinsic::amdgcn_fract) {

2559

2560

2561

2562

2565 APFloat FractU(U - FloorU);

2566 APFloat AlmostOne(U.getSemantics(), 1);

2567 AlmostOne.next( true);

2568 return ConstantFP::get(Ty->getContext(), minimum(FractU, AlmostOne));

2569 }

2570

2571

2572

2573

2574 std::optionalAPFloat::roundingMode RM;

2575 switch (IntrinsicID) {

2576 default:

2577 break;

2578 case Intrinsic::experimental_constrained_nearbyint:

2579 case Intrinsic::experimental_constrained_rint: {

2581 RM = CI->getRoundingMode();

2583 return nullptr;

2584 break;

2585 }

2586 case Intrinsic::experimental_constrained_round:

2588 break;

2589 case Intrinsic::experimental_constrained_ceil:

2591 break;

2592 case Intrinsic::experimental_constrained_floor:

2594 break;

2595 case Intrinsic::experimental_constrained_trunc:

2597 break;

2598 }

2599 if (RM) {

2601 if (U.isFinite()) {

2603 if (IntrinsicID == Intrinsic::experimental_constrained_rint &&

2605 std::optionalfp::ExceptionBehavior EB = CI->getExceptionBehavior();

2607 return nullptr;

2608 }

2609 } else if (U.isSignaling()) {

2610 std::optionalfp::ExceptionBehavior EB = CI->getExceptionBehavior();

2612 return nullptr;

2614 }

2615 return ConstantFP::get(Ty->getContext(), U);

2616 }

2617

2618

2619 switch (IntrinsicID) {

2620

2621 case Intrinsic::nvvm_f2i_rm:

2622 case Intrinsic::nvvm_f2i_rn:

2623 case Intrinsic::nvvm_f2i_rp:

2624 case Intrinsic::nvvm_f2i_rz:

2625 case Intrinsic::nvvm_f2i_rm_ftz:

2626 case Intrinsic::nvvm_f2i_rn_ftz:

2627 case Intrinsic::nvvm_f2i_rp_ftz:

2628 case Intrinsic::nvvm_f2i_rz_ftz:

2629

2630 case Intrinsic::nvvm_f2ui_rm:

2631 case Intrinsic::nvvm_f2ui_rn:

2632 case Intrinsic::nvvm_f2ui_rp:

2633 case Intrinsic::nvvm_f2ui_rz:

2634 case Intrinsic::nvvm_f2ui_rm_ftz:

2635 case Intrinsic::nvvm_f2ui_rn_ftz:

2636 case Intrinsic::nvvm_f2ui_rp_ftz:

2637 case Intrinsic::nvvm_f2ui_rz_ftz:

2638

2639 case Intrinsic::nvvm_d2i_rm:

2640 case Intrinsic::nvvm_d2i_rn:

2641 case Intrinsic::nvvm_d2i_rp:

2642 case Intrinsic::nvvm_d2i_rz:

2643

2644 case Intrinsic::nvvm_d2ui_rm:

2645 case Intrinsic::nvvm_d2ui_rn:

2646 case Intrinsic::nvvm_d2ui_rp:

2647 case Intrinsic::nvvm_d2ui_rz:

2648

2649 case Intrinsic::nvvm_f2ll_rm:

2650 case Intrinsic::nvvm_f2ll_rn:

2651 case Intrinsic::nvvm_f2ll_rp:

2652 case Intrinsic::nvvm_f2ll_rz:

2653 case Intrinsic::nvvm_f2ll_rm_ftz:

2654 case Intrinsic::nvvm_f2ll_rn_ftz:

2655 case Intrinsic::nvvm_f2ll_rp_ftz:

2656 case Intrinsic::nvvm_f2ll_rz_ftz:

2657

2658 case Intrinsic::nvvm_f2ull_rm:

2659 case Intrinsic::nvvm_f2ull_rn:

2660 case Intrinsic::nvvm_f2ull_rp:

2661 case Intrinsic::nvvm_f2ull_rz:

2662 case Intrinsic::nvvm_f2ull_rm_ftz:

2663 case Intrinsic::nvvm_f2ull_rn_ftz:

2664 case Intrinsic::nvvm_f2ull_rp_ftz:

2665 case Intrinsic::nvvm_f2ull_rz_ftz:

2666

2667 case Intrinsic::nvvm_d2ll_rm:

2668 case Intrinsic::nvvm_d2ll_rn:

2669 case Intrinsic::nvvm_d2ll_rp:

2670 case Intrinsic::nvvm_d2ll_rz:

2671

2672 case Intrinsic::nvvm_d2ull_rm:

2673 case Intrinsic::nvvm_d2ull_rn:

2674 case Intrinsic::nvvm_d2ull_rp:

2675 case Intrinsic::nvvm_d2ull_rz: {

2676

2677 if (U.isNaN()) {

2678

2679

2681 return ConstantInt::get(Ty, 0);

2682

2683

2684 unsigned BitWidth = Ty->getIntegerBitWidth();

2686 return ConstantInt::get(Ty, APInt(BitWidth, Val, false));

2687 }

2688

2693

2694 APSInt ResInt(Ty->getIntegerBitWidth(), !IsSigned);

2695 auto FloatToRound = IsFTZ ? FTZPreserveSign(U) : U;

2696

2697

2698

2699 bool IsExact = false;

2700 FloatToRound.convertToInteger(ResInt, RMode, &IsExact);

2701 return ConstantInt::get(Ty, ResInt);

2702 }

2703 }

2704

2705

2706

2707

2708 if (!U.isFinite())

2709 return nullptr;

2710

2711

2712

2713

2714

2715 const APFloat &APF = Op->getValueAPF();

2716

2717 switch (IntrinsicID) {

2718 default: break;

2719 case Intrinsic:🪵

2720 return ConstantFoldFP(log, APF, Ty);

2721 case Intrinsic::log2:

2722

2723 return ConstantFoldFP(log2, APF, Ty);

2724 case Intrinsic::log10:

2725

2726 return ConstantFoldFP(log10, APF, Ty);

2727 case Intrinsic::exp:

2728 return ConstantFoldFP(exp, APF, Ty);

2729 case Intrinsic::exp2:

2730

2731 return ConstantFoldBinaryFP(pow, APFloat(2.0), APF, Ty);

2732 case Intrinsic::exp10:

2733

2734 return ConstantFoldBinaryFP(pow, APFloat(10.0), APF, Ty);

2735 case Intrinsic::sin:

2736 return ConstantFoldFP(sin, APF, Ty);

2737 case Intrinsic::cos:

2738 return ConstantFoldFP(cos, APF, Ty);

2739 case Intrinsic::sinh:

2740 return ConstantFoldFP(sinh, APF, Ty);

2741 case Intrinsic::cosh:

2742 return ConstantFoldFP(cosh, APF, Ty);

2743 case Intrinsic::atan:

2744

2745 if (U.isZero())

2746 return ConstantFP::get(Ty->getContext(), U);

2747 return ConstantFoldFP(atan, APF, Ty);

2748 case Intrinsic::sqrt:

2749 return ConstantFoldFP(sqrt, APF, Ty);

2750

2751

2752 case Intrinsic::nvvm_ceil_ftz_f:

2753 case Intrinsic::nvvm_ceil_f:

2754 case Intrinsic::nvvm_ceil_d:

2755 return ConstantFoldFP(

2756 ceil, APF, Ty,

2759

2760 case Intrinsic::nvvm_fabs_ftz:

2761 case Intrinsic::nvvm_fabs:

2762 return ConstantFoldFP(

2763 fabs, APF, Ty,

2766

2767 case Intrinsic::nvvm_floor_ftz_f:

2768 case Intrinsic::nvvm_floor_f:

2769 case Intrinsic::nvvm_floor_d:

2770 return ConstantFoldFP(

2771 floor, APF, Ty,

2774

2775 case Intrinsic::nvvm_rcp_rm_ftz_f:

2776 case Intrinsic::nvvm_rcp_rn_ftz_f:

2777 case Intrinsic::nvvm_rcp_rp_ftz_f:

2778 case Intrinsic::nvvm_rcp_rz_ftz_f:

2779 case Intrinsic::nvvm_rcp_rm_d:

2780 case Intrinsic::nvvm_rcp_rm_f:

2781 case Intrinsic::nvvm_rcp_rn_d:

2782 case Intrinsic::nvvm_rcp_rn_f:

2783 case Intrinsic::nvvm_rcp_rp_d:

2784 case Intrinsic::nvvm_rcp_rp_f:

2785 case Intrinsic::nvvm_rcp_rz_d:

2786 case Intrinsic::nvvm_rcp_rz_f: {

2789

2790 auto Denominator = IsFTZ ? FTZPreserveSign(APF) : APF;

2793

2795 if (IsFTZ)

2796 Res = FTZPreserveSign(Res);

2797 return ConstantFP::get(Ty->getContext(), Res);

2798 }

2799 return nullptr;

2800 }

2801

2802 case Intrinsic::nvvm_round_ftz_f:

2803 case Intrinsic::nvvm_round_f:

2804 case Intrinsic::nvvm_round_d: {

2805

2806

2807

2809 auto V = IsFTZ ? FTZPreserveSign(APF) : APF;

2811 return ConstantFP::get(Ty->getContext(), V);

2812 }

2813

2814 case Intrinsic::nvvm_saturate_ftz_f:

2815 case Intrinsic::nvvm_saturate_d:

2816 case Intrinsic::nvvm_saturate_f: {

2818 auto V = IsFTZ ? FTZPreserveSign(APF) : APF;

2819 if (V.isNegative() || V.isZero() || V.isNaN())

2822 if (V > One)

2823 return ConstantFP::get(Ty->getContext(), One);

2824 return ConstantFP::get(Ty->getContext(), APF);

2825 }

2826

2827 case Intrinsic::nvvm_sqrt_rn_ftz_f:

2828 case Intrinsic::nvvm_sqrt_f:

2829 case Intrinsic::nvvm_sqrt_rn_d:

2830 case Intrinsic::nvvm_sqrt_rn_f:

2832 return nullptr;

2833 return ConstantFoldFP(

2834 sqrt, APF, Ty,

2837

2838

2839 case Intrinsic::amdgcn_cos:

2840 case Intrinsic::amdgcn_sin: {

2841 double V = getValueAsDouble(Op);

2842 if (V < -256.0 || V > 256.0)

2843

2844

2845

2846 return nullptr;

2847 bool IsCos = IntrinsicID == Intrinsic::amdgcn_cos;

2848 double V4 = V * 4.0;

2849 if (V4 == floor(V4)) {

2850

2851 const double SinVals[4] = { 0.0, 1.0, 0.0, -1.0 };

2852 V = SinVals[((int)V4 + (IsCos ? 1 : 0)) & 3];

2853 } else {

2854 if (IsCos)

2856 else

2858 }

2859 return GetConstantFoldFPValue(V, Ty);

2860 }

2861 }

2862

2863 if (!TLI)

2864 return nullptr;

2865

2866 LibFunc Func = NotLibFunc;

2868 return nullptr;

2869

2870 switch (Func) {

2871 default:

2872 break;

2873 case LibFunc_acos:

2874 case LibFunc_acosf:

2875 case LibFunc_acos_finite:

2876 case LibFunc_acosf_finite:

2877 if (TLI->has(Func))

2878 return ConstantFoldFP(acos, APF, Ty);

2879 break;

2880 case LibFunc_asin:

2881 case LibFunc_asinf:

2882 case LibFunc_asin_finite:

2883 case LibFunc_asinf_finite:

2884 if (TLI->has(Func))

2885 return ConstantFoldFP(asin, APF, Ty);

2886 break;

2887 case LibFunc_atan:

2888 case LibFunc_atanf:

2889

2890 if (U.isZero())

2891 return ConstantFP::get(Ty->getContext(), U);

2892 if (TLI->has(Func))

2893 return ConstantFoldFP(atan, APF, Ty);

2894 break;

2895 case LibFunc_ceil:

2896 case LibFunc_ceilf:

2897 if (TLI->has(Func)) {

2899 return ConstantFP::get(Ty->getContext(), U);

2900 }

2901 break;

2902 case LibFunc_cos:

2903 case LibFunc_cosf:

2904 if (TLI->has(Func))

2905 return ConstantFoldFP(cos, APF, Ty);

2906 break;

2907 case LibFunc_cosh:

2908 case LibFunc_coshf:

2909 case LibFunc_cosh_finite:

2910 case LibFunc_coshf_finite:

2911 if (TLI->has(Func))

2912 return ConstantFoldFP(cosh, APF, Ty);

2913 break;

2914 case LibFunc_exp:

2915 case LibFunc_expf:

2916 case LibFunc_exp_finite:

2917 case LibFunc_expf_finite:

2918 if (TLI->has(Func))

2919 return ConstantFoldFP(exp, APF, Ty);

2920 break;

2921 case LibFunc_exp2:

2922 case LibFunc_exp2f:

2923 case LibFunc_exp2_finite:

2924 case LibFunc_exp2f_finite:

2925 if (TLI->has(Func))

2926

2927 return ConstantFoldBinaryFP(pow, APFloat(2.0), APF, Ty);

2928 break;

2929 case LibFunc_fabs:

2930 case LibFunc_fabsf:

2931 if (TLI->has(Func)) {

2932 U.clearSign();

2933 return ConstantFP::get(Ty->getContext(), U);

2934 }

2935 break;

2936 case LibFunc_floor:

2937 case LibFunc_floorf:

2938 if (TLI->has(Func)) {

2940 return ConstantFP::get(Ty->getContext(), U);

2941 }

2942 break;

2943 case LibFunc_log:

2944 case LibFunc_logf:

2945 case LibFunc_log_finite:

2946 case LibFunc_logf_finite:

2948 return ConstantFoldFP(log, APF, Ty);

2949 break;

2950 case LibFunc_log2:

2951 case LibFunc_log2f:

2952 case LibFunc_log2_finite:

2953 case LibFunc_log2f_finite:

2955

2956 return ConstantFoldFP(log2, APF, Ty);

2957 break;

2958 case LibFunc_log10:

2959 case LibFunc_log10f:

2960 case LibFunc_log10_finite:

2961 case LibFunc_log10f_finite:

2963

2964 return ConstantFoldFP(log10, APF, Ty);

2965 break;

2966 case LibFunc_ilogb:

2967 case LibFunc_ilogbf:

2968 if (!APF.isZero() && TLI->has(Func))

2969 return ConstantInt::get(Ty, ilogb(APF), true);

2970 break;

2971 case LibFunc_logb:

2972 case LibFunc_logbf:

2973 if (!APF.isZero() && TLI->has(Func))

2974 return ConstantFoldFP(logb, APF, Ty);

2975 break;

2976 case LibFunc_log1p:

2977 case LibFunc_log1pf:

2978

2979 if (U.isZero())

2980 return ConstantFP::get(Ty->getContext(), U);

2982 return ConstantFoldFP(log1p, APF, Ty);

2983 break;

2984 case LibFunc_logl:

2985 return nullptr;

2986 case LibFunc_erf:

2987 case LibFunc_erff:

2988 if (TLI->has(Func))

2989 return ConstantFoldFP(erf, APF, Ty);

2990 break;

2991 case LibFunc_nearbyint:

2992 case LibFunc_nearbyintf:

2993 case LibFunc_rint:

2994 case LibFunc_rintf:

2995 case LibFunc_roundeven:

2996 case LibFunc_roundevenf:

2997 if (TLI->has(Func)) {

2999 return ConstantFP::get(Ty->getContext(), U);

3000 }

3001 break;

3002 case LibFunc_round:

3003 case LibFunc_roundf:

3004 if (TLI->has(Func)) {

3006 return ConstantFP::get(Ty->getContext(), U);

3007 }

3008 break;

3009 case LibFunc_sin:

3010 case LibFunc_sinf:

3011 if (TLI->has(Func))

3012 return ConstantFoldFP(sin, APF, Ty);

3013 break;

3014 case LibFunc_sinh:

3015 case LibFunc_sinhf:

3016 case LibFunc_sinh_finite:

3017 case LibFunc_sinhf_finite:

3018 if (TLI->has(Func))

3019 return ConstantFoldFP(sinh, APF, Ty);

3020 break;

3021 case LibFunc_sqrt:

3022 case LibFunc_sqrtf:

3024 return ConstantFoldFP(sqrt, APF, Ty);

3025 break;

3026 case LibFunc_tan:

3027 case LibFunc_tanf:

3028 if (TLI->has(Func))

3029 return ConstantFoldFP(tan, APF, Ty);

3030 break;

3031 case LibFunc_tanh:

3032 case LibFunc_tanhf:

3033 if (TLI->has(Func))

3034 return ConstantFoldFP(tanh, APF, Ty);

3035 break;

3036 case LibFunc_trunc:

3037 case LibFunc_truncf:

3038 if (TLI->has(Func)) {

3040 return ConstantFP::get(Ty->getContext(), U);

3041 }

3042 break;

3043 }

3044 return nullptr;

3045 }

3046

3048 switch (IntrinsicID) {

3049 case Intrinsic::bswap:

3050 return ConstantInt::get(Ty->getContext(), Op->getValue().byteSwap());

3051 case Intrinsic::ctpop:

3052 return ConstantInt::get(Ty, Op->getValue().popcount());

3053 case Intrinsic::bitreverse:

3054 return ConstantInt::get(Ty->getContext(), Op->getValue().reverseBits());

3055 case Intrinsic::convert_from_fp16: {

3057

3058 bool lost = false;

3061

3062

3063 (void)status;

3065 "Precision lost during fp16 constfolding");

3066

3067 return ConstantFP::get(Ty->getContext(), Val);

3068 }

3069

3070 case Intrinsic::amdgcn_s_wqm: {

3072 Val |= (Val & 0x5555555555555555ULL) << 1 |

3073 ((Val >> 1) & 0x5555555555555555ULL);

3074 Val |= (Val & 0x3333333333333333ULL) << 2 |

3075 ((Val >> 2) & 0x3333333333333333ULL);

3076 return ConstantInt::get(Ty, Val);

3077 }

3078

3079 case Intrinsic::amdgcn_s_quadmask: {

3082 for (unsigned I = 0; I < Op->getBitWidth() / 4; ++I, Val >>= 4) {

3083 if (!(Val & 0xF))

3084 continue;

3085

3086 QuadMask |= (1ULL << I);

3087 }

3088 return ConstantInt::get(Ty, QuadMask);

3089 }

3090

3091 case Intrinsic::amdgcn_s_bitreplicate: {

3093 Val = (Val & 0x000000000000FFFFULL) | (Val & 0x00000000FFFF0000ULL) << 16;

3094 Val = (Val & 0x000000FF000000FFULL) | (Val & 0x0000FF000000FF00ULL) << 8;

3095 Val = (Val & 0x000F000F000F000FULL) | (Val & 0x00F000F000F000F0ULL) << 4;

3096 Val = (Val & 0x0303030303030303ULL) | (Val & 0x0C0C0C0C0C0C0C0CULL) << 2;

3097 Val = (Val & 0x1111111111111111ULL) | (Val & 0x2222222222222222ULL) << 1;

3098 Val = Val | Val << 1;

3099 return ConstantInt::get(Ty, Val);

3100 }

3101 }

3102 }

3103

3104 if (Operands[0]->getType()->isVectorTy()) {

3106 switch (IntrinsicID) {

3107 default: break;

3108 case Intrinsic::vector_reduce_add:

3109 case Intrinsic::vector_reduce_mul:

3110 case Intrinsic::vector_reduce_and:

3111 case Intrinsic::vector_reduce_or:

3112 case Intrinsic::vector_reduce_xor:

3113 case Intrinsic::vector_reduce_smin:

3114 case Intrinsic::vector_reduce_smax:

3115 case Intrinsic::vector_reduce_umin:

3116 case Intrinsic::vector_reduce_umax:

3117 if (Constant *C = constantFoldVectorReduce(IntrinsicID, Operands[0]))

3118 return C;

3119 break;

3120 case Intrinsic::x86_sse_cvtss2si:

3121 case Intrinsic::x86_sse_cvtss2si64:

3122 case Intrinsic::x86_sse2_cvtsd2si:

3123 case Intrinsic::x86_sse2_cvtsd2si64:

3126 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3127 false, Ty,

3128 true);

3129 break;

3130 case Intrinsic::x86_sse_cvttss2si:

3131 case Intrinsic::x86_sse_cvttss2si64:

3132 case Intrinsic::x86_sse2_cvttsd2si:

3133 case Intrinsic::x86_sse2_cvttsd2si64:

3136 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3137 true, Ty,

3138 true);

3139 break;

3140

3141 case Intrinsic::wasm_anytrue:

3142 return Op->isZeroValue() ? ConstantInt::get(Ty, 0)

3144

3145 case Intrinsic::wasm_alltrue:

3146

3148 for (unsigned I = 0; I != E; ++I) {

3149 Constant *Elt = Op->getAggregateElement(I);

3150

3152 return ConstantInt::get(Ty, 0);

3153

3155 return nullptr;

3156 }

3157

3158 return ConstantInt::get(Ty, 1);

3159 }

3160 }

3161

3162 return nullptr;

3163}

3164

3170 if (FCmp->isSignaling()) {

3173 } else {

3176 }

3179 return ConstantInt::get(Call->getType()->getScalarType(), Result);

3180 return nullptr;

3181}

3182

3186 if (!TLI)

3187 return nullptr;

3188

3189 LibFunc Func = NotLibFunc;

3191 return nullptr;

3192

3194 if (!Op1)

3195 return nullptr;

3196

3198 if (!Op2)

3199 return nullptr;

3200

3201 const APFloat &Op1V = Op1->getValueAPF();

3202 const APFloat &Op2V = Op2->getValueAPF();

3203

3204 switch (Func) {

3205 default:

3206 break;

3207 case LibFunc_pow:

3208 case LibFunc_powf:

3209 case LibFunc_pow_finite:

3210 case LibFunc_powf_finite:

3211 if (TLI->has(Func))

3212 return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);

3213 break;

3214 case LibFunc_fmod:

3215 case LibFunc_fmodf:

3216 if (TLI->has(Func)) {

3217 APFloat V = Op1->getValueAPF();

3219 return ConstantFP::get(Ty->getContext(), V);

3220 }

3221 break;

3222 case LibFunc_remainder:

3223 case LibFunc_remainderf:

3224 if (TLI->has(Func)) {

3225 APFloat V = Op1->getValueAPF();

3227 return ConstantFP::get(Ty->getContext(), V);

3228 }

3229 break;

3230 case LibFunc_atan2:

3231 case LibFunc_atan2f:

3232

3233

3235 return nullptr;

3236 [[fallthrough]];

3237 case LibFunc_atan2_finite:

3238 case LibFunc_atan2f_finite:

3239 if (TLI->has(Func))

3240 return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);

3241 break;

3242 }

3243

3244 return nullptr;

3245}

3246

3250 assert(Operands.size() == 2 && "Wrong number of operands.");

3251

3252 if (Ty->isFloatingPointTy()) {

3253

3254

3257 switch (IntrinsicID) {

3258 case Intrinsic::maxnum:

3259 case Intrinsic::minnum:

3260 case Intrinsic::maximum:

3261 case Intrinsic::minimum:

3262 case Intrinsic::maximumnum:

3263 case Intrinsic::minimumnum:

3264 case Intrinsic::nvvm_fmax_d:

3265 case Intrinsic::nvvm_fmin_d:

3266

3267 if (IsOp0Undef)

3268 return Operands[1];

3269 if (IsOp1Undef)

3270 return Operands[0];

3271 break;

3272

3273 case Intrinsic::nvvm_fmax_f:

3274 case Intrinsic::nvvm_fmax_ftz_f:

3275 case Intrinsic::nvvm_fmax_ftz_nan_f:

3276 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:

3277 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:

3278 case Intrinsic::nvvm_fmax_nan_f:

3279 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:

3280 case Intrinsic::nvvm_fmax_xorsign_abs_f:

3281

3282 case Intrinsic::nvvm_fmin_f:

3283 case Intrinsic::nvvm_fmin_ftz_f:

3284 case Intrinsic::nvvm_fmin_ftz_nan_f:

3285 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:

3286 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:

3287 case Intrinsic::nvvm_fmin_nan_f:

3288 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:

3289 case Intrinsic::nvvm_fmin_xorsign_abs_f:

3290

3291

3292

3293 if (!IsOp0Undef && !IsOp1Undef)

3294 break;

3296 if (Op->isNaN()) {

3297 APInt NVCanonicalNaN(32, 0x7fffffff);

3298 return ConstantFP::get(

3299 Ty, APFloat(Ty->getFltSemantics(), NVCanonicalNaN));

3300 }

3302 return ConstantFP::get(Ty, FTZPreserveSign(Op->getValueAPF()));

3303 else

3304 return Op;

3305 }

3306 break;

3307 }

3308 }

3309

3311 const APFloat &Op1V = Op1->getValueAPF();

3312

3314 if (Op2->getType() != Op1->getType())

3315 return nullptr;

3316 const APFloat &Op2V = Op2->getValueAPF();

3317

3318 if (const auto *ConstrIntr =

3320 RoundingMode RM = getEvaluationRoundingMode(ConstrIntr);

3323 switch (IntrinsicID) {

3324 default:

3325 return nullptr;

3326 case Intrinsic::experimental_constrained_fadd:

3327 St = Res.add(Op2V, RM);

3328 break;

3329 case Intrinsic::experimental_constrained_fsub:

3330 St = Res.subtract(Op2V, RM);

3331 break;

3332 case Intrinsic::experimental_constrained_fmul:

3333 St = Res.multiply(Op2V, RM);

3334 break;

3335 case Intrinsic::experimental_constrained_fdiv:

3336 St = Res.divide(Op2V, RM);

3337 break;

3338 case Intrinsic::experimental_constrained_frem:

3339 St = Res.mod(Op2V);

3340 break;

3341 case Intrinsic::experimental_constrained_fcmp:

3342 case Intrinsic::experimental_constrained_fcmps:

3343 return evaluateCompare(Op1V, Op2V, ConstrIntr);

3344 }

3346 St))

3347 return ConstantFP::get(Ty->getContext(), Res);

3348 return nullptr;

3349 }

3350

3351 switch (IntrinsicID) {

3352 default:

3353 break;

3354 case Intrinsic::copysign:

3355 return ConstantFP::get(Ty->getContext(), APFloat::copySign(Op1V, Op2V));

3356 case Intrinsic::minnum:

3358 return nullptr;

3359 return ConstantFP::get(Ty->getContext(), minnum(Op1V, Op2V));

3360 case Intrinsic::maxnum:

3362 return nullptr;

3363 return ConstantFP::get(Ty->getContext(), maxnum(Op1V, Op2V));

3364 case Intrinsic::minimum:

3365 return ConstantFP::get(Ty->getContext(), minimum(Op1V, Op2V));

3366 case Intrinsic::maximum:

3367 return ConstantFP::get(Ty->getContext(), maximum(Op1V, Op2V));

3368 case Intrinsic::minimumnum:

3369 return ConstantFP::get(Ty->getContext(), minimumnum(Op1V, Op2V));

3370 case Intrinsic::maximumnum:

3371 return ConstantFP::get(Ty->getContext(), maximumnum(Op1V, Op2V));

3372

3373 case Intrinsic::nvvm_fmax_d:

3374 case Intrinsic::nvvm_fmax_f:

3375 case Intrinsic::nvvm_fmax_ftz_f:

3376 case Intrinsic::nvvm_fmax_ftz_nan_f:

3377 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:

3378 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:

3379 case Intrinsic::nvvm_fmax_nan_f:

3380 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:

3381 case Intrinsic::nvvm_fmax_xorsign_abs_f:

3382

3383 case Intrinsic::nvvm_fmin_d:

3384 case Intrinsic::nvvm_fmin_f:

3385 case Intrinsic::nvvm_fmin_ftz_f:

3386 case Intrinsic::nvvm_fmin_ftz_nan_f:

3387 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:

3388 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:

3389 case Intrinsic::nvvm_fmin_nan_f:

3390 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:

3391 case Intrinsic::nvvm_fmin_xorsign_abs_f: {

3392

3393 bool ShouldCanonicalizeNaNs = !(IntrinsicID == Intrinsic::nvvm_fmax_d ||

3394 IntrinsicID == Intrinsic::nvvm_fmin_d);

3398

3399 APFloat A = IsFTZ ? FTZPreserveSign(Op1V) : Op1V;

3400 APFloat B = IsFTZ ? FTZPreserveSign(Op2V) : Op2V;

3401

3402 bool XorSign = false;

3403 if (IsXorSignAbs) {

3404 XorSign = A.isNegative() ^ B.isNegative();

3407 }

3408

3409 bool IsFMax = false;

3410 switch (IntrinsicID) {

3411 case Intrinsic::nvvm_fmax_d:

3412 case Intrinsic::nvvm_fmax_f:

3413 case Intrinsic::nvvm_fmax_ftz_f:

3414 case Intrinsic::nvvm_fmax_ftz_nan_f:

3415 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:

3416 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:

3417 case Intrinsic::nvvm_fmax_nan_f:

3418 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:

3419 case Intrinsic::nvvm_fmax_xorsign_abs_f:

3420 IsFMax = true;

3421 break;

3422 }

3424

3425 if (ShouldCanonicalizeNaNs) {

3427 if (A.isNaN() && B.isNaN())

3428 return ConstantFP::get(Ty, NVCanonicalNaN);

3429 else if (IsNaNPropagating && (A.isNaN() || B.isNaN()))

3430 return ConstantFP::get(Ty, NVCanonicalNaN);

3431 }

3432

3433 if (A.isNaN() && B.isNaN())

3434 return Operands[1];

3435 else if (A.isNaN())

3436 Res = B;

3437 else if (B.isNaN())

3438 Res = A;

3439

3440 if (IsXorSignAbs && XorSign != Res.isNegative())

3442

3443 return ConstantFP::get(Ty->getContext(), Res);

3444 }

3445

3446 case Intrinsic::nvvm_add_rm_f:

3447 case Intrinsic::nvvm_add_rn_f:

3448 case Intrinsic::nvvm_add_rp_f:

3449 case Intrinsic::nvvm_add_rz_f:

3450 case Intrinsic::nvvm_add_rm_d:

3451 case Intrinsic::nvvm_add_rn_d:

3452 case Intrinsic::nvvm_add_rp_d:

3453 case Intrinsic::nvvm_add_rz_d:

3454 case Intrinsic::nvvm_add_rm_ftz_f:

3455 case Intrinsic::nvvm_add_rn_ftz_f:

3456 case Intrinsic::nvvm_add_rp_ftz_f:

3457 case Intrinsic::nvvm_add_rz_ftz_f: {

3458

3460 APFloat A = IsFTZ ? FTZPreserveSign(Op1V) : Op1V;

3461 APFloat B = IsFTZ ? FTZPreserveSign(Op2V) : Op2V;

3462

3465

3468

3469 if (!Res.isNaN() &&

3471 Res = IsFTZ ? FTZPreserveSign(Res) : Res;

3472 return ConstantFP::get(Ty->getContext(), Res);

3473 }

3474 return nullptr;

3475 }

3476

3477 case Intrinsic::nvvm_mul_rm_f:

3478 case Intrinsic::nvvm_mul_rn_f:

3479 case Intrinsic::nvvm_mul_rp_f:

3480 case Intrinsic::nvvm_mul_rz_f:

3481 case Intrinsic::nvvm_mul_rm_d:

3482 case Intrinsic::nvvm_mul_rn_d:

3483 case Intrinsic::nvvm_mul_rp_d:

3484 case Intrinsic::nvvm_mul_rz_d:

3485 case Intrinsic::nvvm_mul_rm_ftz_f:

3486 case Intrinsic::nvvm_mul_rn_ftz_f:

3487 case Intrinsic::nvvm_mul_rp_ftz_f:

3488 case Intrinsic::nvvm_mul_rz_ftz_f: {

3489

3491 APFloat A = IsFTZ ? FTZPreserveSign(Op1V) : Op1V;

3492 APFloat B = IsFTZ ? FTZPreserveSign(Op2V) : Op2V;

3493

3496

3499

3500 if (!Res.isNaN() &&

3502 Res = IsFTZ ? FTZPreserveSign(Res) : Res;

3503 return ConstantFP::get(Ty->getContext(), Res);

3504 }

3505 return nullptr;

3506 }

3507

3508 case Intrinsic::nvvm_div_rm_f:

3509 case Intrinsic::nvvm_div_rn_f:

3510 case Intrinsic::nvvm_div_rp_f:

3511 case Intrinsic::nvvm_div_rz_f:

3512 case Intrinsic::nvvm_div_rm_d:

3513 case Intrinsic::nvvm_div_rn_d:

3514 case Intrinsic::nvvm_div_rp_d:

3515 case Intrinsic::nvvm_div_rz_d:

3516 case Intrinsic::nvvm_div_rm_ftz_f:

3517 case Intrinsic::nvvm_div_rn_ftz_f:

3518 case Intrinsic::nvvm_div_rp_ftz_f:

3519 case Intrinsic::nvvm_div_rz_ftz_f: {

3521 APFloat A = IsFTZ ? FTZPreserveSign(Op1V) : Op1V;

3522 APFloat B = IsFTZ ? FTZPreserveSign(Op2V) : Op2V;

3525

3528 if (!Res.isNaN() &&

3530 Res = IsFTZ ? FTZPreserveSign(Res) : Res;

3531 return ConstantFP::get(Ty->getContext(), Res);

3532 }

3533 return nullptr;

3534 }

3535 }

3536

3537 if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())

3538 return nullptr;

3539

3540 switch (IntrinsicID) {

3541 default:

3542 break;

3543 case Intrinsic::pow:

3544 return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);

3545 case Intrinsic::amdgcn_fmul_legacy:

3546

3547

3550 return ConstantFP::get(Ty->getContext(), Op1V * Op2V);

3551 }

3552

3554 switch (IntrinsicID) {

3555 case Intrinsic::ldexp: {

3556 return ConstantFP::get(

3557 Ty->getContext(),

3559 }

3560 case Intrinsic::is_fpclass: {

3573 return ConstantInt::get(Ty, Result);

3574 }

3575 case Intrinsic::powi: {

3576 int Exp = static_cast<int>(Op2C->getSExtValue());

3577 switch (Ty->getTypeID()) {

3581 if (Ty->isHalfTy()) {

3584 &Unused);

3585 }

3586 return ConstantFP::get(Ty->getContext(), Res);

3587 }

3589 return ConstantFP::get(Ty, std::pow(Op1V.convertToDouble(), Exp));

3590 default:

3591 return nullptr;

3592 }

3593 }

3594 default:

3595 break;

3596 }

3597 }

3598 return nullptr;

3599 }

3600

3601 if (Operands[0]->getType()->isIntegerTy() &&

3602 Operands[1]->getType()->isIntegerTy()) {

3603 const APInt *C0, *C1;

3604 if (!getConstIntOrUndef(Operands[0], C0) ||

3605 !getConstIntOrUndef(Operands[1], C1))

3606 return nullptr;

3607

3608 switch (IntrinsicID) {

3609 default: break;

3610 case Intrinsic::smax:

3611 case Intrinsic::smin:

3612 case Intrinsic::umax:

3613 case Intrinsic::umin:

3614 if (!C0 && !C1)

3616 if (!C0 || !C1)

3618 return ConstantInt::get(

3621 ? *C0

3622 : *C1);

3623

3624 case Intrinsic::scmp:

3625 case Intrinsic::ucmp:

3626 if (!C0 || !C1)

3627 return ConstantInt::get(Ty, 0);

3628

3629 int Res;

3630 if (IntrinsicID == Intrinsic::scmp)

3631 Res = C0->sgt(*C1) ? 1 : C0->slt(*C1) ? -1 : 0;

3632 else

3633 Res = C0->ugt(*C1) ? 1 : C0->ult(*C1) ? -1 : 0;

3634 return ConstantInt::get(Ty, Res, true);

3635

3636 case Intrinsic::usub_with_overflow:

3637 case Intrinsic::ssub_with_overflow:

3638

3639

3640 if (!C0 || !C1)

3642 [[fallthrough]];

3643 case Intrinsic::uadd_with_overflow:

3644 case Intrinsic::sadd_with_overflow:

3645

3646

3647 if (!C0 || !C1) {

3652 }

3653 [[fallthrough]];

3654 case Intrinsic::smul_with_overflow:

3655 case Intrinsic::umul_with_overflow: {

3656

3657

3658 if (!C0 || !C1)

3660

3662 bool Overflow;

3663 switch (IntrinsicID) {

3665 case Intrinsic::sadd_with_overflow:

3666 Res = C0->sadd_ov(*C1, Overflow);

3667 break;

3668 case Intrinsic::uadd_with_overflow:

3669 Res = C0->uadd_ov(*C1, Overflow);

3670 break;

3671 case Intrinsic::ssub_with_overflow:

3672 Res = C0->ssub_ov(*C1, Overflow);

3673 break;

3674 case Intrinsic::usub_with_overflow:

3675 Res = C0->usub_ov(*C1, Overflow);

3676 break;

3677 case Intrinsic::smul_with_overflow:

3678 Res = C0->smul_ov(*C1, Overflow);

3679 break;

3680 case Intrinsic::umul_with_overflow:

3681 Res = C0->umul_ov(*C1, Overflow);

3682 break;

3683 }

3685 ConstantInt::get(Ty->getContext(), Res),

3686 ConstantInt::get(Type::getInt1Ty(Ty->getContext()), Overflow)

3687 };

3689 }

3690 case Intrinsic::uadd_sat:

3691 case Intrinsic::sadd_sat:

3692 if (!C0 && !C1)

3694 if (!C0 || !C1)

3696 if (IntrinsicID == Intrinsic::uadd_sat)

3697 return ConstantInt::get(Ty, C0->uadd_sat(*C1));

3698 else

3699 return ConstantInt::get(Ty, C0->sadd_sat(*C1));

3700 case Intrinsic::usub_sat:

3701 case Intrinsic::ssub_sat:

3702 if (!C0 && !C1)

3704 if (!C0 || !C1)

3706 if (IntrinsicID == Intrinsic::usub_sat)

3707 return ConstantInt::get(Ty, C0->usub_sat(*C1));

3708 else

3709 return ConstantInt::get(Ty, C0->ssub_sat(*C1));

3710 case Intrinsic::cttz:

3711 case Intrinsic::ctlz:

3712 assert(C1 && "Must be constant int");

3713

3714

3715 if (C1->isOne() && (!C0 || C0->isZero()))

3717 if (!C0)

3719 if (IntrinsicID == Intrinsic::cttz)

3720 return ConstantInt::get(Ty, C0->countr_zero());

3721 else

3722 return ConstantInt::get(Ty, C0->countl_zero());

3723

3724 case Intrinsic::abs:

3725 assert(C1 && "Must be constant int");

3727

3728

3731

3732

3733 if (!C0)

3735

3736 return ConstantInt::get(Ty, C0->abs());

3737 case Intrinsic::amdgcn_wave_reduce_umin:

3738 case Intrinsic::amdgcn_wave_reduce_umax:

3739 case Intrinsic::amdgcn_wave_reduce_max:

3740 case Intrinsic::amdgcn_wave_reduce_min:

3741 case Intrinsic::amdgcn_wave_reduce_add:

3742 case Intrinsic::amdgcn_wave_reduce_sub:

3743 case Intrinsic::amdgcn_wave_reduce_and:

3744 case Intrinsic::amdgcn_wave_reduce_or:

3745 case Intrinsic::amdgcn_wave_reduce_xor:

3747 }

3748

3749 return nullptr;

3750 }

3751

3752

3755

3756

3760 switch (IntrinsicID) {

3761 default: break;

3762 case Intrinsic::x86_avx512_vcvtss2si32:

3763 case Intrinsic::x86_avx512_vcvtss2si64:

3764 case Intrinsic::x86_avx512_vcvtsd2si32:

3765 case Intrinsic::x86_avx512_vcvtsd2si64:

3768 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3769 false, Ty,

3770 true);

3771 break;

3772 case Intrinsic::x86_avx512_vcvtss2usi32:

3773 case Intrinsic::x86_avx512_vcvtss2usi64:

3774 case Intrinsic::x86_avx512_vcvtsd2usi32:

3775 case Intrinsic::x86_avx512_vcvtsd2usi64:

3778 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3779 false, Ty,

3780 false);

3781 break;

3782 case Intrinsic::x86_avx512_cvttss2si:

3783 case Intrinsic::x86_avx512_cvttss2si64:

3784 case Intrinsic::x86_avx512_cvttsd2si:

3785 case Intrinsic::x86_avx512_cvttsd2si64:

3788 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3789 true, Ty,

3790 true);

3791 break;

3792 case Intrinsic::x86_avx512_cvttss2usi:

3793 case Intrinsic::x86_avx512_cvttss2usi64:

3794 case Intrinsic::x86_avx512_cvttsd2usi:

3795 case Intrinsic::x86_avx512_cvttsd2usi64:

3798 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3799 true, Ty,

3800 false);

3801 break;

3802 }

3803 }

3804 return nullptr;

3805}

3806

3811 unsigned ID;

3813 APFloat MA(Sem), SC(Sem), TC(Sem);

3816

3817 ID = 5;

3818 SC = -S0;

3819 } else {

3820 ID = 4;

3821 SC = S0;

3822 }

3823 MA = S2;

3824 TC = -S1;

3825 } else if (abs(S1) >= abs(S0)) {

3826 if (S1.isNegative() && S1.isNonZero() && .isNaN()) {

3827

3828 ID = 3;

3829 TC = -S2;

3830 } else {

3831 ID = 2;

3832 TC = S2;

3833 }

3834 MA = S1;

3835 SC = S0;

3836 } else {

3838

3839 ID = 1;

3840 SC = S2;

3841 } else {

3842 ID = 0;

3843 SC = -S2;

3844 }

3845 MA = S0;

3846 TC = -S1;

3847 }

3848 switch (IntrinsicID) {

3849 default:

3851 case Intrinsic::amdgcn_cubeid:

3853 case Intrinsic::amdgcn_cubema:

3854 return MA + MA;

3855 case Intrinsic::amdgcn_cubesc:

3856 return SC;

3857 case Intrinsic::amdgcn_cubetc:

3858 return TC;

3859 }

3860}

3861

3864 const APInt *C0, *C1, *C2;

3865 if (!getConstIntOrUndef(Operands[0], C0) ||

3866 !getConstIntOrUndef(Operands[1], C1) ||

3867 !getConstIntOrUndef(Operands[2], C2))

3868 return nullptr;

3869

3870 if (!C2)

3872

3873 APInt Val(32, 0);

3874 unsigned NumUndefBytes = 0;

3875 for (unsigned I = 0; I < 32; I += 8) {

3877 unsigned B = 0;

3878

3879 if (Sel >= 13)

3880 B = 0xff;

3881 else if (Sel == 12)

3882 B = 0x00;

3883 else {

3884 const APInt *Src = ((Sel & 10) == 10 || (Sel & 12) == 4) ? C0 : C1;

3885 if (!Src)

3886 ++NumUndefBytes;

3887 else if (Sel < 8)

3888 B = Src->extractBitsAsZExtValue(8, (Sel & 3) * 8);

3889 else

3890 B = Src->extractBitsAsZExtValue(1, (Sel & 1) ? 31 : 15) * 0xff;

3891 }

3892

3893 Val.insertBits(B, I, 8);

3894 }

3895

3896 if (NumUndefBytes == 4)

3898

3899 return ConstantInt::get(Ty, Val);

3900}

3901

3908 assert(Operands.size() == 3 && "Wrong number of operands.");

3909

3913 const APFloat &C1 = Op1->getValueAPF();

3914 const APFloat &C2 = Op2->getValueAPF();

3915 const APFloat &C3 = Op3->getValueAPF();

3916

3918 RoundingMode RM = getEvaluationRoundingMode(ConstrIntr);

3921 switch (IntrinsicID) {

3922 default:

3923 return nullptr;

3924 case Intrinsic::experimental_constrained_fma:

3925 case Intrinsic::experimental_constrained_fmuladd:

3927 break;

3928 }

3929 if (mayFoldConstrained(

3931 return ConstantFP::get(Ty->getContext(), Res);

3932 return nullptr;

3933 }

3934

3935 switch (IntrinsicID) {

3936 default: break;

3937 case Intrinsic::amdgcn_fma_legacy: {

3938

3939

3941

3942

3943 return ConstantFP::get(Ty->getContext(), APFloat(0.0f) + C3);

3944 }

3945 [[fallthrough]];

3946 }

3947 case Intrinsic::fma:

3948 case Intrinsic::fmuladd: {

3951 return ConstantFP::get(Ty->getContext(), V);

3952 }

3953

3954 case Intrinsic::nvvm_fma_rm_f:

3955 case Intrinsic::nvvm_fma_rn_f:

3956 case Intrinsic::nvvm_fma_rp_f:

3957 case Intrinsic::nvvm_fma_rz_f:

3958 case Intrinsic::nvvm_fma_rm_d:

3959 case Intrinsic::nvvm_fma_rn_d:

3960 case Intrinsic::nvvm_fma_rp_d:

3961 case Intrinsic::nvvm_fma_rz_d:

3962 case Intrinsic::nvvm_fma_rm_ftz_f:

3963 case Intrinsic::nvvm_fma_rn_ftz_f:

3964 case Intrinsic::nvvm_fma_rp_ftz_f:

3965 case Intrinsic::nvvm_fma_rz_ftz_f: {

3967 APFloat A = IsFTZ ? FTZPreserveSign(C1) : C1;

3968 APFloat B = IsFTZ ? FTZPreserveSign(C2) : C2;

3969 APFloat C = IsFTZ ? FTZPreserveSign(C3) : C3;

3970

3973

3976

3977 if (!Res.isNaN() &&

3979 Res = IsFTZ ? FTZPreserveSign(Res) : Res;

3980 return ConstantFP::get(Ty->getContext(), Res);

3981 }

3982 return nullptr;

3983 }

3984

3985 case Intrinsic::amdgcn_cubeid:

3986 case Intrinsic::amdgcn_cubema:

3987 case Intrinsic::amdgcn_cubesc:

3988 case Intrinsic::amdgcn_cubetc: {

3989 APFloat V = ConstantFoldAMDGCNCubeIntrinsic(IntrinsicID, C1, C2, C3);

3990 return ConstantFP::get(Ty->getContext(), V);

3991 }

3992 }

3993 }

3994 }

3995 }

3996

3997 if (IntrinsicID == Intrinsic::smul_fix ||

3998 IntrinsicID == Intrinsic::smul_fix_sat) {

3999 const APInt *C0, *C1;

4000 if (!getConstIntOrUndef(Operands[0], C0) ||

4001 !getConstIntOrUndef(Operands[1], C1))

4002 return nullptr;

4003

4004

4005

4006 if (!C0 || !C1)

4008

4009

4010

4011

4012

4013

4014

4015 unsigned Scale = cast(Operands[2])->getZExtValue();

4017 assert(Scale < Width && "Illegal scale.");

4018 unsigned ExtendedWidth = Width * 2;

4020 (C0->sext(ExtendedWidth) * C1->sext(ExtendedWidth)).ashr(Scale);

4021 if (IntrinsicID == Intrinsic::smul_fix_sat) {

4026 }

4027 return ConstantInt::get(Ty->getContext(), Product.sextOrTrunc(Width));

4028 }

4029

4030 if (IntrinsicID == Intrinsic::fshl || IntrinsicID == Intrinsic::fshr) {

4031 const APInt *C0, *C1, *C2;

4032 if (!getConstIntOrUndef(Operands[0], C0) ||

4033 !getConstIntOrUndef(Operands[1], C1) ||

4034 !getConstIntOrUndef(Operands[2], C2))

4035 return nullptr;

4036

4037 bool IsRight = IntrinsicID == Intrinsic::fshr;

4038 if (!C2)

4039 return Operands[IsRight ? 1 : 0];

4040 if (!C0 && !C1)

4042

4043

4044

4047 if (!ShAmt)

4048 return Operands[IsRight ? 1 : 0];

4049

4050

4051 unsigned LshrAmt = IsRight ? ShAmt : BitWidth - ShAmt;

4052 unsigned ShlAmt = !IsRight ? ShAmt : BitWidth - ShAmt;

4053 if (!C0)

4054 return ConstantInt::get(Ty, C1->lshr(LshrAmt));

4055 if (!C1)

4056 return ConstantInt::get(Ty, C0->shl(ShlAmt));

4057 return ConstantInt::get(Ty, C0->shl(ShlAmt) | C1->lshr(LshrAmt));

4058 }

4059

4060 if (IntrinsicID == Intrinsic::amdgcn_perm)

4061 return ConstantFoldAMDGCNPermIntrinsic(Operands, Ty);

4062

4063 return nullptr;

4064}

4065

4076

4077 if (Operands.size() == 1)

4078 return ConstantFoldScalarCall1(Name, IntrinsicID, Ty, Operands, TLI, Call);

4079

4080 if (Operands.size() == 2) {

4081 if (Constant *FoldedLibCall =

4082 ConstantFoldLibCall2(Name, Ty, Operands, TLI)) {

4083 return FoldedLibCall;

4084 }

4085 return ConstantFoldIntrinsicCall2(IntrinsicID, Ty, Operands, Call);

4086 }

4087

4088 if (Operands.size() == 3)

4089 return ConstantFoldScalarCall3(Name, IntrinsicID, Ty, Operands, TLI, Call);

4090

4091 return nullptr;

4092}

4093

4094static Constant *ConstantFoldFixedVectorCall(

4101

4102 switch (IntrinsicID) {

4103 case Intrinsic::masked_load: {

4104 auto *SrcPtr = Operands[0];

4105 auto *Mask = Operands[1];

4106 auto *Passthru = Operands[2];

4107

4109

4112 auto *MaskElt = Mask->getAggregateElement(I);

4113 if (!MaskElt)

4114 break;

4115 auto *PassthruElt = Passthru->getAggregateElement(I);

4118 if (PassthruElt)

4119 NewElements.push_back(PassthruElt);

4120 else if (VecElt)

4122 else

4123 return nullptr;

4124 }

4125 if (MaskElt->isNullValue()) {

4126 if (!PassthruElt)

4127 return nullptr;

4128 NewElements.push_back(PassthruElt);

4129 } else if (MaskElt->isOneValue()) {

4130 if (!VecElt)

4131 return nullptr;

4133 } else {

4134 return nullptr;

4135 }

4136 }

4138 return nullptr;

4140 }

4141 case Intrinsic::arm_mve_vctp8:

4142 case Intrinsic::arm_mve_vctp16:

4143 case Intrinsic::arm_mve_vctp32:

4144 case Intrinsic::arm_mve_vctp64: {

4147 uint64_t Limit = Op->getZExtValue();

4148

4150 for (unsigned i = 0; i < Lanes; i++) {

4151 if (i < Limit)

4153 else

4155 }

4157 }

4158 return nullptr;

4159 }

4160 case Intrinsic::get_active_lane_mask: {

4163 if (Op0 && Op1) {

4166 uint64_t Limit = Op1->getZExtValue();

4167

4169 for (unsigned i = 0; i < Lanes; i++) {

4170 if (Base + i < Limit)

4172 else

4174 }

4176 }

4177 return nullptr;

4178 }

4179 case Intrinsic::vector_extract: {

4181 Constant *Vec = Operands[0];

4183 return nullptr;

4184

4186 unsigned VecNumElements =

4188 unsigned StartingIndex = Idx->getZExtValue();

4189

4190

4191 if (NumElements == VecNumElements && StartingIndex == 0)

4192 return Vec;

4193

4194 for (unsigned I = StartingIndex, E = StartingIndex + NumElements; I < E;

4195 ++I) {

4197 if (!Elt)

4198 return nullptr;

4199 Result[I - StartingIndex] = Elt;

4200 }

4201

4203 }

4204 case Intrinsic::vector_insert: {

4205 Constant *Vec = Operands[0];

4206 Constant *SubVec = Operands[1];

4209 return nullptr;

4210

4211 unsigned SubVecNumElements =

4213 unsigned VecNumElements =

4215 unsigned IdxN = Idx->getZExtValue();

4216

4217 if (SubVecNumElements == VecNumElements && IdxN == 0)

4218 return SubVec;

4219

4220 for (unsigned I = 0; I < VecNumElements; ++I) {

4222 if (I < IdxN + SubVecNumElements)

4224 else

4226 if (!Elt)

4227 return nullptr;

4229 }

4231 }

4232 case Intrinsic::vector_interleave2:

4233 case Intrinsic::vector_interleave3:

4234 case Intrinsic::vector_interleave4:

4235 case Intrinsic::vector_interleave5:

4236 case Intrinsic::vector_interleave6:

4237 case Intrinsic::vector_interleave7:

4238 case Intrinsic::vector_interleave8: {

4239 unsigned NumElements =

4241 unsigned NumOperands = Operands.size();

4242 for (unsigned I = 0; I < NumElements; ++I) {

4243 for (unsigned J = 0; J < NumOperands; ++J) {

4244 Constant *Elt = Operands[J]->getAggregateElement(I);

4245 if (!Elt)

4246 return nullptr;

4247 Result[NumOperands * I + J] = Elt;

4248 }

4249 }

4251 }

4252 case Intrinsic::wasm_dot: {

4253 unsigned NumElements =

4255

4256 assert(NumElements == 8 && Result.size() == 4 &&

4257 "wasm dot takes i16x8 and produces i32x4");

4258 assert(Ty->isIntegerTy());

4259 int32_t MulVector[8];

4260

4261 for (unsigned I = 0; I < NumElements; ++I) {

4266

4268 }

4269 for (unsigned I = 0; I < Result.size(); I++) {

4270 int64_t IAdd = (int64_t)MulVector[I * 2] + (int64_t)MulVector[I * 2 + 1];

4271 Result[I] = ConstantInt::get(Ty, IAdd);

4272 }

4273

4275 }

4276 default:

4277 break;

4278 }

4279

4281

4282 for (unsigned J = 0, JE = Operands.size(); J != JE; ++J) {

4283

4285 Lane[J] = Operands[J];

4286 continue;

4287 }

4288

4289 Constant *Agg = Operands[J]->getAggregateElement(I);

4290 if (!Agg)

4291 return nullptr;

4292

4293 Lane[J] = Agg;

4294 }

4295

4296

4298 ConstantFoldScalarCall(Name, IntrinsicID, Ty, Lane, TLI, Call);

4299 if (!Folded)

4300 return nullptr;

4302 }

4303

4305}

4306

4307static Constant *ConstantFoldScalableVectorCall(

4311 switch (IntrinsicID) {

4312 case Intrinsic::aarch64_sve_convert_from_svbool: {

4314 if (!Src || !Src->isNullValue())

4315 break;

4316

4318 }

4319 case Intrinsic::get_active_lane_mask: {

4322 if (Op0 && Op1 && Op0->getValue().uge(Op1->getValue()))

4324 break;

4325 }

4326 case Intrinsic::vector_interleave2:

4327 case Intrinsic::vector_interleave3:

4328 case Intrinsic::vector_interleave4:

4329 case Intrinsic::vector_interleave5:

4330 case Intrinsic::vector_interleave6:

4331 case Intrinsic::vector_interleave7:

4332 case Intrinsic::vector_interleave8: {

4333 Constant *SplatVal = Operands[0]->getSplatValue();

4334 if (!SplatVal)

4335 return nullptr;

4336

4338 return nullptr;

4339

4341 }

4342 default:

4343 break;

4344 }

4345

4346

4347

4348

4349

4351 return nullptr;

4352

4357 continue;

4358 }

4361 return nullptr;

4363 }

4364 Constant *Folded = ConstantFoldScalarCall(

4366 if (!Folded)

4367 return nullptr;

4369}

4370

4371static std::pair<Constant *, Constant *>

4372ConstantFoldScalarFrexpCall(Constant *Op, Type *IntTy) {

4375

4377 if (!ConstFP)

4378 return {};

4379

4380 const APFloat &U = ConstFP->getValueAPF();

4381 int FrexpExp;

4383 Constant *Result0 = ConstantFP::get(ConstFP->getType(), FrexpMant);

4384

4385

4386

4390 return {Result0, Result1};

4391}

4392

4393

4399

4400 switch (IntrinsicID) {

4401 case Intrinsic::frexp: {

4404

4408

4409 for (unsigned I = 0, E = FVTy0->getNumElements(); I != E; ++I) {

4410 Constant *Lane = Operands[0]->getAggregateElement(I);

4411 std::tie(Results0[I], Results1[I]) =

4412 ConstantFoldScalarFrexpCall(Lane, Ty1);

4413 if (!Results0[I])

4414 return nullptr;

4415 }

4416

4419 }

4420

4421 auto [Result0, Result1] = ConstantFoldScalarFrexpCall(Operands[0], Ty1);

4422 if (!Result0)

4423 return nullptr;

4425 }

4426 case Intrinsic::sincos: {

4429

4430 auto ConstantFoldScalarSincosCall =

4431 [&](Constant *Op) -> std::pair<Constant *, Constant *> {

4433 ConstantFoldScalarCall(Name, Intrinsic::sin, TyScalar, Op, TLI, Call);

4435 ConstantFoldScalarCall(Name, Intrinsic::cos, TyScalar, Op, TLI, Call);

4436 return std::make_pair(SinResult, CosResult);

4437 };

4438

4442

4444 Constant *Lane = Operands[0]->getAggregateElement(I);

4445 std::tie(SinResults[I], CosResults[I]) =

4446 ConstantFoldScalarSincosCall(Lane);

4447 if (!SinResults[I] || !CosResults[I])

4448 return nullptr;

4449 }

4450

4453 }

4454

4455 auto [SinResult, CosResult] = ConstantFoldScalarSincosCall(Operands[0]);

4456 if (!SinResult || !CosResult)

4457 return nullptr;

4459 }

4460 case Intrinsic::vector_deinterleave2:

4461 case Intrinsic::vector_deinterleave3:

4462 case Intrinsic::vector_deinterleave4:

4463 case Intrinsic::vector_deinterleave5:

4464 case Intrinsic::vector_deinterleave6:

4465 case Intrinsic::vector_deinterleave7:

4466 case Intrinsic::vector_deinterleave8: {

4468 auto *Vec = Operands[0];

4470

4473

4478 }

4479

4480 if (!ResultEC.isFixed())

4481 return nullptr;

4482

4483 unsigned NumElements = ResultEC.getFixedValue();

4486 for (unsigned I = 0; I != NumResults; ++I) {

4487 for (unsigned J = 0; J != NumElements; ++J) {

4489 if (!Elt)

4490 return nullptr;

4492 }

4494 }

4496 }

4497 default:

4498

4499

4500 return ConstantFoldScalarCall(Name, IntrinsicID, StTy, Operands, TLI, Call);

4501 }

4502

4503 return nullptr;

4504}

4505

4506}

4507

4512

4513

4515 return nullptr;

4516 return ConstantFoldIntrinsicCall2(ID, Ty, {LHS, RHS}, Call);

4517}

4518

4522 bool AllowNonDeterministic) {

4523 if (Call->isNoBuiltin())

4524 return nullptr;

4525 if (->hasName())

4526 return nullptr;

4527

4528

4531 if (!TLI)

4532 return nullptr;

4533 LibFunc LibF;

4535 return nullptr;

4536 }

4537

4538

4539

4540 Type *Ty = F->getReturnType();

4541 if (!AllowNonDeterministic && Ty->isFPOrFPVectorTy())

4542 return nullptr;

4543

4546 return ConstantFoldFixedVectorCall(

4547 Name, IID, FVTy, Operands, F->getDataLayout(), TLI, Call);

4548

4550 return ConstantFoldScalableVectorCall(

4551 Name, IID, SVTy, Operands, F->getDataLayout(), TLI, Call);

4552

4554 return ConstantFoldStructCall(Name, IID, StTy, Operands,

4555 F->getDataLayout(), TLI, Call);

4556

4557

4558

4559

4560 return ConstantFoldScalarCall(Name, IID, Ty, Operands, TLI, Call);

4561}

4562

4565

4566

4567 if (Call->isNoBuiltin() || Call->isStrictFP())

4568 return false;

4570 if ()

4571 return false;

4572

4573 LibFunc Func;

4575 return false;

4576

4577 if (Call->arg_size() == 1) {

4579 const APFloat &Op = OpC->getValueAPF();

4580 switch (Func) {

4581 case LibFunc_logl:

4582 case LibFunc_log:

4583 case LibFunc_logf:

4584 case LibFunc_log2l:

4585 case LibFunc_log2:

4586 case LibFunc_log2f:

4587 case LibFunc_log10l:

4588 case LibFunc_log10:

4589 case LibFunc_log10f:

4590 return Op.isNaN() || (.isZero() && .isNegative());

4591

4592 case LibFunc_ilogb:

4593 return .isNaN() && .isZero() && .isInfinity();

4594

4595 case LibFunc_expl:

4596 case LibFunc_exp:

4597 case LibFunc_expf:

4598

4599 if (OpC->getType()->isDoubleTy())

4601 if (OpC->getType()->isFloatTy())

4603 break;

4604

4605 case LibFunc_exp2l:

4606 case LibFunc_exp2:

4607 case LibFunc_exp2f:

4608

4609 if (OpC->getType()->isDoubleTy())

4611 if (OpC->getType()->isFloatTy())

4613 break;

4614

4615 case LibFunc_sinl:

4616 case LibFunc_sin:

4617 case LibFunc_sinf:

4618 case LibFunc_cosl:

4619 case LibFunc_cos:

4620 case LibFunc_cosf:

4621 return .isInfinity();

4622

4623 case LibFunc_tanl:

4624 case LibFunc_tan:

4625 case LibFunc_tanf: {

4626

4627

4628 Type *Ty = OpC->getType();

4629 if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy())

4630 return ConstantFoldFP(tan, OpC->getValueAPF(), Ty) != nullptr;

4631 break;

4632 }

4633

4634 case LibFunc_atan:

4635 case LibFunc_atanf:

4636 case LibFunc_atanl:

4637

4638 return true;

4639

4640 case LibFunc_asinl:

4641 case LibFunc_asin:

4642 case LibFunc_asinf:

4643 case LibFunc_acosl:

4644 case LibFunc_acos:

4645 case LibFunc_acosf:

4648

4649 case LibFunc_sinh:

4650 case LibFunc_cosh:

4651 case LibFunc_sinhf:

4652 case LibFunc_coshf:

4653 case LibFunc_sinhl:

4654 case LibFunc_coshl:

4655

4656 if (OpC->getType()->isDoubleTy())

4658 if (OpC->getType()->isFloatTy())

4660 break;

4661

4662 case LibFunc_sqrtl:

4663 case LibFunc_sqrt:

4664 case LibFunc_sqrtf:

4665 return Op.isNaN() || Op.isZero() || .isNegative();

4666

4667

4668

4669 default:

4670 break;

4671 }

4672 }

4673 }

4674

4675 if (Call->arg_size() == 2) {

4678 if (Op0C && Op1C) {

4681

4682 switch (Func) {

4683 case LibFunc_powl:

4684 case LibFunc_pow:

4685 case LibFunc_powf: {

4686

4687

4689 if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy()) {

4690 if (Ty == Op1C->getType())

4691 return ConstantFoldBinaryFP(pow, Op0, Op1, Ty) != nullptr;

4692 }

4693 break;

4694 }

4695

4696 case LibFunc_fmodl:

4697 case LibFunc_fmod:

4698 case LibFunc_fmodf:

4699 case LibFunc_remainderl:

4700 case LibFunc_remainder:

4701 case LibFunc_remainderf:

4702 return Op0.isNaN() || Op1.isNaN() ||

4704

4705 case LibFunc_atan2:

4706 case LibFunc_atan2f:

4707 case LibFunc_atan2l:

4708

4709

4710

4711

4713

4714 default:

4715 break;

4716 }

4717 }

4718 }

4719

4720 return false;

4721}

4722

4726 switch (CastOp) {

4727 case Instruction::BitCast:

4728

4730 case Instruction::Trunc: {

4732 if (Flags) {

4733

4734 Flags->NUW = true;

4735

4736 auto *SExtC =

4738 Flags->NSW = ZExtC == SExtC;

4739 }

4740 return ZExtC;

4741 }

4742 case Instruction::SExt:

4743 case Instruction::ZExt: {

4746

4747 if (!CastInvC || CastInvC != C)

4748 return nullptr;

4749 if (Flags && CastOp == Instruction::ZExt) {

4750 auto *SExtInvC =

4752

4753 Flags->NNeg = CastInvC == SExtInvC;

4754 }

4755 return InvC;

4756 }

4757 default:

4758 return nullptr;

4759 }

4760}

4761

4767

4773

4774void TargetFolder::anchor() {}

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

This file declares a class to represent arbitrary precision floating point values and provide a varie...

This file implements a class to represent arbitrary precision integral constant values and operations...

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

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Function Alias Analysis Results

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

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

static ConstantFP * flushDenormalConstant(Type *Ty, const APFloat &APF, DenormalMode::DenormalModeKind Mode)

Definition ConstantFolding.cpp:1331

Constant * getConstantAtOffset(Constant *Base, APInt Offset, const DataLayout &DL)

If this Offset points exactly to the start of an aggregate element, return that element,...

Definition ConstantFolding.cpp:688

static cl::opt< bool > DisableFPCallFolding("disable-fp-call-folding", cl::desc("Disable constant-folding of FP intrinsics and libcalls."), cl::init(false), cl::Hidden)

static ConstantFP * flushDenormalConstantFP(ConstantFP *CFP, const Instruction *Inst, bool IsOutput)

Definition ConstantFolding.cpp:1360

static DenormalMode getInstrDenormalMode(const Instruction *CtxI, Type *Ty)

Return the denormal mode that can be assumed when executing a floating point operation at CtxI.

Definition ConstantFolding.cpp:1354

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

This file defines the DenseMap class.

amode Optimize addressing mode

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

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

This file contains the definitions of the enumerations and flags associated with NVVM Intrinsics,...

const SmallVectorImpl< MachineOperand > & Cond

static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))

This file defines the SmallVector class.

static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")

static SymbolRef::Type getType(const Symbol *Sym)

The Input class is used to parse a yaml document into in-memory structs and vectors.

static constexpr roundingMode rmTowardZero

llvm::RoundingMode roundingMode

IEEE-754R 4.3: Rounding-direction attributes.

static const fltSemantics & IEEEdouble()

static constexpr roundingMode rmTowardNegative

static constexpr roundingMode rmNearestTiesToEven

static constexpr roundingMode rmTowardPositive

static const fltSemantics & IEEEhalf()

static constexpr roundingMode rmNearestTiesToAway

opStatus

IEEE-754R 7: Default exception handling.

static APFloat getQNaN(const fltSemantics &Sem, bool Negative=false, const APInt *payload=nullptr)

Factory for QNaN values.

opStatus divide(const APFloat &RHS, roundingMode RM)

void copySign(const APFloat &RHS)

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

opStatus subtract(const APFloat &RHS, roundingMode RM)

LLVM_ABI double convertToDouble() const

Converts this APFloat to host double value.

bool isPosInfinity() const

opStatus add(const APFloat &RHS, roundingMode RM)

const fltSemantics & getSemantics() const

static APFloat getOne(const fltSemantics &Sem, bool Negative=false)

Factory for Positive and Negative One.

opStatus multiply(const APFloat &RHS, roundingMode RM)

LLVM_ABI float convertToFloat() const

Converts this APFloat to host float value.

opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend, roundingMode RM)

APInt bitcastToAPInt() const

opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const

opStatus mod(const APFloat &RHS)

bool isNegInfinity() const

opStatus roundToIntegral(roundingMode RM)

static APFloat getZero(const fltSemantics &Sem, bool Negative=false)

Factory for Positive and Negative Zero.

Class for arbitrary precision integers.

LLVM_ABI APInt umul_ov(const APInt &RHS, bool &Overflow) const

LLVM_ABI APInt usub_sat(const APInt &RHS) const

bool isMinSignedValue() const

Determine if this is the smallest signed value.

uint64_t getZExtValue() const

Get zero extended value.

LLVM_ABI uint64_t extractBitsAsZExtValue(unsigned numBits, unsigned bitPosition) const

LLVM_ABI APInt zextOrTrunc(unsigned width) const

Zero extend or truncate to width.

LLVM_ABI APInt trunc(unsigned width) const

Truncate to new width.

APInt abs() const

Get the absolute value.

LLVM_ABI APInt sadd_sat(const APInt &RHS) const

bool sgt(const APInt &RHS) const

Signed greater than comparison.

LLVM_ABI APInt usub_ov(const APInt &RHS, bool &Overflow) const

bool ugt(const APInt &RHS) const

Unsigned greater than comparison.

bool isZero() const

Determine if this value is zero, i.e. all bits are clear.

LLVM_ABI APInt urem(const APInt &RHS) const

Unsigned remainder operation.

unsigned getBitWidth() const

Return the number of bits in the APInt.

bool ult(const APInt &RHS) const

Unsigned less than comparison.

static APInt getSignedMaxValue(unsigned numBits)

Gets maximum signed value of APInt for a specific bit width.

LLVM_ABI APInt sadd_ov(const APInt &RHS, bool &Overflow) const

LLVM_ABI APInt uadd_ov(const APInt &RHS, bool &Overflow) const

unsigned countr_zero() const

Count the number of trailing zero bits.

unsigned countl_zero() const

The APInt version of std::countl_zero.

static APInt getSignedMinValue(unsigned numBits)

Gets minimum signed value of APInt for a specific bit width.

LLVM_ABI APInt sextOrTrunc(unsigned width) const

Sign extend or truncate to width.

LLVM_ABI APInt uadd_sat(const APInt &RHS) const

APInt ashr(unsigned ShiftAmt) const

Arithmetic right-shift function.

LLVM_ABI APInt smul_ov(const APInt &RHS, bool &Overflow) const

LLVM_ABI APInt sext(unsigned width) const

Sign extend to a new width.

APInt shl(unsigned shiftAmt) const

Left-shift function.

bool slt(const APInt &RHS) const

Signed less than comparison.

LLVM_ABI APInt extractBits(unsigned numBits, unsigned bitPosition) const

Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).

LLVM_ABI APInt ssub_ov(const APInt &RHS, bool &Overflow) const

bool isOne() const

Determine if this is a value of 1.

APInt lshr(unsigned shiftAmt) const

Logical right-shift function.

LLVM_ABI APInt ssub_sat(const APInt &RHS) const

An arbitrary precision integer that knows its signedness.

This class represents an incoming formal argument to a Function.

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

size_t size() const

size - Get the array size.

Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...

static LLVM_ABI Instruction::CastOps getCastOpcode(const Value *Val, bool SrcIsSigned, Type *Ty, bool DstIsSigned)

Returns the opcode necessary to cast Val into Ty using usual casting rules.

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.

static LLVM_ABI bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy)

This method can be used to determine if a cast from SrcTy to DstTy using Opcode op is valid or not.

Predicate

This enumeration lists the possible predicates for CmpInst subclasses.

Predicate getSwappedPredicate() const

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

static bool isFPPredicate(Predicate P)

static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)

get() constructor - Return a constant with array type with an element count and element type matching...

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

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 * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)

Convenience function for getting a Cast operation.

static LLVM_ABI Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)

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

static LLVM_ABI Constant * getShuffleVector(Constant *V1, Constant *V2, ArrayRef< int > Mask, Type *OnlyIfReducedTy=nullptr)

static bool isSupportedGetElementPtr(const Type *SrcElemTy)

Whether creating a constant expression for this getelementptr type is supported.

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 Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, GEPNoWrapFlags NW=GEPNoWrapFlags::none(), std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)

Getelementptr form.

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

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

ConstantFP - Floating Point Values [float, double].

const APFloat & getValueAPF() const

static LLVM_ABI Constant * getZero(Type *Ty, bool Negative=false)

This is the shared class of boolean and integer constants.

static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)

static ConstantInt * getSigned(IntegerType *Ty, int64_t V)

Return a ConstantInt with the specified value for the specified type.

static LLVM_ABI ConstantInt * getFalse(LLVMContext &Context)

int64_t getSExtValue() const

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

static LLVM_ABI ConstantInt * getBool(LLVMContext &Context, bool V)

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

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 isZeroValue() const

Return true if the value is negative zero or null value.

LLVM_ABI bool isNullValue() const

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

Constrained floating point compare intrinsics.

This is the common base class for constrained floating point intrinsics.

LLVM_ABI std::optional< fp::ExceptionBehavior > getExceptionBehavior() const

LLVM_ABI std::optional< RoundingMode > getRoundingMode() const

Wrapper for a function that represents a value that functionally represents the original function.

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

iterator find(const_arg_type_t< KeyT > Val)

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

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

Return result of LHS Pred RHS comparison.

This provides a helper for copying FMF from an instruction or setting specified flags.

Class to represent fixed width SIMD vectors.

unsigned getNumElements() const

static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)

DenormalMode getDenormalMode(const fltSemantics &FPType) const

Returns the denormal handling type for the default rounding mode of the function.

Represents flags for the getelementptr instruction/expression.

static GEPNoWrapFlags inBounds()

GEPNoWrapFlags withoutNoUnsignedSignedWrap() const

static GEPNoWrapFlags noUnsignedWrap()

bool hasNoUnsignedSignedWrap() const

static LLVM_ABI Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)

Returns the result type of a getelementptr with the given source element type and indexes.

PointerType * getType() const

Global values are always pointers.

LLVM_ABI const DataLayout & getDataLayout() const

Get the data layout of the module this global belongs to.

const Constant * getInitializer() const

getInitializer - Return the initializer for this global variable.

bool isConstant() const

If the value is a global constant, its value is immutable throughout the runtime execution of the pro...

bool hasDefinitiveInitializer() const

hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...

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

Return result of LHS Pred RHS comparison.

Predicate getSignedPredicate() const

For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.

bool isEquality() const

Return true if this predicate is either EQ or NE.

LLVM_ABI const Function * getFunction() const

Return the function this instruction belongs to.

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

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

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

static APInt getSaturationPoint(Intrinsic::ID ID, unsigned numBits)

Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...

static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)

Returns the comparison predicate underlying the intrinsic.

static LLVM_ABI PoisonValue * get(Type *T)

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

Class to represent scalable SIMD vectors.

void push_back(const T &Elt)

pointer data()

Return a pointer to the vector's buffer, even if empty().

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

StringRef - Represent a constant reference to a string, i.e.

Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...

LLVM_ABI unsigned getElementContainingOffset(uint64_t FixedOffset) const

Given a valid byte offset into the structure, returns the structure index that contains it.

TypeSize getElementOffset(unsigned Idx) const

Class to represent struct types.

unsigned getNumElements() const

Random access to the elements.

Provides information about what library functions are available for the current target.

bool has(LibFunc F) const

Tests whether a library function is available.

bool getLibFunc(StringRef funcName, LibFunc &F) const

Searches for a particular function name.

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

static LLVM_ABI IntegerType * getInt64Ty(LLVMContext &C)

bool isVectorTy() const

True if this is an instance of VectorType.

static LLVM_ABI IntegerType * getInt32Ty(LLVMContext &C)

bool isPointerTy() const

True if this is an instance of PointerType.

LLVM_ABI unsigned getPointerAddressSpace() const

Get the address space of this pointer or pointer vector type.

@ HalfTyID

16-bit floating point type

@ FloatTyID

32-bit floating point type

@ DoubleTyID

64-bit floating point type

static LLVM_ABI IntegerType * getInt8Ty(LLVMContext &C)

Type * getScalarType() const

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

LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY

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

static LLVM_ABI IntegerType * getInt16Ty(LLVMContext &C)

bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const

Return true if it makes sense to take the size of this type.

LLVMContext & getContext() const

Return the LLVMContext in which this type was uniqued.

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 isFloatingPointTy() const

Return true if this is one of the floating-point types.

bool isPtrOrPtrVectorTy() const

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

bool isX86_AMXTy() const

Return true if this is X86 AMX.

bool isIntegerTy() const

True if this is an instance of IntegerType.

static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)

Type * getContainedType(unsigned i) const

This method is used to implement the type iterator (defined at the end of the file).

LLVM_ABI const fltSemantics & getFltSemantics() const

static LLVM_ABI UndefValue * get(Type *T)

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

A Use represents the edge between a Value definition and its users.

LLVM Value Representation.

Type * getType() const

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

LLVM_ABI const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false) const

Accumulate the constant offset this value has compared to a base pointer.

LLVM_ABI LLVMContext & getContext() const

All values hold a context through their type.

LLVM_ABI uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull, bool &CanBeFreed) const

Returns the number of bytes known to be dereferenceable for the pointer value.

Base class of all SIMD vector types.

ElementCount getElementCount() const

Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...

Type * getElementType() const

constexpr ScalarTy getFixedValue() const

constexpr bool isScalable() const

Returns whether the quantity is scaled by a runtime quantity (vscale).

constexpr bool isFixed() const

Returns true if the quantity is not scaled by vscale.

constexpr LeafTy divideCoefficientBy(ScalarTy RHS) const

We do not provide the '/' operator here because division for polynomial types does not work in the sa...

static constexpr bool isKnownGE(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)

const ParentTy * getParent() const

#define llvm_unreachable(msg)

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

const APInt & smin(const APInt &A, const APInt &B)

Determine the smaller of two APInts considered to be signed.

const APInt & smax(const APInt &A, const APInt &B)

Determine the larger of two APInts considered to be signed.

const APInt & umin(const APInt &A, const APInt &B)

Determine the smaller of two APInts considered to be unsigned.

const APInt & umax(const APInt &A, const APInt &B)

Determine the larger of two APInts considered to be unsigned.

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.

@ CE

Windows NT (Windows on ARM)

initializer< Ty > init(const Ty &Val)

@ ebStrict

This corresponds to "fpexcept.strict".

@ ebIgnore

This corresponds to "fpexcept.ignore".

APFloat::roundingMode GetFMARoundingMode(Intrinsic::ID IntrinsicID)

DenormalMode GetNVVMDenormMode(bool ShouldFTZ)

bool FPToIntegerIntrinsicNaNZero(Intrinsic::ID IntrinsicID)

APFloat::roundingMode GetFDivRoundingMode(Intrinsic::ID IntrinsicID)

bool FPToIntegerIntrinsicResultIsSigned(Intrinsic::ID IntrinsicID)

APFloat::roundingMode GetFPToIntegerRoundingMode(Intrinsic::ID IntrinsicID)

bool RCPShouldFTZ(Intrinsic::ID IntrinsicID)

bool FPToIntegerIntrinsicShouldFTZ(Intrinsic::ID IntrinsicID)

bool FDivShouldFTZ(Intrinsic::ID IntrinsicID)

bool FAddShouldFTZ(Intrinsic::ID IntrinsicID)

bool FMinFMaxIsXorSignAbs(Intrinsic::ID IntrinsicID)

APFloat::roundingMode GetFMulRoundingMode(Intrinsic::ID IntrinsicID)

bool UnaryMathIntrinsicShouldFTZ(Intrinsic::ID IntrinsicID)

bool FMinFMaxShouldFTZ(Intrinsic::ID IntrinsicID)

APFloat::roundingMode GetFAddRoundingMode(Intrinsic::ID IntrinsicID)

bool FMAShouldFTZ(Intrinsic::ID IntrinsicID)

bool FMulShouldFTZ(Intrinsic::ID IntrinsicID)

APFloat::roundingMode GetRCPRoundingMode(Intrinsic::ID IntrinsicID)

bool FMinFMaxPropagatesNaNs(Intrinsic::ID IntrinsicID)

NodeAddr< FuncNode * > Func

LLVM_ABI std::error_code status(const Twine &path, file_status &result, bool follow=true)

Get file status as if by POSIX stat().

This is an optimization pass for GlobalISel generic memory operations.

auto drop_begin(T &&RangeOrContainer, size_t N=1)

Return a range covering RangeOrContainer with the first N elements excluded.

LLVM_ABI Constant * ConstantFoldBinaryIntrinsic(Intrinsic::ID ID, Constant *LHS, Constant *RHS, Type *Ty, Instruction *FMFSource)

Definition ConstantFolding.cpp:4508

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 * ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy, const DataLayout &DL)

ConstantFoldLoadThroughBitcast - try to cast constant to destination type returning null if unsuccess...

Definition ConstantFolding.cpp:358

static double log2(double V)

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

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

LLVM_ABI Constant * ConstantFoldFPInstOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL, const Instruction *I, bool AllowNonDeterministic=true)

Attempt to constant fold a floating point binary operation with the specified operands,...

Definition ConstantFolding.cpp:1440

auto enumerate(FirstRange &&First, RestRanges &&...Rest)

Given two or more input ranges, returns a new range whose values are tuples (A, B,...

LLVM_ABI bool canConstantFoldCallTo(const CallBase *Call, const Function *F)

canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function.

Definition ConstantFolding.cpp:1600

unsigned getPointerAddressSpace(const Type *T)

decltype(auto) dyn_cast(const From &Val)

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

LLVM_ABI Constant * ConstantFoldInstruction(const Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)

ConstantFoldInstruction - Try to constant fold the specified instruction.

Definition ConstantFolding.cpp:1135

APFloat abs(APFloat X)

Returns the absolute value of the argument.

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

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

LLVM_ABI bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)

If this constant is a constant offset from a global, return the global and the constant.

Definition ConstantFolding.cpp:304

LLVM_ABI bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI)

Check whether the given call has no side-effects.

Definition ConstantFolding.cpp:4563

LLVM_ABI Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)

Definition ConstantFolding.cpp:658

auto dyn_cast_if_present(const Y &Val)

dyn_cast_if_present - Functionally identical to dyn_cast, except that a null (or none in the case ...

LLVM_READONLY APFloat maximum(const APFloat &A, const APFloat &B)

Implements IEEE 754-2019 maximum semantics.

LLVM_ABI Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const Instruction *I=nullptr)

Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands.

Definition ConstantFolding.cpp:1199

int ilogb(const APFloat &Arg)

Returns the exponent of the internal representation of the APFloat.

bool isa_and_nonnull(const Y &Val)

LLVM_ABI Constant * ConstantFoldCall(const CallBase *Call, Function *F, ArrayRef< Constant * > Operands, const TargetLibraryInfo *TLI=nullptr, bool AllowNonDeterministic=true)

ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified argum...

Definition ConstantFolding.cpp:4519

APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM)

Equivalent of C standard library function.

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

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

LLVM_ABI Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)

ConstantFoldConstant - Fold the constant using the specified DataLayout.

Definition ConstantFolding.cpp:1184

auto dyn_cast_or_null(const Y &Val)

bool any_of(R &&range, UnaryPredicate P)

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

LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)

Implements IEEE-754 2008 maxNum semantics.

LLVM_ABI Constant * ConstantFoldLoadFromUniformValue(Constant *C, Type *Ty, const DataLayout &DL)

If C is a uniform value where all bits are the same (either all zero, all ones, all undef or all pois...

Definition ConstantFolding.cpp:773

LLVM_ABI Constant * ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, const DataLayout &DL)

Attempt to constant fold a unary operation with the specified operand.

Definition ConstantFolding.cpp:1311

LLVM_ABI Constant * FlushFPConstant(Constant *Operand, const Instruction *I, bool IsOutput)

Attempt to flush float point constant according to denormal mode set in the instruction's parent func...

Definition ConstantFolding.cpp:1372

LLVM_ABI Constant * getLosslessUnsignedTrunc(Constant *C, Type *DestTy, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)

Definition ConstantFolding.cpp:4762

decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)

LLVM_READONLY APFloat minimumnum(const APFloat &A, const APFloat &B)

Implements IEEE 754-2019 minimumNumber semantics.

FPClassTest

Floating-point class tests, supported by 'is_fpclass' intrinsic.

APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM)

Returns: X * 2^Exp for integral exponents.

LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)

Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...

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 * getLosslessSignedTrunc(Constant *C, Type *DestTy, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)

Definition ConstantFolding.cpp:4768

LLVM_ABI Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)

Attempt to constant fold a cast with the specified operand.

Definition ConstantFolding.cpp:1483

LLVM_ABI Constant * ConstantFoldLoadFromConst(Constant *C, Type *Ty, const APInt &Offset, const DataLayout &DL)

Extract value of C at the given Offset reinterpreted as Ty.

Definition ConstantFolding.cpp:714

bool isa(const From &Val)

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

LLVM_ABI bool intrinsicPropagatesPoison(Intrinsic::ID IID)

Return whether this intrinsic propagates poison for all operands.

LLVM_ABI Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)

Attempt to constant fold a binary operation with the specified operands.

Definition ConstantFolding.cpp:1318

MutableArrayRef(T &OneElt) -> MutableArrayRef< T >

LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)

Implements IEEE-754 2008 minNum semantics.

@ Sub

Subtraction of integers.

LLVM_ABI bool isVectorIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, unsigned ScalarOpdIdx, const TargetTransformInfo *TTI)

Identifies if the vector form of the intrinsic has a scalar operand.

DWARFExpression::Operation Op

RoundingMode

Rounding mode.

@ NearestTiesToEven

roundTiesToEven.

@ Dynamic

Denotes mode unknown at compile time.

LLVM_ABI bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)

Return true if this function can prove that V does not have undef bits and is never poison.

constexpr unsigned BitWidth

LLVM_ABI Constant * getLosslessInvCast(Constant *C, Type *InvCastTo, unsigned CastOp, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)

Try to cast C to InvC losslessly, satisfying CastOp(InvC) equals C, or CastOp(InvC) is a refined valu...

Definition ConstantFolding.cpp:4723

decltype(auto) cast(const From &Val)

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

bool all_equal(std::initializer_list< T > Values)

Returns true if all Values in the initializer lists are equal or the list.

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

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

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

LLVM_ABI Constant * ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, APInt Offset, const DataLayout &DL)

Return the value that a load from C with offset Offset would produce if it is constant and determinab...

Definition ConstantFolding.cpp:745

LLVM_ABI Constant * ConstantFoldInstOperands(const Instruction *I, ArrayRef< Constant * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, bool AllowNonDeterministic=true)

ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands.

Definition ConstantFolding.cpp:1190

LLVM_READONLY APFloat minimum(const APFloat &A, const APFloat &B)

Implements IEEE 754-2019 minimum semantics.

LLVM_READONLY APFloat maximumnum(const APFloat &A, const APFloat &B)

Implements IEEE 754-2019 maximumNumber semantics.

LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth)

This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....

LLVM_ABI Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)

Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...

Definition ConstantFolding.cpp:1584

LLVM_ABI bool isTriviallyVectorizable(Intrinsic::ID ID)

Identify if the intrinsic is trivially vectorizable.

constexpr detail::IsaCheckPredicate< Types... > IsaPred

Function object wrapper for the llvm::isa type check.

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

Represent subnormal handling kind for floating point instruction inputs and outputs.

DenormalModeKind Input

Denormal treatment kind for floating point instruction inputs in the default floating-point environme...

DenormalModeKind

Represent handled modes for denormal (aka subnormal) modes in the floating point environment.

@ PreserveSign

The sign of a flushed-to-zero number is preserved in the sign of 0.

@ PositiveZero

Denormals are flushed to positive zero.

@ Dynamic

Denormals have unknown treatment.

@ IEEE

IEEE-754 denormal numbers preserved.

DenormalModeKind Output

Denormal flushing mode for floating point instruction results in the default floating point environme...

static constexpr DenormalMode getDynamic()

static constexpr DenormalMode getIEEE()

Incoming for lane maks phi as machine instruction, incoming register Reg and incoming block Block are...

bool isConstant() const

Returns true if we know the value of all bits.

const APInt & getConstant() const

Returns the value when all bits have a known value.