ConstantFolding.cpp Source File (original) (raw)

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

65using namespace llvm;

68 "disable-fp-call-folding",

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

72namespace {

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

80 unsigned NumSrcElts,

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);

93 Result <<= BitShift;

94 continue;

95 }

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 ( GEP )

340 return false;

341

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

344

345

347 DSOEquiv))

348 return false;

349

350

351 if ( GEP ->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 ( Offset .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 ( Size .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 ( Any )

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 ( $all\_of$ (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 CE0->getOpcode() == Instruction::PtrToAddr) {

1230 Type *AddrTy = DL.getAddressType(CE0->getOperand(0)->getType());

1231 if (CE0->getType() == AddrTy) {

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

1235 }

1236 }

1237 }

1238

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

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

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

1243

1244

1245

1247 false, DL);

1249 false, DL);

1250 if (C0 && C1)

1252 }

1253

1254

1255

1256 if (CE0->getOpcode() == Instruction::PtrToInt ||

1257 CE0->getOpcode() == Instruction::PtrToAddr) {

1258 Type *AddrTy = DL.getAddressType(CE0->getOperand(0)->getType());

1259 if (CE0->getType() == AddrTy &&

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

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

1263 }

1264 }

1265 }

1266 }

1267

1268

1269

1270

1271

1272

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

1275 APInt Offset0(IndexWidth, 0);

1278 DL, Offset0, IsEqPred,

1279 false, nullptr,

1280 IsEqPred);

1281 APInt Offset1(IndexWidth, 0);

1283 DL, Offset1, IsEqPred,

1284 false, nullptr,

1285 IsEqPred);

1286 if (Stripped0 == Stripped1)

1291 }

1293

1294

1297 }

1298

1300

1301

1303 if (!Ops0)

1304 return nullptr;

1306 if (!Ops1)

1307 return nullptr;

1308 }

1309

1311}

1312

1319

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

1326 return C;

1327

1331}

1332

1335 switch (Mode) {

1337 return nullptr;

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

1341 return ConstantFP::get(

1342 Ty->getContext(),

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

1347 default:

1348 break;

1349 }

1350

1352}

1353

1354

1355

1361

1364 bool IsOutput) {

1367 return CFP;

1368

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

1372}

1373

1375 bool IsOutput) {

1378

1380 return Operand;

1381

1384 if (VecTy) {

1387 if (!Folded)

1388 return nullptr;

1390 }

1391

1393 }

1394

1396 return Operand;

1397

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

1404 continue;

1405 }

1406

1408 if (!CFP)

1409 return nullptr;

1410

1412 if (!Folded)

1413 return nullptr;

1415 }

1416

1418 }

1419

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

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

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

1426 } else {

1430 if (!Folded)

1431 return nullptr;

1433 }

1434 }

1435

1437 }

1438

1439 return nullptr;

1440}

1441

1445 bool AllowNonDeterministic) {

1447

1449 if (!Op0)

1450 return nullptr;

1452 if (!Op1)

1453 return nullptr;

1454

1455

1456

1457

1458 if (!AllowNonDeterministic)

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

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

1462 return nullptr;

1463

1464

1466 if ()

1467 return nullptr;

1468

1469

1471 if ()

1472 return nullptr;

1473

1474

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

1476 return nullptr;

1477

1478 return C;

1479 }

1480

1481

1483}

1484

1488

1490 if (CE->isCast())

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

1496

1497 switch (Opcode) {

1498 default:

1500 case Instruction::PtrToAddr:

1501 case Instruction::PtrToInt:

1503 Constant *FoldedValue = nullptr;

1504

1505

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

1507

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

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

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

1512 false, DL);

1514

1515

1516

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

1520 DL, BaseOffset, true));

1521 if (Base->isNullValue()) {

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

1523 } else {

1524

1525

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

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

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

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

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

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

1536 Sub->getOperand(1));

1537 }

1538 }

1539 }

1540 if (FoldedValue) {

1541

1543 DL);

1544 }

1545 }

1546 break;

1547 case Instruction::IntToPtr:

1548

1549

1550

1551

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

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

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

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

1557

1558 if (MidIntSize >= SrcPtrSize) {

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

1562 }

1563 }

1564 }

1565 break;

1566 case Instruction::Trunc:

1567 case Instruction::ZExt:

1568 case Instruction::SExt:

1569 case Instruction::FPTrunc:

1570 case Instruction::FPExt:

1571 case Instruction::UIToFP:

1572 case Instruction::SIToFP:

1573 case Instruction::FPToUI:

1574 case Instruction::FPToSI:

1575 case Instruction::AddrSpaceCast:

1576 break;

1577 case Instruction::BitCast:

1579 }

1580

1584}

1585

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

1589 if (SrcTy == DestTy)

1590 return C;

1593 if (IsSigned)

1596}

1597

1598

1599

1600

1601

1603 if (Call->isNoBuiltin())

1604 return false;

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

1606 return false;

1607

1608

1609

1610

1611

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

1615 })))

1616 return false;

1617

