IntrinsicInst.h Source File (original) (raw)

23#ifndef LLVM_IR_INTRINSICINST_H

24#define LLVM_IR_INTRINSICINST_H

38#include

39#include

40#include

42namespace llvm {

50public:

62 case Intrinsic::smax:

63 case Intrinsic::smin:

64 case Intrinsic::umax:

65 case Intrinsic::umin:

66 return true;

67 default:

68 return false;

69 }

70 }

76 case Intrinsic::maxnum:

77 case Intrinsic::minnum:

78 case Intrinsic::maximum:

79 case Intrinsic::minimum:

80 case Intrinsic::maximumnum:

81 case Intrinsic::minimumnum:

82 case Intrinsic::smax:

83 case Intrinsic::smin:

84 case Intrinsic::umax:

85 case Intrinsic::umin:

86 case Intrinsic::sadd_sat:

87 case Intrinsic::uadd_sat:

88 case Intrinsic::sadd_with_overflow:

89 case Intrinsic::uadd_with_overflow:

90 case Intrinsic::smul_with_overflow:

91 case Intrinsic::umul_with_overflow:

92 case Intrinsic::smul_fix:

93 case Intrinsic::umul_fix:

94 case Intrinsic::smul_fix_sat:

95 case Intrinsic::umul_fix_sat:

96 case Intrinsic::fma:

97 case Intrinsic::fmuladd:

98 return true;

99 default:

100 return false;

101 }

102 }

103

104

107 default: break;

108 case Intrinsic::assume:

109 case Intrinsic::sideeffect:

110 case Intrinsic::pseudoprobe:

111 case Intrinsic::dbg_assign:

112 case Intrinsic::dbg_declare:

113 case Intrinsic::dbg_value:

114 case Intrinsic::dbg_label:

115 case Intrinsic::invariant_start:

116 case Intrinsic::invariant_end:

117 case Intrinsic::lifetime_start:

118 case Intrinsic::lifetime_end:

119 case Intrinsic::experimental_noalias_scope_decl:

120 case Intrinsic::objectsize:

121 case Intrinsic::ptr_annotation:

122 case Intrinsic::var_annotation:

123 return true;

124 }

125 return false;

126 }

127

128

129

131

132

135 return F && F->isIntrinsic();

136 }

140};

141

142

144 switch (ID) {

145 case Intrinsic::lifetime_start:

146 case Intrinsic::lifetime_end:

147 return true;

148 default:

149 return false;

150 }

151}

152

153

155public:

156

157

164

165};

166

167

169 switch (ID) {

170 case Intrinsic::dbg_declare:

171 case Intrinsic::dbg_value:

172 case Intrinsic::dbg_label:

173 case Intrinsic::dbg_assign:

174 return true;

175 default:

176 return false;

177 }

178}

179

180

182public:

183

184

191

192};

193

194

195

196

199 std::bidirectional_iterator_tag, Value *> {

201

202public:

205

208 I = R.I;

209 return *this;

210 }

227 else

229 return *this;

230 }

234 else

236 return *this;

237 }

238};

239

240

241

242

244 Metadata *RawLocation = nullptr;

245

246public:

249 : RawLocation(RawLocation) {

250

251 assert(RawLocation && "unexpected null RawLocation");

254 cast<MDNode> (RawLocation)->getNumOperands()));

255 }

257

258

259

269

270

272 return true;

273

275 return true;

276

277

279 }

280

283 return A.RawLocation == B.RawLocation;

284 }

287 return !(A == B);

288 }

291 return A.RawLocation > B.RawLocation;

292 }

295 return A.RawLocation >= B.RawLocation;

296 }

299 return A.RawLocation < B.RawLocation;

300 }

303 return A.RawLocation <= B.RawLocation;

304 }

305};

306

307

309public:

310

311

312

314

316

318 bool AllowEmpty = false);

320

321

322

325

329

333

337

339

340

341

342

346

347

348

349

350

354

356

357

360 if (!RemovedValues.insert(OldValue).second)

361 continue;

364 }

365 }

366

370

374

378

382

386

390

394

395

396

397

401

402

403

405

406

407 std::optionalDIExpression::FragmentInfo getFragment() const {

409 }

410

411

412

413

416

419 if (auto Frag = getExpression()->getFragmentInfo())

420 VariableSlice.OffsetInBits = Frag->OffsetInBits;

421 return VariableSlice;

422 }

423

424

425

427 switch (I->getIntrinsicID()) {

428 case Intrinsic::dbg_declare:

429 case Intrinsic::dbg_value:

430 case Intrinsic::dbg_assign:

431 return true;

432 default:

433 return false;

434 }

435 }

439

440protected:

445};

446

447

449public:

452 "dbg.declare must have exactly 1 location operand.");

454 }

455

456

457

459 return I->getIntrinsicID() == Intrinsic::dbg_declare;

460 }

464

465};

466

467

469public:

470

471

478

479

480

482 return I->getIntrinsicID() == Intrinsic::dbg_value ||

483 I->getIntrinsicID() == Intrinsic::dbg_assign;

484 }

488

489};

490

491

493 enum Operands {

494 OpValue,

495 OpVar,

496 OpExpr,

497 OpAssignID,

498 OpAddress,

499 OpAddressExpr,

500 };

501

502public:

523

525

526

527

528

531

532

534 return I->getIntrinsicID() == Intrinsic::dbg_assign;

535 }

539

540};

541

542

544public:

549

553

554

555

557 return I->getIntrinsicID() == Intrinsic::dbg_label;

558 }

562

563};

564

565

567public:

568

569

570

574

575 LLVM_ABI static std::optional

577 LLVM_ABI static std::optional

579

580

582

583

584

586

587

589

590

593

594

597

598

600

601

602

604

605

606

608

609

610

612 LLVM_ABI static std::optional

614

615

618

619

626

627

631

632

636

637

641

642

643 LLVM_ABI static std::optional

645

646

647 LLVM_ABI static std::optionalIntrinsic::ID

649

650

651 LLVM_ABI static std::optionalIntrinsic::ID

653};

654

655

657public:

659

662

665

666

667

674

675};

676

678public:

680

681

682

689

690};

691

693public:

695

697

698

699

706

707};

708

710public:

712

713

714

721

722};

723

724

725

739

740

742public:

745 return getIntrinsicID() == Intrinsic::experimental_constrained_fcmps;

746 }

747

748

750 switch (I->getIntrinsicID()) {

751 case Intrinsic::experimental_constrained_fcmp:

752 case Intrinsic::experimental_constrained_fcmps:

753 return true;

754 default:

755 return false;

756 }

