Intrinsics.cpp Source File (original) (raw)

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

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

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

21#include "llvm/IR/IntrinsicsBPF.h"

22#include "llvm/IR/IntrinsicsHexagon.h"

23#include "llvm/IR/IntrinsicsLoongArch.h"

24#include "llvm/IR/IntrinsicsMips.h"

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

26#include "llvm/IR/IntrinsicsPowerPC.h"

27#include "llvm/IR/IntrinsicsR600.h"

28#include "llvm/IR/IntrinsicsRISCV.h"

29#include "llvm/IR/IntrinsicsS390.h"

30#include "llvm/IR/IntrinsicsSPIRV.h"

31#include "llvm/IR/IntrinsicsVE.h"

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

33#include "llvm/IR/IntrinsicsXCore.h"

38using namespace llvm;

41#define GET_INTRINSIC_NAME_TABLE

42#include "llvm/IR/IntrinsicImpl.inc"

43#undef GET_INTRINSIC_NAME_TABLE

46 assert(id < num_intrinsics && "Invalid intrinsic ID!");

47 return IntrinsicNameTable[IntrinsicNameOffsetTable[id]];

48}

51 assert(id < num_intrinsics && "Invalid intrinsic ID!");

53 "This version of getName does not support overloading");

55}

70 std::string Result;

72 Result += "p" + utostr(PTyp->getAddressSpace());

74 Result += "a" + utostr(ATyp->getNumElements()) +

77 if (!STyp->isLiteral()) {

78 Result += "s_";

79 if (STyp->hasName())

80 Result += STyp->getName();

81 else

82 HasUnnamedType = true;

83 } else {

84 Result += "sl_";

85 for (auto *Elem : STyp->elements())

87 }

89 Result += "s";

91 Result += "f_" + getMangledTypeStr(FT->getReturnType(), HasUnnamedType);

92 for (size_t i = 0; i < FT->getNumParams(); i++)

94 if (FT->isVarArg())

95 Result += "vararg";

97 Result += "f";

100 if (EC.isScalable())

101 Result += "nx";

102 Result += "v" + utostr(EC.getKnownMinValue()) +

105 Result += "t";

106 Result += TETy->getName();

107 for (Type *ParamTy : TETy->type_params())

109 for (unsigned IntParam : TETy->int_params())

110 Result += "_" + utostr(IntParam);

111

112 Result += "t";

113 } else if (Ty) {

114 switch (Ty->getTypeID()) {

115 default:

118 Result += "isVoid";

119 break;

121 Result += "Metadata";

122 break;

124 Result += "f16";

125 break;

127 Result += "bf16";

128 break;

130 Result += "f32";

131 break;

133 Result += "f64";

134 break;

136 Result += "f80";

137 break;

139 Result += "f128";

140 break;

142 Result += "ppcf128";

143 break;

145 Result += "x86amx";

146 break;

149 break;

150 }

151 }

152 return Result;

153}

154

157 bool EarlyModuleCheck) {

158

159 assert(Id < Intrinsic::num_intrinsics && "Invalid intrinsic ID!");

161 "This version of getName is for overloaded intrinsics only");

162 (void)EarlyModuleCheck;

163 assert((!EarlyModuleCheck || M ||

165 "Intrinsic overloading on pointer types need to provide a Module");

166 bool HasUnnamedType = false;

168 for (Type *Ty : Tys)

170 if (HasUnnamedType) {

171 assert(M && "unnamed types need a module");

172 if (!FT)

174 else

176 "Provided FunctionType must match arguments");

177 return M->getUniqueIntrinsicName(Result, Id, FT);

178 }

179 return Result;

180}

181

184 assert(M && "We need to have a Module");

186}

187

191

192

193

194

195

197#define GET_INTRINSIC_IITINFO

198#include "llvm/IR/IntrinsicImpl.inc"

199#undef GET_INTRINSIC_IITINFO

200};

201

202static void

207

208 bool IsScalableVector = (LastInfo == IIT_SCALABLE_VEC);

209

211

212 switch (Info) {

213 case IIT_Done:

214 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));

215 return;

216 case IIT_VARARG:

217 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));

218 return;

219 case IIT_MMX:

220 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));

221 return;

222 case IIT_AMX:

223 OutputTable.push_back(IITDescriptor::get(IITDescriptor::AMX, 0));

224 return;

225 case IIT_TOKEN:

226 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));

227 return;

228 case IIT_METADATA:

229 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));

230 return;

231 case IIT_F16:

232 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));

233 return;

234 case IIT_BF16:

235 OutputTable.push_back(IITDescriptor::get(IITDescriptor::BFloat, 0));

236 return;

237 case IIT_F32:

238 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));

239 return;

240 case IIT_F64:

241 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));

242 return;

243 case IIT_F128:

244 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Quad, 0));

245 return;

246 case IIT_PPCF128:

247 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PPCQuad, 0));

248 return;

249 case IIT_I1:

250 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));

251 return;

252 case IIT_I2:

253 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 2));

254 return;

255 case IIT_I4:

256 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 4));

257 return;

258 case IIT_AARCH64_SVCOUNT:

259 OutputTable.push_back(IITDescriptor::get(IITDescriptor::AArch64Svcount, 0));

260 return;

261 case IIT_I8:

262 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));

263 return;

264 case IIT_I16:

265 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 16));

266 return;

267 case IIT_I32:

268 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));

269 return;

270 case IIT_I64:

271 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));

272 return;

273 case IIT_I128:

274 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));

275 return;

276 case IIT_V1:

277 OutputTable.push_back(IITDescriptor::getVector(1, IsScalableVector));

279 return;

280 case IIT_V2:

281 OutputTable.push_back(IITDescriptor::getVector(2, IsScalableVector));

283 return;

284 case IIT_V3:

285 OutputTable.push_back(IITDescriptor::getVector(3, IsScalableVector));

287 return;

288 case IIT_V4:

289 OutputTable.push_back(IITDescriptor::getVector(4, IsScalableVector));

291 return;

292 case IIT_V6:

293 OutputTable.push_back(IITDescriptor::getVector(6, IsScalableVector));

295 return;

296 case IIT_V8:

297 OutputTable.push_back(IITDescriptor::getVector(8, IsScalableVector));

299 return;

300 case IIT_V10:

301 OutputTable.push_back(IITDescriptor::getVector(10, IsScalableVector));

303 return;

304 case IIT_V16:

305 OutputTable.push_back(IITDescriptor::getVector(16, IsScalableVector));

307 return;

308 case IIT_V32:

309 OutputTable.push_back(IITDescriptor::getVector(32, IsScalableVector));

311 return;

312 case IIT_V64:

313 OutputTable.push_back(IITDescriptor::getVector(64, IsScalableVector));

315 return;

316 case IIT_V128:

317 OutputTable.push_back(IITDescriptor::getVector(128, IsScalableVector));

319 return;

320 case IIT_V256:

321 OutputTable.push_back(IITDescriptor::getVector(256, IsScalableVector));

323 return;

324 case IIT_V512:

325 OutputTable.push_back(IITDescriptor::getVector(512, IsScalableVector));

327 return;

328 case IIT_V1024:

329 OutputTable.push_back(IITDescriptor::getVector(1024, IsScalableVector));

331 return;

332 case IIT_V2048:

333 OutputTable.push_back(IITDescriptor::getVector(2048, IsScalableVector));

335 return;

336 case IIT_V4096:

337 OutputTable.push_back(IITDescriptor::getVector(4096, IsScalableVector));

339 return;

340 case IIT_EXTERNREF:

341 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 10));

342 return;

343 case IIT_FUNCREF:

344 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 20));

345 return;

346 case IIT_PTR:

347 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));

348 return;

349 case IIT_ANYPTR:

351 IITDescriptor::get(IITDescriptor::Pointer, Infos[NextElt++]));

352 return;

353 case IIT_ARG: {

354 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

355 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));

356 return;

357 }

358 case IIT_EXTEND_ARG: {

359 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

361 IITDescriptor::get(IITDescriptor::ExtendArgument, ArgInfo));

362 return;

363 }

364 case IIT_TRUNC_ARG: {

365 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

367 IITDescriptor::get(IITDescriptor::TruncArgument, ArgInfo));

368 return;

369 }

370 case IIT_ONE_NTH_ELTS_VEC_ARG: {

371 unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

372 unsigned short N = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

374 IITDescriptor::get(IITDescriptor::OneNthEltsVecArgument, N, ArgNo));

375 return;

376 }

377 case IIT_SAME_VEC_WIDTH_ARG: {

378 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

380 IITDescriptor::get(IITDescriptor::SameVecWidthArgument, ArgInfo));

381 return;

382 }

383 case IIT_VEC_OF_ANYPTRS_TO_ELT: {

384 unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

385 unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

387 IITDescriptor::get(IITDescriptor::VecOfAnyPtrsToElt, ArgNo, RefNo));

388 return;

389 }

390 case IIT_EMPTYSTRUCT:

391 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));

392 return;

393 case IIT_STRUCT: {

394 unsigned StructElts = Infos[NextElt++] + 2;

395

397 IITDescriptor::get(IITDescriptor::Struct, StructElts));

398

399 for (unsigned i = 0; i != StructElts; ++i)

