AsmWriter.cpp Source File (original) (raw)

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

78#include

79#include

80#include

81#include

82#include

83#include

84#include

85#include

86#include

87#include

88#include

90using namespace llvm;

96 cl::desc("Print addresses of instructions when dumping"));

100 cl::desc("Pretty print debug locations of instructions when dumping"));

101

104 cl::desc("Pretty print perf data (branch weights, etc) when dumping"));

105

108 cl::desc("Preserve use-list order when writing LLVM assembly."));

109

110

112

113

114

115

116

118

121

122

123

127 return VAM->getValue();

128 return V;

129}

130

132 if (OM.lookup(V))

133 return;

134

137 return;

138

140 for (const Value *Op : C->operands())

143 }

144

145

146

147 unsigned ID = OM.size() + 1;

148 OM[V] = ID;

149}

150

152 OrderMap OM;

153

154 auto OrderConstantValue = [&OM](const Value *V) {

157 };

158

159 auto OrderConstantFromMetadata = [&](Metadata *MD) {

161 OrderConstantValue(VAM->getValue());

163 for (const auto *VAM : AL->getArgs())

164 OrderConstantValue(VAM->getValue());

165 }

166 };

167

169 if (G.hasInitializer())

173 }

178 }

183 }

185 for (const Use &U : F.operands())

188

190

191 if (F.isDeclaration())

192 continue;

193

199

200

201

202

204 OrderConstantFromMetadata(DVR.getRawLocation());

205 if (DVR.isDbgAssign())

206 OrderConstantFromMetadata(DVR.getRawAddress());

207 }

208

209 for (const Value *Op : I.operands()) {

214 }

216 }

217 }

218 }

219 return OM;

220}

221

222static std::vector

224

225 using Entry = std::pair<const Use *, unsigned>;

227 for (const Use &U : V->uses())

228

229 if (OM.lookup(U.getUser()))

230 List.push_back(std::make_pair(&U, List.size()));

231

232 if (List.size() < 2)

233

234 return {};

235

236

237

238

241 ID = OM.lookup(BA->getBasicBlock());

242 llvm::sort(List, [&](const Entry &L, const Entry &R) {

243 const Use *LU = L.first;

244 const Use *RU = R.first;

245 if (LU == RU)

246 return false;

247

248 auto LID = OM.lookup(LU->getUser());

249 auto RID = OM.lookup(RU->getUser());

250

251

252 if (LID < RID) {

253 if (GetsReversed)

254 if (RID <= ID)

255 return true;

256 return false;

257 }

258 if (RID < LID) {

259 if (GetsReversed)

260 if (LID <= ID)

261 return false;

262 return true;

263 }

264

265

266

267 if (GetsReversed)

268 if (LID <= ID)

269 return LU->getOperandNo() < RU->getOperandNo();

270 return LU->getOperandNo() > RU->getOperandNo();

271 });

272

274

275 return {};

276

277

278 std::vector Shuffle(List.size());

279 for (size_t I = 0, E = List.size(); I != E; ++I)

280 Shuffle[I] = List[I].second;

281 return Shuffle;

282}

283

287 for (const auto &Pair : OM) {

288 const Value *V = Pair.first;

289 if (V->use_empty() || std::next(V->use_begin()) == V->use_end())

290 continue;

291

292 std::vector Shuffle =

294 if (Shuffle.empty())

295 continue;

296

299 F = I->getFunction();

301 F = A->getParent();

303 F = BB->getParent();

304 ULOM[F][V] = std::move(Shuffle);

305 }

306 return ULOM;

307}

308

311 return MA->getParent() ? MA->getParent()->getParent() : nullptr;

312

314 return BB->getParent() ? BB->getParent()->getParent() : nullptr;

315

317 const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;

318 return M ? M->getParent() : nullptr;

319 }

320

322 return GV->getParent();

323

325 for (const User *U : MAV->users())

328 return M;

329 return nullptr;

330 }

331

332 return nullptr;

333}

334

338 return M ? M->getParent() : nullptr;

339}

340

344

346 switch (cc) {

347 default: Out << "cc" << cc; break;

370 Out << "aarch64_sve_vector_pcs";

371 break;

373 Out << "aarch64_sme_preservemost_from_x0";

374 break;

376 Out << "aarch64_sme_preservemost_from_x1";

377 break;

379 Out << "aarch64_sme_preservemost_from_x2";

380 break;

394 Out << "hhvmcc";

395 break;

397 Out << "hhvm_ccc";

398 break;

407 Out << "amdgpu_cs_chain";

408 break;

410 Out << "amdgpu_cs_chain_preserve";

411 break;

415 Out << "amdgpu_gfx_whole_wave";

416 break;

419 Out << "riscv_vector_cc";

420 break;

421#define CC_VLS_CASE(ABI_VLEN) \

422 case CallingConv::RISCV_VLSCall_##ABI_VLEN: \

423 Out << "riscv_vls_cc(" #ABI_VLEN ")"; \

424 break;

437#undef CC_VLS_CASE

439 Out << "cheriot_compartmentcallcc";

440 break;

442 Out << "cheriot_compartmentcalleecc";

443 break;

445 Out << "cheriot_librarycallcc";

446 break;

447 }

448}

449

457

459 assert(!Name.empty() && "Cannot get empty name!");

460

461

462 bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));

463 if (!NeedsQuotes) {

464 for (unsigned char C : Name) {

465

466

467

468

469 if (!isalnum(C) && C != '-' && C != '.' && C != '_') {

470 NeedsQuotes = true;

471 break;

472 }

473 }

474 }

475

476

477 if (!NeedsQuotes) {

478 OS << Name;

479 return;

480 }

481

482

483

484 OS << '"';

486 OS << '"';

487}

488

489

490

491

493 switch (Prefix) {

495 break;

497 OS << '@';

498 break;

500 OS << '$';

501 break;

503 break;

505 OS << '%';

506 break;

507 }

509}

510

511

512

513

518

520 Out << ", <";

522 Out << "vscale x ";

523 Out << Mask.size() << " x i32> ";

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

525 Out << "zeroinitializer";

527 Out << "poison";

528 } else {

529 Out << "<";

531 for (int Elt : Mask) {

532 Out << LS << "i32 ";

534 Out << "poison";

535 else

536 Out << Elt;

537 }

538 Out << ">";

539 }

540}

541

542namespace {

543

544class TypePrinting {

545public:

546 TypePrinting(const Module *M = nullptr) : DeferredM(M) {}

547

548 TypePrinting(const TypePrinting &) = delete;

549 TypePrinting &operator=(const TypePrinting &) = delete;

550

551

552 TypeFinder &getNamedTypes();

553

554

555 std::vector<StructType *> &getNumberedTypes();

556

558

559 void print(Type *Ty, raw_ostream &OS);

560

561 void printStructBody(StructType *Ty, raw_ostream &OS);

562

563private:

564 void incorporateTypes();

565

566

567 const Module *DeferredM;

568

569 TypeFinder NamedTypes;

570

571

572 DenseMap<StructType *, unsigned> Type2Number;

573

574 std::vector<StructType *> NumberedTypes;

575};

576

577}

578

579TypeFinder &TypePrinting::getNamedTypes() {

580 incorporateTypes();

581 return NamedTypes;

582}

583

584std::vector<StructType *> &TypePrinting::getNumberedTypes() {

585 incorporateTypes();

586

587

588

589

590 if (NumberedTypes.size() == Type2Number.size())

591 return NumberedTypes;

592

593 NumberedTypes.resize(Type2Number.size());

594 for (const auto &P : Type2Number) {

595 assert(P.second < NumberedTypes.size() && "Didn't get a dense numbering?");

596 assert(!NumberedTypes[P.second] && "Didn't get a unique numbering?");

597 NumberedTypes[P.second] = P.first;

598 }

599 return NumberedTypes;

600}

601

602bool TypePrinting::empty() {

603 incorporateTypes();

604 return NamedTypes.empty() && Type2Number.empty();

605}

606

607void TypePrinting::incorporateTypes() {

608 if (!DeferredM)

609 return;

610

611 NamedTypes.run(*DeferredM, false);

612 DeferredM = nullptr;

613

614

615

616 unsigned NextNumber = 0;

617

618 std::vector<StructType *>::iterator NextToUse = NamedTypes.begin();

619 for (StructType *STy : NamedTypes) {

620

621 if (STy->isLiteral())

622 continue;

623

624 if (STy->getName().empty())

625 Type2Number[STy] = NextNumber++;

626 else

627 *NextToUse++ = STy;

628 }

629

630 NamedTypes.erase(NextToUse, NamedTypes.end());

631}

632

633

634

635void TypePrinting::print(Type *Ty, raw_ostream &OS) {

637 case Type::VoidTyID: OS << "void"; return;

638 case Type::HalfTyID: OS << "half"; return;

639 case Type::BFloatTyID: OS << "bfloat"; return;

640 case Type::FloatTyID: OS << "float"; return;

641 case Type::DoubleTyID: OS << "double"; return;

642 case Type::X86_FP80TyID: OS << "x86_fp80"; return;

643 case Type::FP128TyID: OS << "fp128"; return;

644 case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;

645 case Type::LabelTyID: OS << "label"; return;

646 case Type::MetadataTyID:

647 OS << "metadata";

648 return;

649 case Type::X86_AMXTyID: OS << "x86_amx"; return;

650 case Type::TokenTyID: OS << "token"; return;

651 case Type::IntegerTyID:

652 OS << 'i' << cast(Ty)->getBitWidth();

653 return;

654

655 case Type::FunctionTyID: {

657 print(FTy->getReturnType(), OS);

658 OS << " (";

659 ListSeparator LS;

660 for (Type *Ty : FTy->params()) {

661 OS << LS;

663 }

664 if (FTy->isVarArg())

665 OS << LS << "...";

666 OS << ')';

667 return;

668 }

669 case Type::StructTyID: {

671

673 return printStructBody(STy, OS);

674

677

678 incorporateTypes();

679 const auto I = Type2Number.find(STy);

680 if (I != Type2Number.end())

681 OS << '%' << I->second;

682 else

683 OS << "%\"type " << STy << '\"';

684 return;

685 }

686 case Type::PointerTyID: {

688 OS << "ptr";

689 if (unsigned AddressSpace = PTy->getAddressSpace())

691 return;

692 }

693 case Type::ArrayTyID: {

695 OS << '[' << ATy->getNumElements() << " x ";

696 print(ATy->getElementType(), OS);

697 OS << ']';

698 return;

699 }

700 case Type::FixedVectorTyID:

701 case Type::ScalableVectorTyID: {

703 ElementCount EC = PTy->getElementCount();

704 OS << "<";

705 if (EC.isScalable())

706 OS << "vscale x ";

707 OS << EC.getKnownMinValue() << " x ";

708 print(PTy->getElementType(), OS);

709 OS << '>';

710 return;

711 }

712 case Type::TypedPointerTyID: {

716 return;

717 }

718 case Type::TargetExtTyID:

720 OS << "target(\"";

722 OS << "\"";

724 OS << ", ";

725 Inner->print(OS, false, true);

726 }

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

728 OS << ", " << IntParam;

729 OS << ")";

730 return;

731 }

733}

734

735void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {

737 OS << "opaque";

738 return;

739 }

740

742 OS << '<';

743

745 OS << "{}";

746 } else {

747 OS << "{ ";

748 ListSeparator LS;

750 OS << LS;

752 }

753

754 OS << " }";

755 }

757 OS << '>';

758}

759

761

762

763

764

765

766

768public:

769

771

772private:

773

774 const Module* TheModule;

775

776

777 const Function* TheFunction = nullptr;

778 bool FunctionProcessed = false;

779 bool ShouldInitializeAllMetadata;

780

782 ProcessModuleHookFn;

784 ProcessFunctionHookFn;

785

786

788

789

791 unsigned mNext = 0;

792

793

795 unsigned fNext = 0;

796

797

799 unsigned mdnNext = 0;

800

801

803 unsigned asNext = 0;

804

805

807 unsigned ModulePathNext = 0;

808

809

811 unsigned GUIDNext = 0;

812

813

815 unsigned TypeIdNext = 0;

816

817

818

820 unsigned TypeIdCompatibleVtableNext = 0;

821

822public:

823

824

825

826

827

829 bool ShouldInitializeAllMetadata = false);

830

831

832

833

834

835

837 bool ShouldInitializeAllMetadata = false);

838

839

841

844

846

851

853

854 void createMetadataSlot(const MDNode *N) override;

855

856

857

858 int getLocalSlot(const Value *V);

860 int getMetadataSlot(const MDNode *N) override;

862 int getModulePathSlot(StringRef Path);

865 int getTypeIdCompatibleVtableSlot(StringRef Id);

866

867

868

870 TheFunction = F;

871 FunctionProcessed = false;

872 }

873

875

876

877

878

879 void purgeFunction();

880

881

883

886 unsigned mdn_size() const { return mdnMap.size(); }

887 bool mdn_empty() const { return mdnMap.empty(); }

888

889

891

894 unsigned as_size() const { return asMap.size(); }

895 bool as_empty() const { return asMap.empty(); }

896

897

899

900

903

904

905private:

906

907 void CreateModuleSlot(const GlobalValue *V);

908

909

910 void CreateMetadataSlot(const MDNode *N);

911

912

913 void CreateFunctionSlot(const Value *V);

914

915

916 void CreateAttributeSetSlot(AttributeSet AS);

917

918 inline void CreateModulePathSlot(StringRef Path);

920 void CreateTypeIdSlot(StringRef Id);

921 void CreateTypeIdCompatibleVtableSlot(StringRef Id);

922

923

924

925 void processModule();

926

927 int processIndex();

928

929

931

932

933 void processGlobalObjectMetadata(const GlobalObject &GO);

934

935

936 void processFunctionMetadata(const Function &F);

937

938

939 void processInstructionMetadata(const Instruction &I);

940

941

942 void processDbgRecordMetadata(const DbgRecord &DVR);

943};

944

947 : M(M), F(F), Machine(&Machine) {}

948

950 bool ShouldInitializeAllMetadata)

951 : ShouldCreateStorage(M),

952 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}

953

955

957 if (!ShouldCreateStorage)

958 return Machine;

959

960 ShouldCreateStorage = false;

961 MachineStorage =

962 std::make_unique(M, ShouldInitializeAllMetadata);

963 Machine = MachineStorage.get();

964 if (ProcessModuleHookFn)

965 Machine->setProcessHook(ProcessModuleHookFn);

966 if (ProcessFunctionHookFn)

967 Machine->setProcessHook(ProcessFunctionHookFn);

968 return Machine;

969}

970

972

974 return;

975

976

977 if (this->F == &F)

978 return;

979 if (this->F)

980 Machine->purgeFunction();

981 Machine->incorporateFunction(&F);

982 this->F = &F;

983}

984

986 assert(F && "No function incorporated");

987 return Machine->getLocalSlot(V);

988}

989

992 Fn) {

993 ProcessModuleHookFn = Fn;

994}

995

998 Fn) {

999 ProcessFunctionHookFn = Fn;

1000}

1001

1004 return new SlotTracker(FA->getParent());

1005

1007 if (I->getParent())

1008 return new SlotTracker(I->getParent()->getParent());

1009

1011 return new SlotTracker(BB->getParent());

1012

1014 return new SlotTracker(GV->getParent());

1015

1017 return new SlotTracker(GA->getParent());

1018

1020 return new SlotTracker(GIF->getParent());

1021

1024

1025 return nullptr;

1026}

1027

1028#if 0

1029#define ST_DEBUG(X) dbgs() << X

1030#else

1031#define ST_DEBUG(X)

1032#endif

1033

1034

1035

1037 : TheModule(M), ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}

1038

1039

1040

1042 : TheModule(F ? F->getParent() : nullptr), TheFunction(F),

1043 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}

1044

1046 : TheModule(nullptr), ShouldInitializeAllMetadata(false), TheIndex(Index) {}

1047

1049 if (TheModule) {

1050 processModule();

1051 TheModule = nullptr;

1052 }

1053

1054 if (TheFunction && !FunctionProcessed)

1055 processFunction();

1056}

1057

1059 if (!TheIndex)

1060 return 0;

1061 int NumSlots = processIndex();

1062 TheIndex = nullptr;

1063 return NumSlots;

1064}

1065

1066

1067

1068void SlotTracker::processModule() {

1069 ST_DEBUG("begin processModule!\n");

1070

1071

1073 if (!Var.hasName())

1074 CreateModuleSlot(&Var);

1075 processGlobalObjectMetadata(Var);

1076 auto Attrs = Var.getAttributes();

1077 if (Attrs.hasAttributes())

1078 CreateAttributeSetSlot(Attrs);

1079 }

1080

1082 if (.hasName())

1083 CreateModuleSlot(&A);

1084 }

1085

1086 for (const GlobalIFunc &I : TheModule->ifuncs()) {

1087 if (.hasName())

1088 CreateModuleSlot(&I);

1089 processGlobalObjectMetadata(I);

1090 }

1091

1092

1093 for (const NamedMDNode &NMD : TheModule->named_metadata()) {

1094 for (const MDNode *N : NMD.operands())

1095 CreateMetadataSlot(N);

1096 }

1097

1098 for (const Function &F : *TheModule) {

1099 if (.hasName())

1100

1101 CreateModuleSlot(&F);

1102

1103 if (ShouldInitializeAllMetadata)

1104 processFunctionMetadata(F);

1105

1106

1107

1108 AttributeSet FnAttrs = F.getAttributes().getFnAttrs();

1110 CreateAttributeSetSlot(FnAttrs);

1111 }

1112

1113 if (ProcessModuleHookFn)

1114 ProcessModuleHookFn(this, TheModule, ShouldInitializeAllMetadata);

1115

1116 ST_DEBUG("end processModule!\n");

1117}

1118

1119

1120void SlotTracker::processFunction() {

1121 ST_DEBUG("begin processFunction!\n");

1122 fNext = 0;

1123

1124

1125 if (!ShouldInitializeAllMetadata)

1126 processFunctionMetadata(*TheFunction);

1127

1128

1130 AE = TheFunction->arg_end(); AI != AE; ++AI)

1131 if (!AI->hasName())

1132 CreateFunctionSlot(&*AI);

1133

1134 ST_DEBUG("Inserting Instructions:\n");

1135

1136

1137 for (auto &BB : *TheFunction) {

1138 if (!BB.hasName())

1139 CreateFunctionSlot(&BB);

1140

1141 for (auto &I : BB) {

1142 if (.getType()->isVoidTy() && .hasName())

1143 CreateFunctionSlot(&I);

1144

1145

1146

1148

1150 if (Attrs.hasAttributes())

1151 CreateAttributeSetSlot(Attrs);

1152 }

1153 }

1154 }

1155

1156 if (ProcessFunctionHookFn)

1157 ProcessFunctionHookFn(this, TheFunction, ShouldInitializeAllMetadata);

1158

1159 FunctionProcessed = true;

1160

1161 ST_DEBUG("end processFunction!\n");

1162}

1163

1164

1165int SlotTracker::processIndex() {

1166 ST_DEBUG("begin processIndex!\n");

1168

1169

1170

1171

1172 std::vector ModulePaths;

1173 for (auto &[ModPath, _] : TheIndex->modulePaths())

1174 ModulePaths.push_back(ModPath);

1176 for (auto &ModPath : ModulePaths)

1177 CreateModulePathSlot(ModPath);

1178

1179

1180 GUIDNext = ModulePathNext;

1181

1182 for (auto &GlobalList : *TheIndex)

1183 CreateGUIDSlot(GlobalList.first);

1184

1185

1186 TypeIdCompatibleVtableNext = GUIDNext;

1187 for (auto &TId : TheIndex->typeIdCompatibleVtableMap())

1188 CreateTypeIdCompatibleVtableSlot(TId.first);

1189

1190

1191 TypeIdNext = TypeIdCompatibleVtableNext;

1192 for (const auto &TID : TheIndex->typeIds())

1193 CreateTypeIdSlot(TID.second.first);

1194

1195 ST_DEBUG("end processIndex!\n");

1196 return TypeIdNext;

1197}

1198

1199void SlotTracker::processGlobalObjectMetadata(const GlobalObject &GO) {

1202 for (auto &MD : MDs)

1203 CreateMetadataSlot(MD.second);

1204}

1205

1206void SlotTracker::processFunctionMetadata(const Function &F) {

1207 processGlobalObjectMetadata(F);

1208 for (auto &BB : F) {

1209 for (auto &I : BB) {

1210 for (const DbgRecord &DR : I.getDbgRecordRange())

1211 processDbgRecordMetadata(DR);

1212 processInstructionMetadata(I);

1213 }

1214 }

1215}

1216