1618 switch (F->getIntrinsicID()) {

1619

1620

1621 case Intrinsic::bswap:

1622 case Intrinsic::ctpop:

1623 case Intrinsic::ctlz:

1624 case Intrinsic::cttz:

1625 case Intrinsic::fshl:

1626 case Intrinsic::fshr:

1627 case Intrinsic::launder_invariant_group:

1628 case Intrinsic::strip_invariant_group:

1629 case Intrinsic::masked_load:

1630 case Intrinsic::get_active_lane_mask:

1631 case Intrinsic::abs:

1632 case Intrinsic::smax:

1633 case Intrinsic::smin:

1634 case Intrinsic::umax:

1635 case Intrinsic::umin:

1636 case Intrinsic::scmp:

1637 case Intrinsic::ucmp:

1638 case Intrinsic::sadd_with_overflow:

1639 case Intrinsic::uadd_with_overflow:

1640 case Intrinsic::ssub_with_overflow:

1641 case Intrinsic::usub_with_overflow:

1642 case Intrinsic::smul_with_overflow:

1643 case Intrinsic::umul_with_overflow:

1644 case Intrinsic::sadd_sat:

1645 case Intrinsic::uadd_sat:

1646 case Intrinsic::ssub_sat:

1647 case Intrinsic::usub_sat:

1648 case Intrinsic::smul_fix:

1649 case Intrinsic::smul_fix_sat:

1650 case Intrinsic::bitreverse:

1651 case Intrinsic::is_constant:

1652 case Intrinsic::vector_reduce_add:

1653 case Intrinsic::vector_reduce_mul:

1654 case Intrinsic::vector_reduce_and:

1655 case Intrinsic::vector_reduce_or:

1656 case Intrinsic::vector_reduce_xor:

1657 case Intrinsic::vector_reduce_smin:

1658 case Intrinsic::vector_reduce_smax:

1659 case Intrinsic::vector_reduce_umin:

1660 case Intrinsic::vector_reduce_umax:

1661 case Intrinsic::vector_extract:

1662 case Intrinsic::vector_insert:

1663 case Intrinsic::vector_interleave2:

1664 case Intrinsic::vector_interleave3:

1665 case Intrinsic::vector_interleave4:

1666 case Intrinsic::vector_interleave5:

1667 case Intrinsic::vector_interleave6:

1668 case Intrinsic::vector_interleave7:

1669 case Intrinsic::vector_interleave8:

1670 case Intrinsic::vector_deinterleave2:

1671 case Intrinsic::vector_deinterleave3:

1672 case Intrinsic::vector_deinterleave4:

1673 case Intrinsic::vector_deinterleave5:

1674 case Intrinsic::vector_deinterleave6:

1675 case Intrinsic::vector_deinterleave7:

1676 case Intrinsic::vector_deinterleave8:

1677

1678 case Intrinsic::amdgcn_perm:

1679 case Intrinsic::amdgcn_wave_reduce_umin:

1680 case Intrinsic::amdgcn_wave_reduce_umax:

1681 case Intrinsic::amdgcn_wave_reduce_max:

1682 case Intrinsic::amdgcn_wave_reduce_min:

1683 case Intrinsic::amdgcn_wave_reduce_add:

1684 case Intrinsic::amdgcn_wave_reduce_sub:

1685 case Intrinsic::amdgcn_wave_reduce_and:

1686 case Intrinsic::amdgcn_wave_reduce_or:

1687 case Intrinsic::amdgcn_wave_reduce_xor:

1688 case Intrinsic::amdgcn_s_wqm:

1689 case Intrinsic::amdgcn_s_quadmask:

1690 case Intrinsic::amdgcn_s_bitreplicate:

1691 case Intrinsic::arm_mve_vctp8:

1692 case Intrinsic::arm_mve_vctp16:

1693 case Intrinsic::arm_mve_vctp32:

1694 case Intrinsic::arm_mve_vctp64:

1695 case Intrinsic::aarch64_sve_convert_from_svbool:

1696 case Intrinsic::wasm_alltrue:

1697 case Intrinsic::wasm_anytrue:

1698 case Intrinsic::wasm_dot:

1699

1700 case Intrinsic::wasm_trunc_signed:

1701 case Intrinsic::wasm_trunc_unsigned:

1702 return true;

1703

1704

1705

1706 case Intrinsic::minnum:

1707 case Intrinsic::maxnum:

1708 case Intrinsic::minimum:

1709 case Intrinsic::maximum:

1710 case Intrinsic::minimumnum:

1711 case Intrinsic::maximumnum:

1712 case Intrinsic:🪵

1713 case Intrinsic::log2:

1714 case Intrinsic::log10:

1715 case Intrinsic::exp:

1716 case Intrinsic::exp2:

1717 case Intrinsic::exp10:

1718 case Intrinsic::sqrt:

1719 case Intrinsic::sin:

1720 case Intrinsic::cos:

1721 case Intrinsic::sincos:

1722 case Intrinsic::sinh:

1723 case Intrinsic::cosh:

1724 case Intrinsic::atan:

1725 case Intrinsic::pow:

1726 case Intrinsic::powi:

1727 case Intrinsic::ldexp:

1728 case Intrinsic::fma:

1729 case Intrinsic::fmuladd:

1730 case Intrinsic::frexp:

1731 case Intrinsic::fptoui_sat:

1732 case Intrinsic::fptosi_sat:

1733 case Intrinsic::convert_from_fp16:

1734 case Intrinsic::convert_to_fp16:

1735 case Intrinsic::amdgcn_cos:

1736 case Intrinsic::amdgcn_cubeid:

1737 case Intrinsic::amdgcn_cubema:

1738 case Intrinsic::amdgcn_cubesc:

1739 case Intrinsic::amdgcn_cubetc:

1740 case Intrinsic::amdgcn_fmul_legacy:

1741 case Intrinsic::amdgcn_fma_legacy:

1742 case Intrinsic::amdgcn_fract:

1743 case Intrinsic::amdgcn_sin:

1744

1745 case Intrinsic::x86_sse_cvtss2si:

1746 case Intrinsic::x86_sse_cvtss2si64:

1747 case Intrinsic::x86_sse_cvttss2si:

1748 case Intrinsic::x86_sse_cvttss2si64:

1749 case Intrinsic::x86_sse2_cvtsd2si:

1750 case Intrinsic::x86_sse2_cvtsd2si64:

1751 case Intrinsic::x86_sse2_cvttsd2si:

1752 case Intrinsic::x86_sse2_cvttsd2si64:

1753 case Intrinsic::x86_avx512_vcvtss2si32:

1754 case Intrinsic::x86_avx512_vcvtss2si64:

1755 case Intrinsic::x86_avx512_cvttss2si:

1756 case Intrinsic::x86_avx512_cvttss2si64:

1757 case Intrinsic::x86_avx512_vcvtsd2si32:

1758 case Intrinsic::x86_avx512_vcvtsd2si64:

1759 case Intrinsic::x86_avx512_cvttsd2si:

1760 case Intrinsic::x86_avx512_cvttsd2si64:

1761 case Intrinsic::x86_avx512_vcvtss2usi32:

1762 case Intrinsic::x86_avx512_vcvtss2usi64:

1763 case Intrinsic::x86_avx512_cvttss2usi:

1764 case Intrinsic::x86_avx512_cvttss2usi64:

1765 case Intrinsic::x86_avx512_vcvtsd2usi32:

1766 case Intrinsic::x86_avx512_vcvtsd2usi64:

1767 case Intrinsic::x86_avx512_cvttsd2usi:

1768 case Intrinsic::x86_avx512_cvttsd2usi64:

1769

1770

1771 case Intrinsic::nvvm_fmax_d:

1772 case Intrinsic::nvvm_fmax_f:

1773 case Intrinsic::nvvm_fmax_ftz_f:

1774 case Intrinsic::nvvm_fmax_ftz_nan_f:

1775 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:

1776 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:

1777 case Intrinsic::nvvm_fmax_nan_f:

1778 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:

1779 case Intrinsic::nvvm_fmax_xorsign_abs_f:

1780

1781

1782 case Intrinsic::nvvm_fmin_d:

1783 case Intrinsic::nvvm_fmin_f:

1784 case Intrinsic::nvvm_fmin_ftz_f:

1785 case Intrinsic::nvvm_fmin_ftz_nan_f:

1786 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:

1787 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:

1788 case Intrinsic::nvvm_fmin_nan_f:

1789 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:

1790 case Intrinsic::nvvm_fmin_xorsign_abs_f:

1791

1792

1793 case Intrinsic::nvvm_f2i_rm:

1794 case Intrinsic::nvvm_f2i_rn:

1795 case Intrinsic::nvvm_f2i_rp:

1796 case Intrinsic::nvvm_f2i_rz:

1797 case Intrinsic::nvvm_f2i_rm_ftz:

1798 case Intrinsic::nvvm_f2i_rn_ftz:

1799 case Intrinsic::nvvm_f2i_rp_ftz:

1800 case Intrinsic::nvvm_f2i_rz_ftz:

1801 case Intrinsic::nvvm_f2ui_rm:

1802 case Intrinsic::nvvm_f2ui_rn:

1803 case Intrinsic::nvvm_f2ui_rp:

1804 case Intrinsic::nvvm_f2ui_rz:

1805 case Intrinsic::nvvm_f2ui_rm_ftz:

1806 case Intrinsic::nvvm_f2ui_rn_ftz:

1807 case Intrinsic::nvvm_f2ui_rp_ftz:

1808 case Intrinsic::nvvm_f2ui_rz_ftz:

1809 case Intrinsic::nvvm_d2i_rm:

1810 case Intrinsic::nvvm_d2i_rn:

1811 case Intrinsic::nvvm_d2i_rp:

1812 case Intrinsic::nvvm_d2i_rz:

1813 case Intrinsic::nvvm_d2ui_rm:

1814 case Intrinsic::nvvm_d2ui_rn:

1815 case Intrinsic::nvvm_d2ui_rp:

1816 case Intrinsic::nvvm_d2ui_rz:

1817

1818

1819 case Intrinsic::nvvm_f2ll_rm:

1820 case Intrinsic::nvvm_f2ll_rn:

1821 case Intrinsic::nvvm_f2ll_rp:

1822 case Intrinsic::nvvm_f2ll_rz:

1823 case Intrinsic::nvvm_f2ll_rm_ftz:

1824 case Intrinsic::nvvm_f2ll_rn_ftz:

1825 case Intrinsic::nvvm_f2ll_rp_ftz:

1826 case Intrinsic::nvvm_f2ll_rz_ftz:

1827 case Intrinsic::nvvm_f2ull_rm:

1828 case Intrinsic::nvvm_f2ull_rn:

1829 case Intrinsic::nvvm_f2ull_rp:

1830 case Intrinsic::nvvm_f2ull_rz:

1831 case Intrinsic::nvvm_f2ull_rm_ftz:

1832 case Intrinsic::nvvm_f2ull_rn_ftz:

1833 case Intrinsic::nvvm_f2ull_rp_ftz:

1834 case Intrinsic::nvvm_f2ull_rz_ftz:

1835 case Intrinsic::nvvm_d2ll_rm:

1836 case Intrinsic::nvvm_d2ll_rn:

1837 case Intrinsic::nvvm_d2ll_rp:

1838 case Intrinsic::nvvm_d2ll_rz:

1839 case Intrinsic::nvvm_d2ull_rm:

1840 case Intrinsic::nvvm_d2ull_rn:

1841 case Intrinsic::nvvm_d2ull_rp:

1842 case Intrinsic::nvvm_d2ull_rz:

1843

1844

1845 case Intrinsic::nvvm_ceil_d:

1846 case Intrinsic::nvvm_ceil_f:

1847 case Intrinsic::nvvm_ceil_ftz_f:

1848

1849 case Intrinsic::nvvm_fabs:

1850 case Intrinsic::nvvm_fabs_ftz:

1851

1852 case Intrinsic::nvvm_floor_d:

1853 case Intrinsic::nvvm_floor_f:

1854 case Intrinsic::nvvm_floor_ftz_f:

1855

1856 case Intrinsic::nvvm_rcp_rm_d:

1857 case Intrinsic::nvvm_rcp_rm_f:

1858 case Intrinsic::nvvm_rcp_rm_ftz_f:

1859 case Intrinsic::nvvm_rcp_rn_d:

1860 case Intrinsic::nvvm_rcp_rn_f:

1861 case Intrinsic::nvvm_rcp_rn_ftz_f:

1862 case Intrinsic::nvvm_rcp_rp_d:

1863 case Intrinsic::nvvm_rcp_rp_f:

1864 case Intrinsic::nvvm_rcp_rp_ftz_f:

1865 case Intrinsic::nvvm_rcp_rz_d:

1866 case Intrinsic::nvvm_rcp_rz_f:

1867 case Intrinsic::nvvm_rcp_rz_ftz_f:

1868

1869 case Intrinsic::nvvm_round_d:

1870 case Intrinsic::nvvm_round_f:

1871 case Intrinsic::nvvm_round_ftz_f:

1872

1873 case Intrinsic::nvvm_saturate_d:

1874 case Intrinsic::nvvm_saturate_f:

1875 case Intrinsic::nvvm_saturate_ftz_f:

1876

1877 case Intrinsic::nvvm_sqrt_f:

1878 case Intrinsic::nvvm_sqrt_rn_d:

1879 case Intrinsic::nvvm_sqrt_rn_f:

1880 case Intrinsic::nvvm_sqrt_rn_ftz_f:

1881 return Call ->isStrictFP();

1882

1883

1884 case Intrinsic::nvvm_add_rm_d:

1885 case Intrinsic::nvvm_add_rn_d:

1886 case Intrinsic::nvvm_add_rp_d:

1887 case Intrinsic::nvvm_add_rz_d:

1888 case Intrinsic::nvvm_add_rm_f:

1889 case Intrinsic::nvvm_add_rn_f:

1890 case Intrinsic::nvvm_add_rp_f:

1891 case Intrinsic::nvvm_add_rz_f:

1892 case Intrinsic::nvvm_add_rm_ftz_f:

1893 case Intrinsic::nvvm_add_rn_ftz_f:

1894 case Intrinsic::nvvm_add_rp_ftz_f:

1895 case Intrinsic::nvvm_add_rz_ftz_f:

1896

1897

1898 case Intrinsic::nvvm_div_rm_d:

1899 case Intrinsic::nvvm_div_rn_d:

1900 case Intrinsic::nvvm_div_rp_d:

1901 case Intrinsic::nvvm_div_rz_d:

1902 case Intrinsic::nvvm_div_rm_f:

1903 case Intrinsic::nvvm_div_rn_f:

1904 case Intrinsic::nvvm_div_rp_f:

1905 case Intrinsic::nvvm_div_rz_f:

1906 case Intrinsic::nvvm_div_rm_ftz_f:

1907 case Intrinsic::nvvm_div_rn_ftz_f:

1908 case Intrinsic::nvvm_div_rp_ftz_f:

1909 case Intrinsic::nvvm_div_rz_ftz_f:

1910

1911

1912 case Intrinsic::nvvm_mul_rm_d:

1913 case Intrinsic::nvvm_mul_rn_d:

1914 case Intrinsic::nvvm_mul_rp_d:

1915 case Intrinsic::nvvm_mul_rz_d:

1916 case Intrinsic::nvvm_mul_rm_f:

1917 case Intrinsic::nvvm_mul_rn_f:

1918 case Intrinsic::nvvm_mul_rp_f:

1919 case Intrinsic::nvvm_mul_rz_f:

1920 case Intrinsic::nvvm_mul_rm_ftz_f:

1921 case Intrinsic::nvvm_mul_rn_ftz_f:

1922 case Intrinsic::nvvm_mul_rp_ftz_f:

1923 case Intrinsic::nvvm_mul_rz_ftz_f:

1924

1925

1926 case Intrinsic::nvvm_fma_rm_d:

1927 case Intrinsic::nvvm_fma_rn_d:

1928 case Intrinsic::nvvm_fma_rp_d:

1929 case Intrinsic::nvvm_fma_rz_d:

1930 case Intrinsic::nvvm_fma_rm_f:

1931 case Intrinsic::nvvm_fma_rn_f:

1932 case Intrinsic::nvvm_fma_rp_f:

1933 case Intrinsic::nvvm_fma_rz_f:

1934 case Intrinsic::nvvm_fma_rm_ftz_f:

1935 case Intrinsic::nvvm_fma_rn_ftz_f:

1936 case Intrinsic::nvvm_fma_rp_ftz_f:

1937 case Intrinsic::nvvm_fma_rz_ftz_f:

1938

1939

1940

1941 case Intrinsic::fabs:

1942 case Intrinsic::copysign:

1943 case Intrinsic::is_fpclass:

1944

1945

1946 case Intrinsic::ceil:

1947 case Intrinsic:🤣

1948 case Intrinsic::round:

1949 case Intrinsic::roundeven:

1950 case Intrinsic::trunc:

1951 case Intrinsic::nearbyint:

1952 case Intrinsic::rint:

1953 case Intrinsic::canonicalize:

1954

1955

1956

1957 case Intrinsic::experimental_constrained_fma:

1958 case Intrinsic::experimental_constrained_fmuladd:

1959 case Intrinsic::experimental_constrained_fadd:

1960 case Intrinsic::experimental_constrained_fsub:

1961 case Intrinsic::experimental_constrained_fmul:

1962 case Intrinsic::experimental_constrained_fdiv:

1963 case Intrinsic::experimental_constrained_frem:

1964 case Intrinsic::experimental_constrained_ceil:

1965 case Intrinsic::experimental_constrained_floor:

1966 case Intrinsic::experimental_constrained_round:

1967 case Intrinsic::experimental_constrained_roundeven:

1968 case Intrinsic::experimental_constrained_trunc:

1969 case Intrinsic::experimental_constrained_nearbyint:

1970 case Intrinsic::experimental_constrained_rint:

1971 case Intrinsic::experimental_constrained_fcmp:

1972 case Intrinsic::experimental_constrained_fcmps:

1973 return true;

1974 default:

1975 return false;

1977 }