757 }

761};

762

763

765public:

767 switch (I->getIntrinsicID()) {

768 case Intrinsic::umin:

769 case Intrinsic::umax:

770 case Intrinsic::smin:

771 case Intrinsic::smax:

772 return true;

773 default:

774 return false;

775 }

776 }

780

783

784

786 switch (ID) {

787 case Intrinsic::umin:

789 case Intrinsic::umax:

791 case Intrinsic::smin:

793 case Intrinsic::smax:

795 default:

797 }

798 }

799

800

804

805

809

810

812

813

815 switch (ID) {

816 case Intrinsic::umin:

817 case Intrinsic::smin:

818 return true;

819 case Intrinsic::umax:

820 case Intrinsic::smax:

821 return false;

822 default:

824 }

825 }

826

827

829

830

832

833

834

835

837 switch (ID) {

838 case Intrinsic::umin:

840 case Intrinsic::umax:

842 case Intrinsic::smin:

844 case Intrinsic::smax:

846 default:

848 }

849 }

850

851

852

853

857

858

859

860

865

866

867

868

872};

873

874

876public:

878 switch (I->getIntrinsicID()) {

879 case Intrinsic::scmp:

880 case Intrinsic::ucmp:

881 return true;

882 default:

883 return false;

884 }

885 }

889

892

895

902

909};

910

911

912

914public:

916 switch (I->getIntrinsicID()) {

917 case Intrinsic::uadd_with_overflow:

918 case Intrinsic::sadd_with_overflow:

919 case Intrinsic::usub_with_overflow:

920 case Intrinsic::ssub_with_overflow:

921 case Intrinsic::umul_with_overflow:

922 case Intrinsic::smul_with_overflow:

923 case Intrinsic::uadd_sat:

924 case Intrinsic::sadd_sat:

925 case Intrinsic::usub_sat:

926 case Intrinsic::ssub_sat:

927 return true;

928 default:

929 return false;

930 }

931 }

935

938

939

941

942

944

945

947};

948

949

951public:

953 switch (I->getIntrinsicID()) {

954 case Intrinsic::uadd_with_overflow:

955 case Intrinsic::sadd_with_overflow:

956 case Intrinsic::usub_with_overflow:

957 case Intrinsic::ssub_with_overflow:

958 case Intrinsic::umul_with_overflow:

959 case Intrinsic::smul_with_overflow:

960 return true;

961 default:

962 return false;

963 }

964 }

968};

969

970

972public:

974 switch (I->getIntrinsicID()) {

975 case Intrinsic::uadd_sat:

976 case Intrinsic::sadd_sat:

977 case Intrinsic::usub_sat:

978 case Intrinsic::ssub_sat:

979 return true;

980 default:

981 return false;

982 }

983 }

987};

988

989

990

991

992

994private:

995 enum { ARG_DEST = 0, ARG_LENGTH = 2 };

996

997public:

1003

1009

1012 if ()

1013 return std::nullopt;

1014 return C->getValue();

1015 }

1016

1017

1018

1019

1021

1025

1027

1028

1031 "setDest called with pointer of wrong type!");

1033 }

1034

1037 if (Alignment)

1040 }

1046

1049 "setLength called with value of wrong type!");

1051 }

1052

1056};

1057

1058

1059

1061private:

1062 enum { ARG_SOURCE = 1 };

1063

1064public:

1065

1067 return const_cast<Value *>(BaseCL::getArgOperand(ARG_SOURCE));

1068 }

1070 return BaseCL::getArgOperandUse(ARG_SOURCE);

1071 }

1073

1074

1075

1076

1078

1082

1084 return BaseCL::getParamAlign(ARG_SOURCE);

1085 }

1086

1089 "setSource called with pointer of wrong type!");

1090 BaseCL::setArgOperand(ARG_SOURCE, Ptr);

1091 }

1092

1094 BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);

1095 if (Alignment)

1097 BaseCL::getContext(), *Alignment));

1098 }

1099

1101 BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);

1103 BaseCL::getContext(), Alignment));

1104 }

1105};

1106

1107

1108

1110private:

1111 enum { ARG_VALUE = 1 };

1112

1113public:

1115 return const_cast<Value *>(BaseCL::getArgOperand(ARG_VALUE));

1116 }

1117 const Use &getValueUse() const { return BaseCL::getArgOperandUse(ARG_VALUE); }

1119

1122 "setValue called with value of wrong type!");

1123 BaseCL::setArgOperand(ARG_VALUE, Val);

1124 }

1125};

1126

1127

1129private:

1130 enum { ARG_VOLATILE = 3 };

1131

1132public:

1136

1138

1140

1143 case Intrinsic::memset_inline:

1144 case Intrinsic::memcpy_inline:

1145 return true;

1146 default:

1147 return false;

1148 }

1149 }

1150

1151

1153 switch (I->getIntrinsicID()) {

1154 case Intrinsic::memcpy:

1155 case Intrinsic::memmove:

1156 case Intrinsic::memset:

1157 case Intrinsic::memset_inline:

1158 case Intrinsic::memcpy_inline:

1159 return true;

1160 default:

1161 return false;

1162 }

1163 }

1167};

1168

1169

1171public:

1172

1174 switch (I->getIntrinsicID()) {

1175 case Intrinsic::memset:

1176 case Intrinsic::memset_inline:

1177 return true;

1178 default:

1179 return false;

1180 }

1181 }

1185};

1186

1187

1188

1189

1191private:

1192 enum { ARG_VOLATILE = 3 };

1193

1194public:

1198

1200

1202

1203

1205 return I->getIntrinsicID() == Intrinsic::experimental_memset_pattern;

1206 }

1210};

1211

1212

1214public:

1215

1217 switch (I->getIntrinsicID()) {

1218 case Intrinsic::memcpy:

1219 case Intrinsic::memmove:

1220 case Intrinsic::memcpy_inline:

1221 return true;

1222 default:

1223 return false;

1224 }

1225 }

1229};

1230

1231

1233public:

1234

1236 return I->getIntrinsicID() == Intrinsic::memcpy ||

1237 I->getIntrinsicID() == Intrinsic::memcpy_inline;

1238 }

1242};

1243

1244

1246public:

1247

1249 return I->getIntrinsicID() == Intrinsic::memmove;

1250 }

1254};

1255

1256

1257

1258

1259

1261private:

1262 enum { ARG_ELEMENTSIZE = 3 };