1217void SlotTracker::processDbgRecordMetadata(const DbgRecord &DR) {

1218

1219

1220

1221

1223

1224

1225

1226

1228 CreateMetadataSlot(Empty);

1229 if (DVR->getRawVariable())

1230 CreateMetadataSlot(DVR->getRawVariable());

1231 if (DVR->isDbgAssign()) {

1232 if (auto *AssignID = DVR->getRawAssignID())

1235 CreateMetadataSlot(Empty);

1236 }

1238 CreateMetadataSlot(DLR->getRawLabel());

1239 } else {

1241 }

1244}

1245

1246void SlotTracker::processInstructionMetadata(const Instruction &I) {

1247

1249 if (Function *F = CI->getCalledFunction())

1250 if (F->isIntrinsic())

1251 for (auto &Op : I.operands())

1254 CreateMetadataSlot(N);

1255

1256

1258 I.getAllMetadata(MDs);

1259 for (auto &MD : MDs)

1260 CreateMetadataSlot(MD.second);

1261}

1262

1263

1264

1265

1267 ST_DEBUG("begin purgeFunction!\n");

1268 fMap.clear();

1269 TheFunction = nullptr;

1270 FunctionProcessed = false;

1271 ST_DEBUG("end purgeFunction!\n");

1272}

1273

1274

1276

1278

1279

1281 return MI == mMap.end() ? -1 : (int)MI->second;

1282}

1283

1286 Fn) {

1287 ProcessModuleHookFn = Fn;

1288}

1289

1292 Fn) {

1293 ProcessFunctionHookFn = Fn;

1294}

1295

1296

1298

1299

1301

1303

1304

1306 return MI == mdnMap.end() ? -1 : (int)MI->second;

1307}

1308

1309

1311 assert( isa<Constant> (V) && "Can't get a constant or global slot with this!");

1312

1313

1315

1317 return FI == fMap.end() ? -1 : (int)FI->second;

1318}

1319

1321

1323

1324

1326 return AI == asMap.end() ? -1 : (int)AI->second;

1327}

1328

1330

1332

1333

1334 auto I = ModulePathMap.find(Path);

1335 return I == ModulePathMap.end() ? -1 : (int)I->second;

1336}

1337

1339

1341

1342

1344 return I == GUIDMap.end() ? -1 : (int)I->second;

1345}

1346

1348

1350

1351

1352 auto I = TypeIdMap.find(Id);

1353 return I == TypeIdMap.end() ? -1 : (int)I->second;

1354}

1355

1357

1359

1360

1361 auto I = TypeIdCompatibleVtableMap.find(Id);

1362 return I == TypeIdCompatibleVtableMap.end() ? -1 : (int)I->second;

1363}

1364

1365

1366void SlotTracker::CreateModuleSlot(const GlobalValue *V) {

1367 assert(V && "Can't insert a null Value into SlotTracker!");

1368 assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");

1369 assert(!V->hasName() && "Doesn't need a slot!");

1370

1371 unsigned DestSlot = mNext++;

1372 mMap[V] = DestSlot;

1373

1374 ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<

1375 DestSlot << " [");

1376

1381}

1382

1383

1384void SlotTracker::CreateFunctionSlot(const Value *V) {

1385 assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");

1386

1387 unsigned DestSlot = fNext++;

1388 fMap[V] = DestSlot;

1389

1390

1391 ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<

1392 DestSlot << " [o]\n");

1393}

1394

1395

1396void SlotTracker::CreateMetadataSlot(const MDNode *N) {

1397 assert(N && "Can't insert a null Value into SlotTracker!");

1398

1399

1401 return;

1402

1403 unsigned DestSlot = mdnNext;

1404 if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)

1405 return;

1406 ++mdnNext;

1407

1408

1409 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)

1411 CreateMetadataSlot(Op);

1412}

1413

1414void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {

1416

1417 if (asMap.try_emplace(AS, asNext).second)

1418 ++asNext;

1419}

1420

1421

1422void SlotTracker::CreateModulePathSlot(StringRef Path) {

1423 ModulePathMap[Path] = ModulePathNext++;

1424}

1425

1426

1428 GUIDMap[GUID] = GUIDNext++;

1429}

1430

1431

1432void SlotTracker::CreateTypeIdSlot(StringRef Id) {

1433 TypeIdMap[Id] = TypeIdNext++;

1434}

1435

1436

1437void SlotTracker::CreateTypeIdCompatibleVtableSlot(StringRef Id) {

1438 TypeIdCompatibleVtableMap[Id] = TypeIdCompatibleVtableNext++;

1439}

1440

1441namespace {

1442

1443struct AsmWriterContext {

1444 TypePrinting *TypePrinter = nullptr;

1445 SlotTracker *Machine = nullptr;

1447

1448 AsmWriterContext(TypePrinting *TP, SlotTracker *ST, const Module *M = nullptr)

1450

1451 static AsmWriterContext &getEmpty() {

1452 static AsmWriterContext EmptyCtx(nullptr, nullptr);

1453 return EmptyCtx;

1454 }

1455

1456

1457

1458 virtual void onWriteMetadataAsOperand(const Metadata *) {}

1459

1460 virtual ~AsmWriterContext() = default;

1461};

1462}

1463

1464

1465

1466

1467

1469 AsmWriterContext &WriterCtx,

1470 bool PrintType = false);

1471

1473 AsmWriterContext &WriterCtx,

1474 bool FromValue = false);

1475

1478 Out << FPO->getFastMathFlags();

1479

1481 if (OBO->hasNoUnsignedWrap())

1482 Out << " nuw";

1483 if (OBO->hasNoSignedWrap())

1484 Out << " nsw";

1486 if (Div->isExact())

1487 Out << " exact";

1489 if (PDI->isDisjoint())

1490 Out << " disjoint";

1492 if (GEP->isInBounds())

1493 Out << " inbounds";

1494 else if (GEP->hasNoUnsignedSignedWrap())

1495 Out << " nusw";

1496 if (GEP->hasNoUnsignedWrap())

1497 Out << " nuw";

1498 if (auto InRange = GEP->getInRange()) {

1499 Out << " inrange(" << InRange->getLower() << ", " << InRange->getUpper()

1500 << ")";

1501 }

1503 if (NNI->hasNonNeg())

1504 Out << " nneg";

1506 if (TI->hasNoUnsignedWrap())

1507 Out << " nuw";

1508 if (TI->hasNoSignedWrap())

1509 Out << " nsw";

1511 if (ICmp->hasSameSign())

1512 Out << " samesign";

1513 }

1514}

1515

1519

1520

1521

1522

1523

1524 bool ignored;

1527 bool isNaN = APF.isNaN();

1528

1529 if (!isInf && !isNaN) {

1532 APF.toString(StrVal, 6, 0, false);

1533

1534

1535

1536

1538 ((StrVal[0] == '-' || StrVal[0] == '+') && isDigit(StrVal[1]))) &&

1539 "[-+]?[0-9] regex does not match!");

1540

1542 Out << StrVal;

1543 return;

1544 }

1545 }

1546

1547

1548

1549

1550

1551 static_assert(sizeof(double) == sizeof(uint64_t),

1552 "assuming that double is 64 bits!");

1554

1555

1556

1557 if (!isDouble) {

1558

1559

1562 &ignored);

1563 if (IsSNAN) {

1565 apf =

1567 }

1568 }

1569

1571 return;

1572 }

1573

1574

1575

1576

1577 Out << "0x";

1580 Out << 'K';

1582 true);

1584 true);

1586 Out << 'L';

1588 true);

1590 true);

1592 Out << 'M';

1594 true);

1596 true);

1598 Out << 'H';

1600 true);

1602 Out << 'R';

1604 true);

1605 } else

1607}

1608

1610 AsmWriterContext &WriterCtx) {

1612 Type *Ty = CI->getType();

1613

1614 if (Ty->isVectorTy()) {

1615 Out << "splat (";

1616 WriterCtx.TypePrinter->print(Ty->getScalarType(), Out);

1617 Out << " ";

1618 }

1619

1620 if (Ty->getScalarType()->isIntegerTy(1))

1621 Out << (CI->getZExtValue() ? "true" : "false");

1622 else

1623 Out << CI->getValue();

1624

1625 if (Ty->isVectorTy())

1626 Out << ")";

1627

1628 return;

1629 }

1630

1632 Type *Ty = CFP->getType();

1633

1634 if (Ty->isVectorTy()) {

1635 Out << "splat (";

1636 WriterCtx.TypePrinter->print(Ty->getScalarType(), Out);

1637 Out << " ";

1638 }

1639

1641

1642 if (Ty->isVectorTy())

1643 Out << ")";

1644

1645 return;

1646 }

1647

1649 Out << "zeroinitializer";

1650 return;

1651 }

1652

1654 Out << "blockaddress(";

1656 Out << ", ";

1658 Out << ")";

1659 return;

1660 }

1661

1663 Out << "dso_local_equivalent ";

1665 return;

1666 }

1667

1669 Out << "no_cfi ";

1671 return;

1672 }

1673

1675 Out << "ptrauth (";

1676

1677

1678 unsigned NumOpsToWrite = 2;

1679 if (!CPA->getOperand(2)->isNullValue())

1680 NumOpsToWrite = 3;

1681 if (!CPA->getOperand(3)->isNullValue())

1682 NumOpsToWrite = 4;

1683 if (!CPA->getOperand(4)->isNullValue())

1684 NumOpsToWrite = 5;

1685

1687 for (unsigned i = 0, e = NumOpsToWrite; i != e; ++i) {

1688 Out << LS;

1690 true);

1691 }

1692 Out << ')';

1693 return;

1694 }

1695

1697 Out << '[';

1699 for (const Value *Op : CA->operands()) {

1700 Out << LS;

1702 }

1703 Out << ']';

1704 return;

1705 }

1706

1708

1709

1710 if (CA->isString()) {

1711 Out << "c\"";

1713 Out << '"';

1714 return;

1715 }

1716

1717 Out << '[';

1719 for (uint64_t i = 0, e = CA->getNumElements(); i != e; ++i) {

1720 Out << LS;

1722 true);

1723 }

1724 Out << ']';

1725 return;

1726 }

1727

1729 if (CS->getType()->isPacked())

1730 Out << '<';

1731 Out << '{';

1732 if (CS->getNumOperands() != 0) {

1733 Out << ' ';

1735 for (const Value *Op : CS->operands()) {

1736 Out << LS;

1738 }

1739 Out << ' ';

1740 }

1741 Out << '}';

1742 if (CS->getType()->isPacked())

1743 Out << '>';

1744 return;

1745 }

1746

1749

1750

1751

1752

1753

1754

1757 Out << "splat (";

1759 Out << ')';

1760 return;

1761 }

1762 }

1763

1764 Out << '<';

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

1767 Out << LS;

1769 true);

1770 }

1771 Out << '>';

1772 return;

1773 }

1774

1776 Out << "null";

1777 return;

1778 }

1779

1781 Out << "none";

1782 return;

1783 }

1784

1786 Out << "poison";

1787 return;

1788 }

1789

1791 Out << "undef";

1792 return;

1793 }

1794

1796

1797

1798

1799

1800

1801 if (CE->getOpcode() == Instruction::ShuffleVector) {

1802 if (auto *SplatVal = CE->getSplatValue()) {

1804 Out << "splat (";

1806 Out << ')';

1807 return;

1808 }

1809 }

1810 }

1811

1812 Out << CE->getOpcodeName();

1814 Out << " (";

1815

1817 WriterCtx.TypePrinter->print(GEP->getSourceElementType(), Out);

1818 Out << ", ";

1819 }

1820

1822 for (const Value *Op : CE->operands()) {

1823 Out << LS;

1825 }

1826

1827 if (CE->isCast()) {

1828 Out << " to ";

1829 WriterCtx.TypePrinter->print(CE->getType(), Out);

1830 }

1831

1832 if (CE->getOpcode() == Instruction::ShuffleVector)

1834

1835 Out << ')';

1836 return;

1837 }

1838

1839 Out << "";

1840}

1841

1843 AsmWriterContext &WriterCtx) {

1844 Out << "!{";

1846 for (const Metadata *MD : Node->operands()) {

1847 Out << LS;

1848 if (!MD) {

1849 Out << "null";

1851 Value *V = MDV->getValue();

1853 } else {

1855 WriterCtx.onWriteMetadataAsOperand(MD);

1856 }

1857 }

1858

1859 Out << "}";

1860}

1861

1862namespace {

1863

1864struct MDFieldPrinter {

1865 raw_ostream &Out;

1866 ListSeparator FS;

1867 AsmWriterContext &WriterCtx;

1868

1869 explicit MDFieldPrinter(raw_ostream &Out)

1870 : Out(Out), WriterCtx(AsmWriterContext::getEmpty()) {}

1871 MDFieldPrinter(raw_ostream &Out, AsmWriterContext &Ctx)

1872 : Out(Out), WriterCtx(Ctx) {}

1873

1874 void printTag(const DINode *N);

1875 void printMacinfoType(const DIMacroNode *N);

1876 void printChecksum(const DIFile::ChecksumInfo &N);

1877 void printString(StringRef Name, StringRef Value,

1878 bool ShouldSkipEmpty = true);

1879 void printMetadata(StringRef Name, const Metadata *MD,

1880 bool ShouldSkipNull = true);

1881 void printMetadataOrInt(StringRef Name, const Metadata *MD, bool IsUnsigned,

1882 bool ShouldSkipZero = true);

1883 template

1884 void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);

1885 void printAPInt(StringRef Name, const APInt &Int, bool IsUnsigned,

1886 bool ShouldSkipZero);

1887 void printBool(StringRef Name, bool Value,

1888 std::optional Default = std::nullopt);

1889 void printDIFlags(StringRef Name, DINode::DIFlags Flags);

1891 template <class IntTy, class Stringifier>

1892 void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,

1893 bool ShouldSkipZero = true);

1895 void printNameTableKind(StringRef Name,

1898};

1899

1900}

1901

1902void MDFieldPrinter::printTag(const DINode *N) {

1903 Out << FS << "tag: ";

1905 if ( Tag .empty())

1906 Out << Tag;

1907 else

1908 Out << N->getTag();

1909}

1910

1911void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {

1912 Out << FS << "type: ";

1914 if ( Type .empty())

1915 Out << Type;

1916 else

1917 Out << N->getMacinfoType();

1918}

1919

1920void MDFieldPrinter::printChecksum(

1923 printString("checksum", Checksum.Value, false);

1924}

1925

1927 bool ShouldSkipEmpty) {

1928 if (ShouldSkipEmpty && Value.empty())

1929 return;

1930

1931 Out << FS << Name << ": \"";

1933 Out << "\"";

1934}

1935

1937 AsmWriterContext &WriterCtx) {

1938 if (!MD) {

1939 Out << "null";

1940 return;

1941 }

1943 WriterCtx.onWriteMetadataAsOperand(MD);

1944}

1945

1946void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,

1947 bool ShouldSkipNull) {

1948 if (ShouldSkipNull && !MD)

1949 return;

1950

1951 Out << FS << Name << ": ";

1953}

1954

1955void MDFieldPrinter::printMetadataOrInt(StringRef Name, const Metadata *MD,

1956 bool IsUnsigned, bool ShouldSkipZero) {

1957 if (!MD)

1958 return;

1959

1962 if (IsUnsigned)

1963 printInt(Name, CV->getZExtValue(), ShouldSkipZero);

1964 else

1965 printInt(Name, CV->getSExtValue(), ShouldSkipZero);

1966 } else

1967 printMetadata(Name, MD);

1968}

1969

1970template

1971void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {

1972 if (ShouldSkipZero && Int )

1973 return;

1974

1975 Out << FS << Name << ": " << Int;

1976}

1977

1978void MDFieldPrinter::printAPInt(StringRef Name, const APInt &Int,

1979 bool IsUnsigned, bool ShouldSkipZero) {

1980 if (ShouldSkipZero && Int.isZero())

1981 return;

1982

1983 Out << FS << Name << ": ";

1984 Int.print(Out, !IsUnsigned);

1985}

1986

1987void MDFieldPrinter::printBool(StringRef Name, bool Value,

1988 std::optional Default) {

1990 return;

1991 Out << FS << Name << ": " << (Value ? "true" : "false");

1992}

1993

1995 if (!Flags)

1996 return;

1997

1998 Out << FS << Name << ": ";

1999

2002

2004 for (auto F : SplitFlags) {

2006 assert(!StringF.empty() && "Expected valid flag");

2007 Out << FlagsFS << StringF;

2008 }

2009 if (Extra || SplitFlags.empty())

2010 Out << FlagsFS << Extra;

2011}

2012

2013void MDFieldPrinter::printDISPFlags(StringRef Name,

2015

2016

2017 Out << FS << Name << ": ";

2018

2019 if (!Flags) {

2020 Out << 0;

2021 return;

2022 }

2023

2026

2028 for (auto F : SplitFlags) {

2030 assert(!StringF.empty() && "Expected valid flag");

2031 Out << FlagsFS << StringF;

2032 }

2033 if (Extra || SplitFlags.empty())

2034 Out << FlagsFS << Extra;

2035}

2036

2037void MDFieldPrinter::printEmissionKind(StringRef Name,

2040}

2041

2042void MDFieldPrinter::printNameTableKind(StringRef Name,

2045 return;

2047}

2048

2049void MDFieldPrinter::printFixedPointKind(StringRef Name,

2052}

2053

2054template <class IntTy, class Stringifier>

2055void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,

2056 Stringifier toString, bool ShouldSkipZero) {

2057 if (ShouldSkipZero && Value )

2058 return;

2059

2060 Out << FS << Name << ": ";

2062 if (!S.empty())

2063 Out << S;

2064 else

2066}

2067

2069 AsmWriterContext &WriterCtx) {

2070 Out << "!GenericDINode(";

2071 MDFieldPrinter Printer(Out, WriterCtx);

2073 Printer.printString("header", N->getHeader());

2074 if (N->getNumDwarfOperands()) {

2075 Out << Printer.FS << "operands: {";

2077 for (auto &I : N->dwarf_operands()) {

2078 Out << IFS;

2080 }

2081 Out << "}";

2082 }

2083 Out << ")";

2084}

2085

2087 AsmWriterContext &WriterCtx) {

2088 Out << "!DILocation(";

2089 MDFieldPrinter Printer(Out, WriterCtx);

2090

2091 Printer.printInt("line", DL->getLine(), false);

2092 Printer.printInt("column", DL->getColumn());

2093 Printer.printMetadata("scope", DL->getRawScope(), false);

2094 Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());

2095 Printer.printBool("isImplicitCode", DL->isImplicitCode(),

2096 false);

2097 Printer.printInt("atomGroup", DL->getAtomGroup());

2098 Printer.printInt<unsigned>("atomRank", DL->getAtomRank());

2099 Out << ")";

2100}

2101

2103 AsmWriterContext &WriterCtx) {

2104 Out << "!DIAssignID()";

2105 MDFieldPrinter Printer(Out, WriterCtx);

2106}

2107

2109 AsmWriterContext &WriterCtx) {

2110 Out << "!DISubrange(";

2111 MDFieldPrinter Printer(Out, WriterCtx);

2112

2113 Printer.printMetadataOrInt("count", N->getRawCountNode(),

2114 false,

2115 false);

2116

2117

2118

2119 Printer.printMetadataOrInt("lowerBound", N->getRawLowerBound(),

2120 false,

2121 false);

2122 Printer.printMetadataOrInt("upperBound", N->getRawUpperBound(),

2123 false,

2124 false);

2125 Printer.printMetadataOrInt("stride", N->getRawStride(),

2126 false,

2127 false);

2128

2129 Out << ")";

2130}

2131

2133 AsmWriterContext &WriterCtx) {

2134 Out << "!DIGenericSubrange(";

2135 MDFieldPrinter Printer(Out, WriterCtx);

2136

2137 auto GetConstant = [&](Metadata *Bound) -> std::optional<int64_t> {

2139 if (!BE)

2140 return std::nullopt;

2141 if (BE->isConstant() &&

2143 *BE->isConstant()) {

2144 return static_cast<int64_t>(BE->getElement(1));

2145 }

2146 return std::nullopt;

2147 };

2148

2149 auto *Count = N->getRawCountNode();

2150 if (auto ConstantCount = GetConstant(Count))

2151 Printer.printInt("count", *ConstantCount,

2152 false);

2153 else

2154 Printer.printMetadata("count", Count, true);

2155

2156 auto *LBound = N->getRawLowerBound();

2157 if (auto ConstantLBound = GetConstant(LBound))

2158 Printer.printInt("lowerBound", *ConstantLBound,

2159 false);

2160 else

2161 Printer.printMetadata("lowerBound", LBound, true);

2162

2163 auto *UBound = N->getRawUpperBound();

2164 if (auto ConstantUBound = GetConstant(UBound))

2165 Printer.printInt("upperBound", *ConstantUBound,

2166 false);

2167 else

2168 Printer.printMetadata("upperBound", UBound, true);

2169

2170 auto *Stride = N->getRawStride();

2171 if (auto ConstantStride = GetConstant(Stride))

2172 Printer.printInt("stride", *ConstantStride,

2173 false);

2174 else

2175 Printer.printMetadata("stride", Stride, true);

2176

2177 Out << ")";

2178}