1978

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

1980 return false;

1981

1982

1983

1984

1986 switch (Name[0]) {

1987 default:

1988 return false;

1989

1990 case 'a':

1991 return Name == "acos" || Name == "acosf" ||

1992 Name == "asin" || Name == "asinf" ||

1993 Name == "atan" || Name == "atanf" ||

1994 Name == "atan2" || Name == "atan2f";

1995 case 'c':

1996 return Name == "ceil" || Name == "ceilf" ||

1997 Name == "cos" || Name == "cosf" ||

1998 Name == "cosh" || Name == "coshf";

1999 case 'e':

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

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

2002 case 'f':

2003 return Name == "fabs" || Name == "fabsf" ||

2004 Name == "floor" || Name == "floorf" ||

2005 Name == "fmod" || Name == "fmodf";

2006 case 'i':

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

2008 case 'l':

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

2010 Name == "log2" || Name == "log2f" || Name == "log10" ||

2011 Name == "log10f" || Name == "logb" || Name == "logbf" ||

2012 Name == "log1p" || Name == "log1pf";

2013 case 'n':

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

2015 case 'p':

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

2017 case 'r':

2018 return Name == "remainder" || Name == "remainderf" ||

2019 Name == "rint" || Name == "rintf" ||

2020 Name == "round" || Name == "roundf" ||

2021 Name == "roundeven" || Name == "roundevenf";

2022 case 's':

2023 return Name == "sin" || Name == "sinf" ||

2024 Name == "sinh" || Name == "sinhf" ||

2025 Name == "sqrt" || Name == "sqrtf";

2026 case 't':

2027 return Name == "tan" || Name == "tanf" ||

2028 Name == "tanh" || Name == "tanhf" ||

2029 Name == "trunc" || Name == "truncf";

2030 case '_':

2031

2032

2033

2034

2035

2036

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

2038 return false;

2039 switch (Name[2]) {

2040 default:

2041 return false;

2042 case 'a':

2043 return Name == "__acos_finite" || Name == "__acosf_finite" ||

2044 Name == "__asin_finite" || Name == "__asinf_finite" ||

2045 Name == "__atan2_finite" || Name == "__atan2f_finite";

2046 case 'c':

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

2048 case 'e':

2049 return Name == "__exp_finite" || Name == "__expf_finite" ||

2050 Name == "__exp2_finite" || Name == "__exp2f_finite";

2051 case 'l':

2052 return Name == "__log_finite" || Name == "__logf_finite" ||

2053 Name == "__log10_finite" || Name == "__log10f_finite";

2054 case 'p':

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

2056 case 's':

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

2058 }

2059

2060 }

2061}

2062

2063namespace {

2064

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

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

2068 bool unused;

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

2071 }

2072 if (Ty->isDoubleTy())

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

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

2075}

2076

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

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

2079 if (Ty->isFP128Ty())

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

2082}

2083#endif

2084

2085

2086inline void llvm_fenv_clearexcept() {

2087#if HAVE_DECL_FE_ALL_EXCEPT

2088 feclearexcept(FE_ALL_EXCEPT);

2089#endif

2090 errno = 0;

2091}

2092

2093

2094inline bool llvm_fenv_testexcept() {

2095 int errno_val = errno;

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

2097 return true;

2098#if HAVE_DECL_FE_ALL_EXCEPT && HAVE_DECL_FE_INEXACT

2099 if (fetestexcept(FE_ALL_EXCEPT & ~FE_INEXACT))

2100 return true;

2101#endif

2102 return false;

2103}

2104

2106 if (V.isDenormal())

2108 return V;

2109}

2110

2111static APFloat FlushToPositiveZero(const APFloat &V) {

2112 if (V.isDenormal())

2114 return V;

2115}

2116

2121 switch (DenormKind) {

2123 return V;

2125 return FTZPreserveSign(V);

2127 return FlushToPositiveZero(V);

2128 default:

2130 }

2131}

2132

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

2135 if (!DenormMode.isValid() ||

2138 return nullptr;

2139

2140 llvm_fenv_clearexcept();

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

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

2143 if (llvm_fenv_testexcept()) {

2144 llvm_fenv_clearexcept();

2145 return nullptr;

2146 }

2147

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

2150 return Output;

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

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

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

2154}

2155

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

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

2159 llvm_fenv_clearexcept();

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

2161 if (llvm_fenv_testexcept()) {

2162 llvm_fenv_clearexcept();

2163 return nullptr;

2164 }

2165

2166 return GetConstantFoldFPValue128(Result, Ty);

2167}

2168#endif

2169

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

2172 llvm_fenv_clearexcept();

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

2174 if (llvm_fenv_testexcept()) {

2175 llvm_fenv_clearexcept();

2176 return nullptr;

2177 }

2178

2179 return GetConstantFoldFPValue(Result, Ty);

2180}

2181

2184

2185

2186 if (Op->containsPoisonElement())

2188

2189

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

2191 switch (IID) {

2192 case Intrinsic::vector_reduce_and:

2193 case Intrinsic::vector_reduce_or:

2194 case Intrinsic::vector_reduce_smin:

2195 case Intrinsic::vector_reduce_smax:

2196 case Intrinsic::vector_reduce_umin:

2197 case Intrinsic::vector_reduce_umax:

2198 return SplatVal;

2199 case Intrinsic::vector_reduce_add:

2200 if (SplatVal->isNullValue())

2201 return SplatVal;

2202 break;

2203 case Intrinsic::vector_reduce_mul:

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

2205 return SplatVal;

2206 break;

2207 case Intrinsic::vector_reduce_xor:

2208 if (SplatVal->isNullValue())

2209 return SplatVal;

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

2212 break;

2213 }

2214 }

2215

2217 if (!VT)

2218 return nullptr;

2219

2220

2222 if (!EltC)

2223 return nullptr;

2224

2225 APInt Acc = EltC->getValue();

2228 return nullptr;

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

2230 switch (IID) {

2231 case Intrinsic::vector_reduce_add:

2232 Acc = Acc + X;

2233 break;

2234 case Intrinsic::vector_reduce_mul:

2235 Acc = Acc * X;

2236 break;

2237 case Intrinsic::vector_reduce_and:

2238 Acc = Acc & X;

2239 break;

2240 case Intrinsic::vector_reduce_or:

2241 Acc = Acc | X;

2242 break;

2243 case Intrinsic::vector_reduce_xor:

2244 Acc = Acc ^ X;

2245 break;

2246 case Intrinsic::vector_reduce_smin:

2248 break;

2249 case Intrinsic::vector_reduce_smax:

2251 break;

2252 case Intrinsic::vector_reduce_umin:

2254 break;

2255 case Intrinsic::vector_reduce_umax:

2257 break;

2258 }

2259 }

2260

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

2262}

2263

2264

2265

2266

2267

2268

2269

2270

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

2272 Type *Ty, bool IsSigned) {

2273

2274 unsigned ResultWidth = Ty->getIntegerBitWidth();

2275 assert(ResultWidth <= 64 &&

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

2277

2279 bool isExact = false;

2284 IsSigned, mode, &isExact);

2287 return nullptr;

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

2289}

2290

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

2293

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

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

2296

2297 bool unused;