401 return;

402 }

403 case IIT_SUBDIVIDE2_ARG: {

404 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

406 IITDescriptor::get(IITDescriptor::Subdivide2Argument, ArgInfo));

407 return;

408 }

409 case IIT_SUBDIVIDE4_ARG: {

410 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

412 IITDescriptor::get(IITDescriptor::Subdivide4Argument, ArgInfo));

413 return;

414 }

415 case IIT_VEC_ELEMENT: {

416 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

418 IITDescriptor::get(IITDescriptor::VecElementArgument, ArgInfo));

419 return;

420 }

421 case IIT_SCALABLE_VEC: {

423 return;

424 }

425 case IIT_VEC_OF_BITCASTS_TO_INT: {

426 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);

428 IITDescriptor::get(IITDescriptor::VecOfBitcastsToInt, ArgInfo));

429 return;

430 }

431 }

433}

434

435#define GET_INTRINSIC_GENERATOR_GLOBAL

436#include "llvm/IR/IntrinsicImpl.inc"

437#undef GET_INTRINSIC_GENERATOR_GLOBAL

438

441 static_assert(sizeof(IIT_Table[0]) == 2,

442 "Expect 16-bit entries in IIT_Table");

443

444 uint16_t TableVal = IIT_Table[id - 1];

445

446

449 unsigned NextElt = 0;

450 if (TableVal >> 15) {

451

452 IITEntries = IIT_LongEncodingTable;

453

454

455 NextElt = TableVal & 0x7fff;

456 } else {

457

458

459 do {

460 IITValues.push_back(TableVal & 0xF);

461 TableVal >>= 4;

462 } while (TableVal);

463

464 IITEntries = IITValues;

465 NextElt = 0;

466 }

467

468

470 while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)

472}

473

477

478 IITDescriptor D = Infos.front();

479 Infos = Infos.slice(1);

480

481 switch (D.Kind) {

482 case IITDescriptor::Void:

484 case IITDescriptor::VarArg:

486 case IITDescriptor::MMX:

488 case IITDescriptor::AMX:

490 case IITDescriptor::Token:

492 case IITDescriptor::Metadata:

494 case IITDescriptor::Half:

496 case IITDescriptor::BFloat:

498 case IITDescriptor::Float:

500 case IITDescriptor::Double:

502 case IITDescriptor::Quad:

504 case IITDescriptor::PPCQuad:

506 case IITDescriptor::AArch64Svcount:

508

509 case IITDescriptor::Integer:

511 case IITDescriptor::Vector:

513 D.Vector_Width);

514 case IITDescriptor::Pointer:

516 case IITDescriptor::Struct: {

518 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)

521 }

522 case IITDescriptor::Argument:

523 return Tys[D.getArgumentNumber()];

524 case IITDescriptor::ExtendArgument: {

525 Type *Ty = Tys[D.getArgumentNumber()];

528

530 }

531 case IITDescriptor::TruncArgument: {

532 Type *Ty = Tys[D.getArgumentNumber()];

535

539 }

540 case IITDescriptor::Subdivide2Argument:

541 case IITDescriptor::Subdivide4Argument: {

542 Type *Ty = Tys[D.getArgumentNumber()];

544 assert(VTy && "Expected an argument of Vector Type");

545 int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;

547 }

548 case IITDescriptor::OneNthEltsVecArgument:

551 case IITDescriptor::SameVecWidthArgument: {

553 Type *Ty = Tys[D.getArgumentNumber()];

556 return EltTy;

557 }

558 case IITDescriptor::VecElementArgument: {

559 Type *Ty = Tys[D.getArgumentNumber()];

561 return VTy->getElementType();

563 }

564 case IITDescriptor::VecOfBitcastsToInt: {

565 Type *Ty = Tys[D.getArgumentNumber()];

567 assert(VTy && "Expected an argument of Vector Type");

569 }

570 case IITDescriptor::VecOfAnyPtrsToElt:

571

572 return Tys[D.getOverloadArgNumber()];

573 }

575}

576

581

584

588

589

590

591

592 if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {

595 }

597}

598

600#define GET_INTRINSIC_OVERLOAD_TABLE

601#include "llvm/IR/IntrinsicImpl.inc"

602#undef GET_INTRINSIC_OVERLOAD_TABLE

603}

604

606#define GET_INTRINSIC_PRETTY_PRINT_TABLE

607#include "llvm/IR/IntrinsicImpl.inc"

608#undef GET_INTRINSIC_PRETTY_PRINT_TABLE

609}

610

611

612#define GET_INTRINSIC_TARGET_DATA

613#include "llvm/IR/IntrinsicImpl.inc"

614#undef GET_INTRINSIC_TARGET_DATA