2179

2181 AsmWriterContext &) {

2182 Out << "!DIEnumerator(";

2183 MDFieldPrinter Printer(Out);

2184 Printer.printString("name", N->getName(), false);

2185 Printer.printAPInt("value", N->getValue(), N->isUnsigned(),

2186 false);

2187 if (N->isUnsigned())

2188 Printer.printBool("isUnsigned", true);

2189 Out << ")";

2190}

2191

2193 AsmWriterContext &WriterCtx) {

2194 Out << "!DIBasicType(";

2195 MDFieldPrinter Printer(Out, WriterCtx);

2196 if (N->getTag() != dwarf::DW_TAG_base_type)

2198 Printer.printString("name", N->getName());

2199 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);

2200 Printer.printInt("align", N->getAlignInBits());

2201 Printer.printInt("dataSize", N->getDataSizeInBits());

2202 Printer.printDwarfEnum("encoding", N->getEncoding(),

2204 Printer.printInt("num_extra_inhabitants", N->getNumExtraInhabitants());

2205 Printer.printDIFlags("flags", N->getFlags());

2206 Out << ")";

2207}

2208

2210 AsmWriterContext &WriterCtx) {

2211 Out << "!DIFixedPointType(";

2212 MDFieldPrinter Printer(Out, WriterCtx);

2213 if (N->getTag() != dwarf::DW_TAG_base_type)

2215 Printer.printString("name", N->getName());

2216 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);

2217 Printer.printInt("align", N->getAlignInBits());

2218 Printer.printDwarfEnum("encoding", N->getEncoding(),

2220 Printer.printDIFlags("flags", N->getFlags());

2221 Printer.printFixedPointKind("kind", N->getKind());

2222 if (N->isRational()) {

2223 bool IsUnsigned = ->isSigned();

2224 Printer.printAPInt("numerator", N->getNumerator(), IsUnsigned, false);

2225 Printer.printAPInt("denominator", N->getDenominator(), IsUnsigned, false);

2226 } else {

2227 Printer.printInt("factor", N->getFactor());

2228 }

2229 Out << ")";

2230}

2231

2233 AsmWriterContext &WriterCtx) {

2234 Out << "!DIStringType(";

2235 MDFieldPrinter Printer(Out, WriterCtx);

2236 if (N->getTag() != dwarf::DW_TAG_string_type)

2238 Printer.printString("name", N->getName());

2239 Printer.printMetadata("stringLength", N->getRawStringLength());

2240 Printer.printMetadata("stringLengthExpression", N->getRawStringLengthExp());

2241 Printer.printMetadata("stringLocationExpression",

2242 N->getRawStringLocationExp());

2243 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);

2244 Printer.printInt("align", N->getAlignInBits());

2245 Printer.printDwarfEnum("encoding", N->getEncoding(),

2247 Out << ")";

2248}

2249

2251 AsmWriterContext &WriterCtx) {

2252 Out << "!DIDerivedType(";

2253 MDFieldPrinter Printer(Out, WriterCtx);

2255 Printer.printString("name", N->getName());

2256 Printer.printMetadata("scope", N->getRawScope());

2257 Printer.printMetadata("file", N->getRawFile());

2258 Printer.printInt("line", N->getLine());

2259 Printer.printMetadata("baseType", N->getRawBaseType(),

2260 false);

2261 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);

2262 Printer.printInt("align", N->getAlignInBits());

2263 Printer.printMetadataOrInt("offset", N->getRawOffsetInBits(), true);

2264 Printer.printDIFlags("flags", N->getFlags());

2265 Printer.printMetadata("extraData", N->getRawExtraData());

2266 if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())

2267 Printer.printInt("dwarfAddressSpace", *DWARFAddressSpace,

2268 false);

2269 Printer.printMetadata("annotations", N->getRawAnnotations());

2270 if (auto PtrAuthData = N->getPtrAuthData()) {

2271 Printer.printInt("ptrAuthKey", PtrAuthData->key());

2272 Printer.printBool("ptrAuthIsAddressDiscriminated",

2273 PtrAuthData->isAddressDiscriminated());

2274 Printer.printInt("ptrAuthExtraDiscriminator",

2275 PtrAuthData->extraDiscriminator());

2276 Printer.printBool("ptrAuthIsaPointer", PtrAuthData->isaPointer());

2277 Printer.printBool("ptrAuthAuthenticatesNullValues",

2278 PtrAuthData->authenticatesNullValues());

2279 }

2280 Out << ")";

2281}

2282

2284 AsmWriterContext &WriterCtx) {

2285 Out << "!DISubrangeType(";

2286 MDFieldPrinter Printer(Out, WriterCtx);

2287 Printer.printString("name", N->getName());

2288 Printer.printMetadata("scope", N->getRawScope());

2289 Printer.printMetadata("file", N->getRawFile());

2290 Printer.printInt("line", N->getLine());

2291 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);

2292 Printer.printInt("align", N->getAlignInBits());

2293 Printer.printDIFlags("flags", N->getFlags());

2294 Printer.printMetadata("baseType", N->getRawBaseType(),

2295 false);

2296 Printer.printMetadata("lowerBound", N->getRawLowerBound());

2297 Printer.printMetadata("upperBound", N->getRawUpperBound());

2298 Printer.printMetadata("stride", N->getRawStride());

2299 Printer.printMetadata("bias", N->getRawBias());

2300 Out << ")";

2301}

2302

2304 AsmWriterContext &WriterCtx) {

2305 Out << "!DICompositeType(";

2306 MDFieldPrinter Printer(Out, WriterCtx);

2308 Printer.printString("name", N->getName());

2309 Printer.printMetadata("scope", N->getRawScope());

2310 Printer.printMetadata("file", N->getRawFile());

2311 Printer.printInt("line", N->getLine());

2312 Printer.printMetadata("baseType", N->getRawBaseType());

2313 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);

2314 Printer.printInt("align", N->getAlignInBits());

2315 Printer.printMetadataOrInt("offset", N->getRawOffsetInBits(), true);

2316 Printer.printInt("num_extra_inhabitants", N->getNumExtraInhabitants());

2317 Printer.printDIFlags("flags", N->getFlags());

2318 Printer.printMetadata("elements", N->getRawElements());

2319 Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),

2321 Printer.printMetadata("vtableHolder", N->getRawVTableHolder());

2322 Printer.printMetadata("templateParams", N->getRawTemplateParams());

2323 Printer.printString("identifier", N->getIdentifier());

2324 Printer.printMetadata("discriminator", N->getRawDiscriminator());

2325 Printer.printMetadata("dataLocation", N->getRawDataLocation());

2326 Printer.printMetadata("associated", N->getRawAssociated());

2327 Printer.printMetadata("allocated", N->getRawAllocated());

2328 if (auto *RankConst = N->getRankConst())

2329 Printer.printInt("rank", RankConst->getSExtValue(),

2330 false);

2331 else

2332 Printer.printMetadata("rank", N->getRawRank(), true);

2333 Printer.printMetadata("annotations", N->getRawAnnotations());

2334 if (auto *Specification = N->getRawSpecification())

2335 Printer.printMetadata("specification", Specification);

2336

2337 if (auto EnumKind = N->getEnumKind())

2339 false);

2340

2341 Printer.printMetadata("bitStride", N->getRawBitStride());

2342 Out << ")";

2343}

2344

2346 AsmWriterContext &WriterCtx) {

2347 Out << "!DISubroutineType(";

2348 MDFieldPrinter Printer(Out, WriterCtx);

2349 Printer.printDIFlags("flags", N->getFlags());

2351 Printer.printMetadata("types", N->getRawTypeArray(),

2352 false);

2353 Out << ")";

2354}

2355

2357 Out << "!DIFile(";

2358 MDFieldPrinter Printer(Out);

2359 Printer.printString("filename", N->getFilename(),

2360 false);

2361 Printer.printString("directory", N->getDirectory(),

2362 false);

2363

2364 if (N->getChecksum())

2365 Printer.printChecksum(*N->getChecksum());

2366 if (N->getSource())

2367 Printer.printString("source", *N->getSource(),

2368 false);

2369 Out << ")";

2370}

2371

2373 AsmWriterContext &WriterCtx) {

2374 Out << "!DICompileUnit(";

2375 MDFieldPrinter Printer(Out, WriterCtx);

2376

2378

2381 "sourceLanguageName",

2384 false);

2385

2387 true);

2388 } else {

2390 false);

2391 }

2392

2393 Printer.printMetadata("file", N->getRawFile(), false);

2394 Printer.printString("producer", N->getProducer());

2395 Printer.printBool("isOptimized", N->isOptimized());

2396 Printer.printString("flags", N->getFlags());

2397 Printer.printInt("runtimeVersion", N->getRuntimeVersion(),

2398 false);

2399 Printer.printString("splitDebugFilename", N->getSplitDebugFilename());

2400 Printer.printEmissionKind("emissionKind", N->getEmissionKind());

2401 Printer.printMetadata("enums", N->getRawEnumTypes());

2402 Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());

2403 Printer.printMetadata("globals", N->getRawGlobalVariables());

2404 Printer.printMetadata("imports", N->getRawImportedEntities());

2405 Printer.printMetadata("macros", N->getRawMacros());

2406 Printer.printInt("dwoId", N->getDWOId());

2407 Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);

2408 Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),

2409 false);

2410 Printer.printNameTableKind("nameTableKind", N->getNameTableKind());

2411 Printer.printBool("rangesBaseAddress", N->getRangesBaseAddress(), false);

2412 Printer.printString("sysroot", N->getSysRoot());

2413 Printer.printString("sdk", N->getSDK());

2414 Out << ")";

2415}

2416

2418 AsmWriterContext &WriterCtx) {

2419 Out << "!DISubprogram(";

2420 MDFieldPrinter Printer(Out, WriterCtx);

2421 Printer.printString("name", N->getName());

2422 Printer.printString("linkageName", N->getLinkageName());

2423 Printer.printMetadata("scope", N->getRawScope(), false);

2424 Printer.printMetadata("file", N->getRawFile());

2425 Printer.printInt("line", N->getLine());

2426 Printer.printMetadata("type", N->getRawType());

2427 Printer.printInt("scopeLine", N->getScopeLine());

2428 Printer.printMetadata("containingType", N->getRawContainingType());

2429 if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||

2430 N->getVirtualIndex() != 0)

2431 Printer.printInt("virtualIndex", N->getVirtualIndex(), false);

2432 Printer.printInt("thisAdjustment", N->getThisAdjustment());

2433 Printer.printDIFlags("flags", N->getFlags());

2434 Printer.printDISPFlags("spFlags", N->getSPFlags());

2435 Printer.printMetadata("unit", N->getRawUnit());

2436 Printer.printMetadata("templateParams", N->getRawTemplateParams());

2437 Printer.printMetadata("declaration", N->getRawDeclaration());

2438 Printer.printMetadata("retainedNodes", N->getRawRetainedNodes());

2439 Printer.printMetadata("thrownTypes", N->getRawThrownTypes());

2440 Printer.printMetadata("annotations", N->getRawAnnotations());

2441 Printer.printString("targetFuncName", N->getTargetFuncName());

2442 Printer.printBool("keyInstructions", N->getKeyInstructionsEnabled(), false);

2443 Out << ")";

2444}

2445

2447 AsmWriterContext &WriterCtx) {

2448 Out << "!DILexicalBlock(";

2449 MDFieldPrinter Printer(Out, WriterCtx);

2450 Printer.printMetadata("scope", N->getRawScope(), false);

2451 Printer.printMetadata("file", N->getRawFile());

2452 Printer.printInt("line", N->getLine());

2453 Printer.printInt("column", N->getColumn());

2454 Out << ")";

2455}

2456

2459 AsmWriterContext &WriterCtx) {

2460 Out << "!DILexicalBlockFile(";

2461 MDFieldPrinter Printer(Out, WriterCtx);

2462 Printer.printMetadata("scope", N->getRawScope(), false);

2463 Printer.printMetadata("file", N->getRawFile());

2464 Printer.printInt("discriminator", N->getDiscriminator(),

2465 false);

2466 Out << ")";

2467}

2468

2470 AsmWriterContext &WriterCtx) {

2471 Out << "!DINamespace(";

2472 MDFieldPrinter Printer(Out, WriterCtx);

2473 Printer.printString("name", N->getName());

2474 Printer.printMetadata("scope", N->getRawScope(), false);

2475 Printer.printBool("exportSymbols", N->getExportSymbols(), false);

2476 Out << ")";

2477}

2478

2480 AsmWriterContext &WriterCtx) {

2481 Out << "!DICommonBlock(";

2482 MDFieldPrinter Printer(Out, WriterCtx);

2483 Printer.printMetadata("scope", N->getRawScope(), false);

2484 Printer.printMetadata("declaration", N->getRawDecl(), false);

2485 Printer.printString("name", N->getName());

2486 Printer.printMetadata("file", N->getRawFile());

2487 Printer.printInt("line", N->getLineNo());

2488 Out << ")";

2489}

2490

2492 AsmWriterContext &WriterCtx) {

2493 Out << "!DIMacro(";

2494 MDFieldPrinter Printer(Out, WriterCtx);

2495 Printer.printMacinfoType(N);

2496 Printer.printInt("line", N->getLine());

2497 Printer.printString("name", N->getName());

2498 Printer.printString("value", N->getValue());

2499 Out << ")";

2500}

2501

2503 AsmWriterContext &WriterCtx) {

2504 Out << "!DIMacroFile(";

2505 MDFieldPrinter Printer(Out, WriterCtx);

2506 Printer.printInt("line", N->getLine());

2507 Printer.printMetadata("file", N->getRawFile(), false);

2508 Printer.printMetadata("nodes", N->getRawElements());

2509 Out << ")";

2510}

2511

2513 AsmWriterContext &WriterCtx) {

2514 Out << "!DIModule(";

2515 MDFieldPrinter Printer(Out, WriterCtx);

2516 Printer.printMetadata("scope", N->getRawScope(), false);

2517 Printer.printString("name", N->getName());

2518 Printer.printString("configMacros", N->getConfigurationMacros());

2519 Printer.printString("includePath", N->getIncludePath());

2520 Printer.printString("apinotes", N->getAPINotesFile());

2521 Printer.printMetadata("file", N->getRawFile());

2522 Printer.printInt("line", N->getLineNo());

2523 Printer.printBool("isDecl", N->getIsDecl(), false);

2524 Out << ")";

2525}

2526

2529 AsmWriterContext &WriterCtx) {

2530 Out << "!DITemplateTypeParameter(";

2531 MDFieldPrinter Printer(Out, WriterCtx);

2532 Printer.printString("name", N->getName());

2533 Printer.printMetadata("type", N->getRawType(), false);

2534 Printer.printBool("defaulted", N->isDefault(), false);

2535 Out << ")";

2536}

2537

2540 AsmWriterContext &WriterCtx) {

2541 Out << "!DITemplateValueParameter(";

2542 MDFieldPrinter Printer(Out, WriterCtx);

2543 if (N->getTag() != dwarf::DW_TAG_template_value_parameter)

2545 Printer.printString("name", N->getName());

2546 Printer.printMetadata("type", N->getRawType());

2547 Printer.printBool("defaulted", N->isDefault(), false);

2548 Printer.printMetadata("value", N->getValue(), false);

2549 Out << ")";

2550}

2551

2553 AsmWriterContext &WriterCtx) {

2554 Out << "!DIGlobalVariable(";

2555 MDFieldPrinter Printer(Out, WriterCtx);

2556 Printer.printString("name", N->getName());

2557 Printer.printString("linkageName", N->getLinkageName());

2558 Printer.printMetadata("scope", N->getRawScope(), false);

2559 Printer.printMetadata("file", N->getRawFile());

2560 Printer.printInt("line", N->getLine());

2561 Printer.printMetadata("type", N->getRawType());

2562 Printer.printBool("isLocal", N->isLocalToUnit());

2563 Printer.printBool("isDefinition", N->isDefinition());

2564 Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());

2565 Printer.printMetadata("templateParams", N->getRawTemplateParams());

2566 Printer.printInt("align", N->getAlignInBits());

2567 Printer.printMetadata("annotations", N->getRawAnnotations());

2568 Out << ")";

2569}

2570

2572 AsmWriterContext &WriterCtx) {

2573 Out << "!DILocalVariable(";

2574 MDFieldPrinter Printer(Out, WriterCtx);

2575 Printer.printString("name", N->getName());

2576 Printer.printInt("arg", N->getArg());

2577 Printer.printMetadata("scope", N->getRawScope(), false);

2578 Printer.printMetadata("file", N->getRawFile());

2579 Printer.printInt("line", N->getLine());

2580 Printer.printMetadata("type", N->getRawType());

2581 Printer.printDIFlags("flags", N->getFlags());

2582 Printer.printInt("align", N->getAlignInBits());

2583 Printer.printMetadata("annotations", N->getRawAnnotations());

2584 Out << ")";

2585}

2586

2588 AsmWriterContext &WriterCtx) {

2589 Out << "!DILabel(";

2590 MDFieldPrinter Printer(Out, WriterCtx);

2591 Printer.printMetadata("scope", N->getRawScope(), false);

2592 Printer.printString("name", N->getName());

2593 Printer.printMetadata("file", N->getRawFile());

2594 Printer.printInt("line", N->getLine());

2595 Printer.printInt("column", N->getColumn());

2596 Printer.printBool("isArtificial", N->isArtificial(), false);

2597 if (N->getCoroSuspendIdx())

2598 Printer.printInt("coroSuspendIdx", *N->getCoroSuspendIdx(),

2599 false);

2600 Out << ")";

2601}

2602

2604 AsmWriterContext &WriterCtx) {

2605 Out << "!DIExpression(";

2607 if (N->isValid()) {

2610 assert(!OpStr.empty() && "Expected valid opcode");

2611

2612 Out << FS << OpStr;

2614 Out << FS << Op.getArg(0);

2616 } else {

2617 for (unsigned A = 0, AE = Op.getNumArgs(); A != AE; ++A)

2618 Out << FS << Op.getArg(A);

2619 }

2620 }

2621 } else {

2622 for (const auto &I : N->getElements())

2623 Out << FS << I;

2624 }

2625 Out << ")";

2626}

2627

2629 AsmWriterContext &WriterCtx,

2630 bool FromValue = false) {

2632 "Unexpected DIArgList metadata outside of value argument");

2633 Out << "!DIArgList(";

2635 MDFieldPrinter Printer(Out, WriterCtx);

2636 for (const Metadata *Arg : N->getArgs()) {

2637 Out << FS;

2639 }

2640 Out << ")";

2641}

2642

2645 AsmWriterContext &WriterCtx) {

2646 Out << "!DIGlobalVariableExpression(";

2647 MDFieldPrinter Printer(Out, WriterCtx);

2648 Printer.printMetadata("var", N->getVariable());

2649 Printer.printMetadata("expr", N->getExpression());

2650 Out << ")";

2651}

2652

2654 AsmWriterContext &WriterCtx) {

2655 Out << "!DIObjCProperty(";

2656 MDFieldPrinter Printer(Out, WriterCtx);

2657 Printer.printString("name", N->getName());

2658 Printer.printMetadata("file", N->getRawFile());

2659 Printer.printInt("line", N->getLine());

2660 Printer.printString("setter", N->getSetterName());

2661 Printer.printString("getter", N->getGetterName());

2662 Printer.printInt("attributes", N->getAttributes());

2663 Printer.printMetadata("type", N->getRawType());

2664 Out << ")";

2665}

2666

2668 AsmWriterContext &WriterCtx) {

2669 Out << "!DIImportedEntity(";

2670 MDFieldPrinter Printer(Out, WriterCtx);

2672 Printer.printString("name", N->getName());

2673 Printer.printMetadata("scope", N->getRawScope(), false);

2674 Printer.printMetadata("entity", N->getRawEntity());

2675 Printer.printMetadata("file", N->getRawFile());

2676 Printer.printInt("line", N->getLine());

2677 Printer.printMetadata("elements", N->getRawElements());

2678 Out << ")";

2679}

2680

2682 AsmWriterContext &Ctx) {

2683 if (Node->isDistinct())

2684 Out << "distinct ";

2685 else if (Node->isTemporary())

2686 Out << "<temporary!> ";

2687

2688 switch (Node->getMetadataID()) {

2689 default:

2691#define HANDLE_MDNODE_LEAF(CLASS) \

2692 case Metadata::CLASS##Kind: \

2693 write##CLASS(Out, cast(Node), Ctx); \

2694 break;

2695#include "llvm/IR/Metadata.def"

2696 }

2697}