2298 APFloat APF = Op->getValueAPF();

2301}

2302

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

2305 C = &CI->getValue();

2306 return true;

2307 }

2309 C = nullptr;

2310 return true;

2311 }

2312 return false;

2313}

2314

2315

2316

2317

2318

2319

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

2324

2325

2326

2328 return true;

2329

2330

2331

2333 return false;

2334

2335

2336

2338 return true;

2339

2340

2341

2342 return false;

2343}

2344

2345

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

2350

2351

2352

2353

2355 return *ORM;

2356}

2357

2358

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

2361

2362 if (Src.isZero()) {

2363

2364 return ConstantFP::get(

2367 }

2368

2369 if (!Ty->isIEEELikeFPTy())

2370 return nullptr;

2371

2372

2373

2374

2375

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

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

2378

2382

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

2385

2387 return nullptr;

2388

2389

2394 return nullptr;

2395

2396 bool IsPositive =

2400

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

2403 }

2404

2405 return nullptr;

2406}

2407

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

2415

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

2417

2418

2419

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

2422 return nullptr;

2423 }

2424

2426

2427

2428

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

2430 IntrinsicID == Intrinsic::ctpop ||

2431 IntrinsicID == Intrinsic::fptoui_sat ||

2432 IntrinsicID == Intrinsic::fptosi_sat ||

2433 IntrinsicID == Intrinsic::canonicalize)

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

2436 IntrinsicID == Intrinsic::bitreverse ||

2437 IntrinsicID == Intrinsic::launder_invariant_group ||

2438 IntrinsicID == Intrinsic::strip_invariant_group)

2439 return Operands[0];

2440 }

2441

2443

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

2445 IntrinsicID == Intrinsic::strip_invariant_group) {

2446

2447

2448

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

2451 if (Caller &&

2454 return Operands[0];

2455 }

2456 return nullptr;

2457 }

2458 }

2459

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

2463

2464 bool lost = false;

2466

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

2468 }

2469

2471

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

2473 IntrinsicID == Intrinsic::wasm_trunc_unsigned) {

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

2475

2476 if (U.isNaN())

2477 return nullptr;

2478

2479 unsigned Width = Ty->getIntegerBitWidth();

2481 bool IsExact = false;

2484

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

2487

2488 return nullptr;

2489 }

2490

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

2492 IntrinsicID == Intrinsic::fptosi_sat) {

2493

2494 APSInt Int(Ty->getIntegerBitWidth(),

2495 IntrinsicID == Intrinsic::fptoui_sat);

2496 bool IsExact;

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

2499 }

2500

2501 if (IntrinsicID == Intrinsic::canonicalize)

2502 return constantFoldCanonicalize(Ty, Call, U);

2503

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

2505 if (Ty->isFP128Ty()) {

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

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

2508 return GetConstantFoldFPValue128(Result, Ty);

2509 }

2510

2511 LibFunc Fp128Func = NotLibFunc;

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

2513 Fp128Func == LibFunc_logl)

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

2515 }

2516#endif

2517

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

2519 !Ty->isIntegerTy())

2520 return nullptr;

2521

2522

2523

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

2525 IntrinsicID == Intrinsic::roundeven) {

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

2528 }

2529

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

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

2533 }

2534

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

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

2538 }

2539

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

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

2543 }

2544

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

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

2548 }

2549

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

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

2553 }

2554

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

2556 U.clearSign();

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

2558 }

2559

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

2561

2562

2563

2564

2567 APFloat FractU(U - FloorU);

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

2569 AlmostOne.next( true);

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

2571 }

2572

2573

2574

2575

2576 std::optionalAPFloat::roundingMode RM;

2577 switch (IntrinsicID) {

2578 default:

2579 break;

2580 case Intrinsic::experimental_constrained_nearbyint:

2581 case Intrinsic::experimental_constrained_rint: {

2583 RM = CI->getRoundingMode();

2585 return nullptr;

2586 break;

2587 }

2588 case Intrinsic::experimental_constrained_round:

2590 break;

2591 case Intrinsic::experimental_constrained_ceil:

2593 break;

2594 case Intrinsic::experimental_constrained_floor:

2596 break;

2597 case Intrinsic::experimental_constrained_trunc:

2599 break;

2600 }

2601 if (RM) {

2603 if (U.isFinite()) {

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

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

2609 return nullptr;

2610 }

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

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

2614 return nullptr;

2616 }

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

2618 }

2619

2620

2621 switch (IntrinsicID) {

2622

2623 case Intrinsic::nvvm_f2i_rm:

2624 case Intrinsic::nvvm_f2i_rn:

2625 case Intrinsic::nvvm_f2i_rp:

2626 case Intrinsic::nvvm_f2i_rz:

2627 case Intrinsic::nvvm_f2i_rm_ftz:

2628 case Intrinsic::nvvm_f2i_rn_ftz:

2629 case Intrinsic::nvvm_f2i_rp_ftz:

2630 case Intrinsic::nvvm_f2i_rz_ftz:

2631

2632 case Intrinsic::nvvm_f2ui_rm:

2633 case Intrinsic::nvvm_f2ui_rn:

2634 case Intrinsic::nvvm_f2ui_rp:

2635 case Intrinsic::nvvm_f2ui_rz:

2636 case Intrinsic::nvvm_f2ui_rm_ftz:

2637 case Intrinsic::nvvm_f2ui_rn_ftz:

2638 case Intrinsic::nvvm_f2ui_rp_ftz:

2639 case Intrinsic::nvvm_f2ui_rz_ftz:

2640

2641 case Intrinsic::nvvm_d2i_rm:

2642 case Intrinsic::nvvm_d2i_rn:

2643 case Intrinsic::nvvm_d2i_rp:

2644 case Intrinsic::nvvm_d2i_rz:

2645

2646 case Intrinsic::nvvm_d2ui_rm:

2647 case Intrinsic::nvvm_d2ui_rn:

2648 case Intrinsic::nvvm_d2ui_rp:

2649 case Intrinsic::nvvm_d2ui_rz:

2650

2651 case Intrinsic::nvvm_f2ll_rm:

2652 case Intrinsic::nvvm_f2ll_rn:

2653 case Intrinsic::nvvm_f2ll_rp:

2654 case Intrinsic::nvvm_f2ll_rz:

2655 case Intrinsic::nvvm_f2ll_rm_ftz:

2656 case Intrinsic::nvvm_f2ll_rn_ftz:

2657 case Intrinsic::nvvm_f2ll_rp_ftz:

2658 case Intrinsic::nvvm_f2ll_rz_ftz:

2659

2660 case Intrinsic::nvvm_f2ull_rm:

2661 case Intrinsic::nvvm_f2ull_rn:

2662 case Intrinsic::nvvm_f2ull_rp:

2663 case Intrinsic::nvvm_f2ull_rz:

2664 case Intrinsic::nvvm_f2ull_rm_ftz:

2665 case Intrinsic::nvvm_f2ull_rn_ftz:

2666 case Intrinsic::nvvm_f2ull_rp_ftz:

2667 case Intrinsic::nvvm_f2ull_rz_ftz:

2668

2669 case Intrinsic::nvvm_d2ll_rm:

2670 case Intrinsic::nvvm_d2ll_rn:

2671 case Intrinsic::nvvm_d2ll_rp:

2672 case Intrinsic::nvvm_d2ll_rz:

2673

2674 case Intrinsic::nvvm_d2ull_rm:

2675 case Intrinsic::nvvm_d2ull_rn:

2676 case Intrinsic::nvvm_d2ull_rp:

2677 case Intrinsic::nvvm_d2ull_rz: {

2678

2679 if (U.isNaN()) {

2680

2681

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

2684

2685

2686 unsigned BitWidth = Ty->getIntegerBitWidth();

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

2689 }

2690

2695

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

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

2698

2699

2700

2701 bool IsExact = false;

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

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

2704 }

2705 }

2706

2707

2708

2709

2710 if (!U.isFinite())

2711 return nullptr;

2712

2713

2714

2715

2716

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

2718