615

617 return IID > TargetInfos[0].Count;

618}

619

620

621

622

623

626 assert(Name.starts_with("llvm.") && "Unexpected intrinsic prefix");

627 assert(Name.drop_front(5).starts_with(Target) && "Unexpected target");

628

629

630

631

632

633

634

635

636 size_t CmpEnd = 4;

638 CmpEnd += 1 + Target.size();

639

640 const unsigned *Low = NameOffsetTable.begin();

641 const unsigned *High = NameOffsetTable.end();

642 const unsigned *LastLow = Low;

643 while (CmpEnd < Name.size() && High - Low > 0) {

644 size_t CmpStart = CmpEnd;

645 CmpEnd = Name.find('.', CmpStart + 1);

646 CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;

647 auto Cmp = [CmpStart, CmpEnd](auto LHS, auto RHS) {

648

649

650

651 const char *LHSStr;

652 if constexpr (std::is_integral_v<decltype(LHS)>)

653 LHSStr = IntrinsicNameTable.getCString(LHS);

654 else

655 LHSStr = LHS;

656

657 const char *RHSStr;

658 if constexpr (std::is_integral_v<decltype(RHS)>)

659 RHSStr = IntrinsicNameTable.getCString(RHS);

660 else

661 RHSStr = RHS;

662

663 return strncmp(LHSStr + CmpStart, RHSStr + CmpStart, CmpEnd - CmpStart) <

664 0;

665 };

666 LastLow = Low;

667 std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);

668 }

670 LastLow = Low;

671

672 if (LastLow == NameOffsetTable.end())

673 return -1;

674 StringRef NameFound = IntrinsicNameTable[*LastLow];

675 if (Name == NameFound ||

676 (Name.starts_with(NameFound) && Name[NameFound.size()] == '.'))

677 return LastLow - NameOffsetTable.begin();

678 return -1;

679}

680

681

682

683

684

685

686static std::pair<ArrayRef, StringRef>

688 assert(Name.starts_with("llvm."));

689

691

692

695 Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; });

696

697

698 const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];

699 return {ArrayRef(&IntrinsicNameOffsetTable[1] + TI.Offset, TI.Count),

700 TI.Name};

701}

702

703

704

708 if (Idx == -1)

710

711

712

713 int Adjust = NameOffsetTable.data() - IntrinsicNameOffsetTable;

715

716

717

718 const auto MatchSize = IntrinsicNameTable[NameOffsetTable[Idx]].size();

719 assert(Name.size() >= MatchSize && "Expected either exact or prefix match");

720 bool IsExactMatch = Name.size() == MatchSize;

723}

724

725

726#define GET_INTRINSIC_ATTRIBUTES

727#include "llvm/IR/IntrinsicImpl.inc"

728#undef GET_INTRINSIC_ATTRIBUTES

729

737 FT)

738 .getCallee());

739 if (F->getFunctionType() == FT)

740 return F;

741

742

743

744

745

746

747 F->setName(F->getName() + ".invalid");

751 FT)

752 .getCallee());

753}

754

762

765

768

769

773

775

776

781 "intrinsic signature mismatch");

782

783

786

787 assert(TableRef.empty() && "Unprocessed descriptors remain");

788

790}

791

795

801

802

803#define GET_LLVM_INTRINSIC_FOR_CLANG_BUILTIN

804#include "llvm/IR/IntrinsicImpl.inc"

805#undef GET_LLVM_INTRINSIC_FOR_CLANG_BUILTIN

806

807

808#define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN

809#include "llvm/IR/IntrinsicImpl.inc"

810#undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN

811

813 switch (QID) {

814#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \

815 case Intrinsic::INTRINSIC:

816#include "llvm/IR/ConstrainedOps.def"

817#undef INSTRUCTION

818 return true;

819 default:

820 return false;

821 }

822}

823

825 switch (QID) {

826#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \

827 case Intrinsic::INTRINSIC: \

828 return ROUND_MODE == 1;

829#include "llvm/IR/ConstrainedOps.def"

830#undef INSTRUCTION

831 default:

832 return false;

833 }

834}

835

837 std::pair<Type *, ArrayRefIntrinsic::IITDescriptor>;

838

839static bool