2698

2699

2700

2702 AsmWriterContext &WriterCtx,

2703 bool PrintType) {

2704 if (PrintType) {

2705 WriterCtx.TypePrinter->print(V->getType(), Out);

2706 Out << ' ';

2707 }

2708

2709 if (V->hasName()) {

2711 return;

2712 }

2713

2716 assert(WriterCtx.TypePrinter && "Constants require TypePrinting!");

2718 return;

2719 }

2720

2722 Out << "asm ";

2723 if (IA->hasSideEffects())

2724 Out << "sideeffect ";

2725 if (IA->isAlignStack())

2726 Out << "alignstack ";

2727

2729 Out << "inteldialect ";

2730 if (IA->canThrow())

2731 Out << "unwind ";

2732 Out << '"';

2734 Out << "\", \"";

2736 Out << '"';

2737 return;

2738 }

2739

2742 true);

2743 return;

2744 }

2745

2746 char Prefix = '%';

2747 int Slot;

2748 auto *Machine = WriterCtx.Machine;

2749

2752 Slot = Machine->getGlobalSlot(GV);

2753 Prefix = '@';

2754 } else {

2755 Slot = Machine->getLocalSlot(V);

2756

2757

2758

2759

2760 if (Slot == -1)

2762 Slot = Machine->getLocalSlot(V);

2764 }

2765 }

2767

2769 Slot = Machine->getGlobalSlot(GV);

2770 Prefix = '@';

2771 } else {

2772 Slot = Machine->getLocalSlot(V);

2773 }

2776 } else {

2777 Slot = -1;

2778 }

2779

2780 if (Slot != -1)

2781 Out << Prefix << Slot;

2782 else

2783 Out << "";

2784}

2785

2787 AsmWriterContext &WriterCtx,

2788 bool FromValue) {

2789

2790

2793 return;

2794 }

2797 return;

2798 }

2799

2801 std::unique_ptr MachineStorage;

2803 if (!WriterCtx.Machine) {

2804 MachineStorage = std::make_unique(WriterCtx.Context);

2805 WriterCtx.Machine = MachineStorage.get();

2806 }

2808 if (Slot == -1) {

2811 return;

2812 }

2813

2814

2815 Out << "<" << N << ">";

2816 } else

2817 Out << '!' << Slot;

2818 return;

2819 }

2820

2822 Out << "!\"";

2824 Out << '"';

2825 return;

2826 }

2827

2829 assert(WriterCtx.TypePrinter && "TypePrinter required for metadata values");

2831 "Unexpected function-local metadata outside of value argument");

2832

2834}

2835

2836namespace {

2837

2838class AssemblyWriter {

2839 formatted_raw_ostream &Out;

2840 const Module *TheModule = nullptr;

2841 const ModuleSummaryIndex *TheIndex = nullptr;

2842 std::unique_ptr SlotTrackerStorage;

2844 TypePrinting TypePrinter;

2845 AssemblyAnnotationWriter *AnnotationWriter = nullptr;

2846 SetVector<const Comdat *> Comdats;

2847 bool IsForDebug;

2848 bool ShouldPreserveUseListOrder;

2851

2853 DenseMap<const GlobalValueSummary *, GlobalValue::GUID> SummaryToGUIDMap;

2854

2855public:

2856

2857 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,

2858 AssemblyAnnotationWriter *AAW, bool IsForDebug,

2859 bool ShouldPreserveUseListOrder = false);

2860

2861 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,

2862 const ModuleSummaryIndex *Index, bool IsForDebug);

2863

2865 return AsmWriterContext(&TypePrinter, &Machine, TheModule);

2866 }

2867

2868 void printMDNodeBody(const MDNode *MD);

2869 void printNamedMDNode(const NamedMDNode *NMD);

2870

2871 void printModule(const Module *M);

2872

2873 void writeOperand(const Value *Op, bool PrintType);

2874 void writeParamOperand(const Value *Operand, AttributeSet Attrs);

2875 void writeOperandBundles(const CallBase *Call);

2876 void writeSyncScope(const LLVMContext &Context,

2878 void writeAtomic(const LLVMContext &Context,

2881 void writeAtomicCmpXchg(const LLVMContext &Context,

2885

2886 void writeAllMDNodes();

2887 void writeMDNode(unsigned Slot, const MDNode *Node);

2888 void writeAttribute(const Attribute &Attr, bool InAttrGroup = false);

2889 void writeAttributeSet(const AttributeSet &AttrSet, bool InAttrGroup = false);

2890 void writeAllAttributeGroups();

2891

2892 void printTypeIdentities();

2893 void printGlobal(const GlobalVariable *GV);

2894 void printAlias(const GlobalAlias *GA);

2895 void printIFunc(const GlobalIFunc *GI);

2896 void printComdat(const Comdat *C);

2897 void printFunction(const Function *F);

2898 void printArgument(const Argument *FA, AttributeSet Attrs);

2900 void printInstructionLine(const Instruction &I);

2901 void printInstruction(const Instruction &I);

2902 void printDbgMarker(const DbgMarker &DPI);

2903 void printDbgVariableRecord(const DbgVariableRecord &DVR);

2904 void printDbgLabelRecord(const DbgLabelRecord &DLR);

2905 void printDbgRecord(const DbgRecord &DR);

2906 void printDbgRecordLine(const DbgRecord &DR);

2907

2908 void printUseListOrder(const Value *V, ArrayRef Shuffle);

2909 void printUseLists(const Function *F);

2910

2911 void printModuleSummaryIndex();

2912 void printSummaryInfo(unsigned Slot, const ValueInfo &VI);

2913 void printSummary(const GlobalValueSummary &Summary);

2914 void printAliasSummary(const AliasSummary *AS);

2915 void printGlobalVarSummary(const GlobalVarSummary *GS);

2916 void printFunctionSummary(const FunctionSummary *FS);

2917 void printTypeIdSummary(const TypeIdSummary &TIS);

2919 void printTypeTestResolution(const TypeTestResolution &TTRes);

2920 void printArgs(ArrayRef<uint64_t> Args);

2921 void printWPDRes(const WholeProgramDevirtResolution &WPDRes);

2922 void printTypeIdInfo(const FunctionSummary::TypeIdInfo &TIDInfo);

2923 void printVFuncId(const FunctionSummary::VFuncId VFId);

2925 const char *Tag);

2927 const char *Tag);

2928

2929private:

2930

2931 void printMetadataAttachments(

2932 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,

2933 StringRef Separator);

2934

2935

2936

2937 void printInfoComment(const Value &V, bool isMaterializable = false);

2938

2939

2940

2941 void printGCRelocateComment(const GCRelocateInst &Relocate);

2942};

2943

2944}

2945

2948 bool IsForDebug, bool ShouldPreserveUseListOrder)

2949 : Out(o), TheModule(M), Machine(Mac), TypePrinter(M), AnnotationWriter(AAW),

2950 IsForDebug(IsForDebug),

2951 ShouldPreserveUseListOrder(

2954 : ShouldPreserveUseListOrder) {

2955 if (!TheModule)

2956 return;

2957 for (const GlobalObject &GO : TheModule->global_objects())

2959 Comdats.insert(C);

2960}

2961

2964 : Out(o), TheIndex(Index), Machine(Mac), TypePrinter(nullptr),

2965 IsForDebug(IsForDebug),

2967

2968void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {

2969 if (!Operand) {

2970 Out << "<null operand!>";

2971 return;

2972 }

2975}

2976

2977void AssemblyWriter::writeSyncScope(const LLVMContext &Context,

2979 switch (SSID) {

2981 break;

2982 }

2983 default: {

2984 if (SSNs.empty())

2985 Context.getSyncScopeNames(SSNs);

2986

2987 Out << " syncscope(\"";

2989 Out << "\")";

2990 break;

2991 }

2992 }

2993}

2994

2995void AssemblyWriter::writeAtomic(const LLVMContext &Context,

2998 if (Ordering == AtomicOrdering::NotAtomic)

2999 return;

3000

3001 writeSyncScope(Context, SSID);

3003}

3004

3005void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,

3009 assert(SuccessOrdering != AtomicOrdering::NotAtomic &&

3010 FailureOrdering != AtomicOrdering::NotAtomic);

3011

3012 writeSyncScope(Context, SSID);

3013 Out << " " << toIRString(SuccessOrdering);

3014 Out << " " << toIRString(FailureOrdering);

3015}

3016

3017void AssemblyWriter::writeParamOperand(const Value *Operand,

3018 AttributeSet Attrs) {

3019 if (!Operand) {

3020 Out << "<null operand!>";

3021 return;

3022 }

3023

3024

3025 TypePrinter.print(Operand->getType(), Out);

3026

3027 if (Attrs.hasAttributes()) {

3028 Out << ' ';

3029 writeAttributeSet(Attrs);

3030 }

3031 Out << ' ';

3032

3035}

3036

3037void AssemblyWriter::writeOperandBundles(const CallBase *Call) {

3039 return;

3040

3041 Out << " [ ";

3042

3043 ListSeparator LS;

3046

3047 Out << LS << '"';

3049 Out << '"';

3050

3051 Out << '(';

3052

3053 ListSeparator InnerLS;

3055 for (const auto &Input : BU.Inputs) {

3056 Out << InnerLS;

3057 if (Input == nullptr)

3058 Out << "<null operand bundle!>";

3059 else

3061 }

3062

3063 Out << ')';

3064 }

3065

3066 Out << " ]";

3067}

3068

3069void AssemblyWriter::printModule(const Module *M) {

3070 Machine.initializeIfNeeded();

3071

3072 if (ShouldPreserveUseListOrder)

3074

3075 if (->getModuleIdentifier().empty() &&

3076

3077

3078 M->getModuleIdentifier().find('\n') == std:🧵:npos)

3079 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";

3080

3081 if (->getSourceFileName().empty()) {

3082 Out << "source_filename = \"";

3084 Out << "\"\n";

3085 }

3086

3087 const std::string &DL = M->getDataLayoutStr();

3089 Out << "target datalayout = \"" << DL << "\"\n";

3090 if (->getTargetTriple().empty())

3091 Out << "target triple = \"" << M->getTargetTriple().str() << "\"\n";

3092

3093 if (->getModuleInlineAsm().empty()) {

3094 Out << '\n';

3095

3096

3097 StringRef Asm = M->getModuleInlineAsm();

3098 do {

3099 StringRef Front;

3100 std::tie(Front, Asm) = Asm.split('\n');

3101

3102

3103

3104 Out << "module asm \"";

3106 Out << "\"\n";

3107 } while ( Asm .empty());

3108 }

3109

3110 printTypeIdentities();

3111

3112

3113 if (!Comdats.empty())

3114 Out << '\n';

3115 for (const Comdat *C : Comdats) {

3116 printComdat(C);

3117 if (C != Comdats.back())

3118 Out << '\n';

3119 }

3120

3121

3122 if (->global_empty()) Out << '\n';

3123 for (const GlobalVariable &GV : M->globals()) {

3124 printGlobal(&GV); Out << '\n';

3125 }

3126

3127

3128 if (->alias_empty()) Out << "\n";

3129 for (const GlobalAlias &GA : M->aliases())

3130 printAlias(&GA);

3131

3132

3133 if (->ifunc_empty()) Out << "\n";

3134 for (const GlobalIFunc &GI : M->ifuncs())

3135 printIFunc(&GI);

3136

3137

3138 for (const Function &F : *M) {

3139 Out << '\n';

3140 printFunction(&F);

3141 }

3142

3143

3144 printUseLists(nullptr);

3145

3146

3147 if ( Machine .as_empty()) {

3148 Out << '\n';

3149 writeAllAttributeGroups();

3150 }

3151

3152

3153 if (->named_metadata_empty()) Out << '\n';

3154

3155 for (const NamedMDNode &Node : M->named_metadata())

3156 printNamedMDNode(&Node);

3157

3158

3159 if ( Machine .mdn_empty()) {

3160 Out << '\n';

3161 writeAllMDNodes();

3162 }

3163}

3164

3165void AssemblyWriter::printModuleSummaryIndex() {

3167 int NumSlots = Machine.initializeIndexIfNeeded();

3168

3169 Out << "\n";

3170

3171

3172

3173 std::vector<std::pair<std::string, ModuleHash>> moduleVec;

3174 std::string RegularLTOModuleName =

3176 moduleVec.resize(TheIndex->modulePaths().size());

3177 for (auto &[ModPath, ModHash] : TheIndex->modulePaths())

3178 moduleVec[Machine.getModulePathSlot(ModPath)] = std::make_pair(

3179

3180

3181 ModPath.empty() ? RegularLTOModuleName : std::string(ModPath), ModHash);

3182

3183 unsigned i = 0;

3184 for (auto &ModPair : moduleVec) {

3185 Out << "^" << i++ << " = module: (";

3186 Out << "path: \"";

3188 Out << "\", hash: (";

3189 ListSeparator FS;

3190 for (auto Hash : ModPair.second)

3191 Out << FS << Hash;

3192 Out << "))\n";

3193 }

3194

3195

3196

3197 for (auto &GlobalList : *TheIndex) {

3198 auto GUID = GlobalList.first;

3199 for (auto &Summary : GlobalList.second.getSummaryList())

3201 }

3202

3203

3204 for (auto &GlobalList : *TheIndex) {

3205 auto GUID = GlobalList.first;

3206 auto VI = TheIndex->getValueInfo(GlobalList);

3207 printSummaryInfo(Machine.getGUIDSlot(GUID), VI);

3208 }

3209

3210

3211 for (const auto &TID : TheIndex->typeIds()) {

3212 Out << "^" << Machine.getTypeIdSlot(TID.second.first)

3213 << " = typeid: (name: \"" << TID.second.first << "\"";

3214 printTypeIdSummary(TID.second.second);

3215 Out << ") ; guid = " << TID.first << "\n";

3216 }

3217

3218

3219 for (auto &TId : TheIndex->typeIdCompatibleVtableMap()) {

3221 Out << "^" << Machine.getTypeIdCompatibleVtableSlot(TId.first)

3222 << " = typeidCompatibleVTable: (name: \"" << TId.first << "\"";

3223 printTypeIdCompatibleVtableSummary(TId.second);

3224 Out << ") ; guid = " << GUID << "\n";

3225 }

3226

3227

3228 if (TheIndex->getFlags()) {

3229 Out << "^" << NumSlots << " = flags: " << TheIndex->getFlags() << "\n";

3230 ++NumSlots;

3231 }

3232

3233 Out << "^" << NumSlots << " = blockcount: " << TheIndex->getBlockCount()

3234 << "\n";

3235}

3236

3237static const char *

3239 switch (K) {

3241 return "indir";

3243 return "singleImpl";

3245 return "branchFunnel";

3246 }

3247 llvm_unreachable("invalid WholeProgramDevirtResolution kind");

3248}

3249

3252 switch (K) {

3254 return "indir";

3256 return "uniformRetVal";

3258 return "uniqueRetVal";

3260 return "virtualConstProp";

3261 }

3262 llvm_unreachable("invalid WholeProgramDevirtResolution::ByArg kind");

3263}

3264

3266 switch (K) {

3268 return "unknown";

3270 return "unsat";

3272 return "byteArray";

3274 return "inline";

3276 return "single";

3278 return "allOnes";

3279 }

3281}

3282

3283void AssemblyWriter::printTypeTestResolution(const TypeTestResolution &TTRes) {

3286

3287

3288

3290 Out << ", alignLog2: " << TTRes.AlignLog2;

3292 Out << ", sizeM1: " << TTRes.SizeM1;

3294

3295 Out << ", bitMask: " << (unsigned)TTRes.BitMask;

3297 Out << ", inlineBits: " << TTRes.InlineBits;

3298

3299 Out << ")";

3300}

3301

3302void AssemblyWriter::printTypeIdSummary(const TypeIdSummary &TIS) {

3303 Out << ", summary: (";

3304 printTypeTestResolution(TIS.TTRes);

3305 if (!TIS.WPDRes.empty()) {

3306 Out << ", wpdResolutions: (";

3307 ListSeparator FS;

3308 for (auto &WPDRes : TIS.WPDRes) {

3309 Out << FS;

3310 Out << "(offset: " << WPDRes.first << ", ";

3311 printWPDRes(WPDRes.second);

3312 Out << ")";

3313 }

3314 Out << ")";

3315 }

3316 Out << ")";

3317}

3318

3319void AssemblyWriter::printTypeIdCompatibleVtableSummary(

3321 Out << ", summary: (";

3322 ListSeparator FS;

3323 for (auto &P : TI) {

3324 Out << FS;

3325 Out << "(offset: " << P.AddressPointOffset << ", ";

3326 Out << "^" << Machine.getGUIDSlot(P.VTableVI.getGUID());

3327 Out << ")";

3328 }

3329 Out << ")";

3330}

3331

3332void AssemblyWriter::printArgs(ArrayRef<uint64_t> Args) {

3334}

3335

3336void AssemblyWriter::printWPDRes(const WholeProgramDevirtResolution &WPDRes) {

3337 Out << "wpdRes: (kind: ";

3339

3341 Out << ", singleImplName: \"" << WPDRes.SingleImplName << "\"";

3342

3343 if (!WPDRes.ResByArg.empty()) {

3344 Out << ", resByArg: (";

3345 ListSeparator FS;

3346 for (auto &ResByArg : WPDRes.ResByArg) {

3347 Out << FS;

3348 printArgs(ResByArg.first);

3349 Out << ", byArg: (kind: ";

3351 if (ResByArg.second.TheKind ==

3353 ResByArg.second.TheKind ==

3355 Out << ", info: " << ResByArg.second.Info;

3356

3357

3358

3359 if (ResByArg.second.Byte || ResByArg.second.Bit)

3360 Out << ", byte: " << ResByArg.second.Byte

3361 << ", bit: " << ResByArg.second.Bit;

3362

3363 Out << ")";

3364 }

3365 Out << ")";

3366 }

3367 Out << ")";

3368}

3369

3371 switch (SK) {

3373 return "alias";

3375 return "function";

3377 return "variable";

3378 }

3380}

3381

3382void AssemblyWriter::printAliasSummary(const AliasSummary *AS) {

3383 Out << ", aliasee: ";

3384

3385

3386

3388 Out << "^" << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getAliasee()]);

3389 else

3390 Out << "null";

3391}

3392

3393void AssemblyWriter::printGlobalVarSummary(const GlobalVarSummary *GS) {

3394 auto VTableFuncs = GS->vTableFuncs();

3395 Out << ", varFlags: (readonly: " << GS->VarFlags.MaybeReadOnly << ", "

3396 << "writeonly: " << GS->VarFlags.MaybeWriteOnly << ", "

3397 << "constant: " << GS->VarFlags.Constant;

3398 if (!VTableFuncs.empty())

3399 Out << ", "

3400 << "vcall_visibility: " << GS->VarFlags.VCallVisibility;

3401 Out << ")";

3402

3403 if (!VTableFuncs.empty()) {

3404 Out << ", vTableFuncs: (";

3405 ListSeparator FS;

3406 for (auto &P : VTableFuncs) {

3407 Out << FS;

3408 Out << "(virtFunc: ^" << Machine.getGUIDSlot(P.FuncVI.getGUID())

3409 << ", offset: " << P.VTableOffset;

3410 Out << ")";

3411 }

3412 Out << ")";

3413 }

3414}

3415

3417 switch (LT) {

3419 return "external";

3421 return "private";

3423 return "internal";

3425 return "linkonce";

3427 return "linkonce_odr";

3429 return "weak";

3431 return "weak_odr";

3433 return "common";

3435 return "appending";

3437 return "extern_weak";

3439 return "available_externally";

3440 }

3442}

3443

3444

3445

3446

3452

3454 switch (Vis) {

3456 return "default";

3458 return "hidden";

3460 return "protected";

3461 }

3463}

3464

3466 switch (IK) {

3468 return "definition";

3470 return "declaration";

3471 }

3473}

3474