2719 switch (IntrinsicID) {

2720 default: break;

2721 case Intrinsic:🪵

2722 return ConstantFoldFP(log, APF, Ty);

2723 case Intrinsic::log2:

2724

2725 return ConstantFoldFP(log2, APF, Ty);

2726 case Intrinsic::log10:

2727

2728 return ConstantFoldFP(log10, APF, Ty);

2729 case Intrinsic::exp:

2730 return ConstantFoldFP(exp, APF, Ty);

2731 case Intrinsic::exp2:

2732

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

2734 case Intrinsic::exp10:

2735

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

2737 case Intrinsic::sin:

2738 return ConstantFoldFP(sin, APF, Ty);

2739 case Intrinsic::cos:

2740 return ConstantFoldFP(cos, APF, Ty);

2741 case Intrinsic::sinh:

2742 return ConstantFoldFP(sinh, APF, Ty);

2743 case Intrinsic::cosh:

2744 return ConstantFoldFP(cosh, APF, Ty);

2745 case Intrinsic::atan:

2746

2747 if (U.isZero())

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

2749 return ConstantFoldFP(atan, APF, Ty);

2750 case Intrinsic::sqrt:

2751 return ConstantFoldFP(sqrt, APF, Ty);

2752

2753

2754 case Intrinsic::nvvm_ceil_ftz_f:

2755 case Intrinsic::nvvm_ceil_f:

2756 case Intrinsic::nvvm_ceil_d:

2757 return ConstantFoldFP(

2758 ceil, APF, Ty,

2761

2762 case Intrinsic::nvvm_fabs_ftz:

2763 case Intrinsic::nvvm_fabs:

2764 return ConstantFoldFP(

2765 fabs, APF, Ty,

2768

2769 case Intrinsic::nvvm_floor_ftz_f:

2770 case Intrinsic::nvvm_floor_f:

2771 case Intrinsic::nvvm_floor_d:

2772 return ConstantFoldFP(

2773 floor, APF, Ty,

2776

2777 case Intrinsic::nvvm_rcp_rm_ftz_f:

2778 case Intrinsic::nvvm_rcp_rn_ftz_f:

2779 case Intrinsic::nvvm_rcp_rp_ftz_f:

2780 case Intrinsic::nvvm_rcp_rz_ftz_f:

2781 case Intrinsic::nvvm_rcp_rm_d:

2782 case Intrinsic::nvvm_rcp_rm_f:

2783 case Intrinsic::nvvm_rcp_rn_d:

2784 case Intrinsic::nvvm_rcp_rn_f:

2785 case Intrinsic::nvvm_rcp_rp_d:

2786 case Intrinsic::nvvm_rcp_rp_f:

2787 case Intrinsic::nvvm_rcp_rz_d:

2788 case Intrinsic::nvvm_rcp_rz_f: {

2791

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

2795

2797 if (IsFTZ)

2798 Res = FTZPreserveSign(Res);

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

2800 }

2801 return nullptr;

2802 }

2803

2804 case Intrinsic::nvvm_round_ftz_f:

2805 case Intrinsic::nvvm_round_f:

2806 case Intrinsic::nvvm_round_d: {

2807

2808

2809

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

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

2814 }

2815

2816 case Intrinsic::nvvm_saturate_ftz_f:

2817 case Intrinsic::nvvm_saturate_d:

2818 case Intrinsic::nvvm_saturate_f: {

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

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

2824 if (V > One)

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

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

2827 }

2828

2829 case Intrinsic::nvvm_sqrt_rn_ftz_f:

2830 case Intrinsic::nvvm_sqrt_f:

2831 case Intrinsic::nvvm_sqrt_rn_d:

2832 case Intrinsic::nvvm_sqrt_rn_f:

2834 return nullptr;

2835 return ConstantFoldFP(

2836 sqrt, APF, Ty,

2839

2840

2841 case Intrinsic::amdgcn_cos:

2842 case Intrinsic::amdgcn_sin: {

2843 double V = getValueAsDouble(Op);

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

2845

2846

2847

2848 return nullptr;

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

2850 double V4 = V * 4.0;

2851 if (V4 == floor(V4)) {

2852

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

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

2855 } else {

2856 if (IsCos)

2858 else

2860 }

2861 return GetConstantFoldFPValue(V, Ty);

2862 }

2863 }

2864

2865 if (!TLI)

2866 return nullptr;

2867

2868 LibFunc Func = NotLibFunc;

2870 return nullptr;

2871

2872 switch (Func) {

2873 default:

2874 break;

2875 case LibFunc_acos:

2876 case LibFunc_acosf:

2877 case LibFunc_acos_finite:

2878 case LibFunc_acosf_finite:

2879 if (TLI->has(Func))

2880 return ConstantFoldFP(acos, APF, Ty);

2881 break;

2882 case LibFunc_asin:

2883 case LibFunc_asinf:

2884 case LibFunc_asin_finite:

2885 case LibFunc_asinf_finite:

2886 if (TLI->has(Func))

2887 return ConstantFoldFP(asin, APF, Ty);

2888 break;

2889 case LibFunc_atan:

2890 case LibFunc_atanf:

2891

2892 if (U.isZero())

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

2894 if (TLI->has(Func))

2895 return ConstantFoldFP(atan, APF, Ty);

2896 break;

2897 case LibFunc_ceil:

2898 case LibFunc_ceilf:

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

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

2902 }

2903 break;

2904 case LibFunc_cos:

2905 case LibFunc_cosf:

2906 if (TLI->has(Func))

2907 return ConstantFoldFP(cos, APF, Ty);

2908 break;

2909 case LibFunc_cosh:

2910 case LibFunc_coshf:

2911 case LibFunc_cosh_finite:

2912 case LibFunc_coshf_finite:

2913 if (TLI->has(Func))

2914 return ConstantFoldFP(cosh, APF, Ty);

2915 break;

2916 case LibFunc_exp:

2917 case LibFunc_expf:

2918 case LibFunc_exp_finite:

2919 case LibFunc_expf_finite:

2920 if (TLI->has(Func))

2921 return ConstantFoldFP(exp, APF, Ty);

2922 break;

2923 case LibFunc_exp2:

2924 case LibFunc_exp2f:

2925 case LibFunc_exp2_finite:

2926 case LibFunc_exp2f_finite:

2927 if (TLI->has(Func))

2928

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

2930 break;

2931 case LibFunc_fabs:

2932 case LibFunc_fabsf:

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

2934 U.clearSign();

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

2936 }

2937 break;

2938 case LibFunc_floor:

2939 case LibFunc_floorf:

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

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

2943 }

2944 break;

2945 case LibFunc_log:

2946 case LibFunc_logf:

2947 case LibFunc_log_finite:

2948 case LibFunc_logf_finite:

2950 return ConstantFoldFP(log, APF, Ty);

2951 break;

2952 case LibFunc_log2:

2953 case LibFunc_log2f:

2954 case LibFunc_log2_finite:

2955 case LibFunc_log2f_finite:

2957

2958 return ConstantFoldFP(log2, APF, Ty);

2959 break;

2960 case LibFunc_log10:

2961 case LibFunc_log10f:

2962 case LibFunc_log10_finite:

2963 case LibFunc_log10f_finite:

2965

2966 return ConstantFoldFP(log10, APF, Ty);

2967 break;

2968 case LibFunc_ilogb:

2969 case LibFunc_ilogbf:

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

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

2972 break;

2973 case LibFunc_logb:

2974 case LibFunc_logbf:

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

2976 return ConstantFoldFP(logb, APF, Ty);

2977 break;

2978 case LibFunc_log1p:

2979 case LibFunc_log1pf:

2980

2981 if (U.isZero())

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

2984 return ConstantFoldFP(log1p, APF, Ty);

2985 break;

2986 case LibFunc_logl:

2987 return nullptr;

2988 case LibFunc_erf:

2989 case LibFunc_erff:

2990 if (TLI->has(Func))

2991 return ConstantFoldFP(erf, APF, Ty);

2992 break;

2993 case LibFunc_nearbyint:

2994 case LibFunc_nearbyintf:

2995 case LibFunc_rint:

2996 case LibFunc_rintf:

2997 case LibFunc_roundeven:

2998 case LibFunc_roundevenf:

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

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

3002 }

3003 break;

3004 case LibFunc_round:

3005 case LibFunc_roundf:

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

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

3009 }

3010 break;

3011 case LibFunc_sin:

3012 case LibFunc_sinf:

3013 if (TLI->has(Func))

3014 return ConstantFoldFP(sin, APF, Ty);

3015 break;

3016 case LibFunc_sinh:

3017 case LibFunc_sinhf:

3018 case LibFunc_sinh_finite:

3019 case LibFunc_sinhf_finite:

3020 if (TLI->has(Func))

3021 return ConstantFoldFP(sinh, APF, Ty);

3022 break;

3023 case LibFunc_sqrt:

3024 case LibFunc_sqrtf:

3026 return ConstantFoldFP(sqrt, APF, Ty);

3027 break;

3028 case LibFunc_tan:

3029 case LibFunc_tanf:

3030 if (TLI->has(Func))

3031 return ConstantFoldFP(tan, APF, Ty);

3032 break;

3033 case LibFunc_tanh:

3034 case LibFunc_tanhf:

3035 if (TLI->has(Func))

3036 return ConstantFoldFP(tanh, APF, Ty);

3037 break;

3038 case LibFunc_trunc:

3039 case LibFunc_truncf:

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

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

3043 }

3044 break;

3045 }

3046 return nullptr;

3047 }

3048

3050 switch (IntrinsicID) {

3051 case Intrinsic::bswap:

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

3053 case Intrinsic::ctpop:

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

3055 case Intrinsic::bitreverse:

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

3057 case Intrinsic::convert_from_fp16: {

3059

3060 bool lost = false;

3063

3064

3065 (void)status;

3067 "Precision lost during fp16 constfolding");

3068

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

3070 }

3071

3072 case Intrinsic::amdgcn_s_wqm: {

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

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

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

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

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

3079 }

3080

3081 case Intrinsic::amdgcn_s_quadmask: {

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

3085 if (!(Val & 0xF))

3086 continue;

3087

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

3089 }

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

3091 }

3092

3093 case Intrinsic::amdgcn_s_bitreplicate: {

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

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

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

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

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

3100 Val = Val | Val << 1;

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

3102 }

3103 }

3104 }

3105

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

3108 switch (IntrinsicID) {

3109 default: break;

3110 case Intrinsic::vector_reduce_add:

3111 case Intrinsic::vector_reduce_mul:

3112 case Intrinsic::vector_reduce_and:

3113 case Intrinsic::vector_reduce_or:

3114 case Intrinsic::vector_reduce_xor:

3115 case Intrinsic::vector_reduce_smin:

3116 case Intrinsic::vector_reduce_smax:

3117 case Intrinsic::vector_reduce_umin:

3118 case Intrinsic::vector_reduce_umax:

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

3120 return C;

3121 break;

3122 case Intrinsic::x86_sse_cvtss2si:

3123 case Intrinsic::x86_sse_cvtss2si64:

3124 case Intrinsic::x86_sse2_cvtsd2si:

3125 case Intrinsic::x86_sse2_cvtsd2si64:

3128 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3129 false, Ty,

3130 true);

3131 break;

3132 case Intrinsic::x86_sse_cvttss2si:

3133 case Intrinsic::x86_sse_cvttss2si64:

3134 case Intrinsic::x86_sse2_cvttsd2si:

3135 case Intrinsic::x86_sse2_cvttsd2si64:

3138 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3139 true, Ty,

3140 true);

3141 break;

3142

3143 case Intrinsic::wasm_anytrue:

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

3146

3147 case Intrinsic::wasm_alltrue:

3148

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

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

3152

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

3155

3157 return nullptr;

3158 }

3159

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

3161 }

3162 }

3163

3164 return nullptr;

3165}

3166

3172 if (FCmp->isSignaling()) {

3175 } else {

3178 }

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

3182 return nullptr;

3183}

3184

3188 if (!TLI)

3189 return nullptr;

3190

3191 LibFunc Func = NotLibFunc;

3193 return nullptr;

3194

3196 if (!Op1)

3197 return nullptr;

3198

3200 if (!Op2)