843 bool IsDeferredCheck) {

845

846

847 if (Infos.empty())

848 return true;

849

850

851 auto InfosRef = Infos;

852 auto DeferCheck = [&DeferredChecks, &InfosRef](Type *T) {

854 return false;

855 };

856

857 IITDescriptor D = Infos.front();

858 Infos = Infos.slice(1);

859

860 switch (D.Kind) {

861 case IITDescriptor::Void:

862 return !Ty->isVoidTy();

863 case IITDescriptor::VarArg:

864 return true;

865 case IITDescriptor::MMX: {

869 }

870 case IITDescriptor::AMX:

871 return !Ty->isX86_AMXTy();

872 case IITDescriptor::Token:

873 return !Ty->isTokenTy();

874 case IITDescriptor::Metadata:

875 return !Ty->isMetadataTy();

876 case IITDescriptor::Half:

877 return !Ty->isHalfTy();

878 case IITDescriptor::BFloat:

879 return !Ty->isBFloatTy();

880 case IITDescriptor::Float:

881 return !Ty->isFloatTy();

882 case IITDescriptor::Double:

883 return !Ty->isDoubleTy();

884 case IITDescriptor::Quad:

885 return !Ty->isFP128Ty();

886 case IITDescriptor::PPCQuad:

887 return !Ty->isPPC_FP128Ty();

888 case IITDescriptor::Integer:

889 return !Ty->isIntegerTy(D.Integer_Width);

890 case IITDescriptor::AArch64Svcount:

893 case IITDescriptor::Vector: {

895 return !VT || VT->getElementCount() != D.Vector_Width ||

897 DeferredChecks, IsDeferredCheck);

898 }

899 case IITDescriptor::Pointer: {

901 return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace;

902 }

903

904 case IITDescriptor::Struct: {

906 if (!ST || !ST->isLiteral() || ST->isPacked() ||

907 ST->getNumElements() != D.Struct_NumElements)

908 return true;

909

910 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)

912 DeferredChecks, IsDeferredCheck))

913 return true;

914 return false;

915 }

916

917 case IITDescriptor::Argument:

918

919

920 if (D.getArgumentNumber() < ArgTys.size())

921 return Ty != ArgTys[D.getArgumentNumber()];

922

923 if (D.getArgumentNumber() > ArgTys.size() ||

924 D.getArgumentKind() == IITDescriptor::AK_MatchType)

925 return IsDeferredCheck || DeferCheck(Ty);

926

927 assert(D.getArgumentNumber() == ArgTys.size() && !IsDeferredCheck &&

928 "Table consistency error");

930

931 switch (D.getArgumentKind()) {

932 case IITDescriptor::AK_Any:

933 return false;

934 case IITDescriptor::AK_AnyInteger:

935 return !Ty->isIntOrIntVectorTy();

936 case IITDescriptor::AK_AnyFloat:

937 return !Ty->isFPOrFPVectorTy();

938 case IITDescriptor::AK_AnyVector:

940 case IITDescriptor::AK_AnyPointer:

942 default:

943 break;

944 }

946

947 case IITDescriptor::ExtendArgument: {

948

949 if (D.getArgumentNumber() >= ArgTys.size())

950 return IsDeferredCheck || DeferCheck(Ty);

951

952 Type *NewTy = ArgTys[D.getArgumentNumber()];

956 NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());

957 else

958 return true;

959

960 return Ty != NewTy;

961 }

962 case IITDescriptor::TruncArgument: {

963

964 if (D.getArgumentNumber() >= ArgTys.size())

965 return IsDeferredCheck || DeferCheck(Ty);

966

967 Type *NewTy = ArgTys[D.getArgumentNumber()];

971 NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);

972 else

973 return true;

974

975 return Ty != NewTy;

976 }

977 case IITDescriptor::OneNthEltsVecArgument:

978

979 if (D.getRefArgNumber() >= ArgTys.size())

980 return IsDeferredCheck || DeferCheck(Ty);

984 D.getVectorDivisor()) != Ty;

985 case IITDescriptor::SameVecWidthArgument: {

986 if (D.getArgumentNumber() >= ArgTys.size()) {

987

988 Infos = Infos.slice(1);

989 return IsDeferredCheck || DeferCheck(Ty);

990 }

993

994 if ((ReferenceType != nullptr) != (ThisArgType != nullptr))

995 return true;

996 Type *EltTy = Ty;

997 if (ThisArgType) {

998 if (ReferenceType->getElementCount() != ThisArgType->getElementCount())

999 return true;

1000 EltTy = ThisArgType->getElementType();

1001 }

1003 IsDeferredCheck);

1004 }

1005 case IITDescriptor::VecOfAnyPtrsToElt: {

1006 unsigned RefArgNumber = D.getRefArgNumber();

1007 if (RefArgNumber >= ArgTys.size()) {

1008 if (IsDeferredCheck)

1009 return true;

1010

1011

1013 return DeferCheck(Ty);

1014 }

1015

1016 if (!IsDeferredCheck) {

1017 assert(D.getOverloadArgNumber() == ArgTys.size() &&

1018 "Table consistency error");

1020 }

1021

1022

1023

1024

1028 (ReferenceType->getElementCount() != ThisArgVecTy->getElementCount()))