3475void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {

3476 Out << ", insts: " << FS->instCount();

3477 if (FS->fflags().anyFlagSet())

3478 Out << ", " << FS->fflags();

3479

3480 if (->calls().empty()) {

3481 Out << ", calls: (";

3482 ListSeparator IFS;

3483 for (auto &Call : FS->calls()) {

3484 Out << IFS;

3485 Out << "(callee: ^" << Machine.getGUIDSlot(Call.first.getGUID());

3486 if (Call.second.getHotness() != CalleeInfo::HotnessType::Unknown)

3488 else if (Call.second.RelBlockFreq)

3489 Out << ", relbf: " << Call.second.RelBlockFreq;

3490

3491

3492 if (Call.second.HasTailCall)

3493 Out << ", tail: 1";

3494 Out << ")";

3495 }

3496 Out << ")";

3497 }

3498

3499 if (const auto *TIdInfo = FS->getTypeIdInfo())

3500 printTypeIdInfo(*TIdInfo);

3501

3502

3503

3504 auto AllocTypeName = [](uint8_t Type) -> const char * {

3505 switch (Type) {

3506 case (uint8_t)AllocationType::None:

3507 return "none";

3508 case (uint8_t)AllocationType::NotCold:

3509 return "notcold";

3510 case (uint8_t)AllocationType::Cold:

3511 return "cold";

3512 case (uint8_t)AllocationType::Hot:

3513 return "hot";

3514 }

3516 };

3517

3518 if (->allocs().empty()) {

3519 Out << ", allocs: (";

3520 ListSeparator AFS;

3521 for (auto &AI : FS->allocs()) {

3522 Out << AFS;

3523 Out << "(versions: (";

3524 ListSeparator VFS;

3525 for (auto V : AI.Versions) {

3526 Out << VFS;

3527 Out << AllocTypeName(V);

3528 }

3529 Out << "), memProf: (";

3530 ListSeparator MIBFS;

3531 for (auto &MIB : AI.MIBs) {

3532 Out << MIBFS;

3533 Out << "(type: " << AllocTypeName((uint8_t)MIB.AllocType);

3534 Out << ", stackIds: (";

3535 ListSeparator SIDFS;

3536 for (auto Id : MIB.StackIdIndices) {

3537 Out << SIDFS;

3538 Out << TheIndex->getStackIdAtIndex(Id);

3539 }

3540 Out << "))";

3541 }

3542 Out << "))";

3543 }

3544 Out << ")";

3545 }

3546

3547 if (->callsites().empty()) {

3548 Out << ", callsites: (";

3549 ListSeparator SNFS;

3550 for (auto &CI : FS->callsites()) {

3551 Out << SNFS;

3552 if (CI.Callee)

3553 Out << "(callee: ^" << Machine.getGUIDSlot(CI.Callee.getGUID());

3554 else

3555 Out << "(callee: null";

3556 Out << ", clones: (";

3557 ListSeparator VFS;

3558 for (auto V : CI.Clones) {

3559 Out << VFS;

3560 Out << V;

3561 }

3562 Out << "), stackIds: (";

3563 ListSeparator SIDFS;

3564 for (auto Id : CI.StackIdIndices) {

3565 Out << SIDFS;

3566 Out << TheIndex->getStackIdAtIndex(Id);

3567 }

3568 Out << "))";

3569 }

3570 Out << ")";

3571 }

3572

3573 auto PrintRange = [&](const ConstantRange &Range) {

3575 };

3576

3577 if (->paramAccesses().empty()) {

3578 Out << ", params: (";

3579 ListSeparator IFS;

3580 for (auto &PS : FS->paramAccesses()) {

3581 Out << IFS;

3582 Out << "(param: " << PS.ParamNo;

3583 Out << ", offset: ";

3584 PrintRange(PS.Use);

3585 if (!PS.Calls.empty()) {

3586 Out << ", calls: (";

3587 ListSeparator IFS;

3588 for (auto &Call : PS.Calls) {

3589 Out << IFS;

3590 Out << "(callee: ^" << Machine.getGUIDSlot(Call.Callee.getGUID());

3591 Out << ", param: " << Call.ParamNo;

3592 Out << ", offset: ";

3593 PrintRange(Call.Offsets);

3594 Out << ")";

3595 }

3596 Out << ")";

3597 }

3598 Out << ")";

3599 }

3600 Out << ")";

3601 }

3602}

3603

3604void AssemblyWriter::printTypeIdInfo(

3605 const FunctionSummary::TypeIdInfo &TIDInfo) {

3606 Out << ", typeIdInfo: (";

3607 ListSeparator TIDFS;

3608 if (!TIDInfo.TypeTests.empty()) {

3609 Out << TIDFS;

3610 Out << "typeTests: (";

3611 ListSeparator FS;

3612 for (auto &GUID : TIDInfo.TypeTests) {

3613 auto TidIter = TheIndex->typeIds().equal_range(GUID);

3614 if (TidIter.first == TidIter.second) {

3615 Out << FS;

3616 Out << GUID;

3617 continue;

3618 }

3619

3620 for (const auto &[GUID, TypeIdPair] : make_range(TidIter)) {

3621 Out << FS;

3622 auto Slot = Machine.getTypeIdSlot(TypeIdPair.first);

3624 Out << "^" << Slot;

3625 }

3626 }

3627 Out << ")";

3628 }

3630 Out << TIDFS;

3632 }

3634 Out << TIDFS;

3636 }

3638 Out << TIDFS;

3640 "typeTestAssumeConstVCalls");

3641 }

3643 Out << TIDFS;

3645 "typeCheckedLoadConstVCalls");

3646 }

3647 Out << ")";

3648}

3649

3650void AssemblyWriter::printVFuncId(const FunctionSummary::VFuncId VFId) {

3651 auto TidIter = TheIndex->typeIds().equal_range(VFId.GUID);

3652 if (TidIter.first == TidIter.second) {

3653 Out << "vFuncId: (";

3654 Out << "guid: " << VFId.GUID;

3655 Out << ", offset: " << VFId.Offset;

3656 Out << ")";

3657 return;

3658 }

3659

3660 ListSeparator FS;

3661 for (const auto &[GUID, TypeIdPair] : make_range(TidIter)) {

3662 Out << FS;

3663 Out << "vFuncId: (";

3664 auto Slot = Machine.getTypeIdSlot(TypeIdPair.first);

3666 Out << "^" << Slot;

3667 Out << ", offset: " << VFId.Offset;

3668 Out << ")";

3669 }

3670}

3671

3672void AssemblyWriter::printNonConstVCalls(

3674 Out << Tag << ": (";

3675 ListSeparator FS;

3676 for (auto &VFuncId : VCallList) {

3677 Out << FS;

3678 printVFuncId(VFuncId);

3679 }

3680 Out << ")";

3681}

3682

3683void AssemblyWriter::printConstVCalls(

3685 Out << Tag << ": (";

3686 ListSeparator FS;

3687 for (auto &ConstVCall : VCallList) {

3688 Out << FS;

3689 Out << "(";

3690 printVFuncId(ConstVCall.VFunc);

3691 if (!ConstVCall.Args.empty()) {

3692 Out << ", ";

3693 printArgs(ConstVCall.Args);

3694 }

3695 Out << ")";

3696 }

3697 Out << ")";

3698}

3699

3700void AssemblyWriter::printSummary(const GlobalValueSummary &Summary) {

3701 GlobalValueSummary::GVFlags GVFlags = Summary.flags();

3704 Out << "(module: ^" << Machine.getModulePathSlot(Summary.modulePath())

3705 << ", flags: (";

3707 Out << ", visibility: "

3710 Out << ", live: " << GVFlags.Live;

3711 Out << ", dsoLocal: " << GVFlags.DSOLocal;

3712 Out << ", canAutoHide: " << GVFlags.CanAutoHide;

3713 Out << ", importType: "

3715 Out << ")";

3716

3721 else

3723

3724 auto RefList = Summary.refs();

3725 if (!RefList.empty()) {

3726 Out << ", refs: (";

3727 ListSeparator FS;

3728 for (auto &Ref : RefList) {

3729 Out << FS;

3730 if (Ref.isReadOnly())

3731 Out << "readonly ";

3732 else if (Ref.isWriteOnly())

3733 Out << "writeonly ";

3734 Out << "^" << Machine.getGUIDSlot(Ref.getGUID());

3735 }

3736 Out << ")";

3737 }

3738

3739 Out << ")";

3740}

3741

3742void AssemblyWriter::printSummaryInfo(unsigned Slot, const ValueInfo &VI) {

3743 Out << "^" << Slot << " = gv: (";

3744 if (VI.hasName() && .name().empty())

3745 Out << "name: \"" << VI.name() << "\"";

3746 else

3747 Out << "guid: " << VI.getGUID();

3748 if (.getSummaryList().empty()) {

3749 Out << ", summaries: (";

3750 ListSeparator FS;

3751 for (auto &Summary : VI.getSummaryList()) {

3752 Out << FS;

3753 printSummary(*Summary);

3754 }

3755 Out << ")";

3756 }

3757 Out << ")";

3758 if (VI.hasName() && .name().empty())

3759 Out << " ; guid = " << VI.getGUID();

3760 Out << "\n";

3761}

3762

3765 if (Name.empty()) {

3766 Out << " ";

3767 } else {

3768 unsigned char FirstC = static_cast<unsigned char>(Name[0]);

3769 if (isalpha(FirstC) || FirstC == '-' || FirstC == '$' || FirstC == '.' ||

3770 FirstC == '_')

3771 Out << FirstC;

3772 else

3773 Out << '\\' << hexdigit(FirstC >> 4) << hexdigit(FirstC & 0x0F);

3774 for (unsigned i = 1, e = Name.size(); i != e; ++i) {

3775 unsigned char C = Name[i];

3776 if (isalnum(C) || C == '-' || C == '$' || C == '.' || C == '_')

3777 Out << C;

3778 else

3780 }

3781 }

3782}

3783

3784void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {

3785 Out << '!';

3787 Out << " = !{";

3788 ListSeparator LS;

3789 for (const MDNode *Op : NMD->operands()) {

3790 Out << LS;

3791

3792

3795 continue;

3796 }

3797

3799 if (Slot == -1)

3800 Out << "";

3801 else

3802 Out << '!' << Slot;

3803 }

3804 Out << "}\n";

3805}

3806

3809 switch (Vis) {

3813 }

3814}

3815

3819 Out << "dso_local ";

3820}

3821

3824 switch (SCT) {

3828 }

3829}

3830

3833 switch (TLM) {

3835 break;

3837 Out << "thread_local ";

3838 break;

3840 Out << "thread_local(localdynamic) ";

3841 break;

3843 Out << "thread_local(initialexec) ";

3844 break;

3846 Out << "thread_local(localexec) ";

3847 break;

3848 }

3849}

3850

3852 switch (UA) {

3854 return "";

3856 return "local_unnamed_addr";

3858 return "unnamed_addr";

3859 }

3861}

3862

3866 if ()

3867 return;

3868

3870 Out << ',';

3871 Out << " comdat";

3872

3873 if (GO.getName() == C->getName())

3874 return;

3875

3876 Out << '(';

3878 Out << ')';

3879}

3880

3881void AssemblyWriter::printGlobal(const GlobalVariable *GV) {

3883 Out << "; Materializable\n";

3884

3885 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GV->getParent());

3887 Out << " = ";

3888

3890 Out << "external ";

3891

3898 if (!UA.empty())

3899 Out << UA << ' ';

3900

3902 Out << "addrspace(" << AddressSpace << ") ";

3904 Out << (GV->isConstant() ? "constant " : "global ");

3906

3908 Out << ' ';

3910 }

3911

3913 Out << ", section \"";

3915 Out << '"';

3916 }

3918 Out << ", partition \"";

3920 Out << '"';

3921 }

3923 Out << ", code_model \"";

3924 switch (*CM) {

3926 Out << "tiny";

3927 break;

3929 Out << "small";

3930 break;

3932 Out << "kernel";

3933 break;

3935 Out << "medium";

3936 break;

3938 Out << "large";

3939 break;

3940 }

3941 Out << '"';

3942 }

3943

3948 Out << ", no_sanitize_address";

3950 Out << ", no_sanitize_hwaddress";

3952 Out << ", sanitize_memtag";

3954 Out << ", sanitize_address_dyninit";

3955 }

3956

3958 if (MaybeAlign A = GV->getAlign())

3959 Out << ", align " << A->value();

3960

3963 printMetadataAttachments(MDs, ", ");

3964

3966 if (Attrs.hasAttributes())

3967 Out << " #" << Machine.getAttributeGroupSlot(Attrs);

3968

3970}

3971

3972void AssemblyWriter::printAlias(const GlobalAlias *GA) {

3974 Out << "; Materializable\n";

3975

3976 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GA->getParent());

3978 Out << " = ";

3979

3986 if (!UA.empty())

3987 Out << UA << ' ';

3988

3989 Out << "alias ";

3990

3992 Out << ", ";

3993

3994 if (const Constant *Aliasee = GA->getAliasee()) {

3996 } else {

3997 TypePrinter.print(GA->getType(), Out);

3998 Out << " <>";

3999 }

4000

4002 Out << ", partition \"";

4004 Out << '"';

4005 }

4006

4008 Out << '\n';

4009}

4010

4011void AssemblyWriter::printIFunc(const GlobalIFunc *GI) {

4013 Out << "; Materializable\n";

4014

4015 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GI->getParent());

4017 Out << " = ";

4018

4022

4023 Out << "ifunc ";

4024

4026 Out << ", ";

4027

4028 if (const Constant *Resolver = GI->getResolver()) {

4030 } else {

4031 TypePrinter.print(GI->getType(), Out);

4032 Out << " <>";

4033 }

4034

4036 Out << ", partition \"";

4038 Out << '"';

4039 }

4042 if (!MDs.empty()) {

4043 printMetadataAttachments(MDs, ", ");

4044 }

4045

4047 Out << '\n';

4048}

4049

4050void AssemblyWriter::printComdat(const Comdat *C) {

4051 C->print(Out);

4052}

4053

4054void AssemblyWriter::printTypeIdentities() {

4055 if (TypePrinter.empty())

4056 return;

4057

4058 Out << '\n';

4059

4060

4061 auto &NumberedTypes = TypePrinter.getNumberedTypes();

4062 for (unsigned I = 0, E = NumberedTypes.size(); I != E; ++I) {

4063 Out << '%' << I << " = type ";

4064

4065

4066

4067 TypePrinter.printStructBody(NumberedTypes[I], Out);

4068 Out << '\n';

4069 }

4070

4071 auto &NamedTypes = TypePrinter.getNamedTypes();

4072 for (StructType *NamedType : NamedTypes) {

4074 Out << " = type ";

4075

4076

4077

4078 TypePrinter.printStructBody(NamedType, Out);

4079 Out << '\n';

4080 }

4081}

4082

4083

4084void AssemblyWriter::printFunction(const Function *F) {

4085 if (F->isMaterializable())

4086 Out << "; Materializable\n";

4087 else if (AnnotationWriter)

4089

4090 const AttributeList &Attrs = F->getAttributes();

4091 if (Attrs.hasFnAttrs()) {

4092 AttributeSet AS = Attrs.getFnAttrs();

4093 std::string AttrStr;

4094

4095 for (const Attribute &Attr : AS) {

4096 if (!Attr.isStringAttribute()) {

4097 if (!AttrStr.empty()) AttrStr += ' ';

4098 AttrStr += Attr.getAsString();

4099 }

4100 }

4101

4102 if (!AttrStr.empty())

4103 Out << "; Function Attrs: " << AttrStr << '\n';

4104 }

4105

4107 Out << "; Unknown intrinsic\n";

4108

4109 Machine.incorporateFunction(F);

4110

4111 if (F->isDeclaration()) {

4112 Out << "declare";

4114 F->getAllMetadata(MDs);

4115 printMetadataAttachments(MDs, " ");

4116 Out << ' ';

4117 } else

4118 Out << "define ";

4119

4124

4125

4126 if (F->getCallingConv() != CallingConv::C) {

4128 Out << " ";

4129 }

4130

4131 FunctionType *FT = F->getFunctionType();

4132 if (Attrs.hasRetAttrs())

4133 Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';

4134 TypePrinter.print(F->getReturnType(), Out);

4135 AsmWriterContext WriterCtx(&TypePrinter, &Machine, F->getParent());

4136 Out << ' ';

4138 Out << '(';

4139

4140

4141 if (F->isDeclaration() && !IsForDebug) {

4142

4143 ListSeparator LS;

4144 for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {

4145 Out << LS;

4146

4147 TypePrinter.print(FT->getParamType(I), Out);

4148

4149 AttributeSet ArgAttrs = Attrs.getParamAttrs(I);

4151 Out << ' ';

4152 writeAttributeSet(ArgAttrs);

4153 }

4154 }

4155 } else {

4156

4157 ListSeparator LS;

4158 for (const Argument &Arg : F->args()) {

4159 Out << LS;

4160 printArgument(&Arg, Attrs.getParamAttrs(Arg.getArgNo()));

4161 }

4162 }

4163

4164

4165 if (FT->isVarArg()) {

4166 if (FT->getNumParams()) Out << ", ";

4167 Out << "...";

4168 }

4169 Out << ')';

4171 if (!UA.empty())

4172 Out << ' ' << UA;

4173

4174

4175

4177 if (F->getAddressSpace() != 0 || Mod ||

4178 Mod->getDataLayout().getProgramAddressSpace() != 0)

4179 Out << " addrspace(" << F->getAddressSpace() << ")";

4180 if (Attrs.hasFnAttrs())

4181 Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttrs());

4182 if (F->hasSection()) {

4183 Out << " section \"";

4185 Out << '"';

4186 }

4187 if (F->hasPartition()) {

4188 Out << " partition \"";

4190 Out << '"';

4191 }

4193 if (MaybeAlign A = F->getAlign())

4194 Out << " align " << A->value();

4195 if (F->hasGC())

4196 Out << " gc \"" << F->getGC() << '"';

4197 if (F->hasPrefixData()) {

4198 Out << " prefix ";

4199 writeOperand(F->getPrefixData(), true);

4200 }

4201 if (F->hasPrologueData()) {

4202 Out << " prologue ";

4203 writeOperand(F->getPrologueData(), true);

4204 }

4205 if (F->hasPersonalityFn()) {

4206 Out << " personality ";

4207 writeOperand(F->getPersonalityFn(), true);

4208 }

4209

4211 if (auto *MDProf = F->getMetadata(LLVMContext::MD_prof)) {

4212 Out << " ";

4213 MDProf->print(Out, TheModule, true);

4214 }

4215 }

4216

4217 if (F->isDeclaration()) {

4218 Out << '\n';

4219 } else {

4221 F->getAllMetadata(MDs);

4222 printMetadataAttachments(MDs, " ");

4223

4224 Out << " {";

4225

4226 for (const BasicBlock &BB : *F)

4228

4229

4230 printUseLists(F);

4231

4232 Out << "}\n";

4233 }

4234

4235 Machine.purgeFunction();

4236}

4237

4238

4239

4240void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {

4241

4242 TypePrinter.print(Arg->getType(), Out);

4243

4244

4245 if (Attrs.hasAttributes()) {

4246 Out << ' ';

4247 writeAttributeSet(Attrs);

4248 }

4249

4250

4252 Out << ' ';

4254 } else {

4256 assert(Slot != -1 && "expect argument in function here");

4257 Out << " %" << Slot;

4258 }

4259}

4260

4261

4262void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {

4264 if (BB->hasName()) {

4265 Out << "\n";

4267 Out << ':';

4268 } else if (!IsEntryBlock) {

4269 Out << "\n";

4270 int Slot = Machine.getLocalSlot(BB);

4271 if (Slot != -1)

4272 Out << Slot << ":";

4273 else

4274 Out << ":";

4275 }

4276

4277 if (!IsEntryBlock) {

4278

4280 Out << ";";

4282 Out << " No predecessors!";

4283 } else {

4284 Out << " preds = ";

4287 Out << LS;

4288 writeOperand(Pred, false);

4289 }

4290 }

4291 }

4292

4293 Out << "\n";

4294

4296

4297

4299 for (const DbgRecord &DR : I.getDbgRecordRange())

4300 printDbgRecordLine(DR);

4301 printInstructionLine(I);

4302 }

4303

4305}

4306

4307

4308void AssemblyWriter::printInstructionLine(const Instruction &I) {

4309 printInstruction(I);

4310 Out << '\n';

4311}

4312

4313

4314

4315void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {

4316 Out << " ; (";

4317 writeOperand(Relocate.getBasePtr(), false);

4318 Out << ", ";

4320 Out << ")";

4321}

4322

4323

4324

4325void AssemblyWriter::printInfoComment(const Value &V, bool isMaterializable) {

4327 printGCRelocateComment(*Relocate);

4328

4329 if (AnnotationWriter && !isMaterializable)

4331

4334 if (I->getDebugLoc()) {

4335 Out << " ; ";

4336 I->getDebugLoc().print(Out);

4337 }

4338 }

4339 }

4342 if (auto *MD = I->getMetadata(LLVMContext::MD_prof)) {

4343 Out << " ; ";

4344 MD->print(Out, TheModule, true);

4345 }

4346 }

4347 }

4348

4350 Out << " ; " << &V;

4351}

4352

4355

4356 if (Operand == nullptr) {

4357 Out << " <cannot get addrspace!>";

4358 return;

4359 }

4361 bool PrintAddrSpace = CallAddrSpace != 0;