1263

1264public:

1266

1268 return MI->isVolatile();

1269 return false;

1270 }

1271

1274 case Intrinsic::memcpy_element_unordered_atomic:

1275 case Intrinsic::memmove_element_unordered_atomic:

1276 case Intrinsic::memset_element_unordered_atomic:

1277 return true;

1278 default:

1279 return false;

1280 }

1281 }

1282

1284 switch (I->getIntrinsicID()) {

1285 case Intrinsic::memcpy:

1286 case Intrinsic::memcpy_inline:

1287 case Intrinsic::memmove:

1288 case Intrinsic::memset:

1289 case Intrinsic::memset_inline:

1290 case Intrinsic::memcpy_element_unordered_atomic:

1291 case Intrinsic::memmove_element_unordered_atomic:

1292 case Intrinsic::memset_element_unordered_atomic:

1293 return true;

1294 default:

1295 return false;

1296 }

1297 }

1301

1306

1311};

1312

1313

1314

1315

1317public:

1319 switch (I->getIntrinsicID()) {

1320 case Intrinsic::memset:

1321 case Intrinsic::memset_inline:

1322 case Intrinsic::memset_element_unordered_atomic:

1323 return true;

1324 default:

1325 return false;

1326 }

1327 }

1331};

1332

1333

1334

1335

1337public:

1339 switch (I->getIntrinsicID()) {

1340 case Intrinsic::memcpy:

1341 case Intrinsic::memcpy_inline:

1342 case Intrinsic::memmove:

1343 case Intrinsic::memcpy_element_unordered_atomic:

1344 case Intrinsic::memmove_element_unordered_atomic:

1345 return true;

1346 default:

1347 return false;

1348 }

1349 }

1353};

1354

1355

1356

1357

1359public:

1361 switch (I->getIntrinsicID()) {

1362 case Intrinsic::memcpy:

1363 case Intrinsic::memcpy_inline:

1364 case Intrinsic::memcpy_element_unordered_atomic:

1365 return true;

1366 default:

1367 return false;

1368 }

1369 }

1373};

1374

1375

1376

1377

1379public:

1381 switch (I->getIntrinsicID()) {

1382 case Intrinsic::memmove:

1383 case Intrinsic::memmove_element_unordered_atomic:

1384 return true;

1385 default:

1386 return false;

1387 }

1388 }

1392};

1393

1394

1396public:

1398 return I->getIntrinsicID() == Intrinsic::vastart;

1399 }

1403

1405};

1406

1407

1409public:

1411 return I->getIntrinsicID() == Intrinsic::vaend;

1412 }

1416

1418};

1419

1420

1422public:

1424 return I->getIntrinsicID() == Intrinsic::vacopy;

1425 }

1429

1432};

1433

1434

1436protected:

1438 switch (I.getIntrinsicID()) {

1439 case Intrinsic::instrprof_cover:

1440 case Intrinsic::instrprof_increment:

1441 case Intrinsic::instrprof_increment_step:

1442 case Intrinsic::instrprof_callsite:

1443 case Intrinsic::instrprof_timestamp:

1444 case Intrinsic::instrprof_value_profile:

1445 return true;

1446 }

1447 return false;

1448 }

1450 switch (I.getIntrinsicID()) {

1451 case Intrinsic::instrprof_mcdc_parameters:

1452 case Intrinsic::instrprof_mcdc_tvbitmap_update:

1453 return true;

1454 }

1455 return false;

1456 }

1457

1458public:

1462 return false;

1463 }

1464

1465

1469

1470

1471

1472

1474

1476

1477

1479};

1480

1481

1483public:

1487 return false;

1488 }

1489

1490

1492

1495};

1496

1497

1499public:

1501 return I->getIntrinsicID() == Intrinsic::instrprof_cover;

1502 }

1506};

1507

1508

1510public:

1512 return I->getIntrinsicID() == Intrinsic::instrprof_increment ||

1513 I->getIntrinsicID() == Intrinsic::instrprof_increment_step;

1514 }

1519};

1520

1521

1523public:

1525 return I->getIntrinsicID() == Intrinsic::instrprof_increment_step;

1526 }

1530};

1531

1532

1533

1534

1535

1537public:

1539 return I->getIntrinsicID() == Intrinsic::instrprof_callsite;

1540 }

1544

1552};

1553

1554

1556public:

1558 return I->getIntrinsicID() == Intrinsic::instrprof_timestamp;

1559 }

1563};

1564

1565

1567public:

1569 return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;

1570 }

1574

1576

1580

1581

1583};

1584

1585

1587public:

1594

1595

1596

1600

1601

1602

1606};

1607

1608

1610public:

1612 return I->getIntrinsicID() == Intrinsic::instrprof_mcdc_parameters;

1613 }

1617};

1618

1619

1621public:

1623 return I->getIntrinsicID() == Intrinsic::instrprof_mcdc_tvbitmap_update;

1624 }

1628

1629

1630

1634

1635

1636

1638};

1639

1641public:

1643 return I->getIntrinsicID() == Intrinsic::pseudoprobe;

1644 }

1645

1649

1653

1655

1659

1661};

1662

1664public:

1666 return I->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl;

1667 }

1668

1672

1678

1683};

1684

1685

1686

1688public:

1690 return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate ||

1691 I->getIntrinsicID() == Intrinsic::experimental_gc_result;

1692 }

1693

1697

1698

1699

1705

1706

1708};

1709

1710

1712public:

1714 return I->getIntrinsicID() == Intrinsic::experimental_gc_relocate;

1715 }

1716

1720

1721

1722

1723

1727

1728

1729

1733

1736};

1737

1738

1740public:

1742 return I->getIntrinsicID() == Intrinsic::experimental_gc_result;

1743 }

1744

1748};

1749

1750

1751

1753public:

1755 return I->getIntrinsicID() == Intrinsic::assume;

1756 }

1760};

1761

1762

1764 switch (IntrinsicID) {

1765 default:

1766 return false;

1767 case Intrinsic::experimental_convergence_anchor:

1768 case Intrinsic::experimental_convergence_entry:

1769 case Intrinsic::experimental_convergence_loop:

1770 return true;

1771 }

1772}

1773

1774

1776public:

1780

1784

1786 return getIntrinsicID() == Intrinsic::experimental_convergence_anchor;

1787 }

1789 return getIntrinsicID() == Intrinsic::experimental_convergence_entry;

1790 }

1792 return getIntrinsicID() == Intrinsic::experimental_convergence_loop;