1029 return true;

1030 return !ThisArgVecTy->getElementType()->isPointerTy();

1031 }

1032 case IITDescriptor::VecElementArgument: {

1033 if (D.getArgumentNumber() >= ArgTys.size())

1034 return IsDeferredCheck ? true : DeferCheck(Ty);

1037 }

1038 case IITDescriptor::Subdivide2Argument:

1039 case IITDescriptor::Subdivide4Argument: {

1040

1041 if (D.getArgumentNumber() >= ArgTys.size())

1042 return IsDeferredCheck || DeferCheck(Ty);

1043

1044 Type *NewTy = ArgTys[D.getArgumentNumber()];

1046 int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;

1048 return Ty != NewTy;

1049 }

1050 return true;

1051 }

1052 case IITDescriptor::VecOfBitcastsToInt: {

1053 if (D.getArgumentNumber() >= ArgTys.size())

1054 return IsDeferredCheck || DeferCheck(Ty);

1058 return true;

1060 }

1061 }

1063}

1064

1071 false))

1073

1074 unsigned NumDeferredReturnChecks = DeferredChecks.size();

1075

1076 for (auto *Ty : FTy->params())

1079

1080 for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) {

1083 true))

1086 }

1087

1089}

1090

1093

1094 if (Infos.empty())

1095 return isVarArg;

1096

1097

1098 if (Infos.size() != 1)

1099 return true;

1100

1101

1103 Infos = Infos.slice(1);

1105 return !isVarArg;

1106

1107 return true;

1108}

1109

1112 if ()

1113 return false;

1114

1118

1121 return false;

1122 }

1124 return false;

1125 return true;

1126}

1127

1133

1137 return std::nullopt;

1138

1141 std::string WantedName =

1143 if (Name == WantedName)

1144 return std::nullopt;

1145

1147 if (auto *ExistingGV = F->getParent()->getNamedValue(WantedName)) {

1149 if (ExistingF->getFunctionType() == F->getFunctionType())

1150 return ExistingF;

1151

1152

1153

1154

1155

1156 ExistingGV->setName(WantedName + ".renamed");

1157 }

1159 }();

1160

1163 "Shouldn't change the signature");

1164 return NewDecl;

1165}

1166

1170

1172 {Intrinsic::vector_interleave2, Intrinsic::vector_deinterleave2},

1173 {Intrinsic::vector_interleave3, Intrinsic::vector_deinterleave3},

1174 {Intrinsic::vector_interleave4, Intrinsic::vector_deinterleave4},

1175 {Intrinsic::vector_interleave5, Intrinsic::vector_deinterleave5},

1176 {Intrinsic::vector_interleave6, Intrinsic::vector_deinterleave6},

1177 {Intrinsic::vector_interleave7, Intrinsic::vector_deinterleave7},

1178 {Intrinsic::vector_interleave8, Intrinsic::vector_deinterleave8},

1179};

1180

1182 assert(Factor >= 2 && Factor <= 8 && "Unexpected factor");

1184}

1185

1187 assert(Factor >= 2 && Factor <= 8 && "Unexpected factor");

1189}

1190

1191#define GET_INTRINSIC_PRETTY_PRINT_ARGUMENTS

1192#include "llvm/IR/IntrinsicImpl.inc"

1193#undef GET_INTRINSIC_PRETTY_PRINT_ARGUMENTS

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

ArrayRef< TableEntry > TableRef

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

Analysis containing CSE Info

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

static bool matchIntrinsicType(Type *Ty, ArrayRef< Intrinsic::IITDescriptor > &Infos, SmallVectorImpl< Type * > &ArgTys, SmallVectorImpl< DeferredIntrinsicMatchPair > &DeferredChecks, bool IsDeferredCheck)

Definition Intrinsics.cpp:840

static std::string getIntrinsicNameImpl(Intrinsic::ID Id, ArrayRef< Type * > Tys, Module *M, FunctionType *FT, bool EarlyModuleCheck)

Definition Intrinsics.cpp:155

static InterleaveIntrinsic InterleaveIntrinsics[]

Definition Intrinsics.cpp:1171

static Function * getOrInsertIntrinsicDeclarationImpl(Module *M, Intrinsic::ID id, ArrayRef< Type * > Tys, FunctionType *FT)

Definition Intrinsics.cpp:730

static std::pair< ArrayRef< unsigned >, StringRef > findTargetSubtable(StringRef Name)

Find the segment of IntrinsicNameOffsetTable for intrinsics with the same target as Name,...

Definition Intrinsics.cpp:687