4362 if (!PrintAddrSpace) {

4364

4365

4366

4367 if ( Mod || Mod->getDataLayout().getProgramAddressSpace() != 0)

4368 PrintAddrSpace = true;

4369 }

4370 if (PrintAddrSpace)

4371 Out << " addrspace(" << CallAddrSpace << ")";

4372}

4373

4374

4375void AssemblyWriter::printInstruction(const Instruction &I) {

4377

4378

4379 Out << " ";

4380

4381

4382 if (I.hasName()) {

4384 Out << " = ";

4385 } else if (.getType()->isVoidTy()) {

4386

4387 int SlotNum = Machine.getLocalSlot(&I);

4388 if (SlotNum == -1)

4389 Out << " = ";

4390 else

4391 Out << '%' << SlotNum << " = ";

4392 }

4393

4395 if (CI->isMustTailCall())

4396 Out << "musttail ";

4397 else if (CI->isTailCall())

4398 Out << "tail ";

4399 else if (CI->isNoTailCall())

4400 Out << "notail ";

4401 }

4402

4403

4404 Out << I.getOpcodeName();

4405

4406

4409 Out << " atomic";

4410

4412 Out << " weak";

4413

4414

4419 Out << " volatile";

4420

4421

4423

4424

4426 Out << ' ' << CI->getPredicate();

4427

4428

4431

4432

4433 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;

4434

4435

4438 Out << ' ';

4439 writeOperand(BI.getCondition(), true);

4440 Out << ", ";

4441 writeOperand(BI.getSuccessor(0), true);

4442 Out << ", ";

4443 writeOperand(BI.getSuccessor(1), true);

4444

4447

4448 Out << ' ';

4449 writeOperand(SI.getCondition(), true);

4450 Out << ", ";

4451 writeOperand(SI.getDefaultDest(), true);

4452 Out << " [";

4453 for (auto Case : SI.cases()) {

4454 Out << "\n ";

4455 writeOperand(Case.getCaseValue(), true);

4456 Out << ", ";

4457 writeOperand(Case.getCaseSuccessor(), true);

4458 }

4459 Out << "\n ]";

4461

4462 Out << ' ';

4463 writeOperand(Operand, true);

4464 Out << ", [";

4465

4466 ListSeparator LS;

4467 for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {

4468 Out << LS;

4469 writeOperand(I.getOperand(i), true);

4470 }

4471 Out << ']';

4473 Out << ' ';

4474 TypePrinter.print(I.getType(), Out);

4475 Out << ' ';

4476

4477 ListSeparator LS;

4478 for (const auto &[V, Block] :

4479 zip_equal(PN->incoming_values(), PN->blocks())) {

4480 Out << LS << "[ ";

4481 writeOperand(V, false);

4482 Out << ", ";

4483 writeOperand(Block, false);

4484 Out << " ]";

4485 }

4487 Out << ' ';

4488 writeOperand(I.getOperand(0), true);

4489 Out << ", ";

4492 Out << ' ';

4493 writeOperand(I.getOperand(0), true); Out << ", ";

4494 writeOperand(I.getOperand(1), true);

4495 Out << ", ";

4498 Out << ' ';

4499 TypePrinter.print(I.getType(), Out);

4500 if (LPI->isCleanup() || LPI->getNumClauses() != 0)

4501 Out << '\n';

4502

4503 if (LPI->isCleanup())

4504 Out << " cleanup";

4505

4506 for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {

4507 if (i != 0 || LPI->isCleanup()) Out << "\n";

4508 if (LPI->isCatch(i))

4509 Out << " catch ";

4510 else

4511 Out << " filter ";

4512

4513 writeOperand(LPI->getClause(i), true);

4514 }

4516 Out << " within ";

4517 writeOperand(CatchSwitch->getParentPad(), false);

4518 Out << " [";

4519 ListSeparator LS;

4520 for (const BasicBlock *PadBB : CatchSwitch->handlers()) {

4521 Out << LS;

4522 writeOperand(PadBB, true);

4523 }

4524 Out << "] unwind ";

4525 if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())

4526 writeOperand(UnwindDest, true);

4527 else

4528 Out << "to caller";

4530 Out << " within ";

4531 writeOperand(FPI->getParentPad(), false);

4532 Out << " [";

4533 ListSeparator LS;

4534 for (const Value *Op : FPI->arg_operands()) {

4535 Out << LS;

4536 writeOperand(Op, true);

4537 }

4538 Out << ']';

4540 Out << " void";

4542 Out << " from ";

4543 writeOperand(CRI->getOperand(0), false);

4544

4545 Out << " to ";

4546 writeOperand(CRI->getOperand(1), true);

4548 Out << " from ";

4549 writeOperand(CRI->getOperand(0), false);

4550

4551 Out << " unwind ";

4552 if (CRI->hasUnwindDest())

4553 writeOperand(CRI->getOperand(1), true);

4554 else

4555 Out << "to caller";

4557

4558 if (CI->getCallingConv() != CallingConv::C) {

4559 Out << " ";

4561 }

4562

4563 Operand = CI->getCalledOperand();

4564 FunctionType *FTy = CI->getFunctionType();

4565 Type *RetTy = FTy->getReturnType();

4566 const AttributeList &PAL = CI->getAttributes();

4567

4568 if (PAL.hasRetAttrs())

4569 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);

4570

4571

4573

4574

4575

4576

4577 Out << ' ';

4578 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);

4579 Out << ' ';

4580 writeOperand(Operand, false);

4581 Out << '(';

4582 bool HasPrettyPrintedArgs =

4585

4586 ListSeparator LS;

4587 Function *CalledFunc = CI->getCalledFunction();

4588 auto PrintArgComment = [&](unsigned ArgNo) {

4589 const auto *ConstArg = dyn_cast(CI->getArgOperand(ArgNo));

4590 if (!ConstArg)

4591 return;

4592 std::string ArgComment;

4593 raw_string_ostream ArgCommentStream(ArgComment);

4596 if (ArgComment.empty())

4597 return;

4598 Out << "/* " << ArgComment << " */ ";

4599 };

4600 if (HasPrettyPrintedArgs) {

4601 for (unsigned ArgNo = 0, NumArgs = CI->arg_size(); ArgNo < NumArgs;

4602 ++ArgNo) {

4603 Out << LS;

4604 PrintArgComment(ArgNo);

4605 writeParamOperand(CI->getArgOperand(ArgNo), PAL.getParamAttrs(ArgNo));

4606 }

4607 } else {

4608 for (unsigned ArgNo = 0, NumArgs = CI->arg_size(); ArgNo < NumArgs;

4609 ++ArgNo) {

4610 Out << LS;

4611 writeParamOperand(CI->getArgOperand(ArgNo), PAL.getParamAttrs(ArgNo));

4612 }

4613 }

4614

4615

4616 if (CI->isMustTailCall() && CI->getParent() &&

4617 CI->getParent()->getParent() &&

4618 CI->getParent()->getParent()->isVarArg()) {

4619 if (CI->arg_size() > 0)

4620 Out << ", ";

4621 Out << "...";

4622 }

4623

4624 Out << ')';

4625 if (PAL.hasFnAttrs())

4626 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());

4627

4628 writeOperandBundles(CI);

4630 Operand = II->getCalledOperand();

4631 FunctionType *FTy = II->getFunctionType();

4632 Type *RetTy = FTy->getReturnType();

4633 const AttributeList &PAL = II->getAttributes();

4634

4635

4636 if (II->getCallingConv() != CallingConv::C) {

4637 Out << " ";

4639 }

4640

4641 if (PAL.hasRetAttrs())

4642 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);

4643

4644

4646

4647

4648

4649

4650

4651 Out << ' ';

4652 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);

4653 Out << ' ';

4654 writeOperand(Operand, false);

4655 Out << '(';

4656 ListSeparator LS;

4657 for (unsigned op = 0, Eop = II->arg_size(); op < Eop; ++op) {

4658 Out << LS;

4659 writeParamOperand(II->getArgOperand(op), PAL.getParamAttrs(op));

4660 }

4661

4662 Out << ')';

4663 if (PAL.hasFnAttrs())

4664 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());

4665

4666 writeOperandBundles(II);

4667

4668 Out << "\n to ";

4669 writeOperand(II->getNormalDest(), true);

4670 Out << " unwind ";

4671 writeOperand(II->getUnwindDest(), true);

4673 Operand = CBI->getCalledOperand();

4674 FunctionType *FTy = CBI->getFunctionType();

4675 Type *RetTy = FTy->getReturnType();

4676 const AttributeList &PAL = CBI->getAttributes();

4677

4678

4679 if (CBI->getCallingConv() != CallingConv::C) {

4680 Out << " ";

4682 }

4683

4684 if (PAL.hasRetAttrs())

4685 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);

4686

4687

4688

4689

4690

4691 Out << ' ';

4692 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);

4693 Out << ' ';

4694 writeOperand(Operand, false);

4695 Out << '(';

4696 ListSeparator ArgLS;

4697 for (unsigned op = 0, Eop = CBI->arg_size(); op < Eop; ++op) {

4698 Out << ArgLS;

4699 writeParamOperand(CBI->getArgOperand(op), PAL.getParamAttrs(op));

4700 }

4701

4702 Out << ')';

4703 if (PAL.hasFnAttrs())

4704 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());

4705

4706 writeOperandBundles(CBI);

4707

4708 Out << "\n to ";

4709 writeOperand(CBI->getDefaultDest(), true);

4710 Out << " [";

4711 ListSeparator DestLS;

4712 for (const BasicBlock *Dest : CBI->getIndirectDests()) {

4713 Out << DestLS;

4714 writeOperand(Dest, true);

4715 }

4716 Out << ']';

4718 Out << ' ';

4719 if (AI->isUsedWithInAlloca())

4720 Out << "inalloca ";

4721 if (AI->isSwiftError())

4722 Out << "swifterror ";

4723 TypePrinter.print(AI->getAllocatedType(), Out);

4724

4725

4726

4727

4728

4729 if (!AI->getArraySize() || AI->isArrayAllocation() ||

4730 !AI->getArraySize()->getType()->isIntegerTy(32)) {

4731 Out << ", ";

4732 writeOperand(AI->getArraySize(), true);

4733 }

4734 if (MaybeAlign A = AI->getAlign()) {

4735 Out << ", align " << A->value();

4736 }

4737

4738 unsigned AddrSpace = AI->getAddressSpace();

4739 if (AddrSpace != 0)

4740 Out << ", addrspace(" << AddrSpace << ')';

4742 if (Operand) {

4743 Out << ' ';

4744 writeOperand(Operand, true);

4745 }

4746 Out << " to ";

4747 TypePrinter.print(I.getType(), Out);

4749 if (Operand) {

4750 Out << ' ';

4751 writeOperand(Operand, true);

4752 }

4753 Out << ", ";

4754 TypePrinter.print(I.getType(), Out);

4755 } else if (Operand) {

4757 Out << ' ';

4758 TypePrinter.print(GEP->getSourceElementType(), Out);

4759 Out << ',';

4761 Out << ' ';

4762 TypePrinter.print(LI->getType(), Out);

4763 Out << ',';

4764 }

4765

4766

4767

4768

4769 bool PrintAllTypes = false;

4771

4772

4773

4777 PrintAllTypes = true;

4778 } else {

4779 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {

4780 Operand = I.getOperand(i);

4781

4782

4783 if (Operand && Operand->getType() != TheType) {

4784 PrintAllTypes = true;

4785 break;

4786 }

4787 }

4788 }

4789

4790 if (!PrintAllTypes) {

4791 Out << ' ';

4792 TypePrinter.print(TheType, Out);

4793 }

4794

4795 Out << ' ';

4796 ListSeparator LS;

4797 for (const Value *Op : I.operands()) {

4798 Out << LS;

4799 writeOperand(Op, PrintAllTypes);

4800 }

4801 }

4802

4803

4805 if (LI->isAtomic())

4806 writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());

4807 if (MaybeAlign A = LI->getAlign())

4808 Out << ", align " << A->value();

4810 if (SI->isAtomic())

4811 writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());

4812 if (MaybeAlign A = SI->getAlign())

4813 Out << ", align " << A->value();

4815 writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),

4816 CXI->getFailureOrdering(), CXI->getSyncScopeID());

4817 Out << ", align " << CXI->getAlign().value();

4819 writeAtomic(RMWI->getContext(), RMWI->getOrdering(),

4820 RMWI->getSyncScopeID());

4821 Out << ", align " << RMWI->getAlign().value();

4823 writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());

4825 printShuffleMask(Out, SVI->getType(), SVI->getShuffleMask());

4826 }

4827

4828

4831 printMetadataAttachments(InstMD, ", ");

4832

4833

4834 printInfoComment(I);

4835}

4836

4837void AssemblyWriter::printDbgMarker(const DbgMarker &Marker) {

4838

4839

4841 printDbgRecord(DPR);

4842 Out << "\n";

4843 }

4844

4845 Out << " DbgMarker -> { ";

4847 Out << " }";

4848}

4849

4850void AssemblyWriter::printDbgRecord(const DbgRecord &DR) {

4852 printDbgVariableRecord(*DVR);

4854 printDbgLabelRecord(*DLR);

4855 else

4857}

4858

4859void AssemblyWriter::printDbgVariableRecord(const DbgVariableRecord &DVR) {

4861 Out << "#dbg_";

4862 switch (DVR.getType()) {

4863 case DbgVariableRecord::LocationType::Value:

4864 Out << "value";

4865 break;

4866 case DbgVariableRecord::LocationType::Declare:

4867 Out << "declare";

4868 break;

4869 case DbgVariableRecord::LocationType::DeclareValue:

4870 Out << "declare_value";

4871 break;

4872 case DbgVariableRecord::LocationType::Assign:

4873 Out << "assign";

4874 break;

4875 default:

4877 "Tried to print a DbgVariableRecord with an invalid LocationType!");

4878 }

4879

4880 auto PrintOrNull = [&](Metadata *M) {

4881 if (!M)

4882 Out << "(null)";

4883 else

4885 };

4886

4887 Out << "(";

4889 Out << ", ";

4891 Out << ", ";

4893 Out << ", ";

4896 Out << ", ";

4898 Out << ", ";

4900 Out << ", ";

4901 }

4903 Out << ")";

4904}

4905

4906

4907

4908void AssemblyWriter::printDbgRecordLine(const DbgRecord &DR) {

4909

4910 Out << " ";

4911 printDbgRecord(DR);

4912 Out << '\n';

4913}

4914

4915void AssemblyWriter::printDbgLabelRecord(const DbgLabelRecord &Label) {

4917 Out << "#dbg_label(";

4919 Out << ", ";

4921 Out << ")";

4922}

4923

4924void AssemblyWriter::printMetadataAttachments(

4925 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,

4926 StringRef Separator) {

4927 if (MDs.empty())

4928 return;

4929

4930 if (MDNames.empty())

4931 MDs[0].second->getContext().getMDKindNames(MDNames);

4932

4934 for (const auto &I : MDs) {

4935 unsigned Kind = I.first;

4936 Out << Separator;

4937 if (Kind < MDNames.size()) {

4938 Out << "!";

4940 } else

4941 Out << "!<unknown kind #" << Kind << ">";

4942 Out << ' ';

4944 }

4945}

4946

4947void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {

4948 Out << '!' << Slot << " = ";

4949 printMDNodeBody(Node);

4950 Out << "\n";

4951}

4952

4953void AssemblyWriter::writeAllMDNodes() {

4958

4959 for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {

4960 writeMDNode(i, Nodes[i]);

4961 }

4962}

4963

4964void AssemblyWriter::printMDNodeBody(const MDNode *Node) {

4967}

4968

4969void AssemblyWriter::writeAttribute(const Attribute &Attr, bool InAttrGroup) {

4972 return;

4973 }

4974

4975 Out << Attribute::getNameFromAttrKind(Attr.getKindAsEnum());

4977 Out << '(';

4978 TypePrinter.print(Ty, Out);

4979 Out << ')';

4980 }

4981}

4982

4983void AssemblyWriter::writeAttributeSet(const AttributeSet &AttrSet,

4984 bool InAttrGroup) {

4985 ListSeparator LS(" ");

4986 for (const auto &Attr : AttrSet) {

4987 Out << LS;

4988 writeAttribute(Attr, InAttrGroup);

4989 }

4990}

4991

4992void AssemblyWriter::writeAllAttributeGroups() {

4993 std::vector<std::pair<AttributeSet, unsigned>> asVec;

4994 asVec.resize(Machine.as_size());

4995

4997 asVec[I.second] = I;

4998

4999 for (const auto &I : asVec)

5000 Out << "attributes #" << I.second << " = { "

5001 << I.first.getAsString(true) << " }\n";

5002}

5003

5004void AssemblyWriter::printUseListOrder(const Value *V,

5005 ArrayRef Shuffle) {

5007 if (IsInFunction)

5008 Out << " ";

5009

5010 Out << "uselistorder";

5011 if (const BasicBlock *BB = IsInFunction ? nullptr : dyn_cast(V)) {

5012 Out << "_bb ";

5013 writeOperand(BB->getParent(), false);

5014 Out << ", ";

5015 writeOperand(BB, false);

5016 } else {

5017 Out << " ";

5018 writeOperand(V, true);

5019 }

5020

5021 assert(Shuffle.size() >= 2 && "Shuffle too small");

5023}

5024

5025void AssemblyWriter::printUseLists(const Function *F) {

5026 auto It = UseListOrders.find(F);

5027 if (It == UseListOrders.end())

5028 return;

5029

5030 Out << "\n; uselistorder directives\n";

5031 for (const auto &Pair : It->second)

5032 printUseListOrder(Pair.first, Pair.second);

5033}

5034

5035

5036

5037

5038

5040 bool ShouldPreserveUseListOrder, bool IsForDebug) const {

5043 AssemblyWriter W(OS, SlotTable, this->getParent(), AAW, IsForDebug,

5044 ShouldPreserveUseListOrder);

5045 W.printFunction(this);

5046}

5047

5049 bool ShouldPreserveUseListOrder,

5050 bool IsForDebug) const {

5053 AssemblyWriter W(OS, SlotTable, this->getModule(), AAW,

5054 IsForDebug,

5055 ShouldPreserveUseListOrder);

5056 W.printBasicBlock(this);

5057}

5058

5060 bool ShouldPreserveUseListOrder, bool IsForDebug) const {

5063 AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,

5064 ShouldPreserveUseListOrder);

5065 W.printModule(this);

5066}

5067

5071 AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);

5072 W.printNamedMDNode(this);

5073}

5074

5076 bool IsForDebug) const {

5077 std::optional LocalST;

5080 SlotTable = ST;

5081 else {

5083 SlotTable = &*LocalST;

5084 }

5085

5087 AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);

5088 W.printNamedMDNode(this);

5089}

5090

5093 ROS << " = comdat ";

5094

5097 ROS << "any";

5098 break;

5100 ROS << "exactmatch";

5101 break;

5103 ROS << "largest";

5104 break;

5106 ROS << "nodeduplicate";

5107 break;

5109 ROS << "samesize";

5110 break;

5111 }

5112

5113 ROS << '\n';

5114}

5115

5117 TypePrinting TP;

5118 TP.print(const_cast<Type*>(this), OS);

5119

5120 if (NoDetails)

5121 return;

5122

5123

5126 OS << " = type ";

5127 TP.printStructBody(STy, OS);

5128 }

5129}

5130

5133 if (Function *F = CI->getCalledFunction())

5134 if (F->isIntrinsic())

5135 for (auto &Op : I.operands())

5138 return true;

5139 return false;

5140}

5141

5143

5145 print(ROS, MST, IsForDebug);

5146}

5147

5149

5151 print(ROS, MST, IsForDebug);

5152}

5153

5155 bool IsForDebug) const {

5157 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));

5161 if (F)

5163 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);

5164 W.printDbgMarker(*this);

5165}

5166

5168

5170 print(ROS, MST, IsForDebug);

5171}

5172

5174 bool IsForDebug) const {

5176 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));

5180 ? Marker->getParent()->getParent()

5181 : nullptr;

5182 if (F)

5184 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);

5185 W.printDbgVariableRecord(*this);

5186}

5187

5189 bool IsForDebug) const {

5191 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));

5195 Marker->getParent() ? Marker->getParent()->getParent() : nullptr;

5196 if (F)

5198

5199 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);

5200 W.printDbgLabelRecord(*this);

5201}

5202

5204 bool ShouldInitializeAllMetadata = false;

5208 ShouldInitializeAllMetadata = true;

5209

5211 print(ROS, MST, IsForDebug);

5212}

5213

5215 bool IsForDebug) const {

5217 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));

5220 auto IncorporateFunction = [&](const Function *F) {

5221 if (F)

5223 };

5224

5226 IncorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);