1793 }

1794

1799};

1800

1801}

1802

1803#endif

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

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

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

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

This file contains the declarations of entities that describe floating point environment and related ...

MachineInstr unsigned OpIdx

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

Class for arbitrary precision integers.

static APInt getMaxValue(unsigned numBits)

Gets maximum unsigned value of APInt for specific bit width.

static APInt getSignedMaxValue(unsigned numBits)

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

static APInt getMinValue(unsigned numBits)

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

static APInt getSignedMinValue(unsigned numBits)

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

This class represents any memcpy intrinsic i.e.

Definition IntrinsicInst.h:1358

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1360

static bool classof(const Value *V)

Definition IntrinsicInst.h:1370

Definition IntrinsicInst.h:1260

static bool classof(const Value *V)

Definition IntrinsicInst.h:1298

Value * getRawElementSizeInBytes() const

Definition IntrinsicInst.h:1302

bool isAtomic() const

Definition IntrinsicInst.h:1272

uint32_t getElementSizeInBytes() const

Definition IntrinsicInst.h:1307

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1283

bool isVolatile() const

Definition IntrinsicInst.h:1265

This class represents any memmove intrinsic i.e.

Definition IntrinsicInst.h:1378

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1380

static bool classof(const Value *V)

Definition IntrinsicInst.h:1389

This class represents any memset intrinsic.

Definition IntrinsicInst.h:1316

static bool classof(const Value *V)

Definition IntrinsicInst.h:1328

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1318

Definition IntrinsicInst.h:1336

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1338

static bool classof(const Value *V)

Definition IntrinsicInst.h:1350

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

This represents the llvm.assume intrinsic.

Definition IntrinsicInst.h:1752

static bool classof(const Value *V)

Definition IntrinsicInst.h:1757

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1754

static LLVM_ABI Attribute getWithAlignment(LLVMContext &Context, Align Alignment)

Return a uniquified Attribute object that has the specific alignment set.

LLVM Basic Block Representation.

This class represents an intrinsic that is based on a binary operation.

Definition IntrinsicInst.h:913

Value * getRHS() const

Definition IntrinsicInst.h:937

static bool classof(const Value *V)

Definition IntrinsicInst.h:932

LLVM_ABI unsigned getNoWrapKind() const

Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.

LLVM_ABI bool isSigned() const

Whether the intrinsic is signed or unsigned.

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:915

LLVM_ABI Instruction::BinaryOps getBinaryOp() const

Returns the binary operation underlying the intrinsic.

Value * getLHS() const

Definition IntrinsicInst.h:936

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

bool isInlineAsm() const

Check if this call is an inline asm statement.

void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)

Removes the attribute from the given argument.

LLVM_ABI bool isIndirectCall() const

Return true if the callsite is an indirect call.

MaybeAlign getParamAlign(unsigned ArgNo) const

Extract the alignment for a call or parameter (0=unknown).

Value * getCalledOperand() const

const Use & getArgOperandUse(unsigned i) const

Wrappers for getting the Use of a call argument.

Value * getArgOperand(unsigned i) const

void setArgOperand(unsigned i, Value *v)

LLVM_ABI Intrinsic::ID getIntrinsicID() const

Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...

void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)

Adds the attribute to the indicated argument.

Predicate

This enumeration lists the possible predicates for CmpInst subclasses.

@ ICMP_SLT

signed less than

@ ICMP_UGT

unsigned greater than

@ ICMP_SGT

signed greater than

@ ICMP_ULT

unsigned less than

This class represents a ucmp/scmp intrinsic.

Definition IntrinsicInst.h:875

static CmpInst::Predicate getGTPredicate(Intrinsic::ID ID)

Definition IntrinsicInst.h:896

Value * getRHS() const

Definition IntrinsicInst.h:891

CmpInst::Predicate getLTPredicate() const

Definition IntrinsicInst.h:906

static CmpInst::Predicate getLTPredicate(Intrinsic::ID ID)

Definition IntrinsicInst.h:903

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:877

static bool isSigned(Intrinsic::ID ID)

Definition IntrinsicInst.h:893

bool isSigned() const

Definition IntrinsicInst.h:894

CmpInst::Predicate getGTPredicate() const

Definition IntrinsicInst.h:899

Value * getLHS() const

Definition IntrinsicInst.h:890

static bool classof(const Value *V)

Definition IntrinsicInst.h:886

This is the shared class of boolean and integer constants.

bool isZero() const

This is just a convenience method to make client code smaller for a common code.

This is an important base class in LLVM.

static LLVM_ABI Constant * getIntegerValue(Type *Ty, const APInt &V)

Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...

Constrained floating point compare intrinsics.

Definition IntrinsicInst.h:741

LLVM_ABI FCmpInst::Predicate getPredicate() const

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:749

static bool classof(const Value *V)

Definition IntrinsicInst.h:758

bool isSignaling() const

Definition IntrinsicInst.h:744

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

Definition IntrinsicInst.h:726

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

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

LLVM_ABI unsigned getNonMetadataArgCount() const

static LLVM_ABI bool classof(const IntrinsicInst *I)

static bool classof(const Value *V)

Definition IntrinsicInst.h:735

LLVM_ABI bool isDefaultFPEnvironment() const

Represents calls to the llvm.experimintal.convergence.* intrinsics.

Definition IntrinsicInst.h:1775

static bool classof(const Value *V)

Definition IntrinsicInst.h:1781

static LLVM_ABI ConvergenceControlInst * CreateAnchor(BasicBlock &BB)

bool isLoop() const

Definition IntrinsicInst.h:1791

bool isEntry() const

Definition IntrinsicInst.h:1788

static LLVM_ABI ConvergenceControlInst * CreateLoop(BasicBlock &BB, ConvergenceControlInst *Parent)

bool isAnchor() const

Definition IntrinsicInst.h:1785

static LLVM_ABI ConvergenceControlInst * CreateEntry(BasicBlock &BB)

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1777

DbgVariableFragmentInfo FragmentInfo

static LLVM_ABI std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)

Retrieve the details of this fragment expression.

This represents the llvm.dbg.assign instruction.

Definition IntrinsicInst.h:492

DIAssignID * getAssignID() const

Definition IntrinsicInst.h:510

LLVM_ABI void setValue(Value *V)

static bool classof(const Value *V)

Definition IntrinsicInst.h:536

LLVM_ABI void setAssignId(DIAssignID *New)

LLVM_ABI void setKillAddress()

Kill the address component.