std::pair< Type *, ArrayRef< Intrinsic::IITDescriptor > > DeferredIntrinsicMatchPair

Definition Intrinsics.cpp:836

static void DecodeIITType(unsigned &NextElt, ArrayRef< unsigned char > Infos, IIT_Info LastInfo, SmallVectorImpl< Intrinsic::IITDescriptor > &OutputTable)

Definition Intrinsics.cpp:203

IIT_Info

IIT_Info - These are enumerators that describe the entries returned by the getIntrinsicInfoTableEntri...

Definition Intrinsics.cpp:196

static Type * DecodeFixedType(ArrayRef< Intrinsic::IITDescriptor > &Infos, ArrayRef< Type * > Tys, LLVMContext &Context)

Definition Intrinsics.cpp:474

static int lookupLLVMIntrinsicByName(ArrayRef< unsigned > NameOffsetTable, StringRef Name, StringRef Target="")

Looks up Name in NameTable via binary search.

Definition Intrinsics.cpp:624

static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType)

Returns a stable mangling for the type specified for use in the name mangling scheme used by 'any' ty...

Definition Intrinsics.cpp:69

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

static StringRef getName(Value *V)

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

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

Returns the bitwidth of the given scalar or pointer type.

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

const T & front() const

front - Get the first element.

size_t size() const

size - Get the array size.

bool empty() const

empty - Check if the array is empty.

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

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

Class to represent fixed width SIMD vectors.

unsigned getNumElements() const

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

Class to represent function types.

ArrayRef< Type * > params() const

Type * getReturnType() const

static LLVM_ABI FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)

This static method is the primary way of constructing a FunctionType.

FunctionType * getFunctionType() const

Returns the FunctionType for me.

const Function & getFunction() const

void setCallingConv(CallingConv::ID CC)

Class to represent integer types.

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

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

unsigned getBitWidth() const

Get the number of bits in this IntegerType.

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

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

static LLVM_ABI PointerType * get(Type *ElementType, unsigned AddressSpace)

This constructs a pointer to an object of the specified type in a numbered address space.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

reference emplace_back(ArgTypes &&... Args)

void push_back(const T &Elt)

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.

static constexpr size_t npos

constexpr size_t size() const

size - Get the string size.

Class to represent struct types.

static LLVM_ABI StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)

This static method is the primary way to create a literal StructType.

Class to represent target extensions types, which are generally unintrospectable from target-independ...

static LLVM_ABI TargetExtType * get(LLVMContext &Context, StringRef Name, ArrayRef< Type * > Types={}, ArrayRef< unsigned > Ints={})

Return a target extension type having the specified name and optional type and integer parameters.

Target - Wrapper for Target specific information.

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

static LLVM_ABI Type * getX86_AMXTy(LLVMContext &C)

static LLVM_ABI Type * getMetadataTy(LLVMContext &C)

static LLVM_ABI Type * getTokenTy(LLVMContext &C)

static LLVM_ABI Type * getPPC_FP128Ty(LLVMContext &C)

static LLVM_ABI Type * getFP128Ty(LLVMContext &C)

@ X86_AMXTyID

AMX vectors (8192 bits, X86 specific)

@ HalfTyID

16-bit floating point type

@ VoidTyID

type with no size

@ FloatTyID

32-bit floating point type

@ IntegerTyID

Arbitrary bit width integers.

@ BFloatTyID

16-bit floating point type (7-bit significand)

@ DoubleTyID

64-bit floating point type

@ X86_FP80TyID

80-bit floating point type (X87)

@ PPC_FP128TyID

128-bit floating point type (two 64-bits, PowerPC)

@ FP128TyID

128-bit floating point type (112-bit significand)

static LLVM_ABI Type * getVoidTy(LLVMContext &C)

bool isIntegerTy() const

True if this is an instance of IntegerType.

static LLVM_ABI Type * getDoubleTy(LLVMContext &C)

static LLVM_ABI Type * getFloatTy(LLVMContext &C)

static LLVM_ABI Type * getBFloatTy(LLVMContext &C)

static LLVM_ABI Type * getHalfTy(LLVMContext &C)

static VectorType * getExtendedElementVectorType(VectorType *VTy)

This static method is like getInteger except that the element types are twice as wide as the elements...

static VectorType * getOneNthElementsVectorType(VectorType *VTy, unsigned Denominator)

static VectorType * getSubdividedVectorType(VectorType *VTy, int NumSubdivs)

static VectorType * getInteger(VectorType *VTy)

This static method gets a VectorType with the same number of elements as the input type,...

static VectorType * getTruncatedElementVectorType(VectorType *VTy)

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

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

Type * getElementType() const

#define llvm_unreachable(msg)

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