5227 AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);

5228 W.printInstruction(*I);

5230 IncorporateFunction(BB->getParent());

5231 AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);

5232 W.printBasicBlock(BB);

5234 AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);

5236 W.printGlobal(V);

5238 W.printFunction(F);

5240 W.printAlias(A);

5242 W.printIFunc(I);

5243 else

5248 TypePrinting TypePrinter;

5249 TypePrinter.print(C->getType(), OS);

5250 OS << ' ';

5251 AsmWriterContext WriterCtx(&TypePrinter, MST.getMachine());

5254 this->printAsOperand(OS, true, MST);

5255 } else {

5257 }

5258}

5259

5260

5261

5262

5267 AsmWriterContext WriterCtx(nullptr, Machine, M);

5269 return true;

5270 }

5271 return false;

5272}

5273

5280

5282 const Module *M) const {

5283 if (!M)

5285

5286 if (!PrintType)

5288 return;

5289

5294}

5295

5298 if (!PrintType)

5300 return;

5301

5303}

5304

5305

5307 AsmWriterContext &WriterCtx) {

5310

5313 return;

5314

5315 OS << " = ";

5317}

5318

5319namespace {

5320struct MDTreeAsmWriterContext : public AsmWriterContext {

5321 unsigned Level;

5322

5323 using EntryTy = std::pair<unsigned, std::string>;

5325

5326

5327 SmallPtrSet<const Metadata *, 4> Visited;

5328

5329 raw_ostream &MainOS;

5330

5331 MDTreeAsmWriterContext(TypePrinting *TP, SlotTracker *ST, const Module *M,

5332 raw_ostream &OS, const Metadata *InitMD)

5333 : AsmWriterContext(TP, ST, M), Level(0U), Visited({InitMD}), MainOS(OS) {}

5334

5335 void onWriteMetadataAsOperand(const Metadata *MD) override {

5336 if (!Visited.insert(MD).second)

5337 return;

5338

5339 std::string Str;

5340 raw_string_ostream SS(Str);

5342

5343

5344 Buffer.emplace_back(std::make_pair(Level, ""));

5345 unsigned InsertIdx = Buffer.size() - 1;

5346

5348 Buffer[InsertIdx].second = std::move(SS.str());

5350 }

5351

5352 ~MDTreeAsmWriterContext() override {

5353 for (const auto &Entry : Buffer) {

5354 MainOS << "\n";

5355 unsigned NumIndent = Entry.first * 2U;

5356 MainOS.indent(NumIndent) << Entry.second;

5357 }

5358 }

5359};

5360}

5361

5364 bool OnlyAsOperand, bool PrintAsTree = false) {

5366

5367 TypePrinting TypePrinter(M);

5368

5369 std::unique_ptr WriterCtx;

5370 if (PrintAsTree && !OnlyAsOperand)

5371 WriterCtx = std::make_unique(

5372 &TypePrinter, MST.getMachine(), M, OS, &MD);

5373 else

5374 WriterCtx =

5375 std::make_unique(&TypePrinter, MST.getMachine(), M);

5376

5378

5381 return;

5382

5383 OS << " = ";

5385}

5386

5391

5393 const Module *M) const {

5395}

5396

5402

5407

5413

5415 const Module *M) const {

5417 true);

5418}

5419

5423 AssemblyWriter W(OS, SlotTable, this, IsForDebug);

5424 W.printModuleSummaryIndex();

5425}

5426

5428 unsigned UB) const {

5430 if (!ST)

5431 return;

5432

5433 for (auto &I : llvm::make_range(ST->mdn_begin(), ST->mdn_end()))

5434 if (I.second >= LB && I.second < UB)

5435 L.push_back(std::make_pair(I.second, I.first));

5436}

5437

5438#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

5439

5442

5443

5449

5450

5453

5454

5457

5458

5464

5465

5468

5469

5472

5475

5481

5484

5488 dbgs() << '\n';

5489}

5490

5491

5494#endif

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

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)