LLVM_ABI bool isKillAddress() const

Check whether this kills the address component.

Metadata * getRawAddress() const

Definition IntrinsicInst.h:504

DIExpression * getAddressExpression() const

Definition IntrinsicInst.h:514

LLVM_ABI Value * getAddress() const

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:533

Metadata * getRawAddressExpression() const

Definition IntrinsicInst.h:511

Metadata * getRawAssignID() const

Definition IntrinsicInst.h:507

LLVM_ABI void setAddress(Value *V)

void setAddressExpression(DIExpression *NewExpr)

Definition IntrinsicInst.h:517

This represents the llvm.dbg.declare instruction.

Definition IntrinsicInst.h:448

static bool classof(const Value *V)

Definition IntrinsicInst.h:461

Value * getAddress() const

Definition IntrinsicInst.h:450

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:458

This is the common base class for debug info intrinsics.

Definition IntrinsicInst.h:181

static bool classof(const Value *V)

Definition IntrinsicInst.h:188

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:185

This represents the llvm.dbg.label instruction.

Definition IntrinsicInst.h:543

Metadata * getRawLabel() const

Definition IntrinsicInst.h:550

static bool classof(const IntrinsicInst *I)

Methods for support type inquiry through isa, cast, and dyn_cast:

Definition IntrinsicInst.h:556

DILabel * getLabel() const

Definition IntrinsicInst.h:545

static bool classof(const Value *V)

Definition IntrinsicInst.h:559

void setLabel(DILabel *NewLabel)

Definition IntrinsicInst.h:546

This represents the llvm.dbg.value instruction.

Definition IntrinsicInst.h:468

iterator_range< location_op_iterator > getValues() const

Definition IntrinsicInst.h:475

static bool classof(const Value *V)

Definition IntrinsicInst.h:485

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:481

Value * getValue(unsigned OpIdx=0) const

Definition IntrinsicInst.h:472

This is the common base class for debug info intrinsics for variables.

Definition IntrinsicInst.h:308

DIExpression::FragmentInfo getFragmentOrEntireVariable() const

Get the FragmentInfo for the variable if it exists, otherwise return a FragmentInfo that covers the e...

Definition IntrinsicInst.h:414

void setVariable(DILocalVariable *NewVar)

Definition IntrinsicInst.h:326

LLVM_ABI iterator_range< location_op_iterator > location_ops() const

Get the locations corresponding to the variable referenced by the debug info intrinsic.

LLVM_ABI void addVariableLocationOps(ArrayRef< Value * > NewValues, DIExpression *NewExpr)

Adding a new location operand will always result in this intrinsic using an ArgList,...

bool isValueOfVariable() const

Determine if this describes the value of a local variable.

Definition IntrinsicInst.h:351

void setRawLocation(Metadata *Location)

Use of this should generally be avoided; instead, replaceVariableLocationOp and addVariableLocationOp...

Definition IntrinsicInst.h:398

LLVM_ABI void replaceVariableLocationOp(Value *OldValue, Value *NewValue, bool AllowEmpty=false)

LLVM_ABI Value * getVariableLocationOp(unsigned OpIdx) const

std::optional< DIExpression::FragmentInfo > getFragment() const

Get the FragmentInfo for the variable.

Definition IntrinsicInst.h:407

static bool classof(const Value *V)

Definition IntrinsicInst.h:436

void setExpression(DIExpression *NewExpr)

Definition IntrinsicInst.h:330

Metadata * getRawLocation() const

Definition IntrinsicInst.h:379

DILocalVariable * getVariable() const

Definition IntrinsicInst.h:371

unsigned getNumVariableLocationOps() const

Definition IntrinsicInst.h:334

bool isAddressOfVariable() const

Does this describe the address of a local variable.

Definition IntrinsicInst.h:343

void setOperand(unsigned i, Value *v)

Definition IntrinsicInst.h:444

void setKillLocation()

Definition IntrinsicInst.h:355

Metadata * getRawVariable() const

Definition IntrinsicInst.h:387

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:426

bool hasArgList() const

Definition IntrinsicInst.h:338

LLVM_ABI std::optional< uint64_t > getFragmentSizeInBits() const

Get the size (in bits) of the variable, or fragment of the variable that is described.

DIExpression * getExpression() const

Definition IntrinsicInst.h:375

void setArgOperand(unsigned i, Value *v)

Definition IntrinsicInst.h:441

Metadata * getRawExpression() const

Definition IntrinsicInst.h:391

RawLocationWrapper getWrappedLocation() const

Definition IntrinsicInst.h:383

bool isKillLocation() const

Definition IntrinsicInst.h:367

Class representing an expression and its matching format.

Common base class for representing values projected from a statepoint.

Definition IntrinsicInst.h:1687

LLVM_ABI const Value * getStatepoint() const

The statepoint with which this gc.relocate is associated.

bool isTiedToInvoke() const

Return true if this relocate is tied to the invoke statepoint.

Definition IntrinsicInst.h:1700

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1689

static bool classof(const Value *V)

Definition IntrinsicInst.h:1694

Represents calls to the gc.relocate intrinsic.

Definition IntrinsicInst.h:1711

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1713

static bool classof(const Value *V)

Definition IntrinsicInst.h:1717

LLVM_ABI Value * getBasePtr() const

unsigned getBasePtrIndex() const

The index into the associate statepoint's argument list which contains the base pointer of the pointe...

Definition IntrinsicInst.h:1724

LLVM_ABI Value * getDerivedPtr() const

unsigned getDerivedPtrIndex() const

The index into the associate statepoint's argument list which contains the pointer whose relocation t...

Definition IntrinsicInst.h:1730

Represents calls to the gc.result intrinsic.

Definition IntrinsicInst.h:1739

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1741

static bool classof(const Value *V)

Definition IntrinsicInst.h:1745

This represents the llvm.instrprof.callsite intrinsic.

Definition IntrinsicInst.h:1536

LLVM_ABI void setCallee(Value *Callee)

LLVM_ABI Value * getCallee() const

static bool classof(const Value *V)

Definition IntrinsicInst.h:1541

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1538

static bool canInstrumentCallsite(const CallBase &CB)

Definition IntrinsicInst.h:1545

A base class for all instrprof counter intrinsics.

Definition IntrinsicInst.h:1482

static bool classof(const Value *V)

Definition IntrinsicInst.h:1484

LLVM_ABI ConstantInt * getIndex() const

LLVM_ABI void setIndex(uint32_t Idx)

LLVM_ABI ConstantInt * getNumCounters() const