3201 return nullptr;

3202

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

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

3205

3206 switch (Func) {

3207 default:

3208 break;

3209 case LibFunc_pow:

3210 case LibFunc_powf:

3211 case LibFunc_pow_finite:

3212 case LibFunc_powf_finite:

3213 if (TLI->has(Func))

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

3215 break;

3216 case LibFunc_fmod:

3217 case LibFunc_fmodf:

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

3219 APFloat V = Op1->getValueAPF();

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

3222 }

3223 break;

3224 case LibFunc_remainder:

3225 case LibFunc_remainderf:

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

3227 APFloat V = Op1->getValueAPF();

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

3230 }

3231 break;

3232 case LibFunc_atan2:

3233 case LibFunc_atan2f:

3234

3235

3237 return nullptr;

3238 [[fallthrough]];

3239 case LibFunc_atan2_finite:

3240 case LibFunc_atan2f_finite:

3241 if (TLI->has(Func))

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

3243 break;

3244 }

3245

3246 return nullptr;

3247}

3248

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

3253

3254 if (Ty->isFloatingPointTy()) {

3255

3256

3259 switch (IntrinsicID) {

3260 case Intrinsic::maxnum:

3261 case Intrinsic::minnum:

3262 case Intrinsic::maximum:

3263 case Intrinsic::minimum:

3264 case Intrinsic::maximumnum:

3265 case Intrinsic::minimumnum:

3266 case Intrinsic::nvvm_fmax_d:

3267 case Intrinsic::nvvm_fmin_d:

3268

3269 if (IsOp0Undef)

3270 return Operands[1];

3271 if (IsOp1Undef)

3272 return Operands[0];

3273 break;

3274

3275 case Intrinsic::nvvm_fmax_f:

3276 case Intrinsic::nvvm_fmax_ftz_f:

3277 case Intrinsic::nvvm_fmax_ftz_nan_f:

3278 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:

3279 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:

3280 case Intrinsic::nvvm_fmax_nan_f:

3281 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:

3282 case Intrinsic::nvvm_fmax_xorsign_abs_f:

3283

3284 case Intrinsic::nvvm_fmin_f:

3285 case Intrinsic::nvvm_fmin_ftz_f:

3286 case Intrinsic::nvvm_fmin_ftz_nan_f:

3287 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:

3288 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:

3289 case Intrinsic::nvvm_fmin_nan_f:

3290 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:

3291 case Intrinsic::nvvm_fmin_xorsign_abs_f:

3292

3293

3294

3295 if (!IsOp0Undef && !IsOp1Undef)

3296 break;

3298 if (Op->isNaN()) {

3299 APInt NVCanonicalNaN(32, 0x7fffffff);

3300 return ConstantFP::get(

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

3302 }

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

3305 else

3306 return Op;

3307 }

3308 break;

3309 }

3310 }

3311

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

3314

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

3317 return nullptr;

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

3319

3320 if (const auto *ConstrIntr =

3322 RoundingMode RM = getEvaluationRoundingMode(ConstrIntr);

3325 switch (IntrinsicID) {

3326 default:

3327 return nullptr;

3328 case Intrinsic::experimental_constrained_fadd:

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

3330 break;

3331 case Intrinsic::experimental_constrained_fsub:

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

3333 break;

3334 case Intrinsic::experimental_constrained_fmul:

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

3336 break;

3337 case Intrinsic::experimental_constrained_fdiv:

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

3339 break;

3340 case Intrinsic::experimental_constrained_frem:

3341 St = Res.mod(Op2V);

3342 break;

3343 case Intrinsic::experimental_constrained_fcmp:

3344 case Intrinsic::experimental_constrained_fcmps:

3345 return evaluateCompare(Op1V, Op2V, ConstrIntr);

3346 }

3348 St))

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

3350 return nullptr;

3351 }

3352

3353 switch (IntrinsicID) {

3354 default:

3355 break;

3356 case Intrinsic::copysign:

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

3358 case Intrinsic::minnum:

3360 return nullptr;

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

3362 case Intrinsic::maxnum:

3364 return nullptr;

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

3366 case Intrinsic::minimum:

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

3368 case Intrinsic::maximum:

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

3370 case Intrinsic::minimumnum:

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

3372 case Intrinsic::maximumnum:

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

3374

3375 case Intrinsic::nvvm_fmax_d:

3376 case Intrinsic::nvvm_fmax_f:

3377 case Intrinsic::nvvm_fmax_ftz_f:

3378 case Intrinsic::nvvm_fmax_ftz_nan_f:

3379 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:

3380 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:

3381 case Intrinsic::nvvm_fmax_nan_f:

3382 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:

3383 case Intrinsic::nvvm_fmax_xorsign_abs_f:

3384

3385 case Intrinsic::nvvm_fmin_d:

3386 case Intrinsic::nvvm_fmin_f:

3387 case Intrinsic::nvvm_fmin_ftz_f:

3388 case Intrinsic::nvvm_fmin_ftz_nan_f:

3389 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:

3390 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:

3391 case Intrinsic::nvvm_fmin_nan_f:

3392 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:

3393 case Intrinsic::nvvm_fmin_xorsign_abs_f: {

3394

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

3396 IntrinsicID == Intrinsic::nvvm_fmin_d);

3400

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

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

3403

3404 bool XorSign = false;

3405 if (IsXorSignAbs) {

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

3409 }

3410

3411 bool IsFMax = false;

3412 switch (IntrinsicID) {

3413 case Intrinsic::nvvm_fmax_d:

3414 case Intrinsic::nvvm_fmax_f:

3415 case Intrinsic::nvvm_fmax_ftz_f:

3416 case Intrinsic::nvvm_fmax_ftz_nan_f:

3417 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:

3418 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:

3419 case Intrinsic::nvvm_fmax_nan_f:

3420 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:

3421 case Intrinsic::nvvm_fmax_xorsign_abs_f:

3422 IsFMax = true;

3423 break;

3424 }

3426

3427 if (ShouldCanonicalizeNaNs) {

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

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

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

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

3433 }

3434

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

3436 return Operands[1];

3437 else if (A.isNaN())

3438 Res = B;

3439 else if (B.isNaN())

3440 Res = A;

3441

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

3444

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

3446 }

3447

3448 case Intrinsic::nvvm_add_rm_f:

3449 case Intrinsic::nvvm_add_rn_f:

3450 case Intrinsic::nvvm_add_rp_f:

3451 case Intrinsic::nvvm_add_rz_f:

3452 case Intrinsic::nvvm_add_rm_d:

3453 case Intrinsic::nvvm_add_rn_d:

3454 case Intrinsic::nvvm_add_rp_d:

3455 case Intrinsic::nvvm_add_rz_d:

3456 case Intrinsic::nvvm_add_rm_ftz_f:

3457 case Intrinsic::nvvm_add_rn_ftz_f:

3458 case Intrinsic::nvvm_add_rp_ftz_f:

3459 case Intrinsic::nvvm_add_rz_ftz_f: {

3460

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

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

3464

3467

3470

3471 if (!Res.isNaN() &&

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

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

3475 }

3476 return nullptr;

3477 }

3478

3479 case Intrinsic::nvvm_mul_rm_f:

3480 case Intrinsic::nvvm_mul_rn_f:

3481 case Intrinsic::nvvm_mul_rp_f:

3482 case Intrinsic::nvvm_mul_rz_f:

3483 case Intrinsic::nvvm_mul_rm_d:

3484 case Intrinsic::nvvm_mul_rn_d:

3485 case Intrinsic::nvvm_mul_rp_d:

3486 case Intrinsic::nvvm_mul_rz_d:

3487 case Intrinsic::nvvm_mul_rm_ftz_f:

3488 case Intrinsic::nvvm_mul_rn_ftz_f:

3489 case Intrinsic::nvvm_mul_rp_ftz_f:

3490 case Intrinsic::nvvm_mul_rz_ftz_f: {

3491

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

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

3495

3498

3501

3502 if (!Res.isNaN() &&

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

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

3506 }

3507 return nullptr;

3508 }

3509

3510 case Intrinsic::nvvm_div_rm_f:

3511 case Intrinsic::nvvm_div_rn_f:

3512 case Intrinsic::nvvm_div_rp_f:

3513 case Intrinsic::nvvm_div_rz_f:

3514 case Intrinsic::nvvm_div_rm_d:

3515 case Intrinsic::nvvm_div_rn_d:

3516 case Intrinsic::nvvm_div_rp_d:

3517 case Intrinsic::nvvm_div_rz_d:

3518 case Intrinsic::nvvm_div_rm_ftz_f:

3519 case Intrinsic::nvvm_div_rn_ftz_f:

3520 case Intrinsic::nvvm_div_rp_ftz_f:

3521 case Intrinsic::nvvm_div_rz_ftz_f: {

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

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

3527

3530 if (!Res.isNaN() &&

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

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

3534 }

3535 return nullptr;

3536 }

3537 }

3538

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

3540 return nullptr;

3541

3542 switch (IntrinsicID) {

3543 default:

3544 break;

3545 case Intrinsic::pow:

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

3547 case Intrinsic::amdgcn_fmul_legacy:

3548

3549

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

3553 }

3554

3556 switch (IntrinsicID) {

3557 case Intrinsic::ldexp: {

3558 return ConstantFP::get(

3559 Ty->getContext(),

3561 }

3562 case Intrinsic::is_fpclass: {

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

3576 }

3577 case Intrinsic::powi: {

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

3579 switch (Ty->getTypeID()) {

3583 if (Ty->isHalfTy()) {

3586 &Unused);

3587 }

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

3589 }

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

3592 default:

3593 return nullptr;

3594 }

3595 }

3596 default:

3597 break;

3598 }

3599 }

3600 return nullptr;

3601 }

3602

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

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

3605 const APInt *C0, *C1;

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

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

3608 return nullptr;

3609