This namespace contains an enum with a value for every intrinsic/builtin function known by LLVM.

LLVM_ABI Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > Tys={})

Look up the Function declaration of the intrinsic id in the Module M.

Definition Intrinsics.cpp:755

LLVM_ABI Intrinsic::ID getDeinterleaveIntrinsicID(unsigned Factor)

Returns the corresponding llvm.vector.deinterleaveN intrinsic for factor N.

Definition Intrinsics.cpp:1186

LLVM_ABI MatchIntrinsicTypesResult matchIntrinsicSignature(FunctionType *FTy, ArrayRef< IITDescriptor > &Infos, SmallVectorImpl< Type * > &ArgTys)

Match the specified function type with the type constraints specified by the .td file.

Definition Intrinsics.cpp:1066

LLVM_ABI void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)

Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.

Definition Intrinsics.cpp:439

MatchIntrinsicTypesResult

@ MatchIntrinsicTypes_Match

@ MatchIntrinsicTypes_NoMatchRet

@ MatchIntrinsicTypes_NoMatchArg

LLVM_ABI Function * getDeclarationIfExists(const Module *M, ID id)

Look up the Function declaration of the intrinsic id in the Module M and return it if it exists.

Definition Intrinsics.cpp:792

LLVM_ABI std::string getNameNoUnnamedTypes(ID Id, ArrayRef< Type * > Tys)

Return the LLVM name for an intrinsic.

Definition Intrinsics.cpp:188

LLVM_ABI std::optional< Function * > remangleIntrinsicFunction(Function *F)

Definition Intrinsics.cpp:1134

LLVM_ABI bool hasConstrainedFPRoundingModeOperand(ID QID)

Returns true if the intrinsic ID is for one of the "ConstrainedFloating-Point Intrinsics" that take r...

Definition Intrinsics.cpp:824

LLVM_ABI StringRef getName(ID id)

Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".

Definition Intrinsics.cpp:50

LLVM_ABI bool isConstrainedFPIntrinsic(ID QID)

Returns true if the intrinsic ID is for one of the "ConstrainedFloating-Point Intrinsics".

Definition Intrinsics.cpp:812

LLVM_ABI ID lookupIntrinsicID(StringRef Name)

This does the actual lookup of an intrinsic ID which matches the given function name.

Definition Intrinsics.cpp:705

LLVM_ABI bool hasPrettyPrintedArgs(ID id)

Returns true if the intrinsic has pretty printed immediate arguments.

Definition Intrinsics.cpp:605

LLVM_ABI StringRef getBaseName(ID id)

Return the LLVM name for an intrinsic, without encoded types for overloading, such as "llvm....

Definition Intrinsics.cpp:45

LLVM_ABI Intrinsic::ID getInterleaveIntrinsicID(unsigned Factor)

Returns the corresponding llvm.vector.interleaveN intrinsic for factor N.

Definition Intrinsics.cpp:1181

LLVM_ABI bool isOverloaded(ID id)

Returns true if the intrinsic can be overloaded.

Definition Intrinsics.cpp:599

LLVM_ABI FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys={})

Return the function type for an intrinsic.

Definition Intrinsics.cpp:577

LLVM_ABI bool getIntrinsicSignature(Intrinsic::ID, FunctionType *FT, SmallVectorImpl< Type * > &ArgTys)

Gets the type arguments of an intrinsic call by matching type contraints specified by the ....

Definition Intrinsics.cpp:1110

LLVM_ABI bool isTargetIntrinsic(ID IID)

isTargetIntrinsic - Returns true if IID is an intrinsic specific to a certain target.

Definition Intrinsics.cpp:616

LLVM_ABI bool matchIntrinsicVarArg(bool isVarArg, ArrayRef< IITDescriptor > &Infos)

Verify if the intrinsic has variable arguments.

Definition Intrinsics.cpp:1091

This is an optimization pass for GlobalISel generic memory operations.

@ Low

Lower the current thread's priority such that it does not affect foreground tasks significantly.

decltype(auto) dyn_cast(const From &Val)

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

auto partition_point(R &&Range, Predicate P)

Binary search for the first iterator in a range where a predicate is false.

std::string utostr(uint64_t X, bool isNeg=false)

bool any_of(R &&range, UnaryPredicate P)

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

bool isa(const From &Val)

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

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

decltype(auto) cast(const From &Val)

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

Definition Intrinsics.cpp:1167

Intrinsic::ID Interleave

Definition Intrinsics.cpp:1168

Intrinsic::ID Deinterleave

Definition Intrinsics.cpp:1168

Helper struct shared between Function Specialization and SCCP Solver.

This is a type descriptor which explains the type requirements of an intrinsic.