This represents the llvm.instrprof.cover intrinsic.

Definition IntrinsicInst.h:1498

static bool classof(const Value *V)

Definition IntrinsicInst.h:1503

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1500

This represents the llvm.instrprof.increment.step intrinsic.

Definition IntrinsicInst.h:1522

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1524

static bool classof(const Value *V)

Definition IntrinsicInst.h:1527

This represents the llvm.instrprof.increment intrinsic.

Definition IntrinsicInst.h:1509

static bool classof(const Value *V)

Definition IntrinsicInst.h:1515

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1511

LLVM_ABI Value * getStep() const

A base class for all instrprof intrinsics.

Definition IntrinsicInst.h:1435

static bool classof(const Value *V)

Definition IntrinsicInst.h:1459

void setNameValue(Value *V)

Definition IntrinsicInst.h:1475

GlobalVariable * getName() const

Definition IntrinsicInst.h:1466

ConstantInt * getHash() const

Definition IntrinsicInst.h:1478

Value * getNameValue() const

Definition IntrinsicInst.h:1473

static bool isCounterBase(const IntrinsicInst &I)

Definition IntrinsicInst.h:1437

static bool isMCDCBitmapBase(const IntrinsicInst &I)

Definition IntrinsicInst.h:1449

A base class for instrprof mcdc intrinsics that require global bitmap bytes.

Definition IntrinsicInst.h:1586

ConstantInt * getNumBitmapBits() const

Definition IntrinsicInst.h:1597

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1588

auto getNumBitmapBytes() const

Definition IntrinsicInst.h:1603

static bool classof(const Value *V)

Definition IntrinsicInst.h:1591

This represents the llvm.instrprof.mcdc.parameters intrinsic.

Definition IntrinsicInst.h:1609

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1611

static bool classof(const Value *V)

Definition IntrinsicInst.h:1614

This represents the llvm.instrprof.mcdc.tvbitmap.update intrinsic.

Definition IntrinsicInst.h:1620

Value * getMCDCCondBitmapAddr() const

Definition IntrinsicInst.h:1637

ConstantInt * getBitmapIndex() const

Definition IntrinsicInst.h:1631

static bool classof(const Value *V)

Definition IntrinsicInst.h:1625

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1622

This represents the llvm.instrprof.timestamp intrinsic.

Definition IntrinsicInst.h:1555

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1557

static bool classof(const Value *V)

Definition IntrinsicInst.h:1560

This represents the llvm.instrprof.value.profile intrinsic.

Definition IntrinsicInst.h:1566

ConstantInt * getIndex() const

Definition IntrinsicInst.h:1582

Value * getTargetValue() const

Definition IntrinsicInst.h:1575

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1568

ConstantInt * getValueKind() const

Definition IntrinsicInst.h:1577

static bool classof(const Value *V)

Definition IntrinsicInst.h:1571

A wrapper class for inspecting calls to intrinsic functions.

Definition IntrinsicInst.h:49

bool isAssumeLikeIntrinsic() const

Checks if the intrinsic is an annotation.

Definition IntrinsicInst.h:105

static LLVM_ABI bool mayLowerToFunctionCall(Intrinsic::ID IID)

Check if the intrinsic might lower into a regular function call in the course of IR transformations.

IntrinsicInst(const IntrinsicInst &)=delete

Intrinsic::ID getIntrinsicID() const

Return the intrinsic ID of this intrinsic.

Definition IntrinsicInst.h:56

bool isCommutative() const

Return true if swapping the first two arguments to the intrinsic produces the same result.

Definition IntrinsicInst.h:74

static bool classof(const Value *V)

Definition IntrinsicInst.h:137

IntrinsicInst & operator=(const IntrinsicInst &)=delete

static bool classof(const CallInst *I)

Methods for support type inquiry through isa, cast, and dyn_cast:

Definition IntrinsicInst.h:133

bool isAssociative() const

Definition IntrinsicInst.h:60

This is the common base class for lifetime intrinsics.

Definition IntrinsicInst.h:154

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:158

static bool classof(const Value *V)

Definition IntrinsicInst.h:161

LLVMContext & getContext() const

This class wraps the llvm.memcpy intrinsic.

Definition IntrinsicInst.h:1232

static bool classof(const Value *V)

Definition IntrinsicInst.h:1239

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1235

Common base class for all memory intrinsics.

Definition IntrinsicInst.h:993

const Use & getRawDestUse() const

Definition IntrinsicInst.h:1001

Value * getLength() const

Definition IntrinsicInst.h:1004

Value * getRawDest() const

Definition IntrinsicInst.h:998

void setDestAlignment(Align Alignment)

Definition IntrinsicInst.h:1041

void setLength(Value *L)

Definition IntrinsicInst.h:1047

Value * getDest() const

This is just like getRawDest, but it strips off any cast instructions (including addrspacecast) that ...

Definition IntrinsicInst.h:1020

void setDestAlignment(MaybeAlign Alignment)

Definition IntrinsicInst.h:1035

void setLength(uint64_t L)

Definition IntrinsicInst.h:1053

void setDest(Value *Ptr)

Set the specified arguments of the instruction.

Definition IntrinsicInst.h:1029

Use & getRawDestUse()

Definition IntrinsicInst.h:1002

MaybeAlign getDestAlign() const

Definition IntrinsicInst.h:1026

const Use & getLengthUse() const

Definition IntrinsicInst.h:1007

unsigned getDestAddressSpace() const

Definition IntrinsicInst.h:1022

std::optional< APInt > getLengthInBytes() const

Definition IntrinsicInst.h:1010

Use & getLengthUse()

Definition IntrinsicInst.h:1008

This is the common base class for memset/memcpy/memmove.

Definition IntrinsicInst.h:1128

ConstantInt * getVolatileCst() const

Definition IntrinsicInst.h:1133

void setVolatile(Constant *V)

Definition IntrinsicInst.h:1139

bool isForceInlined() const

Definition IntrinsicInst.h:1141

static bool classof(const Value *V)

Definition IntrinsicInst.h:1164

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1152

bool isVolatile() const

Definition IntrinsicInst.h:1137

This class wraps the llvm.memmove intrinsic.

Definition IntrinsicInst.h:1245

static bool classof(const Value *V)

Definition IntrinsicInst.h:1251

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1248

Common base class for all memset intrinsics.

Definition IntrinsicInst.h:1109

Use & getValueUse()

Definition IntrinsicInst.h:1118

void setValue(Value *Val)