3610 switch (IntrinsicID) {

3611 default: break;

3612 case Intrinsic::smax:

3613 case Intrinsic::smin:

3614 case Intrinsic::umax:

3615 case Intrinsic::umin:

3616 if (!C0 && !C1)

3618 if (!C0 || !C1)

3620 return ConstantInt::get(

3623 ? *C0

3624 : *C1);

3625

3626 case Intrinsic::scmp:

3627 case Intrinsic::ucmp:

3628 if (!C0 || !C1)

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

3630

3631 int Res;

3632 if (IntrinsicID == Intrinsic::scmp)

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

3634 else

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

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

3637

3638 case Intrinsic::usub_with_overflow:

3639 case Intrinsic::ssub_with_overflow:

3640

3641

3642 if (!C0 || !C1)

3644 [[fallthrough]];

3645 case Intrinsic::uadd_with_overflow:

3646 case Intrinsic::sadd_with_overflow:

3647

3648

3649 if (!C0 || !C1) {

3654 }

3655 [[fallthrough]];

3656 case Intrinsic::smul_with_overflow:

3657 case Intrinsic::umul_with_overflow: {

3658

3659

3660 if (!C0 || !C1)

3662

3664 bool Overflow;

3665 switch (IntrinsicID) {

3667 case Intrinsic::sadd_with_overflow:

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

3669 break;

3670 case Intrinsic::uadd_with_overflow:

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

3672 break;

3673 case Intrinsic::ssub_with_overflow:

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

3675 break;

3676 case Intrinsic::usub_with_overflow:

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

3678 break;

3679 case Intrinsic::smul_with_overflow:

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

3681 break;

3682 case Intrinsic::umul_with_overflow:

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

3684 break;

3685 }

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

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

3689 };

3691 }

3692 case Intrinsic::uadd_sat:

3693 case Intrinsic::sadd_sat:

3694 if (!C0 && !C1)

3696 if (!C0 || !C1)

3698 if (IntrinsicID == Intrinsic::uadd_sat)

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

3700 else

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

3702 case Intrinsic::usub_sat:

3703 case Intrinsic::ssub_sat:

3704 if (!C0 && !C1)

3706 if (!C0 || !C1)

3708 if (IntrinsicID == Intrinsic::usub_sat)

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

3710 else

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

3712 case Intrinsic::cttz:

3713 case Intrinsic::ctlz:

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

3715

3716

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

3719 if (!C0)

3721 if (IntrinsicID == Intrinsic::cttz)

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

3723 else

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

3725

3726 case Intrinsic::abs:

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

3729

3730

3733

3734

3735 if (!C0)

3737

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

3739 case Intrinsic::amdgcn_wave_reduce_umin:

3740 case Intrinsic::amdgcn_wave_reduce_umax:

3741 case Intrinsic::amdgcn_wave_reduce_max:

3742 case Intrinsic::amdgcn_wave_reduce_min:

3743 case Intrinsic::amdgcn_wave_reduce_add:

3744 case Intrinsic::amdgcn_wave_reduce_sub:

3745 case Intrinsic::amdgcn_wave_reduce_and:

3746 case Intrinsic::amdgcn_wave_reduce_or:

3747 case Intrinsic::amdgcn_wave_reduce_xor:

3749 }

3750

3751 return nullptr;

3752 }

3753

3754

3757

3758

3762 switch (IntrinsicID) {

3763 default: break;

3764 case Intrinsic::x86_avx512_vcvtss2si32:

3765 case Intrinsic::x86_avx512_vcvtss2si64:

3766 case Intrinsic::x86_avx512_vcvtsd2si32:

3767 case Intrinsic::x86_avx512_vcvtsd2si64:

3770 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3771 false, Ty,

3772 true);

3773 break;

3774 case Intrinsic::x86_avx512_vcvtss2usi32:

3775 case Intrinsic::x86_avx512_vcvtss2usi64:

3776 case Intrinsic::x86_avx512_vcvtsd2usi32:

3777 case Intrinsic::x86_avx512_vcvtsd2usi64:

3780 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3781 false, Ty,

3782 false);

3783 break;

3784 case Intrinsic::x86_avx512_cvttss2si:

3785 case Intrinsic::x86_avx512_cvttss2si64:

3786 case Intrinsic::x86_avx512_cvttsd2si:

3787 case Intrinsic::x86_avx512_cvttsd2si64:

3790 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3791 true, Ty,

3792 true);

3793 break;

3794 case Intrinsic::x86_avx512_cvttss2usi:

3795 case Intrinsic::x86_avx512_cvttss2usi64:

3796 case Intrinsic::x86_avx512_cvttsd2usi:

3797 case Intrinsic::x86_avx512_cvttsd2usi64:

3800 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),

3801 true, Ty,

3802 false);

3803 break;

3804 }

3805 }

3806 return nullptr;

3807}

3808

3813 unsigned ID;

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

3818

3819 ID = 5;

3820 SC = -S0;

3821 } else {

3822 ID = 4;

3823 SC = S0;

3824 }

3825 MA = S2;

3826 TC = -S1;

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

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

3829

3830 ID = 3;

3831 TC = -S2;

3832 } else {

3833 ID = 2;

3834 TC = S2;

3835 }

3836 MA = S1;

3837 SC = S0;

3838 } else {

3840

3841 ID = 1;

3842 SC = S2;

3843 } else {

3844 ID = 0;

3845 SC = -S2;

3846 }

3847 MA = S0;

3848 TC = -S1;

3849 }

3850 switch (IntrinsicID) {

3851 default:

3853 case Intrinsic::amdgcn_cubeid:

3855 case Intrinsic::amdgcn_cubema:

3856 return MA + MA;

3857 case Intrinsic::amdgcn_cubesc:

3858 return SC;

3859 case Intrinsic::amdgcn_cubetc:

3860 return TC;

3861 }

3862}

3863

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

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

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

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

3870 return nullptr;

3871

3872 if (!C2)

3874

3875 APInt Val(32, 0);

3876 unsigned NumUndefBytes = 0;

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

3879 unsigned B = 0;

3880

3881 if (Sel >= 13)

3882 B = 0xff;

3883 else if (Sel == 12)

3884 B = 0x00;

3885 else {

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

3887 if (!Src)

3888 ++NumUndefBytes;

3889 else if (Sel < 8)

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

3891 else

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

3893 }

3894

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

3896 }

3897

3898 if (NumUndefBytes == 4)

3900

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

3902}

3903

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

3911

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

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

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

3918

3920 RoundingMode RM = getEvaluationRoundingMode(ConstrIntr);

3923 switch (IntrinsicID) {

3924 default:

3925 return nullptr;

3926 case Intrinsic::experimental_constrained_fma:

3927 case Intrinsic::experimental_constrained_fmuladd:

3929 break;

3930 }

3931 if (mayFoldConstrained(

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

3934 return nullptr;

3935 }

3936

3937 switch (IntrinsicID) {

3938 default: break;

3939 case Intrinsic::amdgcn_fma_legacy: {

3940

3941

3943

3944

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

3946 }

3947 [[fallthrough]];

3948 }

3949 case Intrinsic::fma:

3950 case Intrinsic::fmuladd: {

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

3954 }

3955

3956 case Intrinsic::nvvm_fma_rm_f:

3957 case Intrinsic::nvvm_fma_rn_f:

3958 case Intrinsic::nvvm_fma_rp_f:

3959 case Intrinsic::nvvm_fma_rz_f:

3960 case Intrinsic::nvvm_fma_rm_d:

3961 case Intrinsic::nvvm_fma_rn_d:

3962 case Intrinsic::nvvm_fma_rp_d:

3963 case Intrinsic::nvvm_fma_rz_d:

3964 case Intrinsic::nvvm_fma_rm_ftz_f:

3965 case Intrinsic::nvvm_fma_rn_ftz_f:

3966 case Intrinsic::nvvm_fma_rp_ftz_f:

3967 case Intrinsic::nvvm_fma_rz_ftz_f: {

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

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

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

3972

3975

3978

3979 if (!Res.isNaN() &&

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

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

3983 }

3984 return nullptr;

3985 }

3986

3987 case Intrinsic::amdgcn_cubeid:

3988 case Intrinsic::amdgcn_cubema:

3989 case Intrinsic::amdgcn_cubesc:

3990 case Intrinsic::amdgcn_cubetc: {

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

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

3993 }

3994 }

3995 }

3996 }

3997 }

3998

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

4000 IntrinsicID == Intrinsic::smul_fix_sat) {

4001 const APInt *C0, *C1;

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

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

4004 return nullptr;

4005

4006

4007

4008 if (!C0 || !C1)

4010

4011

4012

4013

4014

4015

4016

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

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

4020 unsigned ExtendedWidth = Width * 2;

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

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

4028 }

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

4030 }

4031

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

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

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

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

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

4037 return nullptr;

4038

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

4040 if (!C2)

4041 return Operands[IsRight ? 1 : 0];

4042 if (!C0 && !C1)

4044

4045

4046

4049 if (!ShAmt)

4050 return Operands[IsRight ? 1 : 0];

4051

4052

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

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

4055 if (!C0)

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

4057 if (!C1)

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

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

4060 }

4061

4062 if (IntrinsicID == Intrinsic::amdgcn_perm)

4063 return ConstantFoldAMDGCNPermIntrinsic(Operands, Ty);

4064

4065 return nullptr;

4066}

4067

4078

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

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

4081

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

4083 if (Constant *FoldedLibCall =

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

4085 return FoldedLibCall;

4086 }

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

4088 }

4089

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

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

4092

4093 return nullptr;

4094}

4095

4096static Constant *ConstantFoldFixedVectorCall(

4103

4104 switch (IntrinsicID) {

4105 case Intrinsic::masked_load: {

4106 auto *SrcPtr = Operands[0];

4107 auto *Mask = Operands[1];

4108 auto *Passthru = Operands[2];

4109

4111

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

4115 if (!MaskElt)

4116 break;

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

4120 if (PassthruElt)

4121 NewElements.push_back(PassthruElt);

4122 else if (VecElt)

4124 else

4125 return nullptr;

4126 }

4127 if (MaskElt->isNullValue()) {

4128 if (!PassthruElt)

4129 return nullptr;

4130 NewElements.push_back(PassthruElt);

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

4132 if (!VecElt)

4133 return nullptr;

4135 } else {

4136 return nullptr;

4137 }

4138 }

4140 return nullptr;

4142 }