static void writeDIMacro(raw_ostream &Out, const DIMacro *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2491

static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:1936

static void writeDIGlobalVariableExpression(raw_ostream &Out, const DIGlobalVariableExpression *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2643

static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2303

static void writeDIFixedPointType(raw_ostream &Out, const DIFixedPointType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2209

static void printDSOLocation(const GlobalValue &GV, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3816

static const char * getWholeProgDevirtResKindName(WholeProgramDevirtResolution::Kind K)

Definition AsmWriter.cpp:3238

static void writeDISubrangeType(raw_ostream &Out, const DISubrangeType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2283

static void writeAPFloatInternal(raw_ostream &Out, const APFloat &APF)

Definition AsmWriter.cpp:1516

static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD, ModuleSlotTracker &MST, const Module *M, bool OnlyAsOperand, bool PrintAsTree=false)

Definition AsmWriter.cpp:5362

static void writeDIStringType(raw_ostream &Out, const DIStringType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2232

static std::string getLinkageNameWithSpace(GlobalValue::LinkageTypes LT)

Definition AsmWriter.cpp:3447

static cl::opt< bool > PreserveAssemblyUseListOrder("preserve-ll-uselistorder", cl::Hidden, cl::init(false), cl::desc("Preserve use-list order when writing LLVM assembly."))

static std::vector< unsigned > predictValueUseListOrder(const Value *V, unsigned ID, const OrderMap &OM)

Definition AsmWriter.cpp:223

static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2552

static void orderValue(const Value *V, OrderMap &OM)

Definition AsmWriter.cpp:131

static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2192

static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA)

Definition AsmWriter.cpp:3851

static const char * getWholeProgDevirtResByArgKindName(WholeProgramDevirtResolution::ByArg::Kind K)

Definition AsmWriter.cpp:3250

static void writeMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, AsmWriterContext &Ctx)

Definition AsmWriter.cpp:2681

static void writeDIModule(raw_ostream &Out, const DIModule *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2512

static void writeDIFile(raw_ostream &Out, const DIFile *N, AsmWriterContext &)

Definition AsmWriter.cpp:2356

static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2345

static void writeOptimizationInfo(raw_ostream &Out, const User *U)

Definition AsmWriter.cpp:1476

static bool isReferencingMDNode(const Instruction &I)

Definition AsmWriter.cpp:5131

#define CC_VLS_CASE(ABI_VLEN)

static void writeDILabel(raw_ostream &Out, const DILabel *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2587

static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2250

static void printMetadataIdentifier(StringRef Name, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3763

static void printShuffleMask(raw_ostream &Out, Type *Ty, ArrayRef< int > Mask)

Definition AsmWriter.cpp:519

static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2667

static const Module * getModuleFromDPI(const DbgMarker *Marker)

Definition AsmWriter.cpp:335

static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType, ModuleSlotTracker &MST)

Definition AsmWriter.cpp:5274

static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2653

static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2417

static const char * getSummaryKindName(GlobalValueSummary::SummaryKind SK)

Definition AsmWriter.cpp:3370

static OrderMap orderModule(const Module *M)

Definition AsmWriter.cpp:151

static const char * getVisibilityName(GlobalValue::VisibilityTypes Vis)

Definition AsmWriter.cpp:3453

static void printCallingConv(unsigned cc, raw_ostream &Out)

Definition AsmWriter.cpp:345

static cl::opt< bool > PrintInstDebugLocs("print-inst-debug-locs", cl::Hidden, cl::desc("Pretty print debug locations of instructions when dumping"))

static void printMetadataImplRec(raw_ostream &ROS, const Metadata &MD, AsmWriterContext &WriterCtx)

Recursive version of printMetadataImpl.

Definition AsmWriter.cpp:5306

static SlotTracker * createSlotTracker(const Value *V)

Definition AsmWriter.cpp:1002

static void writeDILocation(raw_ostream &Out, const DILocation *DL, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2086

static void writeDINamespace(raw_ostream &Out, const DINamespace *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2469

DenseMap< const Function *, MapVector< const Value *, std::vector< unsigned > > > UseListOrderMap

Definition AsmWriter.cpp:119

static void writeDICommonBlock(raw_ostream &Out, const DICommonBlock *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2479

static UseListOrderMap predictUseListOrder(const Module *M)

Definition AsmWriter.cpp:284

static void printThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3831

static std::string getLinkageName(GlobalValue::LinkageTypes LT)

Definition AsmWriter.cpp:3416

static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2068

static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2571

static const char * getTTResKindName(TypeTestResolution::Kind K)

Definition AsmWriter.cpp:3265

static void writeDITemplateTypeParameter(raw_ostream &Out, const DITemplateTypeParameter *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2527

static const char * getImportTypeName(GlobalValueSummary::ImportKind IK)

Definition AsmWriter.cpp:3465

static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2372

static const Module * getModuleFromVal(const Value *V)

Definition AsmWriter.cpp:309

static void printLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix)

Turn the specified name into an 'LLVM name', which is either prefixed with % (if the string only cont...

Definition AsmWriter.cpp:492

static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I, raw_ostream &Out)

Definition AsmWriter.cpp:4353

static void writeDIGenericSubrange(raw_ostream &Out, const DIGenericSubrange *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2132

static void writeDISubrange(raw_ostream &Out, const DISubrange *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2108

static void writeDILexicalBlockFile(raw_ostream &Out, const DILexicalBlockFile *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2457

static void writeConstantInternal(raw_ostream &Out, const Constant *CV, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:1609

static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N, AsmWriterContext &)

Definition AsmWriter.cpp:2180

static void writeAsOperandInternal(raw_ostream &Out, const Value *V, AsmWriterContext &WriterCtx, bool PrintType=false)

Definition AsmWriter.cpp:2701

static void printVisibility(GlobalValue::VisibilityTypes Vis, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3807

static cl::opt< bool > PrintProfData("print-prof-data", cl::Hidden, cl::desc("Pretty print perf data (branch weights, etc) when dumping"))

static void writeMDTuple(raw_ostream &Out, const MDTuple *Node, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:1842

static void writeDIExpression(raw_ostream &Out, const DIExpression *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2603

static cl::opt< bool > PrintInstAddrs("print-inst-addrs", cl::Hidden, cl::desc("Print addresses of instructions when dumping"))

static void writeDIAssignID(raw_ostream &Out, const DIAssignID *DL, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2102

static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2446

PrefixType

Definition AsmWriter.cpp:450

@ GlobalPrefix

Definition AsmWriter.cpp:451

@ LabelPrefix

Definition AsmWriter.cpp:453

@ LocalPrefix

Definition AsmWriter.cpp:454

@ NoPrefix

Definition AsmWriter.cpp:455

@ ComdatPrefix

Definition AsmWriter.cpp:452

static void maybePrintComdat(formatted_raw_ostream &Out, const GlobalObject &GO)

Definition AsmWriter.cpp:3863

static void printDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3822

static bool printWithoutType(const Value &V, raw_ostream &O, SlotTracker *Machine, const Module *M)

Print without a type, skipping the TypePrinting object.

Definition AsmWriter.cpp:5263

#define ST_DEBUG(X)

Definition AsmWriter.cpp:1031

static void writeDIArgList(raw_ostream &Out, const DIArgList *N, AsmWriterContext &WriterCtx, bool FromValue=false)

Definition AsmWriter.cpp:2628

static void writeDITemplateValueParameter(raw_ostream &Out, const DITemplateValueParameter *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2538

static const Value * skipMetadataWrapper(const Value *V)

Look for a value that might be wrapped as metadata, e.g.

Definition AsmWriter.cpp:124

static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2502

Atomic ordering constants.

This file contains the simple types necessary to represent the attributes associated with functions a...

static const Function * getParent(const Value *V)

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

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

#define LLVM_DUMP_METHOD

Mark debug helper function definitions like dump() that should not be stripped from debug builds.

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

dxil pretty DXIL Metadata Pretty Printer

This file defines the DenseMap class.

This file contains constants used for implementing Dwarf debug support.

This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...

GlobalValue::SanitizerMetadata SanitizerMetadata

This file provides various utilities for inspecting and working with the control flow graph in LLVM I...

This file contains an interface for creating legacy passes to print out IR in various granularities.

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

This defines the Use class.

Machine Check Debug Module

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

ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...

static bool processFunction(Function &F, NVPTXTargetMachine &TM)

ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))

uint64_t IntrinsicInst * II

Function const char TargetMachine * Machine

if(auto Err=PB.parsePassPipeline(MPM, Passes)) return wrap(std MPM run * Mod

static StringRef getName(Value *V)

This file provides utility classes that use RAII to save and restore values.

This file implements a set that has insertion order iteration characteristics.

This file defines the SmallPtrSet class.

This file defines the SmallString class.

This file defines the SmallVector class.

LocallyHashedType DenseMapInfo< LocallyHashedType >::Empty

static UseListOrderStack predictUseListOrder(const Module &M)

static const fltSemantics & IEEEsingle()

static const fltSemantics & BFloat()

static const fltSemantics & IEEEquad()

static const fltSemantics & IEEEdouble()

static const fltSemantics & x87DoubleExtended()

static constexpr roundingMode rmNearestTiesToEven

static const fltSemantics & IEEEhalf()

static const fltSemantics & PPCDoubleDouble()

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

Factory for SNaN values.

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

LLVM_ABI double convertToDouble() const

Converts this APFloat to host double value.

void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const

const fltSemantics & getSemantics() const

APInt bitcastToAPInt() const

Class for arbitrary precision integers.

LLVM_ABI APInt getLoBits(unsigned numBits) const

Compute an APInt containing numBits lowbits from this APInt.

uint64_t getZExtValue() const

Get zero extended value.

LLVM_ABI APInt getHiBits(unsigned numBits) const

Compute an APInt containing numBits highbits from this APInt.

Abstract interface of slot tracker storage.

virtual ~AbstractSlotTrackerStorage()

const GlobalValueSummary & getAliasee() const

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.

virtual void emitBasicBlockStartAnnot(const BasicBlock *, formatted_raw_ostream &)

emitBasicBlockStartAnnot - This may be implemented to emit a string right after the basic block label...

virtual void emitBasicBlockEndAnnot(const BasicBlock *, formatted_raw_ostream &)

emitBasicBlockEndAnnot - This may be implemented to emit a string right after the basic block.

virtual void emitFunctionAnnot(const Function *, formatted_raw_ostream &)

emitFunctionAnnot - This may be implemented to emit a string right before the start of a function.

virtual void emitInstructionAnnot(const Instruction *, formatted_raw_ostream &)

emitInstructionAnnot - This may be implemented to emit a string right before an instruction is emitte...

virtual void printInfoComment(const Value &, formatted_raw_ostream &)

printInfoComment - This may be implemented to emit a comment to the right of an instruction or global...

virtual ~AssemblyAnnotationWriter()

static LLVM_ABI StringRef getOperationName(BinOp Op)

This class holds the attributes for a particular argument, parameter, function, or return value.

bool hasAttributes() const

Return true if attributes exists in this set.

LLVM_ABI std::string getAsString(bool InAttrGrp=false) const

The Attribute is converted to a string of equivalent mnemonic.

LLVM_ABI Attribute::AttrKind getKindAsEnum() const

Return the attribute's kind as an enum (Attribute::AttrKind).

LLVM_ABI bool isTypeAttribute() const

Return true if the attribute is a type attribute.

LLVM_ABI Type * getValueAsType() const

Return the attribute's value as a Type.

LLVM Basic Block Representation.

const Function * getParent() const

Return the enclosing method, or null if none.

LLVM_ABI void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW=nullptr, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const

Print the basic block to an output stream with an optional AssemblyAnnotationWriter.

Definition AsmWriter.cpp:5048

LLVM_ABI bool isEntryBlock() const

Return true if this is the entry block of the containing function.

LLVM_ABI const Module * getModule() const

Return the module owning the function this basic block belongs to, or nullptr if the function does no...

OperandBundleUse getOperandBundleAt(unsigned Index) const

Return the operand bundle at a specific index.

unsigned getNumOperandBundles() const

Return the number of operand bundles associated with this User.

AttributeList getAttributes() const

Return the attributes for this call.

bool hasOperandBundles() const

Return true if this User has any operand bundles.

LLVM_ABI void print(raw_ostream &OS, bool IsForDebug=false) const

Definition AsmWriter.cpp:5091

LLVM_ABI void dump() const

Definition AsmWriter.cpp:5467

@ Largest

The linker will choose the largest COMDAT.

@ SameSize

The data referenced by the COMDAT must be the same size.

@ Any

The linker may choose any COMDAT.

@ NoDeduplicate

No deduplication is performed.

@ ExactMatch

The data referenced by the COMDAT must be the same.

SelectionKind getSelectionKind() const

LLVM_ABI APInt getSignedMin() const

Return the smallest signed value contained in the ConstantRange.

LLVM_ABI APInt getSignedMax() const

Return the largest signed value contained in the ConstantRange.

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.

LLVM_ABI Constant * getAggregateElement(unsigned Elt) const

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

List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.

Basic type, like 'int' or 'float'.

static LLVM_ABI const char * nameTableKindString(DebugNameTableKind PK)

static LLVM_ABI const char * emissionKindString(DebugEmissionKind EK)

A lightweight wrapper around an expression operand.

static LLVM_ABI const char * fixedPointKindString(FixedPointKind)

A pair of DIGlobalVariable and DIExpression.

An imported module (C++ using directive or similar).

Macro Info DWARF-like metadata node.

Represents a module in the programming language, for example, a Clang module, or a Fortran module.

Tagged DWARF-like metadata node.

static LLVM_ABI DIFlags splitFlags(DIFlags Flags, SmallVectorImpl< DIFlags > &SplitFlags)

Split up a flags bitfield.

static LLVM_ABI StringRef getFlagString(DIFlags Flag)

Wrapper structure that holds a language name and its version.

uint32_t getVersion() const

Returns language version. Only valid for versioned language names.

bool hasVersionedName() const

uint16_t getName() const

Returns a versioned or unversioned language name.

String type, Fortran CHARACTER(n)

Subprogram description. Uses SubclassData1.

static LLVM_ABI DISPFlags splitFlags(DISPFlags Flags, SmallVectorImpl< DISPFlags > &SplitFlags)

Split up a flags bitfield for easier printing.

static LLVM_ABI StringRef getFlagString(DISPFlags Flag)

DISPFlags

Debug info subprogram flags.

Type array for a subprogram.

LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false) const

Definition AsmWriter.cpp:5167

Per-instruction record of debug-info.

LLVM_ABI void dump() const

Definition AsmWriter.cpp:5445

Instruction * MarkedInstr

Link back to the Instruction that owns this marker.

LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false) const

Implement operator<< on DbgMarker.

Definition AsmWriter.cpp:5142

LLVM_ABI const BasicBlock * getParent() const

simple_ilist< DbgRecord > StoredDbgRecords

List of DbgRecords, the non-instruction equivalent of llvm.dbg.

Base class for non-instruction debug metadata records that have positions within IR.

DebugLoc getDebugLoc() const

LLVM_ABI void dump() const

Definition AsmWriter.cpp:5452

DbgMarker * Marker

Marker that this DbgRecord is linked into.

Record of a variable value-assignment, aka a non instruction representation of the dbg....

LocationType getType() const

LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false) const

Definition AsmWriter.cpp:5148

MDNode * getRawExpression() const

MDNode * getRawAddressExpression() const

Metadata * getRawAssignID() const

MDNode * getRawVariable() const

Metadata * getRawLocation() const

Returns the metadata operand for the first location description.

Metadata * getRawAddress() const

MDNode * getAsMDNode() const

Return this as a bar MDNode.

DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator

Intrinsic::ID getIntrinsicID() const LLVM_READONLY

getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...

void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW=nullptr, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const

Print the function to an output stream with an optional AssemblyAnnotationWriter.

Definition AsmWriter.cpp:5039

const Function & getFunction() const

const Argument * const_arg_iterator

LLVM_ABI Value * getBasePtr() const

LLVM_ABI Value * getDerivedPtr() const

Generic tagged DWARF-like metadata node.

const Constant * getAliasee() const

const Constant * getResolver() const

StringRef getSection() const

Get the custom section of this global if it has one.

LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const

Appends all metadata attached to this value to MDs, sorting by KindID.

const Comdat * getComdat() const

bool hasSection() const

Check if this global has a custom object file section.

SummaryKind

Sububclass discriminator (for dyn_cast<> et al.)

bool hasPartition() const

static LLVM_ABI GUID getGUIDAssumingExternalLinkage(StringRef GlobalName)

Return a 64-bit global unique ID constructed from the name of a global symbol.

LLVM_ABI const SanitizerMetadata & getSanitizerMetadata() const

bool hasExternalLinkage() const

VisibilityTypes getVisibility() const

bool isImplicitDSOLocal() const

LinkageTypes getLinkage() const

uint64_t GUID

Declare a type to represent a global unique identifier for a global value.

ThreadLocalMode getThreadLocalMode() const

DLLStorageClassTypes

Storage classes of global values for PE targets.

@ DLLExportStorageClass

Function to be accessible from DLL.

@ DLLImportStorageClass

Function to be imported from DLL.

bool hasSanitizerMetadata() const

LLVM_ABI StringRef getPartition() const

Module * getParent()

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

PointerType * getType() const

Global values are always pointers.

VisibilityTypes

An enumeration for the kinds of visibility of global values.

@ DefaultVisibility

The GV is visible.

@ HiddenVisibility

The GV is hidden.

@ ProtectedVisibility

The GV is protected.

LLVM_ABI bool isMaterializable() const

If this function's Module is being lazily streamed in functions from disk or some other source,...

UnnamedAddr getUnnamedAddr() const

LinkageTypes

An enumeration for the kinds of linkage for global values.

@ PrivateLinkage

Like Internal, but omit from symbol table.

@ CommonLinkage

Tentative definitions.

@ InternalLinkage

Rename collisions when linking (static functions).

@ LinkOnceAnyLinkage

Keep one copy of function when linking (inline)

@ WeakODRLinkage

Same, but only replaced by something equivalent.

@ ExternalLinkage

Externally visible function.

@ WeakAnyLinkage

Keep one copy of named function when linking (weak)

@ AppendingLinkage

Special purpose, only applies to global arrays.

@ AvailableExternallyLinkage

Available for inspection, not emission.

@ ExternalWeakLinkage

ExternalWeak linkage description.

@ LinkOnceODRLinkage

Same, but only replaced by something equivalent.

DLLStorageClassTypes getDLLStorageClass() const

Type * getValueType() const

const Constant * getInitializer() const

getInitializer - Return the initializer for this global variable.

bool isExternallyInitialized() const

bool hasInitializer() const

Definitions have initializers, declarations don't.

AttributeSet getAttributes() const

Return the attribute set for this global.

std::optional< CodeModel::Model > getCodeModel() const

Get the custom code model of this global if it has one.

MaybeAlign getAlign() const

Returns the alignment of the given variable.

bool isConstant() const

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

A helper class to return the specified delimiter string after the first invocation of operator String...

LLVM_ABI void printTree(raw_ostream &OS, const Module *M=nullptr) const

Print in tree shape.

Definition AsmWriter.cpp:5408

LLVM_ABI void dumpTree() const

User-friendly dump in tree shape.

Definition AsmWriter.cpp:5483

This class implements a map that also provides access to all stored values in a deterministic order.

Manage lifetime of a slot tracker for printing IR.

const Module * getModule() const

ModuleSlotTracker(SlotTracker &Machine, const Module *M, const Function *F=nullptr)

Wrap a preinitialized SlotTracker.

Definition AsmWriter.cpp:945

virtual ~ModuleSlotTracker()

Destructor to clean up storage.

std::vector< std::pair< unsigned, const MDNode * > > MachineMDNodeListType

int getLocalSlot(const Value *V)

Return the slot number of the specified local value.

Definition AsmWriter.cpp:985

void collectMDNodes(MachineMDNodeListType &L, unsigned LB, unsigned UB) const

Definition AsmWriter.cpp:5427

SlotTracker * getMachine()

Lazily creates a slot tracker.

Definition AsmWriter.cpp:956

void setProcessHook(std::function< void(AbstractSlotTrackerStorage *, const Module *, bool)>)

Definition AsmWriter.cpp:990

void incorporateFunction(const Function &F)

Incorporate the given function.

Definition AsmWriter.cpp:971

Class to hold module path string table and global value map, and encapsulate methods for operating on...

static constexpr const char * getRegularLTOModuleName()

LLVM_ABI void dump() const

Dump to stderr (for debugging).

Definition AsmWriter.cpp:5493

LLVM_ABI void print(raw_ostream &OS, bool IsForDebug=false) const

Print to an output stream.

Definition AsmWriter.cpp:5420

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

iterator_range< alias_iterator > aliases()

iterator_range< global_iterator > globals()

void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const

Print the module to an output stream with an optional AssemblyAnnotationWriter.

Definition AsmWriter.cpp:5059

void dump() const

Dump the module to stderr (for debugging).

Definition AsmWriter.cpp:5460

LLVM_ABI void dump() const

Definition AsmWriter.cpp:5471

LLVM_ABI StringRef getName() const

LLVM_ABI void print(raw_ostream &ROS, bool IsForDebug=false) const

Definition AsmWriter.cpp:5068

iterator_range< op_iterator > operands()

unsigned getAddressSpace() const

Return the address space of the Pointer type.

This class provides computation of slot numbers for LLVM Assembly writing.

Definition AsmWriter.cpp:767

DenseMap< const Value *, unsigned > ValueMap

ValueMap - A mapping of Values to slot numbers.

Definition AsmWriter.cpp:770

bool mdn_empty() const

Definition AsmWriter.cpp:887

int getMetadataSlot(const MDNode *N) override

getMetadataSlot - Get the slot number of a MDNode.

Definition AsmWriter.cpp:1300

~SlotTracker() override=default

int getTypeIdCompatibleVtableSlot(StringRef Id)

Definition AsmWriter.cpp:1356

int getModulePathSlot(StringRef Path)

Definition AsmWriter.cpp:1329

bool as_empty() const

Definition AsmWriter.cpp:895

unsigned mdn_size() const

Definition AsmWriter.cpp:886

SlotTracker(const SlotTracker &)=delete

void purgeFunction()

After calling incorporateFunction, use this method to remove the most recently incorporated function ...

Definition AsmWriter.cpp:1266

mdn_iterator mdn_end()

Definition AsmWriter.cpp:885

int getTypeIdSlot(StringRef Id)

Definition AsmWriter.cpp:1347

void initializeIfNeeded()

These functions do the actual initialization.

Definition AsmWriter.cpp:1048

int getGlobalSlot(const GlobalValue *V)

getGlobalSlot - Get the slot number of a global value.

Definition AsmWriter.cpp:1275

as_iterator as_begin()

Definition AsmWriter.cpp:892

const Function * getFunction() const

Definition AsmWriter.cpp:874

unsigned getNextMetadataSlot() override

Definition AsmWriter.cpp:852

DenseMap< GlobalValue::GUID, unsigned >::iterator guid_iterator

GUID map iterators.

Definition AsmWriter.cpp:898

void incorporateFunction(const Function *F)

If you'd like to deal with a function instead of just a module, use this method to get its data into ...

Definition AsmWriter.cpp:869

int getLocalSlot(const Value *V)

Return the slot number of the specified value in it's type plane.

Definition AsmWriter.cpp:1310

int getAttributeGroupSlot(AttributeSet AS)

Definition AsmWriter.cpp:1320

SlotTracker(const Module *M, bool ShouldInitializeAllMetadata=false)

Construct from a module.

Definition AsmWriter.cpp:1036

void createMetadataSlot(const MDNode *N) override

getMetadataSlot - Get the slot number of a MDNode.

Definition AsmWriter.cpp:1297

void setProcessHook(std::function< void(AbstractSlotTrackerStorage *, const Module *, bool)>)

Definition AsmWriter.cpp:1284

DenseMap< const MDNode *, unsigned >::iterator mdn_iterator

MDNode map iterators.

Definition AsmWriter.cpp:882

as_iterator as_end()

Definition AsmWriter.cpp:893

unsigned as_size() const

Definition AsmWriter.cpp:894

SlotTracker & operator=(const SlotTracker &)=delete

int getGUIDSlot(GlobalValue::GUID GUID)

Definition AsmWriter.cpp:1338

mdn_iterator mdn_begin()

Definition AsmWriter.cpp:884

int initializeIndexIfNeeded()

Definition AsmWriter.cpp:1058

DenseMap< AttributeSet, unsigned >::iterator as_iterator

AttributeSet map iterators.

Definition AsmWriter.cpp:890

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

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

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

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.

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

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

constexpr bool empty() const

empty - Check if the string is empty.

ArrayRef< Type * > elements() const

unsigned getNumElements() const

Random access to the elements.

bool isLiteral() const

Return true if this type is uniqued by structural equivalence, false if it is a struct definition.

bool isOpaque() const

Return true if this is a type with an identity that has no body specified yet.

LLVM_ABI StringRef getName() const

Return the name for this struct type if it has an identity.

ArrayRef< Type * > type_params() const

Return the type parameters for this particular target extension type.

ArrayRef< unsigned > int_params() const

Return the integer parameters for this particular target extension type.

TypeFinder - Walk over a module, identifying all of the types that are used by the module.

void run(const Module &M, bool onlyNamed)

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

LLVM_ABI unsigned getPointerAddressSpace() const

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

LLVM_ABI StringRef getTargetExtName() const

Type(LLVMContext &C, TypeID tid)

LLVM_ABI void dump() const

Definition AsmWriter.cpp:5456

LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const

Print the current type.

Definition AsmWriter.cpp:5116

TypeID getTypeID() const

Return the type id for the type.

Type * getElementType() const

unsigned getAddressSpace() const

Return the address space of the Pointer 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 void print(raw_ostream &O, bool IsForDebug=false) const

Implement operator<< on Value.

Definition AsmWriter.cpp:5203

LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const

Appends all metadata attached to this value to MDs, sorting by KindID.

iterator_range< user_iterator > users()

LLVM_ABI void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const

Print the name of this Value out to the specified raw_ostream.

Definition AsmWriter.cpp:5281

iterator_range< use_iterator > uses()

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

LLVM_ABI void dump() const

Support for debugging, callable in GDB: V->dump()

Definition AsmWriter.cpp:5441

formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...

formatted_raw_ostream & PadToColumn(unsigned NewCol)

PadToColumn - Align the output to some column number.

This class implements an extremely fast bulk output stream that can only output to a stream.

raw_ostream & indent(unsigned NumSpaces)

indent - Insert 'NumSpaces' spaces.

LLVM_ABI StringRef SourceLanguageNameString(SourceLanguageName Lang)

LLVM_ABI StringRef EnumKindString(unsigned EnumKind)

LLVM_ABI StringRef LanguageString(unsigned Language)

LLVM_ABI StringRef AttributeEncodingString(unsigned Encoding)

LLVM_ABI StringRef ConventionString(unsigned Convention)

LLVM_ABI StringRef MacinfoString(unsigned Encoding)

LLVM_ABI StringRef OperationEncodingString(unsigned Encoding)

LLVM_ABI StringRef TagString(unsigned Tag)

This provides a very simple, boring adaptor for a begin and end iterator into a range type.

This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.

#define llvm_unreachable(msg)

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

constexpr char Attrs[]

Key for Kernel::Metadata::mAttrs.

unsigned ID

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

@ AArch64_VectorCall

Used between AArch64 Advanced SIMD functions.

@ X86_64_SysV

The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...

@ RISCV_VectorCall

Calling convention used for RISC-V V-extension.

@ AMDGPU_CS

Used for Mesa/AMDPAL compute shaders.

@ AMDGPU_VS

Used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (vertex shader if tess...

@ AVR_SIGNAL

Used for AVR signal routines.

@ Swift

Calling convention for Swift.

@ AMDGPU_KERNEL

Used for AMDGPU code object kernels.

@ AArch64_SVE_VectorCall

Used between AArch64 SVE functions.

@ ARM_APCS

ARM Procedure Calling Standard (obsolete, but still used on some targets).

@ CHERIoT_CompartmentCall

Calling convention used for CHERIoT when crossing a protection boundary.

@ CFGuard_Check

Special calling convention on Windows for calling the Control Guard Check ICall funtion.

@ AVR_INTR

Used for AVR interrupt routines.

@ PreserveMost

Used for runtime calls that preserves most registers.

@ AnyReg

OBSOLETED - Used for stack based JavaScript calls.

@ AMDGPU_Gfx

Used for AMD graphics targets.

@ DUMMY_HHVM

Placeholders for HHVM calling conventions (deprecated, removed).

@ AMDGPU_CS_ChainPreserve

Used on AMDGPUs to give the middle-end more control over argument placement.

@ AMDGPU_HS

Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).

@ ARM_AAPCS

ARM Architecture Procedure Calling Standard calling convention (aka EABI).

@ CHERIoT_CompartmentCallee

Calling convention used for the callee of CHERIoT_CompartmentCall.

@ AMDGPU_GS

Used for Mesa/AMDPAL geometry shaders.

@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2

Preserve X2-X15, X19-X29, SP, Z0-Z31, P0-P15.

@ CHERIoT_LibraryCall

Calling convention used for CHERIoT for cross-library calls to a stateless compartment.

@ CXX_FAST_TLS

Used for access functions.

@ X86_INTR

x86 hardware interrupt context.

@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0

Preserve X0-X13, X19-X29, SP, Z0-Z31, P0-P15.

@ AMDGPU_CS_Chain

Used on AMDGPUs to give the middle-end more control over argument placement.

@ GHC

Used by the Glasgow Haskell Compiler (GHC).

@ AMDGPU_PS

Used for Mesa/AMDPAL pixel shaders.

@ Cold

Attempts to make code in the caller as efficient as possible under the assumption that the call is no...

@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X1

Preserve X1-X15, X19-X29, SP, Z0-Z31, P0-P15.

@ X86_ThisCall

Similar to X86_StdCall.

@ PTX_Device

Call to a PTX device function.

@ SPIR_KERNEL

Used for SPIR kernel functions.

@ PreserveAll

Used for runtime calls that preserves (almost) all registers.

@ X86_StdCall

stdcall is mostly used by the Win32 API.

@ SPIR_FUNC

Used for SPIR non-kernel device functions.

@ Fast

Attempts to make calls as fast as possible (e.g.

@ MSP430_INTR

Used for MSP430 interrupt routines.

@ X86_VectorCall

MSVC calling convention that passes vectors and vector aggregates in SSE registers.

@ Intel_OCL_BI

Used for Intel OpenCL built-ins.

@ PreserveNone

Used for runtime calls that preserves none general registers.

@ AMDGPU_ES

Used for AMDPAL shader stage before geometry shader if geometry is in use.

@ Tail

Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...

@ Win64

The C convention as implemented on Windows/x86-64 and AArch64.

@ PTX_Kernel

Call to a PTX kernel. Passes all arguments in parameter space.

@ SwiftTail

This follows the Swift calling convention in how arguments are passed but guarantees tail calls will ...

@ GRAAL

Used by GraalVM. Two additional registers are reserved.

@ AMDGPU_LS

Used for AMDPAL vertex shader if tessellation is in use.

@ ARM_AAPCS_VFP

Same as ARM_AAPCS, but uses hard floating point ABI.

@ X86_RegCall

@ M68k_RTD

Used for M68k rtd-based CC (similar to X86's stdcall).

@ C

The default llvm calling convention, compatible with C.

@ X86_FastCall

'fast' analog of X86_StdCall.

LLVM_ABI void printImmArg(ID IID, unsigned ArgIdx, raw_ostream &OS, const Constant *ImmArgVal)

Print the argument info for the arguments with ArgInfo.

LLVM_ABI bool hasPrettyPrintedArgs(ID id)

Returns true if the intrinsic has pretty printed immediate arguments.

@ System

Synchronized with respect to all concurrently executing threads.

initializer< Ty > init(const Ty &Val)

@ DW_OP_LLVM_convert

Only used in LLVM metadata.

Context & getContext() const

This is an optimization pass for GlobalISel generic memory operations.

void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)

FunctionAddr VTableAddr Value

bool all_of(R &&range, UnaryPredicate P)

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

Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr, unsigned DynamicVGPRBlockSize=0)

detail::zippy< detail::zip_first, T, U, Args... > zip_equal(T &&t, U &&u, Args &&...args)

zip iterator that assumes that all iteratees have the same length.

InterleavedRange< Range > interleaved(const Range &R, StringRef Separator=", ", StringRef Prefix="", StringRef Suffix="")

Output range R as a sequence of interleaved elements.

const char * getHotnessName(CalleeInfo::HotnessType HT)

decltype(auto) dyn_cast(const From &Val)

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

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

iterator_range< T > make_range(T x, T y)

Convenience function for iterating over sub-ranges.

LLVM_ABI void printEscapedString(StringRef Name, raw_ostream &Out)

Print each character of the specified string, escaping it if it is not printable or if it is an escap...

const char * toIRString(AtomicOrdering ao)

String used by LLVM IR to represent atomic ordering.

auto dyn_cast_or_null(const Y &Val)

void sort(IteratorTy Start, IteratorTy End)

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

char hexdigit(unsigned X, bool LowerCase=false)

hexdigit - Return the hexadecimal character for the given number X (which should be less than 16).

bool isDigit(char C)

Checks if character C is one of the 10 decimal digits.

FunctionAddr VTableAddr Count

bool is_sorted(R &&Range, Compare C)

Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...

class LLVM_GSL_OWNER SmallVector

Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...

FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)

format_hex - Output N as a fixed width hexadecimal.

FormattedNumber format_hex_no_prefix(uint64_t N, unsigned Width, bool Upper=false)

format_hex_no_prefix - Output N as a fixed width hexadecimal.

bool isa(const From &Val)

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

constexpr int PoisonMaskElem

AtomicOrdering

Atomic ordering for LLVM's memory model.

@ Ref

The access may reference the value stored in memory.

DWARFExpression::Operation Op

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

std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)

LLVM_ABI Printable printBasicBlock(const BasicBlock *BB)

Print BasicBlock BB as an operand or print "" if BB is a nullptr.

Definition AsmWriter.cpp:4262

decltype(auto) cast(const From &Val)

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

auto predecessors(const MachineBasicBlock *BB)

bool pred_empty(const BasicBlock *BB)

std::vector< TypeIdOffsetVtableInfo > TypeIdCompatibleVtableInfo

List of vtable definitions decorated by a particular type identifier, and their corresponding offsets...

@ Default

The result values are uniform if and only if all operands are uniform.

static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)

Filter the DbgRecord range to DbgVariableRecord types only and downcast.

LLVM_ABI void printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name)

Print out a name of an LLVM value without any prefixes.

Definition AsmWriter.cpp:458

A single checksum, represented by a Kind and a Value (a string).

T Value

The string value of the checksum.

StringRef getKindAsString() const

std::vector< ConstVCall > TypeCheckedLoadConstVCalls

std::vector< VFuncId > TypeCheckedLoadVCalls

std::vector< ConstVCall > TypeTestAssumeConstVCalls

List of virtual calls made by this function using (respectively) llvm.assume(llvm....

std::vector< GlobalValue::GUID > TypeTests

List of type identifiers used by this function in llvm.type.test intrinsics referenced by something o...

std::vector< VFuncId > TypeTestAssumeVCalls

List of virtual calls made by this function using (respectively) llvm.assume(llvm....

unsigned DSOLocal

Indicates that the linker resolved the symbol to a definition from within the same linkage unit.

unsigned CanAutoHide

In the per-module summary, indicates that the global value is linkonce_odr and global unnamed addr (s...

unsigned ImportType

This field is written by the ThinLTO indexing step to postlink combined summary.

unsigned NotEligibleToImport

Indicate if the global value cannot be imported (e.g.

unsigned Linkage

The linkage type of the associated global value.

unsigned Visibility

Indicates the visibility.

unsigned Live

In per-module summary, indicate that the global value must be considered a live root for index-based ...

StringRef getTagName() const

Return the tag of this operand bundle as a string.

A utility class that uses RAII to save and restore the value of a variable.

std::map< uint64_t, WholeProgramDevirtResolution > WPDRes

Mapping from byte offset to whole-program devirt resolution for that (typeid, byte offset) pair.

Kind

Specifies which kind of type check we should emit for this byte array.

@ Unknown

Unknown (analysis not performed, don't lower)

@ Single

Single element (last example in "Short Inline Bit Vectors")

@ Inline

Inlined bit vector ("Short Inline Bit Vectors")

@ Unsat

Unsatisfiable type (i.e. no global has this type metadata)

@ AllOnes

All-ones bit vector ("Eliminating Bit Vector Checks for All-Ones Bit Vectors")

@ ByteArray

Test a byte array (first example)

unsigned SizeM1BitWidth

Range of size-1 expressed as a bit width.

enum llvm::TypeTestResolution::Kind TheKind

@ UniformRetVal

Uniform return value optimization.

@ VirtualConstProp

Virtual constant propagation.

@ UniqueRetVal

Unique return value optimization.

@ Indir

Just do a regular virtual call.

enum llvm::WholeProgramDevirtResolution::Kind TheKind

std::map< std::vector< uint64_t >, ByArg > ResByArg

Resolutions for calls with all constant integer arguments (excluding the first argument,...

std::string SingleImplName

@ SingleImpl

Single implementation devirtualization.

@ Indir

Just do a regular virtual call.

@ BranchFunnel

When retpoline mitigation is enabled, use a branch funnel that is defined in the merged module.

Function object to check whether the second component of a container supported by std::get (like std:...