Definition IntrinsicInst.h:1120

const Use & getValueUse() const

Definition IntrinsicInst.h:1117

Value * getValue() const

Definition IntrinsicInst.h:1114

This class wraps the llvm.memset and llvm.memset.inline intrinsics.

Definition IntrinsicInst.h:1170

static bool classof(const Value *V)

Definition IntrinsicInst.h:1182

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1173

This class wraps the llvm.experimental.memset.pattern intrinsic.

Definition IntrinsicInst.h:1190

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1204

static bool classof(const Value *V)

Definition IntrinsicInst.h:1207

ConstantInt * getVolatileCst() const

Definition IntrinsicInst.h:1195

bool isVolatile() const

Definition IntrinsicInst.h:1199

void setVolatile(Constant *V)

Definition IntrinsicInst.h:1201

Common base class for all memory transfer intrinsics.

Definition IntrinsicInst.h:1060

Use & getRawSourceUse()

Definition IntrinsicInst.h:1072

void setSource(Value *Ptr)

Definition IntrinsicInst.h:1087

Value * getRawSource() const

Return the arguments to the instruction.

Definition IntrinsicInst.h:1066

unsigned getSourceAddressSpace() const

Definition IntrinsicInst.h:1079

MaybeAlign getSourceAlign() const

Definition IntrinsicInst.h:1083

Value * getSource() const

This is just like getRawSource, but it strips off any cast instructions that feed it,...

Definition IntrinsicInst.h:1077

void setSourceAlignment(MaybeAlign Alignment)

Definition IntrinsicInst.h:1093

void setSourceAlignment(Align Alignment)

Definition IntrinsicInst.h:1100

const Use & getRawSourceUse() const

Definition IntrinsicInst.h:1069

This class wraps the llvm.memcpy/memmove intrinsics.

Definition IntrinsicInst.h:1213

static bool classof(const Value *V)

Definition IntrinsicInst.h:1226

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1216

This class represents min/max intrinsics.

Definition IntrinsicInst.h:764

static bool classof(const Value *V)

Definition IntrinsicInst.h:777

static Constant * getSaturationPoint(Intrinsic::ID ID, Type *Ty)

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

Definition IntrinsicInst.h:861

APInt getSaturationPoint(unsigned numBits) const

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

Definition IntrinsicInst.h:854

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...

Definition IntrinsicInst.h:836

Value * getLHS() const

Definition IntrinsicInst.h:781

Value * getRHS() const

Definition IntrinsicInst.h:782

bool isMin() const

Whether the intrinsic is a smin or a umin.

Definition IntrinsicInst.h:828

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

Returns the comparison predicate underlying the intrinsic.

Definition IntrinsicInst.h:785

ICmpInst::Predicate getPredicate() const

Returns the comparison predicate underlying the intrinsic.

Definition IntrinsicInst.h:801

static bool isMin(Intrinsic::ID ID)

Whether the intrinsic is a smin or umin.

Definition IntrinsicInst.h:814

static bool isSigned(Intrinsic::ID ID)

Whether the intrinsic is signed or unsigned.

Definition IntrinsicInst.h:806

bool isMax() const

Whether the intrinsic is a smax or a umax.

Definition IntrinsicInst.h:831

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:766

bool isSigned() const

Whether the intrinsic is signed or unsigned.

Definition IntrinsicInst.h:811

Constant * getSaturationPoint(Type *Ty) const

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

Definition IntrinsicInst.h:869

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

Definition IntrinsicInst.h:1663

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1665

void setScopeList(MDNode *ScopeList)

Definition IntrinsicInst.h:1679

static bool classof(const Value *V)

Definition IntrinsicInst.h:1669

MDNode * getScopeList() const

Definition IntrinsicInst.h:1673

A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...

static LLVM_ABI PoisonValue * get(Type *T)

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

Definition IntrinsicInst.h:1640

ConstantInt * getAttributes() const

Definition IntrinsicInst.h:1656

ConstantInt * getIndex() const

Definition IntrinsicInst.h:1654

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1642

static bool classof(const Value *V)

Definition IntrinsicInst.h:1646

ConstantInt * getFactor() const

Definition IntrinsicInst.h:1660

ConstantInt * getFuncGuid() const

Definition IntrinsicInst.h:1650

Lightweight class that wraps the location operand metadata of a debug intrinsic.

Definition IntrinsicInst.h:243

friend bool operator<=(const RawLocationWrapper &A, const RawLocationWrapper &B)

Definition IntrinsicInst.h:301

Metadata * getRawLocation() const

Definition IntrinsicInst.h:256

friend bool operator>(const RawLocationWrapper &A, const RawLocationWrapper &B)

Definition IntrinsicInst.h:289

RawLocationWrapper(Metadata *RawLocation)

Definition IntrinsicInst.h:248

RawLocationWrapper()=default

friend bool operator<(const RawLocationWrapper &A, const RawLocationWrapper &B)

Definition IntrinsicInst.h:297

friend bool operator==(const RawLocationWrapper &A, const RawLocationWrapper &B)

Definition IntrinsicInst.h:281

LLVM_ABI iterator_range< location_op_iterator > location_ops() const

Get the locations corresponding to the variable referenced by the debug info intrinsic.

LLVM_ABI Value * getVariableLocationOp(unsigned OpIdx) const

bool isKillLocation(const DIExpression *Expression) const

Definition IntrinsicInst.h:268

bool hasArgList() const

Definition IntrinsicInst.h:267

friend bool operator!=(const RawLocationWrapper &A, const RawLocationWrapper &B)

Definition IntrinsicInst.h:285

unsigned getNumVariableLocationOps() const

Definition IntrinsicInst.h:262

friend bool operator>=(const RawLocationWrapper &A, const RawLocationWrapper &B)

Definition IntrinsicInst.h:293

Represents a saturating add/sub intrinsic.

Definition IntrinsicInst.h:971

static bool classof(const Value *V)

Definition IntrinsicInst.h:984

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:973

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

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

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

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

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

void setOperand(unsigned i, Value *Val)

Value * getOperand(unsigned i) const

This represents the llvm.va_copy intrinsic.

Definition IntrinsicInst.h:1421

Value * getSrc() const

Definition IntrinsicInst.h:1431

static bool classof(const Value *V)

Definition IntrinsicInst.h:1426

Value * getDest() const

Definition IntrinsicInst.h:1430

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1423

This represents the llvm.va_end intrinsic.

Definition IntrinsicInst.h:1408

Value * getArgList() const

Definition IntrinsicInst.h:1417