4143 case Intrinsic::arm_mve_vctp8:

4144 case Intrinsic::arm_mve_vctp16:

4145 case Intrinsic::arm_mve_vctp32:

4146 case Intrinsic::arm_mve_vctp64: {

4149 uint64_t Limit = Op->getZExtValue();

4150

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

4153 if (i < Limit)

4155 else

4157 }

4159 }

4160 return nullptr;

4161 }

4162 case Intrinsic::get_active_lane_mask: {

4165 if (Op0 && Op1) {

4168 uint64_t Limit = Op1->getZExtValue();

4169

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

4172 if (Base + i < Limit)

4174 else

4176 }

4178 }

4179 return nullptr;

4180 }

4181 case Intrinsic::vector_extract: {

4183 Constant *Vec = Operands[0];

4185 return nullptr;

4186

4188 unsigned VecNumElements =

4190 unsigned StartingIndex = Idx->getZExtValue();

4191

4192

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

4194 return Vec;

4195

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

4197 ++I) {

4199 if (!Elt)

4200 return nullptr;

4201 Result[I - StartingIndex] = Elt;

4202 }

4203

4205 }

4206 case Intrinsic::vector_insert: {

4207 Constant *Vec = Operands[0];

4208 Constant *SubVec = Operands[1];

4211 return nullptr;

4212

4213 unsigned SubVecNumElements =

4215 unsigned VecNumElements =

4217 unsigned IdxN = Idx->getZExtValue();

4218

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

4220 return SubVec;

4221

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

4224 if (I < IdxN + SubVecNumElements)

4226 else

4228 if (!Elt)

4229 return nullptr;

4231 }

4233 }

4234 case Intrinsic::vector_interleave2:

4235 case Intrinsic::vector_interleave3:

4236 case Intrinsic::vector_interleave4:

4237 case Intrinsic::vector_interleave5:

4238 case Intrinsic::vector_interleave6:

4239 case Intrinsic::vector_interleave7:

4240 case Intrinsic::vector_interleave8: {

4241 unsigned NumElements =

4243 unsigned NumOperands = Operands.size();

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

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

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

4247 if (!Elt)

4248 return nullptr;

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

4250 }

4251 }

4253 }

4254 case Intrinsic::wasm_dot: {

4255 unsigned NumElements =

4257

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

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

4260 assert(Ty->isIntegerTy());

4261 int32_t MulVector[8];

4262

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

4268

4270 }

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

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

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

4274 }

4275

4277 }

4278 default:

4279 break;

4280 }

4281

4283

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

4285

4287 Lane[J] = Operands[J];

4288 continue;

4289 }

4290

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

4292 if (!Agg)

4293 return nullptr;

4294

4295 Lane[J] = Agg;

4296 }

4297

4298

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

4301 if (!Folded)

4302 return nullptr;

4304 }

4305

4307}

4308

4309static Constant *ConstantFoldScalableVectorCall(

4313 switch (IntrinsicID) {

4314 case Intrinsic::aarch64_sve_convert_from_svbool: {

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

4317 break;

4318

4320 }

4321 case Intrinsic::get_active_lane_mask: {

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

4326 break;

4327 }

4328 case Intrinsic::vector_interleave2:

4329 case Intrinsic::vector_interleave3:

4330 case Intrinsic::vector_interleave4:

4331 case Intrinsic::vector_interleave5:

4332 case Intrinsic::vector_interleave6:

4333 case Intrinsic::vector_interleave7:

4334 case Intrinsic::vector_interleave8: {

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

4336 if (!SplatVal)

4337 return nullptr;

4338

4340 return nullptr;

4341

4343 }

4344 default:

4345 break;

4346 }

4347

4348

4349

4350

4351

4353 return nullptr;

4354

4359 continue;

4360 }

4363 return nullptr;

4365 }

4366 Constant *Folded = ConstantFoldScalarCall(

4368 if (!Folded)

4369 return nullptr;

4371}

4372

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

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

4377

4379 if (!ConstFP)

4380 return {};

4381

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

4383 int FrexpExp;

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

4386

4387

4388

4392 return {Result0, Result1};

4393}

4394

4395

4401

4402 switch (IntrinsicID) {

4403 case Intrinsic::frexp: {

4406

4410

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

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

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

4414 ConstantFoldScalarFrexpCall(Lane, Ty1);

4415 if (!Results0[I])

4416 return nullptr;

4417 }

4418

4421 }

4422

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

4424 if (!Result0)

4425 return nullptr;

4427 }

4428 case Intrinsic::sincos: {

4431

4432 auto ConstantFoldScalarSincosCall =

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

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

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

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

4439 };

4440

4444

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

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

4448 ConstantFoldScalarSincosCall(Lane);

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

4450 return nullptr;

4451 }

4452

4455 }

4456

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

4458 if (!SinResult || !CosResult)

4459 return nullptr;

4461 }

4462 case Intrinsic::vector_deinterleave2:

4463 case Intrinsic::vector_deinterleave3:

4464 case Intrinsic::vector_deinterleave4:

4465 case Intrinsic::vector_deinterleave5:

4466 case Intrinsic::vector_deinterleave6:

4467 case Intrinsic::vector_deinterleave7:

4468 case Intrinsic::vector_deinterleave8: {

4470 auto *Vec = Operands[0];

4472

4475

4480 }

4481

4482 if (!ResultEC.isFixed())

4483 return nullptr;

4484

4485 unsigned NumElements = ResultEC.getFixedValue();

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

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

4491 if (!Elt)

4492 return nullptr;

4494 }

4496 }

4498 }

4499 default:

4500

4501

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

4503 }

4504

4505 return nullptr;

4506}

4507

4508}

4509

4514

4515

4517 return nullptr;

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

4519}

4520

4524 bool AllowNonDeterministic) {

4525 if (Call->isNoBuiltin())

4526 return nullptr;

4527 if (->hasName())

4528 return nullptr;

4529

4530

4533 if (!TLI)

4534 return nullptr;

4535 LibFunc LibF;

4537 return nullptr;

4538 }

4539

4540

4541

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

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

4544 return nullptr;

4545

4548 return ConstantFoldFixedVectorCall(

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

4550

4552 return ConstantFoldScalableVectorCall(

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

4554

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

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

4558

4559

4560

4561

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

4563}

4564

4567

4568

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

4570 return false;

4572 if ()

4573 return false;

4574

4575 LibFunc Func;

4577 return false;

4578

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

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

4582 switch (Func) {

4583 case LibFunc_logl:

4584 case LibFunc_log:

4585 case LibFunc_logf:

4586 case LibFunc_log2l:

4587 case LibFunc_log2:

4588 case LibFunc_log2f:

4589 case LibFunc_log10l:

4590 case LibFunc_log10:

4591 case LibFunc_log10f:

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

4593

4594 case LibFunc_ilogb:

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

4596

4597 case LibFunc_expl:

4598 case LibFunc_exp:

4599 case LibFunc_expf:

4600

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

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

4605 break;

4606

4607 case LibFunc_exp2l:

4608 case LibFunc_exp2:

4609 case LibFunc_exp2f:

4610

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

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

4615 break;

4616

4617 case LibFunc_sinl:

4618 case LibFunc_sin:

4619 case LibFunc_sinf:

4620 case LibFunc_cosl:

4621 case LibFunc_cos:

4622 case LibFunc_cosf:

4623 return .isInfinity();

4624

4625 case LibFunc_tanl:

4626 case LibFunc_tan:

4627 case LibFunc_tanf: {

4628

4629

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

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

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

4633 break;

4634 }

4635

4636 case LibFunc_atan:

4637 case LibFunc_atanf:

4638 case LibFunc_atanl:

4639

4640 return true;

4641

4642 case LibFunc_asinl:

4643 case LibFunc_asin:

4644 case LibFunc_asinf:

4645 case LibFunc_acosl:

4646 case LibFunc_acos:

4647 case LibFunc_acosf:

4650

4651 case LibFunc_sinh:

4652 case LibFunc_cosh:

4653 case LibFunc_sinhf:

4654 case LibFunc_coshf:

4655 case LibFunc_sinhl:

4656 case LibFunc_coshl:

4657

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

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

4662 break;

4663

4664 case LibFunc_sqrtl:

4665 case LibFunc_sqrt:

4666 case LibFunc_sqrtf:

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

4668

4669

4670

4671 default:

4672 break;

4673 }

4674 }

4675 }

4676

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

4680 if (Op0C && Op1C) {

4683

4684 switch (Func) {

4685 case LibFunc_powl:

4686 case LibFunc_pow:

4687 case LibFunc_powf: {

4688

4689

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

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

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

4694 }

4695 break;

4696 }

4697

4698 case LibFunc_fmodl:

4699 case LibFunc_fmod:

4700 case LibFunc_fmodf:

4701 case LibFunc_remainderl:

4702 case LibFunc_remainder:

4703 case LibFunc_remainderf:

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

4706

4707 case LibFunc_atan2:

4708 case LibFunc_atan2f:

4709 case LibFunc_atan2l:

4710

4711

4712

4713

4715

4716 default:

4717 break;

4718 }

4719 }

4720 }

4721

4722 return false;

4723}

4724

4728 switch (CastOp) {

4729 case Instruction::BitCast:

4730

4732 case Instruction::Trunc: {

4734 if (Flags) {

4735

4736 Flags->NUW = true;

4737

4738 auto *SExtC =

4740 Flags->NSW = ZExtC == SExtC;

4741 }

4742 return ZExtC;

4743 }

4744 case Instruction::SExt:

4745 case Instruction::ZExt: {

4748

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

4750 return nullptr;

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

4752 auto *SExtInvC =

4754

4755 Flags->NNeg = CastInvC == SExtInvC;

4756 }

4757 return InvC;

4758 }

4759 default:

4760 return nullptr;

4761 }

4762}

4763

4769

4775

4776void 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:1333

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:1362

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:1356

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:4510

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:1442

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:1602

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:4565

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:4521

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:1313

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:1374

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

Definition ConstantFolding.cpp:4764

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:4770

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:1485

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:1320

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:4725

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:1586

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.