static bool classof(const Value *V)

Definition IntrinsicInst.h:1413

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1410

This represents the llvm.va_start intrinsic.

Definition IntrinsicInst.h:1395

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:1397

static bool classof(const Value *V)

Definition IntrinsicInst.h:1400

Value * getArgList() const

Definition IntrinsicInst.h:1404

Definition IntrinsicInst.h:709

static LLVM_ABI bool isVPBinOp(Intrinsic::ID ID)

static bool classof(const IntrinsicInst *I)

Methods for support type inquiry through isa, cast, and dyn_cast:

Definition IntrinsicInst.h:715

static bool classof(const Value *V)

Definition IntrinsicInst.h:718

Definition IntrinsicInst.h:677

static LLVM_ABI bool isVPCast(Intrinsic::ID ID)

static bool classof(const Value *V)

Definition IntrinsicInst.h:686

static bool classof(const IntrinsicInst *I)

Methods for support type inquiry through isa, cast, and dyn_cast:

Definition IntrinsicInst.h:683

Definition IntrinsicInst.h:692

static bool classof(const IntrinsicInst *I)

Methods for support type inquiry through isa, cast, and dyn_cast:

Definition IntrinsicInst.h:700

static bool classof(const Value *V)

Definition IntrinsicInst.h:703

static LLVM_ABI bool isVPCmp(Intrinsic::ID ID)

LLVM_ABI CmpInst::Predicate getPredicate() const

This is the common base class for vector predication intrinsics.

Definition IntrinsicInst.h:566

std::optional< unsigned > getFunctionalIntrinsicID() const

Definition IntrinsicInst.h:633

static bool classof(const Value *V)

Definition IntrinsicInst.h:623

static LLVM_ABI std::optional< unsigned > getMaskParamPos(Intrinsic::ID IntrinsicID)

LLVM_ABI bool canIgnoreVectorLengthParam() const

LLVM_ABI void setMaskParam(Value *)

static LLVM_ABI std::optional< unsigned > getFunctionalOpcodeForVP(Intrinsic::ID ID)

static LLVM_ABI std::optional< unsigned > getMemoryDataParamPos(Intrinsic::ID)

LLVM_ABI Value * getVectorLengthParam() const

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:620

static LLVM_ABI std::optional< Intrinsic::ID > getFunctionalIntrinsicIDForVP(Intrinsic::ID ID)

LLVM_ABI void setVectorLengthParam(Value *)

static LLVM_ABI std::optional< unsigned > getVectorLengthParamPos(Intrinsic::ID IntrinsicID)

static LLVM_ABI Intrinsic::ID getForOpcode(unsigned OC)

The llvm.vp.* intrinsics for this instruction Opcode.

static LLVM_ABI Function * getOrInsertDeclarationForParams(Module *M, Intrinsic::ID, Type *ReturnType, ArrayRef< Value * > Params)

Declares a llvm.vp.

static LLVM_ABI std::optional< unsigned > getMemoryPointerParamPos(Intrinsic::ID)

static LLVM_ABI bool isVPIntrinsic(Intrinsic::ID)

LLVM_ABI Value * getMemoryDataParam() const

static LLVM_ABI Intrinsic::ID getForIntrinsic(Intrinsic::ID Id)

The llvm.vp.

LLVM_ABI Value * getMemoryPointerParam() const

std::optional< unsigned > getConstrainedIntrinsicID() const

Definition IntrinsicInst.h:638

LLVM_ABI MaybeAlign getPointerAlignment() const

LLVM_ABI Value * getMaskParam() const

LLVM_ABI ElementCount getStaticVectorLength() const

static LLVM_ABI std::optional< Intrinsic::ID > getConstrainedIntrinsicIDForVP(Intrinsic::ID ID)

std::optional< unsigned > getFunctionalOpcode() const

Definition IntrinsicInst.h:628

This represents vector predication reduction intrinsics.

Definition IntrinsicInst.h:656

static bool classof(const Value *V)

Definition IntrinsicInst.h:671

static bool classof(const IntrinsicInst *I)

Methods for support type inquiry through isa, cast, and dyn_cast:

Definition IntrinsicInst.h:668

static LLVM_ABI bool isVPReduction(Intrinsic::ID ID)

LLVM_ABI unsigned getStartParamPos() const

LLVM_ABI unsigned getVectorParamPos() const

LLVM Value Representation.

Type * getType() const

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

LLVM_ABI const Value * stripPointerCasts() const

Strip off pointer casts, all-zero GEPs and address space casts.

LLVM_ABI LLVMContext & getContext() const

All values hold a context through their type.

Represents an op.with.overflow intrinsic.

Definition IntrinsicInst.h:950

static bool classof(const Value *V)

Definition IntrinsicInst.h:965

static bool classof(const IntrinsicInst *I)

Definition IntrinsicInst.h:952

CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...

A range adaptor for a pair of iterators.

bool operator==(const location_op_iterator &RHS) const

Definition IntrinsicInst.h:211

location_op_iterator & operator=(const location_op_iterator &R)

Definition IntrinsicInst.h:207

location_op_iterator(ValueAsMetadata **MultiIter)

Definition IntrinsicInst.h:204

location_op_iterator(const location_op_iterator &R)

Definition IntrinsicInst.h:206

Value * operator*()

Definition IntrinsicInst.h:218

location_op_iterator & operator++()

Definition IntrinsicInst.h:224

location_op_iterator(ValueAsMetadata *SingleIter)

Definition IntrinsicInst.h:203

location_op_iterator & operator--()

Definition IntrinsicInst.h:231

const Value * operator*() const

Definition IntrinsicInst.h:212

#define llvm_unreachable(msg)

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

unsigned ID

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

@ C

The default llvm calling convention, compatible with C.

static const int NoAliasScopeDeclScopeArg

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

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

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.

static bool isLifetimeIntrinsic(Intrinsic::ID ID)

Check if ID corresponds to a lifetime intrinsic.

Definition IntrinsicInst.h:143

static bool isDbgInfoIntrinsic(Intrinsic::ID ID)

Check if ID corresponds to a debug info intrinsic.

Definition IntrinsicInst.h:168

bool isa(const From &Val)

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

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

decltype(auto) cast(const From &Val)

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

static bool isConvergenceControlIntrinsic(unsigned IntrinsicID)

Check if ID corresponds to a convergence control intrinsic.

Definition IntrinsicInst.h:1763

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

This struct is a compact representation of a valid (power of two) or undefined (0) alignment.