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

112 cl::desc("Print address space names"));

113

114

116

117

118

119

120

122

125

126

127

131 return VAM->getValue();

132 return V;

133}

134

136 if (OM.lookup(V))

137 return;

138

141 return;

142

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

147 }

148

149

150

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

152 OM[V] = ID;

153}

154

156 OrderMap OM;

157

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

161 };

162

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

165 OrderConstantValue(VAM->getValue());

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

168 OrderConstantValue(VAM->getValue());

169 }

170 };

171

173 if (G.hasInitializer())

177 }

182 }

187 }

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

192

194

195 if (F.isDeclaration())

196 continue;

197

203

204

205

206

208 OrderConstantFromMetadata(DVR.getRawLocation());

209 if (DVR.isDbgAssign())

210 OrderConstantFromMetadata(DVR.getRawAddress());

211 }

212

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

218 }

220 }

221 }

222 }

223 return OM;

224}

225

226static std::vector

228

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

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

232

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

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

235

236 if (List.size() < 2)

237

238 return {};

239

240

241

242

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

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

247 const Use *LU = L.first;

248 const Use *RU = R.first;

249 if (LU == RU)

250 return false;

251

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

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

254

255

256 if (LID < RID) {

257 if (GetsReversed)

258 if (RID <= ID)

259 return true;

260 return false;

261 }

262 if (RID < LID) {

263 if (GetsReversed)

264 if (LID <= ID)

265 return false;

266 return true;

267 }

268

269

270

271 if (GetsReversed)

272 if (LID <= ID)

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

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

275 });

276

278

279 return {};

280

281

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

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

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

285 return Shuffle;

286}

287

291 for (const auto &Pair : OM) {

292 const Value *V = Pair.first;

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

294 continue;

295

296 std::vector Shuffle =

298 if (Shuffle.empty())

299 continue;

300

303 F = I->getFunction();

305 F = A->getParent();

307 F = BB->getParent();

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

309 }

310 return ULOM;

311}

312

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

316

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

319

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

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

323 }

324

326 return GV->getParent();

327

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

332 return M;

333 return nullptr;

334 }

335

336 return nullptr;

337}

338

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

343}

344

348

350 switch (cc) {

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

374 Out << "aarch64_sve_vector_pcs";

375 break;

377 Out << "aarch64_sme_preservemost_from_x0";

378 break;

380 Out << "aarch64_sme_preservemost_from_x1";

381 break;

383 Out << "aarch64_sme_preservemost_from_x2";

384 break;

398 Out << "hhvmcc";

399 break;

401 Out << "hhvm_ccc";

402 break;

411 Out << "amdgpu_cs_chain";

412 break;

414 Out << "amdgpu_cs_chain_preserve";

415 break;

419 Out << "amdgpu_gfx_whole_wave";

420 break;

423 Out << "riscv_vector_cc";

424 break;

425#define CC_VLS_CASE(ABI_VLEN) \

426 case CallingConv::RISCV_VLSCall_##ABI_VLEN: \

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

428 break;

441#undef CC_VLS_CASE

443 Out << "cheriot_compartmentcallcc";

444 break;

446 Out << "cheriot_compartmentcalleecc";

447 break;

449 Out << "cheriot_librarycallcc";

450 break;

451 }

452}

453

461

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

464

465

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

467 if (!NeedsQuotes) {

468 for (unsigned char C : Name) {

469

470

471

472

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

474 NeedsQuotes = true;

475 break;

476 }

477 }

478 }

479

480

481 if (!NeedsQuotes) {

482 OS << Name;

483 return;

484 }

485

486

487

488 OS << '"';

490 OS << '"';

491}

492

493

494

495

497 switch (Prefix) {

499 break;

501 OS << '@';

502 break;

504 OS << '$';

505 break;

507 break;

509 OS << '%';

510 break;

511 }

513}

514

515

516

517

522

524 Out << ", <";

526 Out << "vscale x ";

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

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

529 Out << "zeroinitializer";

531 Out << "poison";

532 } else {

533 Out << "<";

535 for (int Elt : Mask) {

536 Out << LS << "i32 ";

538 Out << "poison";

539 else

540 Out << Elt;

541 }

542 Out << ">";

543 }

544}

545

546namespace {

547

548class TypePrinting {

549public:

550 TypePrinting(const Module *M = nullptr)

551 : M(M), TypesIncorporated(M == nullptr) {}

552

553 TypePrinting(const TypePrinting &) = delete;

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

555

556

557 TypeFinder &getNamedTypes();

558

559

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

561

563

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

565

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

567

568private:

569 void incorporateTypes();

570

571

573 bool TypesIncorporated;

574

575 TypeFinder NamedTypes;

576

577

578 DenseMap<StructType *, unsigned> Type2Number;

579

580 std::vector<StructType *> NumberedTypes;

581};

582

583}

584

585TypeFinder &TypePrinting::getNamedTypes() {

586 incorporateTypes();

587 return NamedTypes;

588}

589

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

591 incorporateTypes();

592

593

594

595

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

597 return NumberedTypes;

598

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

600 for (const auto &P : Type2Number) {

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

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

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

604 }

605 return NumberedTypes;

606}

607

608bool TypePrinting::empty() {

609 incorporateTypes();

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

611}

612

613void TypePrinting::incorporateTypes() {

614 if (TypesIncorporated)

615 return;

616

617 NamedTypes.run(*M, false);

618 TypesIncorporated = true;

619

620

621

622 unsigned NextNumber = 0;

623

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

625 for (StructType *STy : NamedTypes) {

626

627 if (STy->isLiteral())

628 continue;

629

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

631 Type2Number[STy] = NextNumber++;

632 else

633 *NextToUse++ = STy;

634 }

635

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

637}

638

641 bool ForcePrint = false) {

642 if (AS == 0 && !ForcePrint)

643 return;

644 OS << Prefix << "addrspace(";

646 PrintAddrspaceName && M ? M->getDataLayout().getAddressSpaceName(AS) : "";

647 if (!ASName.empty())

648 OS << "\"" << ASName << "\"";

649 else

650 OS << AS;

651 OS << ")" << Suffix;

652}

653

654

655

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

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

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

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

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

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

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

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

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

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

667 case Type::MetadataTyID:

668 OS << "metadata";

669 return;

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

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

672 case Type::IntegerTyID:

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

674 return;

675

676 case Type::FunctionTyID: {

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

679 OS << " (";

680 ListSeparator LS;

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

682 OS << LS;

684 }

685 if (FTy->isVarArg())

686 OS << LS << "...";

687 OS << ')';

688 return;

689 }

690 case Type::StructTyID: {

692

694 return printStructBody(STy, OS);

695

698

699 incorporateTypes();

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

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

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

703 else

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

705 return;

706 }

707 case Type::PointerTyID: {

709 OS << "ptr";

711 return;

712 }

713 case Type::ArrayTyID: {

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

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

717 OS << ']';

718 return;

719 }

720 case Type::FixedVectorTyID:

721 case Type::ScalableVectorTyID: {

723 ElementCount EC = PTy->getElementCount();

724 OS << "<";

725 if (EC.isScalable())

726 OS << "vscale x ";

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

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

729 OS << '>';

730 return;

731 }

732 case Type::TypedPointerTyID: {

736 return;

737 }

738 case Type::TargetExtTyID:

740 OS << "target(\"";

742 OS << "\"";

744 OS << ", ";

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

746 }

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

748 OS << ", " << IntParam;

749 OS << ")";

750 return;

751 }

753}

754

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

757 OS << "opaque";

758 return;

759 }

760

762 OS << '<';

763

765 OS << "{}";

766 } else {

767 OS << "{ ";

768 ListSeparator LS;

770 OS << LS;

772 }

773

774 OS << " }";

775 }

777 OS << '>';

778}

779

781

782

783

784

785

786

788public:

789

791

792private:

793

794 const Module* TheModule;

795

796

797 const Function* TheFunction = nullptr;

798 bool FunctionProcessed = false;

799 bool ShouldInitializeAllMetadata;

800

802 ProcessModuleHookFn;

804 ProcessFunctionHookFn;

805

806

808

809

811 unsigned mNext = 0;

812

813

815 unsigned fNext = 0;

816

817

819 unsigned mdnNext = 0;

820

821

823 unsigned asNext = 0;

824

825

827 unsigned ModulePathNext = 0;

828

829

831 unsigned GUIDNext = 0;

832

833

835 unsigned TypeIdNext = 0;

836

837

838

840 unsigned TypeIdCompatibleVtableNext = 0;

841

842public:

843

844

845

846

847

849 bool ShouldInitializeAllMetadata = false);

850

851

852

853

854

855

857 bool ShouldInitializeAllMetadata = false);

858

859

861

864

866

871

873

874 void createMetadataSlot(const MDNode *N) override;

875

876

877

878 int getLocalSlot(const Value *V);

880 int getMetadataSlot(const MDNode *N) override;

882 int getModulePathSlot(StringRef Path);

885 int getTypeIdCompatibleVtableSlot(StringRef Id);

886

887

888

890 TheFunction = F;

891 FunctionProcessed = false;

892 }

893

895

896

897

898

899 void purgeFunction();

900

901

903

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

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

908

909

911

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

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

916

917

919

920

923

924

925private:

926

927 void CreateModuleSlot(const GlobalValue *V);

928

929

930 void CreateMetadataSlot(const MDNode *N);

931

932

933 void CreateFunctionSlot(const Value *V);

934

935

936 void CreateAttributeSetSlot(AttributeSet AS);

937

938 inline void CreateModulePathSlot(StringRef Path);

940 void CreateTypeIdSlot(StringRef Id);

941 void CreateTypeIdCompatibleVtableSlot(StringRef Id);

942

943

944

945 void processModule();

946

947 int processIndex();

948

949

951

952

953 void processGlobalObjectMetadata(const GlobalObject &GO);

954

955

956 void processFunctionMetadata(const Function &F);

957

958

959 void processInstructionMetadata(const Instruction &I);

960

961

962 void processDbgRecordMetadata(const DbgRecord &DVR);

963};

964

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

968

970 bool ShouldInitializeAllMetadata)

971 : ShouldCreateStorage(M),

972 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}

973

975

977 if (!ShouldCreateStorage)

978 return Machine;

979

980 ShouldCreateStorage = false;

981 MachineStorage =

982 std::make_unique(M, ShouldInitializeAllMetadata);

983 Machine = MachineStorage.get();

984 if (ProcessModuleHookFn)

985 Machine->setProcessHook(ProcessModuleHookFn);

986 if (ProcessFunctionHookFn)

987 Machine->setProcessHook(ProcessFunctionHookFn);

988 return Machine;

989}

990

992

994 return;

995

996

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

998 return;

999 if (this->F)

1000 Machine->purgeFunction();

1001 Machine->incorporateFunction(&F);

1002 this->F = &F;

1003}

1004

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

1007 return Machine->getLocalSlot(V);

1008}

1009

1012 Fn) {

1013 ProcessModuleHookFn = Fn;

1014}

1015

1018 Fn) {

1019 ProcessFunctionHookFn = Fn;

1020}

1021

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

1025

1027 if (I->getParent())

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

1029

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

1032

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

1035

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

1038

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

1041

1044

1045 return nullptr;

1046}

1047

1048#if 0

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

1050#else

1051#define ST_DEBUG(X)

1052#endif

1053

1054

1055

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

1058

1059

1060

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

1063 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}

1064

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

1067

1069 if (TheModule) {

1070 processModule();

1071 TheModule = nullptr;

1072 }

1073

1074 if (TheFunction && !FunctionProcessed)

1075 processFunction();

1076}

1077

1079 if (!TheIndex)

1080 return 0;

1081 int NumSlots = processIndex();

1082 TheIndex = nullptr;

1083 return NumSlots;

1084}

1085

1086

1087

1088void SlotTracker::processModule() {

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

1090

1091

1093 if (!Var.hasName())

1094 CreateModuleSlot(&Var);

1095 processGlobalObjectMetadata(Var);

1096 auto Attrs = Var.getAttributes();

1097 if (Attrs.hasAttributes())

1098 CreateAttributeSetSlot(Attrs);

1099 }

1100

1102 if (.hasName())

1103 CreateModuleSlot(&A);

1104 }

1105

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

1107 if (.hasName())

1108 CreateModuleSlot(&I);

1109 processGlobalObjectMetadata(I);

1110 }

1111

1112

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

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

1115 CreateMetadataSlot(N);

1116 }

1117

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

1119 if (.hasName())

1120

1121 CreateModuleSlot(&F);

1122

1123 if (ShouldInitializeAllMetadata)

1124 processFunctionMetadata(F);

1125

1126

1127

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

1130 CreateAttributeSetSlot(FnAttrs);

1131 }

1132

1133 if (ProcessModuleHookFn)

1134 ProcessModuleHookFn(this, TheModule, ShouldInitializeAllMetadata);

1135

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

1137}

1138

1139

1140void SlotTracker::processFunction() {

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

1142 fNext = 0;

1143

1144

1145 if (!ShouldInitializeAllMetadata)

1146 processFunctionMetadata(*TheFunction);

1147

1148

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

1151 if (!AI->hasName())

1152 CreateFunctionSlot(&*AI);

1153

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

1155

1156

1157 for (auto &BB : *TheFunction) {

1158 if (!BB.hasName())

1159 CreateFunctionSlot(&BB);

1160

1161 for (auto &I : BB) {

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

1163 CreateFunctionSlot(&I);

1164

1165

1166

1168

1170 if (Attrs.hasAttributes())

1171 CreateAttributeSetSlot(Attrs);

1172 }

1173 }

1174 }

1175

1176 if (ProcessFunctionHookFn)

1177 ProcessFunctionHookFn(this, TheFunction, ShouldInitializeAllMetadata);

1178

1179 FunctionProcessed = true;

1180

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

1182}

1183

1184

1185int SlotTracker::processIndex() {

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

1188

1189

1190

1191

1192 std::vector ModulePaths;

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

1194 ModulePaths.push_back(ModPath);

1196 for (auto &ModPath : ModulePaths)

1197 CreateModulePathSlot(ModPath);

1198

1199

1200 GUIDNext = ModulePathNext;

1201

1202 for (auto &GlobalList : *TheIndex)

1203 CreateGUIDSlot(GlobalList.first);

1204

1205

1206 TypeIdCompatibleVtableNext = GUIDNext;

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

1208 CreateTypeIdCompatibleVtableSlot(TId.first);

1209

1210

1211 TypeIdNext = TypeIdCompatibleVtableNext;

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

1213 CreateTypeIdSlot(TID.second.first);

1214

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

1216 return TypeIdNext;

1217}

1218

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

1222 for (auto &MD : MDs)

1223 CreateMetadataSlot(MD.second);

1224}

1225

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

1227 processGlobalObjectMetadata(F);

1228 for (auto &BB : F) {

1229 for (auto &I : BB) {

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

1231 processDbgRecordMetadata(DR);

1232 processInstructionMetadata(I);

1233 }

1234 }

1235}

1236

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

1238

1239

1240

1241

1243

1244

1245

1246

1248 CreateMetadataSlot(Empty);

1249 if (DVR->getRawVariable())

1250 CreateMetadataSlot(DVR->getRawVariable());

1251 if (DVR->isDbgAssign()) {

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

1255 CreateMetadataSlot(Empty);

1256 }

1258 CreateMetadataSlot(DLR->getRawLabel());

1259 } else {

1261 }

1264}

1265

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

1267

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

1270 if (F->isIntrinsic())

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

1274 CreateMetadataSlot(N);

1275

1276

1278 I.getAllMetadata(MDs);

1279 for (auto &MD : MDs)

1280 CreateMetadataSlot(MD.second);

1281}

1282

1283

1284

1285

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

1288 fMap.clear();

1289 TheFunction = nullptr;

1290 FunctionProcessed = false;

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

1292}

1293

1294

1296

1298

1299

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

1302}

1303

1306 Fn) {

1307 ProcessModuleHookFn = Fn;

1308}

1309

1312 Fn) {

1313 ProcessFunctionHookFn = Fn;

1314}

1315

1316

1318

1319

1321

1323

1324

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

1327}

1328

1329

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

1332

1333

1335

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

1338}

1339

1341

1343

1344

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

1347}

1348

1350

1352

1353

1354 auto I = ModulePathMap.find(Path);

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

1356}

1357

1359

1361

1362

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

1365}

1366

1368

1370

1371

1372 auto I = TypeIdMap.find(Id);

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

1374}

1375

1377

1379

1380

1381 auto I = TypeIdCompatibleVtableMap.find(Id);

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

1383}

1384

1385

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

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

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

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

1390

1391 unsigned DestSlot = mNext++;

1392 mMap[V] = DestSlot;

1393

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

1395 DestSlot << " [");

1396

1401}

1402

1403

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

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

1406

1407 unsigned DestSlot = fNext++;

1408 fMap[V] = DestSlot;

1409

1410

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

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

1413}

1414

1415

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

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

1418

1419

1421 return;

1422

1423 unsigned DestSlot = mdnNext;

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

1425 return;

1426 ++mdnNext;

1427

1428

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

1431 CreateMetadataSlot(Op);

1432}

1433

1434void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {

1436

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

1438 ++asNext;

1439}

1440

1441

1442void SlotTracker::CreateModulePathSlot(StringRef Path) {

1443 ModulePathMap[Path] = ModulePathNext++;

1444}

1445

1446

1448 GUIDMap[GUID] = GUIDNext++;

1449}

1450

1451

1452void SlotTracker::CreateTypeIdSlot(StringRef Id) {

1453 TypeIdMap[Id] = TypeIdNext++;

1454}

1455

1456

1457void SlotTracker::CreateTypeIdCompatibleVtableSlot(StringRef Id) {

1458 TypeIdCompatibleVtableMap[Id] = TypeIdCompatibleVtableNext++;

1459}

1460

1461namespace {

1462

1463struct AsmWriterContext {

1464 TypePrinting *TypePrinter = nullptr;

1465 SlotTracker *Machine = nullptr;

1467

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

1470

1471 static AsmWriterContext &getEmpty() {

1472 static AsmWriterContext EmptyCtx(nullptr, nullptr);

1473 return EmptyCtx;

1474 }

1475

1476

1477

1478 virtual void onWriteMetadataAsOperand(const Metadata *) {}

1479

1480 virtual ~AsmWriterContext() = default;

1481};

1482}

1483

1484

1485

1486

1487

1489 AsmWriterContext &WriterCtx,

1490 bool PrintType = false);

1491

1493 AsmWriterContext &WriterCtx,

1494 bool FromValue = false);

1495

1498 Out << FPO->getFastMathFlags();

1499

1501 if (OBO->hasNoUnsignedWrap())

1502 Out << " nuw";

1503 if (OBO->hasNoSignedWrap())

1504 Out << " nsw";

1506 if (Div->isExact())

1507 Out << " exact";

1509 if (PDI->isDisjoint())

1510 Out << " disjoint";

1512 if (GEP->isInBounds())

1513 Out << " inbounds";

1514 else if (GEP->hasNoUnsignedSignedWrap())

1515 Out << " nusw";

1516 if (GEP->hasNoUnsignedWrap())

1517 Out << " nuw";

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

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

1520 << ")";

1521 }

1523 if (NNI->hasNonNeg())

1524 Out << " nneg";

1526 if (TI->hasNoUnsignedWrap())

1527 Out << " nuw";

1528 if (TI->hasNoSignedWrap())

1529 Out << " nsw";

1531 if (ICmp->hasSameSign())

1532 Out << " samesign";

1533 }

1534}

1535

1539

1540

1541

1542

1543

1544 bool ignored;

1547 bool isNaN = APF.isNaN();

1548

1549 if (!isInf && !isNaN) {

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

1553

1554

1555

1556

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

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

1560

1562 Out << StrVal;

1563 return;

1564 }

1565 }

1566

1567

1568

1569

1570

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

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

1574

1575

1576

1577 if (!isDouble) {

1578

1579

1582 &ignored);

1583 if (IsSNAN) {

1585 apf =

1587 }

1588 }

1589

1591 return;

1592 }

1593

1594

1595

1596

1597 Out << "0x";

1600 Out << 'K';

1602 true);

1604 true);

1606 Out << 'L';

1608 true);

1610 true);

1612 Out << 'M';

1614 true);

1616 true);

1618 Out << 'H';

1620 true);

1622 Out << 'R';

1624 true);

1625 } else

1627}

1628

1630 AsmWriterContext &WriterCtx) {

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

1633

1634 if (Ty->isVectorTy()) {

1635 Out << "splat (";

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

1637 Out << " ";

1638 }

1639

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

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

1642 else

1643 Out << CI->getValue();

1644

1645 if (Ty->isVectorTy())

1646 Out << ")";

1647

1648 return;

1649 }

1650

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

1653

1654 if (Ty->isVectorTy()) {

1655 Out << "splat (";

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

1657 Out << " ";

1658 }

1659

1661

1662 if (Ty->isVectorTy())

1663 Out << ")";

1664

1665 return;

1666 }

1667

1669 Out << "zeroinitializer";

1670 return;

1671 }

1672

1674 Out << "blockaddress(";

1676 Out << ", ";

1678 Out << ")";

1679 return;

1680 }

1681

1683 Out << "dso_local_equivalent ";

1685 return;

1686 }

1687

1689 Out << "no_cfi ";

1691 return;

1692 }

1693

1695 Out << "ptrauth (";

1696

1697

1698 unsigned NumOpsToWrite = 2;

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

1700 NumOpsToWrite = 3;

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

1702 NumOpsToWrite = 4;

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

1704 NumOpsToWrite = 5;

1705

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

1708 Out << LS;

1710 true);

1711 }

1712 Out << ')';

1713 return;

1714 }

1715

1717 Out << '[';

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

1720 Out << LS;

1722 }

1723 Out << ']';

1724 return;

1725 }

1726

1728

1729

1730 if (CA->isString()) {

1731 Out << "c\"";

1733 Out << '"';

1734 return;

1735 }

1736

1737 Out << '[';

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

1740 Out << LS;

1742 true);

1743 }

1744 Out << ']';

1745 return;

1746 }

1747

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

1750 Out << '<';

1751 Out << '{';

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

1753 Out << ' ';

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

1756 Out << LS;

1758 }

1759 Out << ' ';

1760 }

1761 Out << '}';

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

1763 Out << '>';

1764 return;

1765 }

1766

1769

1770

1771

1772

1773

1774

1777 Out << "splat (";

1779 Out << ')';

1780 return;

1781 }

1782 }

1783

1784 Out << '<';

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

1787 Out << LS;

1789 true);

1790 }

1791 Out << '>';

1792 return;

1793 }

1794

1796 Out << "null";

1797 return;

1798 }

1799

1801 Out << "none";

1802 return;

1803 }

1804

1806 Out << "poison";

1807 return;

1808 }

1809

1811 Out << "undef";

1812 return;

1813 }

1814

1816

1817

1818

1819

1820

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

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

1824 Out << "splat (";

1826 Out << ')';

1827 return;

1828 }

1829 }

1830 }

1831

1832 Out << CE->getOpcodeName();

1834 Out << " (";

1835

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

1838 Out << ", ";

1839 }

1840

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

1843 Out << LS;

1845 }

1846

1847 if (CE->isCast()) {

1848 Out << " to ";

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

1850 }

1851

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

1854

1855 Out << ')';

1856 return;

1857 }

1858

1859 Out << "";

1860}

1861

1863 AsmWriterContext &WriterCtx) {

1864 Out << "!{";

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

1867 Out << LS;

1868 if (!MD) {

1869 Out << "null";

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

1873 } else {

1875 WriterCtx.onWriteMetadataAsOperand(MD);

1876 }

1877 }

1878

1879 Out << "}";

1880}

1881

1882namespace {

1883

1884struct MDFieldPrinter {

1885 raw_ostream &Out;

1886 ListSeparator FS;

1887 AsmWriterContext &WriterCtx;

1888

1889 explicit MDFieldPrinter(raw_ostream &Out)

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

1891 MDFieldPrinter(raw_ostream &Out, AsmWriterContext &Ctx)

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

1893

1894 void printTag(const DINode *N);

1895 void printMacinfoType(const DIMacroNode *N);

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

1897 void printString(StringRef Name, StringRef Value,

1898 bool ShouldSkipEmpty = true);

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

1900 bool ShouldSkipNull = true);

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

1902 bool ShouldSkipZero = true);

1903 template

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

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

1906 bool ShouldSkipZero);

1907 void printBool(StringRef Name, bool Value,

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

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

1911 template <class IntTy, class Stringifier>

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

1913 bool ShouldSkipZero = true);

1915 void printNameTableKind(StringRef Name,

1918};

1919

1920}

1921

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

1923 Out << FS << "tag: ";

1925 if ( Tag .empty())

1926 Out << Tag;

1927 else

1928 Out << N->getTag();

1929}

1930

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

1932 Out << FS << "type: ";

1934 if ( Type .empty())

1935 Out << Type;

1936 else

1937 Out << N->getMacinfoType();

1938}

1939

1940void MDFieldPrinter::printChecksum(

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

1944}

1945

1947 bool ShouldSkipEmpty) {

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

1949 return;

1950

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

1953 Out << "\"";

1954}

1955

1957 AsmWriterContext &WriterCtx) {

1958 if (!MD) {

1959 Out << "null";

1960 return;

1961 }

1963 WriterCtx.onWriteMetadataAsOperand(MD);

1964}

1965

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

1967 bool ShouldSkipNull) {

1968 if (ShouldSkipNull && !MD)

1969 return;

1970

1971 Out << FS << Name << ": ";

1973}

1974

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

1976 bool IsUnsigned, bool ShouldSkipZero) {

1977 if (!MD)

1978 return;

1979

1982 if (IsUnsigned)

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

1984 else

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

1986 } else

1987 printMetadata(Name, MD);

1988}

1989

1990template

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

1992 if (ShouldSkipZero && Int )

1993 return;

1994

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

1996}

1997

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

1999 bool IsUnsigned, bool ShouldSkipZero) {

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

2001 return;

2002

2003 Out << FS << Name << ": ";

2004 Int.print(Out, !IsUnsigned);

2005}

2006

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

2008 std::optional Default) {

2010 return;

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

2012}

2013

2015 if (!Flags)

2016 return;

2017

2018 Out << FS << Name << ": ";

2019

2022

2024 for (auto F : SplitFlags) {

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

2027 Out << FlagsFS << StringF;

2028 }

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

2030 Out << FlagsFS << Extra;

2031}

2032

2033void MDFieldPrinter::printDISPFlags(StringRef Name,

2035

2036

2037 Out << FS << Name << ": ";

2038

2039 if (!Flags) {

2040 Out << 0;

2041 return;

2042 }

2043

2046

2048 for (auto F : SplitFlags) {

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

2051 Out << FlagsFS << StringF;

2052 }

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

2054 Out << FlagsFS << Extra;

2055}

2056

2057void MDFieldPrinter::printEmissionKind(StringRef Name,

2060}

2061

2062void MDFieldPrinter::printNameTableKind(StringRef Name,

2065 return;

2067}

2068

2069void MDFieldPrinter::printFixedPointKind(StringRef Name,

2072}

2073

2074template <class IntTy, class Stringifier>

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

2076 Stringifier toString, bool ShouldSkipZero) {

2077 if (ShouldSkipZero && Value )

2078 return;

2079

2080 Out << FS << Name << ": ";

2082 if (!S.empty())

2083 Out << S;

2084 else

2086}

2087

2089 AsmWriterContext &WriterCtx) {

2090 Out << "!GenericDINode(";

2091 MDFieldPrinter Printer(Out, WriterCtx);

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

2094 if (N->getNumDwarfOperands()) {

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

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

2098 Out << IFS;

2100 }

2101 Out << "}";

2102 }

2103 Out << ")";

2104}

2105

2107 AsmWriterContext &WriterCtx) {

2108 Out << "!DILocation(";

2109 MDFieldPrinter Printer(Out, WriterCtx);

2110

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

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

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

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

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

2116 false);

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

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

2119 Out << ")";

2120}

2121

2123 AsmWriterContext &WriterCtx) {

2124 Out << "!DIAssignID()";

2125 MDFieldPrinter Printer(Out, WriterCtx);

2126}

2127

2129 AsmWriterContext &WriterCtx) {

2130 Out << "!DISubrange(";

2131 MDFieldPrinter Printer(Out, WriterCtx);

2132

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

2134 false,

2135 false);

2136

2137

2138

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

2140 false,

2141 false);

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

2143 false,

2144 false);

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

2146 false,

2147 false);

2148

2149 Out << ")";

2150}

2151

2153 AsmWriterContext &WriterCtx) {

2154 Out << "!DIGenericSubrange(";

2155 MDFieldPrinter Printer(Out, WriterCtx);

2156

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

2159 if (!BE)

2160 return std::nullopt;

2161 if (BE->isConstant() &&

2163 *BE->isConstant()) {

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

2165 }

2166 return std::nullopt;

2167 };

2168

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

2170 if (auto ConstantCount = GetConstant(Count))

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

2172 false);

2173 else

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

2175

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

2177 if (auto ConstantLBound = GetConstant(LBound))

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

2179 false);

2180 else

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

2182

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

2184 if (auto ConstantUBound = GetConstant(UBound))

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

2186 false);

2187 else

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

2189

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

2191 if (auto ConstantStride = GetConstant(Stride))

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

2193 false);

2194 else

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

2196

2197 Out << ")";

2198}

2199

2201 AsmWriterContext &) {

2202 Out << "!DIEnumerator(";

2203 MDFieldPrinter Printer(Out);

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

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

2206 false);

2207 if (N->isUnsigned())

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

2209 Out << ")";

2210}

2211

2213 AsmWriterContext &WriterCtx) {

2214 Out << "!DIBasicType(";

2215 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

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

2226 Out << ")";

2227}

2228

2230 AsmWriterContext &WriterCtx) {

2231 Out << "!DIFixedPointType(";

2232 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

2242 if (N->isRational()) {

2243 bool IsUnsigned = ->isSigned();

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

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

2246 } else {

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

2248 }

2249 Out << ")";

2250}

2251

2253 AsmWriterContext &WriterCtx) {

2254 Out << "!DIStringType(";

2255 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

2261 Printer.printMetadata("stringLocationExpression",

2262 N->getRawStringLocationExp());

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

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

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

2267 Out << ")";

2268}

2269

2271 AsmWriterContext &WriterCtx) {

2272 Out << "!DIDerivedType(";

2273 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

2280 false);

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

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

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

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

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

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

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

2288 false);

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

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

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

2292 Printer.printBool("ptrAuthIsAddressDiscriminated",

2293 PtrAuthData->isAddressDiscriminated());

2294 Printer.printInt("ptrAuthExtraDiscriminator",

2295 PtrAuthData->extraDiscriminator());

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

2297 Printer.printBool("ptrAuthAuthenticatesNullValues",

2298 PtrAuthData->authenticatesNullValues());

2299 }

2300 Out << ")";

2301}

2302

2304 AsmWriterContext &WriterCtx) {

2305 Out << "!DISubrangeType(";

2306 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

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

2315 false);

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

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

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

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

2320 Out << ")";

2321}

2322

2324 AsmWriterContext &WriterCtx) {

2325 Out << "!DICompositeType(";

2326 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2350 false);

2351 else

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

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

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

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

2356

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

2359 false);

2360

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

2362 Out << ")";

2363}

2364

2366 AsmWriterContext &WriterCtx) {

2367 Out << "!DISubroutineType(";

2368 MDFieldPrinter Printer(Out, WriterCtx);

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

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

2372 false);

2373 Out << ")";

2374}

2375

2377 Out << "!DIFile(";

2378 MDFieldPrinter Printer(Out);

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

2380 false);

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

2382 false);

2383

2384 if (N->getChecksum())

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

2386 if (N->getSource())

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

2388 false);

2389 Out << ")";

2390}

2391

2393 AsmWriterContext &WriterCtx) {

2394 Out << "!DICompileUnit(";

2395 MDFieldPrinter Printer(Out, WriterCtx);

2396

2398

2401 "sourceLanguageName",

2404 false);

2405

2407 true);

2408 } else {

2410 false);

2411 }

2412

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

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

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

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

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

2418 false);

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

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

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

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

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

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

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

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

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

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

2429 false);

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

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

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

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

2434 Out << ")";

2435}

2436

2438 AsmWriterContext &WriterCtx) {

2439 Out << "!DISubprogram(";

2440 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

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

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

2450 N->getVirtualIndex() != 0)

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

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

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

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

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

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

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

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

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

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

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

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

2463 Out << ")";

2464}

2465

2467 AsmWriterContext &WriterCtx) {

2468 Out << "!DILexicalBlock(";

2469 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

2474 Out << ")";

2475}

2476

2479 AsmWriterContext &WriterCtx) {

2480 Out << "!DILexicalBlockFile(";

2481 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

2485 false);

2486 Out << ")";

2487}

2488

2490 AsmWriterContext &WriterCtx) {

2491 Out << "!DINamespace(";

2492 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

2496 Out << ")";

2497}

2498

2500 AsmWriterContext &WriterCtx) {

2501 Out << "!DICommonBlock(";

2502 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

2508 Out << ")";

2509}

2510

2512 AsmWriterContext &WriterCtx) {

2513 Out << "!DIMacro(";

2514 MDFieldPrinter Printer(Out, WriterCtx);

2515 Printer.printMacinfoType(N);

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

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

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

2519 Out << ")";

2520}

2521

2523 AsmWriterContext &WriterCtx) {

2524 Out << "!DIMacroFile(";

2525 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

2529 Out << ")";

2530}

2531

2533 AsmWriterContext &WriterCtx) {

2534 Out << "!DIModule(";

2535 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

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

2544 Out << ")";

2545}

2546

2549 AsmWriterContext &WriterCtx) {

2550 Out << "!DITemplateTypeParameter(";

2551 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

2555 Out << ")";

2556}

2557

2560 AsmWriterContext &WriterCtx) {

2561 Out << "!DITemplateValueParameter(";

2562 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

2569 Out << ")";

2570}

2571

2573 AsmWriterContext &WriterCtx) {

2574 Out << "!DIGlobalVariable(";

2575 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

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

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

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

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

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

2588 Out << ")";

2589}

2590

2592 AsmWriterContext &WriterCtx) {

2593 Out << "!DILocalVariable(";

2594 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

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

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

2604 Out << ")";

2605}

2606

2608 AsmWriterContext &WriterCtx) {

2609 Out << "!DILabel(";

2610 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

2617 if (N->getCoroSuspendIdx())

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

2619 false);

2620 Out << ")";

2621}

2622

2624 AsmWriterContext &WriterCtx) {

2625 Out << "!DIExpression(";

2627 if (N->isValid()) {

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

2631

2632 Out << FS << OpStr;

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

2636 } else {

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

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

2639 }

2640 }

2641 } else {

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

2643 Out << FS << I;

2644 }

2645 Out << ")";

2646}

2647

2649 AsmWriterContext &WriterCtx,

2650 bool FromValue = false) {

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

2653 Out << "!DIArgList(";

2655 MDFieldPrinter Printer(Out, WriterCtx);

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

2657 Out << FS;

2659 }

2660 Out << ")";

2661}

2662

2665 AsmWriterContext &WriterCtx) {

2666 Out << "!DIGlobalVariableExpression(";

2667 MDFieldPrinter Printer(Out, WriterCtx);

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

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

2670 Out << ")";

2671}

2672

2674 AsmWriterContext &WriterCtx) {

2675 Out << "!DIObjCProperty(";

2676 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

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

2684 Out << ")";

2685}

2686

2688 AsmWriterContext &WriterCtx) {

2689 Out << "!DIImportedEntity(";

2690 MDFieldPrinter Printer(Out, WriterCtx);

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

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

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

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

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

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

2698 Out << ")";

2699}

2700

2702 AsmWriterContext &Ctx) {

2703 if (Node->isDistinct())

2704 Out << "distinct ";

2705 else if (Node->isTemporary())

2706 Out << "<temporary!> ";

2707

2708 switch (Node->getMetadataID()) {

2709 default:

2711#define HANDLE_MDNODE_LEAF(CLASS) \

2712 case Metadata::CLASS##Kind: \

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

2714 break;

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

2716 }

2717}

2718

2719

2720

2722 AsmWriterContext &WriterCtx,

2723 bool PrintType) {

2724 if (PrintType) {

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

2726 Out << ' ';

2727 }

2728

2729 if (V->hasName()) {

2731 return;

2732 }

2733

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

2738 return;

2739 }

2740

2742 Out << "asm ";

2743 if (IA->hasSideEffects())

2744 Out << "sideeffect ";

2745 if (IA->isAlignStack())

2746 Out << "alignstack ";

2747

2749 Out << "inteldialect ";

2750 if (IA->canThrow())

2751 Out << "unwind ";

2752 Out << '"';

2754 Out << "\", \"";

2756 Out << '"';

2757 return;

2758 }

2759

2762 true);

2763 return;

2764 }

2765

2766 char Prefix = '%';

2767 int Slot;

2768 auto *Machine = WriterCtx.Machine;

2769

2772 Slot = Machine->getGlobalSlot(GV);

2773 Prefix = '@';

2774 } else {

2775 Slot = Machine->getLocalSlot(V);

2776

2777

2778

2779

2780 if (Slot == -1)

2782 Slot = Machine->getLocalSlot(V);

2784 }

2785 }

2787

2789 Slot = Machine->getGlobalSlot(GV);

2790 Prefix = '@';

2791 } else {

2792 Slot = Machine->getLocalSlot(V);

2793 }

2796 } else {

2797 Slot = -1;

2798 }

2799

2800 if (Slot != -1)

2801 Out << Prefix << Slot;

2802 else

2803 Out << "";

2804}

2805

2807 AsmWriterContext &WriterCtx,

2808 bool FromValue) {

2809

2810

2813 return;

2814 }

2817 return;

2818 }

2819

2821 std::unique_ptr MachineStorage;

2823 if (!WriterCtx.Machine) {

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

2825 WriterCtx.Machine = MachineStorage.get();

2826 }

2828 if (Slot == -1) {

2831 return;

2832 }

2833

2834

2835 Out << "<" << N << ">";

2836 } else

2837 Out << '!' << Slot;

2838 return;

2839 }

2840

2842 Out << "!\"";

2844 Out << '"';

2845 return;

2846 }

2847

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

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

2852

2854}

2855

2856namespace {

2857

2858class AssemblyWriter {

2859 formatted_raw_ostream &Out;

2860 const Module *TheModule = nullptr;

2861 const ModuleSummaryIndex *TheIndex = nullptr;

2862 std::unique_ptr SlotTrackerStorage;

2864 TypePrinting TypePrinter;

2865 AssemblyAnnotationWriter *AnnotationWriter = nullptr;

2866 SetVector<const Comdat *> Comdats;

2867 bool IsForDebug;

2868 bool ShouldPreserveUseListOrder;

2871

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

2874

2875public:

2876

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

2878 AssemblyAnnotationWriter *AAW, bool IsForDebug,

2879 bool ShouldPreserveUseListOrder = false);

2880

2881 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,

2882 const ModuleSummaryIndex *Index, bool IsForDebug);

2883

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

2886 }

2887

2888 void printMDNodeBody(const MDNode *MD);

2889 void printNamedMDNode(const NamedMDNode *NMD);

2890

2891 void printModule(const Module *M);

2892

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

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

2895 void writeOperandBundles(const CallBase *Call);

2896 void writeSyncScope(const LLVMContext &Context,

2898 void writeAtomic(const LLVMContext &Context,

2901 void writeAtomicCmpXchg(const LLVMContext &Context,

2905

2906 void writeAllMDNodes();

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

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

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

2910 void writeAllAttributeGroups();

2911

2912 void printTypeIdentities();

2913 void printGlobal(const GlobalVariable *GV);

2914 void printAlias(const GlobalAlias *GA);

2915 void printIFunc(const GlobalIFunc *GI);

2916 void printComdat(const Comdat *C);

2917 void printFunction(const Function *F);

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

2920 void printInstructionLine(const Instruction &I);

2921 void printInstruction(const Instruction &I);

2922 void printDbgMarker(const DbgMarker &DPI);

2923 void printDbgVariableRecord(const DbgVariableRecord &DVR);

2924 void printDbgLabelRecord(const DbgLabelRecord &DLR);

2925 void printDbgRecord(const DbgRecord &DR);

2926 void printDbgRecordLine(const DbgRecord &DR);

2927

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

2929 void printUseLists(const Function *F);

2930

2931 void printModuleSummaryIndex();

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

2933 void printSummary(const GlobalValueSummary &Summary);

2934 void printAliasSummary(const AliasSummary *AS);

2935 void printGlobalVarSummary(const GlobalVarSummary *GS);

2936 void printFunctionSummary(const FunctionSummary *FS);

2937 void printTypeIdSummary(const TypeIdSummary &TIS);

2939 void printTypeTestResolution(const TypeTestResolution &TTRes);

2940 void printArgs(ArrayRef<uint64_t> Args);

2941 void printWPDRes(const WholeProgramDevirtResolution &WPDRes);

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

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

2945 const char *Tag);

2947 const char *Tag);

2948

2949private:

2950

2951 void printMetadataAttachments(

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

2953 StringRef Separator);

2954

2955

2956

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

2958

2959

2960

2961 void printGCRelocateComment(const GCRelocateInst &Relocate);

2962};

2963

2964}

2965

2968 bool IsForDebug, bool ShouldPreserveUseListOrder)

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

2970 IsForDebug(IsForDebug),

2971 ShouldPreserveUseListOrder(

2974 : ShouldPreserveUseListOrder) {

2975 if (!TheModule)

2976 return;

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

2979 Comdats.insert(C);

2980}

2981

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

2985 IsForDebug(IsForDebug),

2987

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

2989 if (!Operand) {

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

2991 return;

2992 }

2995}

2996

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

2999 switch (SSID) {

3001 break;

3002 }

3003 default: {

3004 if (SSNs.empty())

3005 Context.getSyncScopeNames(SSNs);

3006

3007 Out << " syncscope(\"";

3009 Out << "\")";

3010 break;

3011 }

3012 }

3013}

3014

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

3018 if (Ordering == AtomicOrdering::NotAtomic)

3019 return;

3020

3021 writeSyncScope(Context, SSID);

3023}

3024

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

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

3030 FailureOrdering != AtomicOrdering::NotAtomic);

3031

3032 writeSyncScope(Context, SSID);

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

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

3035}

3036

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

3038 AttributeSet Attrs) {

3039 if (!Operand) {

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

3041 return;

3042 }

3043

3044

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

3046

3047 if (Attrs.hasAttributes()) {

3048 Out << ' ';

3049 writeAttributeSet(Attrs);

3050 }

3051 Out << ' ';

3052

3055}

3056

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

3059 return;

3060

3061 Out << " [ ";

3062

3063 ListSeparator LS;

3066

3067 Out << LS << '"';

3069 Out << '"';

3070

3071 Out << '(';

3072

3073 ListSeparator InnerLS;

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

3076 Out << InnerLS;

3077 if (Input == nullptr)

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

3079 else

3081 }

3082

3083 Out << ')';

3084 }

3085

3086 Out << " ]";

3087}

3088

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

3090 Machine.initializeIfNeeded();

3091

3092 if (ShouldPreserveUseListOrder)

3094

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

3096

3097

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

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

3100

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

3102 Out << "source_filename = \"";

3104 Out << "\"\n";

3105 }

3106

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

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

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

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

3112

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

3114 Out << '\n';

3115

3116

3117 StringRef Asm = M->getModuleInlineAsm();

3118 do {

3119 StringRef Front;

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

3121

3122

3123

3124 Out << "module asm \"";

3126 Out << "\"\n";

3127 } while ( Asm .empty());

3128 }

3129

3130 printTypeIdentities();

3131

3132

3133 if (!Comdats.empty())

3134 Out << '\n';

3135 for (const Comdat *C : Comdats) {

3136 printComdat(C);

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

3138 Out << '\n';

3139 }

3140

3141

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

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

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

3145 }

3146

3147

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

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

3150 printAlias(&GA);

3151

3152

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

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

3155 printIFunc(&GI);

3156

3157

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

3159 Out << '\n';

3160 printFunction(&F);

3161 }

3162

3163

3164 printUseLists(nullptr);

3165

3166

3167 if ( Machine .as_empty()) {

3168 Out << '\n';

3169 writeAllAttributeGroups();

3170 }

3171

3172

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

3174

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

3176 printNamedMDNode(&Node);

3177

3178

3179 if ( Machine .mdn_empty()) {

3180 Out << '\n';

3181 writeAllMDNodes();

3182 }

3183}

3184

3185void AssemblyWriter::printModuleSummaryIndex() {

3187 int NumSlots = Machine.initializeIndexIfNeeded();

3188

3189 Out << "\n";

3190

3191

3192

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

3194 std::string RegularLTOModuleName =

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

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

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

3199

3200

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

3202

3203 unsigned i = 0;

3204 for (auto &ModPair : moduleVec) {

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

3206 Out << "path: \"";

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

3209 ListSeparator FS;

3210 for (auto Hash : ModPair.second)

3211 Out << FS << Hash;

3212 Out << "))\n";

3213 }

3214

3215

3216

3217 for (auto &GlobalList : *TheIndex) {

3218 auto GUID = GlobalList.first;

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

3221 }

3222

3223

3224 for (auto &GlobalList : *TheIndex) {

3225 auto GUID = GlobalList.first;

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

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

3228 }

3229

3230

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

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

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

3234 printTypeIdSummary(TID.second.second);

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

3236 }

3237

3238

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

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

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

3243 printTypeIdCompatibleVtableSummary(TId.second);

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

3245 }

3246

3247

3248 if (TheIndex->getFlags()) {

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

3250 ++NumSlots;

3251 }

3252

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

3254 << "\n";

3255}

3256

3257static const char *

3259 switch (K) {

3261 return "indir";

3263 return "singleImpl";

3265 return "branchFunnel";

3266 }

3267 llvm_unreachable("invalid WholeProgramDevirtResolution kind");

3268}

3269

3272 switch (K) {

3274 return "indir";

3276 return "uniformRetVal";

3278 return "uniqueRetVal";

3280 return "virtualConstProp";

3281 }

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

3283}

3284

3286 switch (K) {

3288 return "unknown";

3290 return "unsat";

3292 return "byteArray";

3294 return "inline";

3296 return "single";

3298 return "allOnes";

3299 }

3301}

3302

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

3306

3307

3308

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

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

3314

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

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

3318

3319 Out << ")";

3320}

3321

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

3323 Out << ", summary: (";

3324 printTypeTestResolution(TIS.TTRes);

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

3326 Out << ", wpdResolutions: (";

3327 ListSeparator FS;

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

3329 Out << FS;

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

3331 printWPDRes(WPDRes.second);

3332 Out << ")";

3333 }

3334 Out << ")";

3335 }

3336 Out << ")";

3337}

3338

3339void AssemblyWriter::printTypeIdCompatibleVtableSummary(

3341 Out << ", summary: (";

3342 ListSeparator FS;

3343 for (auto &P : TI) {

3344 Out << FS;

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

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

3347 Out << ")";

3348 }

3349 Out << ")";

3350}

3351

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

3354}

3355

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

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

3359

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

3362

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

3364 Out << ", resByArg: (";

3365 ListSeparator FS;

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

3367 Out << FS;

3368 printArgs(ResByArg.first);

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

3371 if (ResByArg.second.TheKind ==

3373 ResByArg.second.TheKind ==

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

3376

3377

3378

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

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

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

3382

3383 Out << ")";

3384 }

3385 Out << ")";

3386 }

3387 Out << ")";

3388}

3389

3391 switch (SK) {

3393 return "alias";

3395 return "function";

3397 return "variable";

3398 }

3400}

3401

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

3403 Out << ", aliasee: ";

3404

3405

3406

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

3409 else

3410 Out << "null";

3411}

3412

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

3414 auto VTableFuncs = GS->vTableFuncs();

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

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

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

3418 if (!VTableFuncs.empty())

3419 Out << ", "

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

3421 Out << ")";

3422

3423 if (!VTableFuncs.empty()) {

3424 Out << ", vTableFuncs: (";

3425 ListSeparator FS;

3426 for (auto &P : VTableFuncs) {

3427 Out << FS;

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

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

3430 Out << ")";

3431 }

3432 Out << ")";

3433 }

3434}

3435

3437 switch (LT) {

3439 return "external";

3441 return "private";

3443 return "internal";

3445 return "linkonce";

3447 return "linkonce_odr";

3449 return "weak";

3451 return "weak_odr";

3453 return "common";

3455 return "appending";

3457 return "extern_weak";

3459 return "available_externally";

3460 }

3462}

3463

3464

3465

3466

3472

3474 switch (Vis) {

3476 return "default";

3478 return "hidden";

3480 return "protected";

3481 }

3483}

3484

3486 switch (IK) {

3488 return "definition";

3490 return "declaration";

3491 }

3493}

3494

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

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

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

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

3499

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

3501 Out << ", calls: (";

3502 ListSeparator IFS;

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

3504 Out << IFS;

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

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

3508 else if (Call.second.RelBlockFreq)

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

3510

3511

3512 if (Call.second.HasTailCall)

3513 Out << ", tail: 1";

3514 Out << ")";

3515 }

3516 Out << ")";

3517 }

3518

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

3520 printTypeIdInfo(*TIdInfo);

3521

3522

3523

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

3525 switch (Type) {

3526 case (uint8_t)AllocationType::None:

3527 return "none";

3528 case (uint8_t)AllocationType::NotCold:

3529 return "notcold";

3530 case (uint8_t)AllocationType::Cold:

3531 return "cold";

3532 case (uint8_t)AllocationType::Hot:

3533 return "hot";

3534 }

3536 };

3537

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

3539 Out << ", allocs: (";

3540 ListSeparator AFS;

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

3542 Out << AFS;

3543 Out << "(versions: (";

3544 ListSeparator VFS;

3545 for (auto V : AI.Versions) {

3546 Out << VFS;

3547 Out << AllocTypeName(V);

3548 }

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

3550 ListSeparator MIBFS;

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

3552 Out << MIBFS;

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

3554 Out << ", stackIds: (";

3555 ListSeparator SIDFS;

3556 for (auto Id : MIB.StackIdIndices) {

3557 Out << SIDFS;

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

3559 }

3560 Out << "))";

3561 }

3562 Out << "))";

3563 }

3564 Out << ")";

3565 }

3566

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

3568 Out << ", callsites: (";

3569 ListSeparator SNFS;

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

3571 Out << SNFS;

3572 if (CI.Callee)

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

3574 else

3575 Out << "(callee: null";

3576 Out << ", clones: (";

3577 ListSeparator VFS;

3578 for (auto V : CI.Clones) {

3579 Out << VFS;

3580 Out << V;

3581 }

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

3583 ListSeparator SIDFS;

3584 for (auto Id : CI.StackIdIndices) {

3585 Out << SIDFS;

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

3587 }

3588 Out << "))";

3589 }

3590 Out << ")";

3591 }

3592

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

3595 };

3596

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

3598 Out << ", params: (";

3599 ListSeparator IFS;

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

3601 Out << IFS;

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

3603 Out << ", offset: ";

3604 PrintRange(PS.Use);

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

3606 Out << ", calls: (";

3607 ListSeparator IFS;

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

3609 Out << IFS;

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

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

3612 Out << ", offset: ";

3613 PrintRange(Call.Offsets);

3614 Out << ")";

3615 }

3616 Out << ")";

3617 }

3618 Out << ")";

3619 }

3620 Out << ")";

3621 }

3622}

3623

3624void AssemblyWriter::printTypeIdInfo(

3625 const FunctionSummary::TypeIdInfo &TIDInfo) {

3626 Out << ", typeIdInfo: (";

3627 ListSeparator TIDFS;

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

3629 Out << TIDFS;

3630 Out << "typeTests: (";

3631 ListSeparator FS;

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

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

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

3635 Out << FS;

3636 Out << GUID;

3637 continue;

3638 }

3639

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

3641 Out << FS;

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

3644 Out << "^" << Slot;

3645 }

3646 }

3647 Out << ")";

3648 }

3650 Out << TIDFS;

3652 }

3654 Out << TIDFS;

3656 }

3658 Out << TIDFS;

3660 "typeTestAssumeConstVCalls");

3661 }

3663 Out << TIDFS;

3665 "typeCheckedLoadConstVCalls");

3666 }

3667 Out << ")";

3668}

3669

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

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

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

3673 Out << "vFuncId: (";

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

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

3676 Out << ")";

3677 return;

3678 }

3679

3680 ListSeparator FS;

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

3682 Out << FS;

3683 Out << "vFuncId: (";

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

3686 Out << "^" << Slot;

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

3688 Out << ")";

3689 }

3690}

3691

3692void AssemblyWriter::printNonConstVCalls(

3694 Out << Tag << ": (";

3695 ListSeparator FS;

3696 for (auto &VFuncId : VCallList) {

3697 Out << FS;

3698 printVFuncId(VFuncId);

3699 }

3700 Out << ")";

3701}

3702

3703void AssemblyWriter::printConstVCalls(

3705 Out << Tag << ": (";

3706 ListSeparator FS;

3707 for (auto &ConstVCall : VCallList) {

3708 Out << FS;

3709 Out << "(";

3710 printVFuncId(ConstVCall.VFunc);

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

3712 Out << ", ";

3713 printArgs(ConstVCall.Args);

3714 }

3715 Out << ")";

3716 }

3717 Out << ")";

3718}

3719

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

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

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

3725 << ", flags: (";

3727 Out << ", visibility: "

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

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

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

3733 Out << ", importType: "

3735 Out << ")";

3736

3741 else

3743

3744 auto RefList = Summary.refs();

3745 if (!RefList.empty()) {

3746 Out << ", refs: (";

3747 ListSeparator FS;

3748 for (auto &Ref : RefList) {

3749 Out << FS;

3750 if (Ref.isReadOnly())

3751 Out << "readonly ";

3752 else if (Ref.isWriteOnly())

3753 Out << "writeonly ";

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

3755 }

3756 Out << ")";

3757 }

3758

3759 Out << ")";

3760}

3761

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

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

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

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

3766 else

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

3768 if (.getSummaryList().empty()) {

3769 Out << ", summaries: (";

3770 ListSeparator FS;

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

3772 Out << FS;

3773 printSummary(*Summary);

3774 }

3775 Out << ")";

3776 }

3777 Out << ")";

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

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

3780 Out << "\n";

3781}

3782

3785 if (Name.empty()) {

3786 Out << " ";

3787 } else {

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

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

3790 FirstC == '_')

3791 Out << FirstC;

3792 else

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

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

3795 unsigned char C = Name[i];

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

3797 Out << C;

3798 else

3800 }

3801 }

3802}

3803

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

3805 Out << '!';

3807 Out << " = !{";

3808 ListSeparator LS;

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

3810 Out << LS;

3811

3812

3815 continue;

3816 }

3817

3819 if (Slot == -1)

3820 Out << "";

3821 else

3822 Out << '!' << Slot;

3823 }

3824 Out << "}\n";

3825}

3826

3829 switch (Vis) {

3833 }

3834}

3835

3839 Out << "dso_local ";

3840}

3841

3844 switch (SCT) {

3848 }

3849}

3850

3853 switch (TLM) {

3855 break;

3857 Out << "thread_local ";

3858 break;

3860 Out << "thread_local(localdynamic) ";

3861 break;

3863 Out << "thread_local(initialexec) ";

3864 break;

3866 Out << "thread_local(localexec) ";

3867 break;

3868 }

3869}

3870

3872 switch (UA) {

3874 return "";

3876 return "local_unnamed_addr";

3878 return "unnamed_addr";

3879 }

3881}

3882

3886 if ()

3887 return;

3888

3890 Out << ',';

3891 Out << " comdat";

3892

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

3894 return;

3895

3896 Out << '(';

3898 Out << ')';

3899}

3900

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

3903 Out << "; Materializable\n";

3904

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

3907 Out << " = ";

3908

3910 Out << "external ";

3911

3918 if (!UA.empty())

3919 Out << UA << ' ';

3920

3922 "", " ");

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

3926

3928 Out << ' ';

3930 }

3931

3933 Out << ", section \"";

3935 Out << '"';

3936 }

3938 Out << ", partition \"";

3940 Out << '"';

3941 }

3943 Out << ", code_model \"";

3944 switch (*CM) {

3946 Out << "tiny";

3947 break;

3949 Out << "small";

3950 break;

3952 Out << "kernel";

3953 break;

3955 Out << "medium";

3956 break;

3958 Out << "large";

3959 break;

3960 }

3961 Out << '"';

3962 }

3963

3968 Out << ", no_sanitize_address";

3970 Out << ", no_sanitize_hwaddress";

3972 Out << ", sanitize_memtag";

3974 Out << ", sanitize_address_dyninit";

3975 }

3976

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

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

3980

3983 printMetadataAttachments(MDs, ", ");

3984

3986 if (Attrs.hasAttributes())

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

3988

3990}

3991

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

3994 Out << "; Materializable\n";

3995

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

3998 Out << " = ";

3999

4006 if (!UA.empty())

4007 Out << UA << ' ';

4008

4009 Out << "alias ";

4010

4012 Out << ", ";

4013

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

4016 } else {

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

4018 Out << " <>";

4019 }

4020

4022 Out << ", partition \"";

4024 Out << '"';

4025 }

4026

4028 Out << '\n';

4029}

4030

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

4033 Out << "; Materializable\n";

4034

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

4037 Out << " = ";

4038

4042

4043 Out << "ifunc ";

4044

4046 Out << ", ";

4047

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

4050 } else {

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

4052 Out << " <>";

4053 }

4054

4056 Out << ", partition \"";

4058 Out << '"';

4059 }

4062 if (!MDs.empty()) {

4063 printMetadataAttachments(MDs, ", ");

4064 }

4065

4067 Out << '\n';

4068}

4069

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

4071 C->print(Out);

4072}

4073

4074void AssemblyWriter::printTypeIdentities() {

4075 if (TypePrinter.empty())

4076 return;

4077

4078 Out << '\n';

4079

4080

4081 auto &NumberedTypes = TypePrinter.getNumberedTypes();

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

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

4084

4085

4086

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

4088 Out << '\n';

4089 }

4090

4091 auto &NamedTypes = TypePrinter.getNamedTypes();

4092 for (StructType *NamedType : NamedTypes) {

4094 Out << " = type ";

4095

4096

4097

4098 TypePrinter.printStructBody(NamedType, Out);

4099 Out << '\n';

4100 }

4101}

4102

4103

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

4105 if (F->isMaterializable())

4106 Out << "; Materializable\n";

4107 else if (AnnotationWriter)

4109

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

4111 if (Attrs.hasFnAttrs()) {

4112 AttributeSet AS = Attrs.getFnAttrs();

4113 std::string AttrStr;

4114

4115 for (const Attribute &Attr : AS) {

4116 if (!Attr.isStringAttribute()) {

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

4118 AttrStr += Attr.getAsString();

4119 }

4120 }

4121

4122 if (!AttrStr.empty())

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

4124 }

4125

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

4128

4129 Machine.incorporateFunction(F);

4130

4131 if (F->isDeclaration()) {

4132 Out << "declare";

4134 F->getAllMetadata(MDs);

4135 printMetadataAttachments(MDs, " ");

4136 Out << ' ';

4137 } else

4138 Out << "define ";

4139

4144

4145

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

4148 Out << " ";

4149 }

4150

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

4152 if (Attrs.hasRetAttrs())

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

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

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

4156 Out << ' ';

4158 Out << '(';

4159

4160

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

4162

4163 ListSeparator LS;

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

4165 Out << LS;

4166

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

4168

4169 AttributeSet ArgAttrs = Attrs.getParamAttrs(I);

4171 Out << ' ';

4172 writeAttributeSet(ArgAttrs);

4173 }

4174 }

4175 } else {

4176

4177 ListSeparator LS;

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

4179 Out << LS;

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

4181 }

4182 }

4183

4184

4185 if (FT->isVarArg()) {

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

4187 Out << "...";

4188 }

4189 Out << ')';

4191 if (!UA.empty())

4192 Out << ' ' << UA;

4193

4194

4195

4197 bool ForcePrintAddressSpace =

4198 Mod || Mod->getDataLayout().getProgramAddressSpace() != 0;

4200 "", ForcePrintAddressSpace);

4201 if (Attrs.hasFnAttrs())

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

4203 if (F->hasSection()) {

4204 Out << " section \"";

4206 Out << '"';

4207 }

4208 if (F->hasPartition()) {

4209 Out << " partition \"";

4211 Out << '"';

4212 }

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

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

4216 if (F->hasGC())

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

4218 if (F->hasPrefixData()) {

4219 Out << " prefix ";

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

4221 }

4222 if (F->hasPrologueData()) {

4223 Out << " prologue ";

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

4225 }

4226 if (F->hasPersonalityFn()) {

4227 Out << " personality ";

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

4229 }

4230

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

4233 Out << " ";

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

4235 }

4236 }

4237

4238 if (F->isDeclaration()) {

4239 Out << '\n';

4240 } else {

4242 F->getAllMetadata(MDs);

4243 printMetadataAttachments(MDs, " ");

4244

4245 Out << " {";

4246

4247 for (const BasicBlock &BB : *F)

4249

4250

4251 printUseLists(F);

4252

4253 Out << "}\n";

4254 }

4255

4256 Machine.purgeFunction();

4257}

4258

4259

4260

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

4262

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

4264

4265

4266 if (Attrs.hasAttributes()) {

4267 Out << ' ';

4268 writeAttributeSet(Attrs);

4269 }

4270

4271

4273 Out << ' ';

4275 } else {

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

4278 Out << " %" << Slot;

4279 }

4280}

4281

4282

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

4285 if (BB->hasName()) {

4286 Out << "\n";

4288 Out << ':';

4289 } else if (!IsEntryBlock) {

4290 Out << "\n";

4291 int Slot = Machine.getLocalSlot(BB);

4292 if (Slot != -1)

4293 Out << Slot << ":";

4294 else

4295 Out << ":";

4296 }

4297

4298 if (!IsEntryBlock) {

4299

4301 Out << ";";

4303 Out << " No predecessors!";

4304 } else {

4305 Out << " preds = ";

4308 Out << LS;

4309 writeOperand(Pred, false);

4310 }

4311 }

4312 }

4313

4314 Out << "\n";

4315

4317

4318

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

4321 printDbgRecordLine(DR);

4322 printInstructionLine(I);

4323 }

4324

4326}

4327

4328

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

4330 printInstruction(I);

4331 Out << '\n';

4332}

4333

4334

4335

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

4337 Out << " ; (";

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

4339 Out << ", ";

4341 Out << ")";

4342}

4343

4344

4345

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

4348 printGCRelocateComment(*Relocate);

4349

4350 if (AnnotationWriter && !isMaterializable)

4352

4355 if (I->getDebugLoc()) {

4356 Out << " ; ";

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

4358 }

4359 }

4360 }

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

4364 Out << " ; ";

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

4366 }

4367 }

4368 }

4369

4371 Out << " ; " << &V;

4372}

4373

4376 if (Operand == nullptr) {

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

4378 return;

4379 }

4380

4381

4382

4383

4384

4387 bool ForcePrintAddrSpace =

4388 Mod || Mod->getDataLayout().getProgramAddressSpace() != 0;

4390 ForcePrintAddrSpace);

4391}

4392

4393

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

4396

4397

4398 Out << " ";

4399

4400

4401 if (I.hasName()) {

4403 Out << " = ";

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

4405

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

4407 if (SlotNum == -1)

4408 Out << " = ";

4409 else

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

4411 }

4412

4414 if (CI->isMustTailCall())

4415 Out << "musttail ";

4416 else if (CI->isTailCall())

4417 Out << "tail ";

4418 else if (CI->isNoTailCall())

4419 Out << "notail ";

4420 }

4421

4422

4423 Out << I.getOpcodeName();

4424

4425

4428 Out << " atomic";

4429

4431 Out << " weak";

4432

4433

4438 Out << " volatile";

4439

4440

4442

4443

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

4446

4447

4450

4451

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

4453

4454

4457 Out << ' ';

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

4459 Out << ", ";

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

4461 Out << ", ";

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

4463

4466

4467 Out << ' ';

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

4469 Out << ", ";

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

4471 Out << " [";

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

4473 Out << "\n ";

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

4475 Out << ", ";

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

4477 }

4478 Out << "\n ]";

4480

4481 Out << ' ';

4482 writeOperand(Operand, true);

4483 Out << ", [";

4484

4485 ListSeparator LS;

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

4487 Out << LS;

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

4489 }

4490 Out << ']';

4492 Out << ' ';

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

4494 Out << ' ';

4495

4496 ListSeparator LS;

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

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

4499 Out << LS << "[ ";

4500 writeOperand(V, false);

4501 Out << ", ";

4502 writeOperand(Block, false);

4503 Out << " ]";

4504 }

4506 Out << ' ';

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

4508 Out << ", ";

4511 Out << ' ';

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

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

4514 Out << ", ";

4517 Out << ' ';

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

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

4520 Out << '\n';

4521

4522 if (LPI->isCleanup())

4523 Out << " cleanup";

4524

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

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

4527 if (LPI->isCatch(i))

4528 Out << " catch ";

4529 else

4530 Out << " filter ";

4531

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

4533 }

4535 Out << " within ";

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

4537 Out << " [";

4538 ListSeparator LS;

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

4540 Out << LS;

4541 writeOperand(PadBB, true);

4542 }

4543 Out << "] unwind ";

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

4545 writeOperand(UnwindDest, true);

4546 else

4547 Out << "to caller";

4549 Out << " within ";

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

4551 Out << " [";

4552 ListSeparator LS;

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

4554 Out << LS;

4555 writeOperand(Op, true);

4556 }

4557 Out << ']';

4559 Out << " void";

4561 Out << " from ";

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

4563

4564 Out << " to ";

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

4567 Out << " from ";

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

4569

4570 Out << " unwind ";

4571 if (CRI->hasUnwindDest())

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

4573 else

4574 Out << "to caller";

4576

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

4578 Out << " ";

4580 }

4581

4582 Operand = CI->getCalledOperand();

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

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

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

4586

4587 if (PAL.hasRetAttrs())

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

4589

4590

4592

4593

4594

4595

4596 Out << ' ';

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

4598 Out << ' ';

4599 writeOperand(Operand, false);

4600 Out << '(';

4601 bool HasPrettyPrintedArgs =

4604

4605 ListSeparator LS;

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

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

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

4609 if (!ConstArg)

4610 return;

4611 std::string ArgComment;

4612 raw_string_ostream ArgCommentStream(ArgComment);

4615 if (ArgComment.empty())

4616 return;

4617 Out << "/* " << ArgComment << " */ ";

4618 };

4619 if (HasPrettyPrintedArgs) {

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

4621 ++ArgNo) {

4622 Out << LS;

4623 PrintArgComment(ArgNo);

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

4625 }

4626 } else {

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

4628 ++ArgNo) {

4629 Out << LS;

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

4631 }

4632 }

4633

4634

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

4636 CI->getParent()->getParent() &&

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

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

4639 Out << ", ";

4640 Out << "...";

4641 }

4642

4643 Out << ')';

4644 if (PAL.hasFnAttrs())

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

4646

4647 writeOperandBundles(CI);

4649 Operand = II->getCalledOperand();

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

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

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

4653

4654

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

4656 Out << " ";

4658 }

4659

4660 if (PAL.hasRetAttrs())

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

4662

4663

4665

4666

4667

4668

4669

4670 Out << ' ';

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

4672 Out << ' ';

4673 writeOperand(Operand, false);

4674 Out << '(';

4675 ListSeparator LS;

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

4677 Out << LS;

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

4679 }

4680

4681 Out << ')';

4682 if (PAL.hasFnAttrs())

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

4684

4685 writeOperandBundles(II);

4686

4687 Out << "\n to ";

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

4689 Out << " unwind ";

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

4692 Operand = CBI->getCalledOperand();

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

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

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

4696

4697

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

4699 Out << " ";

4701 }

4702

4703 if (PAL.hasRetAttrs())

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

4705

4706

4707

4708

4709

4710 Out << ' ';

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

4712 Out << ' ';

4713 writeOperand(Operand, false);

4714 Out << '(';

4715 ListSeparator ArgLS;

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

4717 Out << ArgLS;

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

4719 }

4720

4721 Out << ')';

4722 if (PAL.hasFnAttrs())

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

4724

4725 writeOperandBundles(CBI);

4726

4727 Out << "\n to ";

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

4729 Out << " [";

4730 ListSeparator DestLS;

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

4732 Out << DestLS;

4733 writeOperand(Dest, true);

4734 }

4735 Out << ']';

4737 Out << ' ';

4738 if (AI->isUsedWithInAlloca())

4739 Out << "inalloca ";

4740 if (AI->isSwiftError())

4741 Out << "swifterror ";

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

4743

4744

4745

4746

4747

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

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

4750 Out << ", ";

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

4752 }

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

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

4755 }

4756

4758 ", ");

4760 if (Operand) {

4761 Out << ' ';

4762 writeOperand(Operand, true);

4763 }

4764 Out << " to ";

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

4767 if (Operand) {

4768 Out << ' ';

4769 writeOperand(Operand, true);

4770 }

4771 Out << ", ";

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

4773 } else if (Operand) {

4775 Out << ' ';

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

4777 Out << ',';

4779 Out << ' ';

4780 TypePrinter.print(LI->getType(), Out);

4781 Out << ',';

4782 }

4783

4784

4785

4786

4787 bool PrintAllTypes = false;

4789

4790

4791

4795 PrintAllTypes = true;

4796 } else {

4797 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {

4798 Operand = I.getOperand(i);

4799

4800

4801 if (Operand && Operand->getType() != TheType) {

4802 PrintAllTypes = true;

4803 break;

4804 }

4805 }

4806 }

4807

4808 if (!PrintAllTypes) {

4809 Out << ' ';

4810 TypePrinter.print(TheType, Out);

4811 }

4812

4813 Out << ' ';

4814 ListSeparator LS;

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

4816 Out << LS;

4817 writeOperand(Op, PrintAllTypes);

4818 }

4819 }

4820

4821

4823 if (LI->isAtomic())

4824 writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());

4825 if (MaybeAlign A = LI->getAlign())

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

4828 if (SI->isAtomic())

4829 writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());

4830 if (MaybeAlign A = SI->getAlign())

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

4833 writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),

4834 CXI->getFailureOrdering(), CXI->getSyncScopeID());

4835 Out << ", align " << CXI->getAlign().value();

4837 writeAtomic(RMWI->getContext(), RMWI->getOrdering(),

4838 RMWI->getSyncScopeID());

4839 Out << ", align " << RMWI->getAlign().value();

4841 writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());

4843 printShuffleMask(Out, SVI->getType(), SVI->getShuffleMask());

4844 }

4845

4846

4849 printMetadataAttachments(InstMD, ", ");

4850

4851

4852 printInfoComment(I);

4853}

4854

4855void AssemblyWriter::printDbgMarker(const DbgMarker &Marker) {

4856

4857

4859 printDbgRecord(DPR);

4860 Out << "\n";

4861 }

4862

4863 Out << " DbgMarker -> { ";

4865 Out << " }";

4866}

4867

4868void AssemblyWriter::printDbgRecord(const DbgRecord &DR) {

4870 printDbgVariableRecord(*DVR);

4872 printDbgLabelRecord(*DLR);

4873 else

4875}

4876

4877void AssemblyWriter::printDbgVariableRecord(const DbgVariableRecord &DVR) {

4879 Out << "#dbg_";

4880 switch (DVR.getType()) {

4881 case DbgVariableRecord::LocationType::Value:

4882 Out << "value";

4883 break;

4884 case DbgVariableRecord::LocationType::Declare:

4885 Out << "declare";

4886 break;

4887 case DbgVariableRecord::LocationType::DeclareValue:

4888 Out << "declare_value";

4889 break;

4890 case DbgVariableRecord::LocationType::Assign:

4891 Out << "assign";

4892 break;

4893 default:

4895 "Tried to print a DbgVariableRecord with an invalid LocationType!");

4896 }

4897

4898 auto PrintOrNull = [&](Metadata *M) {

4899 if (!M)

4900 Out << "(null)";

4901 else

4903 };

4904

4905 Out << "(";

4907 Out << ", ";

4909 Out << ", ";

4911 Out << ", ";

4914 Out << ", ";

4916 Out << ", ";

4918 Out << ", ";

4919 }

4921 Out << ")";

4922}

4923

4924

4925

4926void AssemblyWriter::printDbgRecordLine(const DbgRecord &DR) {

4927

4928 Out << " ";

4929 printDbgRecord(DR);

4930 Out << '\n';

4931}

4932

4933void AssemblyWriter::printDbgLabelRecord(const DbgLabelRecord &Label) {

4935 Out << "#dbg_label(";

4937 Out << ", ";

4939 Out << ")";

4940}

4941

4942void AssemblyWriter::printMetadataAttachments(

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

4944 StringRef Separator) {

4945 if (MDs.empty())

4946 return;

4947

4948 if (MDNames.empty())

4949 MDs[0].second->getContext().getMDKindNames(MDNames);

4950

4952 for (const auto &I : MDs) {

4953 unsigned Kind = I.first;

4954 Out << Separator;

4955 if (Kind < MDNames.size()) {

4956 Out << "!";

4958 } else

4959 Out << "!<unknown kind #" << Kind << ">";

4960 Out << ' ';

4962 }

4963}

4964

4965void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {

4966 Out << '!' << Slot << " = ";

4967 printMDNodeBody(Node);

4968 Out << "\n";

4969}

4970

4971void AssemblyWriter::writeAllMDNodes() {

4976

4977 for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {

4978 writeMDNode(i, Nodes[i]);

4979 }

4980}

4981

4982void AssemblyWriter::printMDNodeBody(const MDNode *Node) {

4985}

4986

4987void AssemblyWriter::writeAttribute(const Attribute &Attr, bool InAttrGroup) {

4990 return;

4991 }

4992

4993 Out << Attribute::getNameFromAttrKind(Attr.getKindAsEnum());

4995 Out << '(';

4996 TypePrinter.print(Ty, Out);

4997 Out << ')';

4998 }

4999}

5000

5001void AssemblyWriter::writeAttributeSet(const AttributeSet &AttrSet,

5002 bool InAttrGroup) {

5003 ListSeparator LS(" ");

5004 for (const auto &Attr : AttrSet) {

5005 Out << LS;

5006 writeAttribute(Attr, InAttrGroup);

5007 }

5008}

5009

5010void AssemblyWriter::writeAllAttributeGroups() {

5011 std::vector<std::pair<AttributeSet, unsigned>> asVec;

5012 asVec.resize(Machine.as_size());

5013

5015 asVec[I.second] = I;

5016

5017 for (const auto &I : asVec)

5018 Out << "attributes #" << I.second << " = { "

5019 << I.first.getAsString(true) << " }\n";

5020}

5021

5022void AssemblyWriter::printUseListOrder(const Value *V,

5023 ArrayRef Shuffle) {

5025 if (IsInFunction)

5026 Out << " ";

5027

5028 Out << "uselistorder";

5029 if (const BasicBlock *BB = IsInFunction ? nullptr : dyn_cast(V)) {

5030 Out << "_bb ";

5031 writeOperand(BB->getParent(), false);

5032 Out << ", ";

5033 writeOperand(BB, false);

5034 } else {

5035 Out << " ";

5036 writeOperand(V, true);

5037 }

5038

5039 assert(Shuffle.size() >= 2 && "Shuffle too small");

5041}

5042

5043void AssemblyWriter::printUseLists(const Function *F) {

5044 auto It = UseListOrders.find(F);

5045 if (It == UseListOrders.end())

5046 return;

5047

5048 Out << "\n; uselistorder directives\n";

5049 for (const auto &Pair : It->second)

5050 printUseListOrder(Pair.first, Pair.second);

5051}

5052

5053

5054

5055

5056

5058 bool ShouldPreserveUseListOrder, bool IsForDebug) const {

5061 AssemblyWriter W(OS, SlotTable, this->getParent(), AAW, IsForDebug,

5062 ShouldPreserveUseListOrder);

5063 W.printFunction(this);

5064}

5065

5067 bool ShouldPreserveUseListOrder,

5068 bool IsForDebug) const {

5071 AssemblyWriter W(OS, SlotTable, this->getModule(), AAW,

5072 IsForDebug,

5073 ShouldPreserveUseListOrder);

5074 W.printBasicBlock(this);

5075}

5076

5078 bool ShouldPreserveUseListOrder, bool IsForDebug) const {

5081 AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,

5082 ShouldPreserveUseListOrder);

5083 W.printModule(this);

5084}

5085

5089 AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);

5090 W.printNamedMDNode(this);

5091}

5092

5094 bool IsForDebug) const {

5095 std::optional LocalST;

5098 SlotTable = ST;

5099 else {

5101 SlotTable = &*LocalST;

5102 }

5103

5105 AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);

5106 W.printNamedMDNode(this);

5107}

5108

5111 ROS << " = comdat ";

5112

5115 ROS << "any";

5116 break;

5118 ROS << "exactmatch";

5119 break;

5121 ROS << "largest";

5122 break;

5124 ROS << "nodeduplicate";

5125 break;

5127 ROS << "samesize";

5128 break;

5129 }

5130

5131 ROS << '\n';

5132}

5133

5135 TypePrinting TP;

5136 TP.print(const_cast<Type*>(this), OS);

5137

5138 if (NoDetails)

5139 return;

5140

5141

5144 OS << " = type ";

5145 TP.printStructBody(STy, OS);

5146 }

5147}

5148

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

5152 if (F->isIntrinsic())

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

5156 return true;

5157 return false;

5158}

5159

5161

5163 print(ROS, MST, IsForDebug);

5164}

5165

5167

5169 print(ROS, MST, IsForDebug);

5170}

5171

5173 bool IsForDebug) const {

5175 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));

5179 if (F)

5181 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);

5182 W.printDbgMarker(*this);

5183}

5184

5186

5188 print(ROS, MST, IsForDebug);

5189}

5190

5192 bool IsForDebug) const {

5194 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));

5198 ? Marker->getParent()->getParent()

5199 : nullptr;

5200 if (F)

5202 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);

5203 W.printDbgVariableRecord(*this);

5204}

5205

5207 bool IsForDebug) const {

5209 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));

5213 Marker->getParent() ? Marker->getParent()->getParent() : nullptr;

5214 if (F)

5216

5217 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);

5218 W.printDbgLabelRecord(*this);

5219}

5220

5222 bool ShouldInitializeAllMetadata = false;

5226 ShouldInitializeAllMetadata = true;

5227

5229 print(ROS, MST, IsForDebug);

5230}

5231

5233 bool IsForDebug) const {

5235 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));

5238 auto IncorporateFunction = [&](const Function *F) {

5239 if (F)

5241 };

5242

5244 IncorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);

5245 AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);

5246 W.printInstruction(*I);

5248 IncorporateFunction(BB->getParent());

5249 AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);

5250 W.printBasicBlock(BB);

5252 AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);

5254 W.printGlobal(V);

5256 W.printFunction(F);

5258 W.printAlias(A);

5260 W.printIFunc(I);

5261 else

5266 TypePrinting TypePrinter;

5267 TypePrinter.print(C->getType(), OS);

5268 OS << ' ';

5269 AsmWriterContext WriterCtx(&TypePrinter, MST.getMachine());

5272 this->printAsOperand(OS, true, MST);

5273 } else {

5275 }

5276}

5277

5278

5279

5280

5285 AsmWriterContext WriterCtx(nullptr, Machine, M);

5287 return true;

5288 }

5289 return false;

5290}

5291

5298

5300 const Module *M) const {

5301 if (!M)

5303

5304 if (!PrintType)

5306 return;

5307

5312}

5313

5316 if (!PrintType)

5318 return;

5319

5321}

5322

5323

5325 AsmWriterContext &WriterCtx) {

5328

5331 return;

5332

5333 OS << " = ";

5335}

5336

5337namespace {

5338struct MDTreeAsmWriterContext : public AsmWriterContext {

5339 unsigned Level;

5340

5341 using EntryTy = std::pair<unsigned, std::string>;

5343

5344

5345 SmallPtrSet<const Metadata *, 4> Visited;

5346

5347 raw_ostream &MainOS;

5348

5349 MDTreeAsmWriterContext(TypePrinting *TP, SlotTracker *ST, const Module *M,

5350 raw_ostream &OS, const Metadata *InitMD)

5351 : AsmWriterContext(TP, ST, M), Level(0U), Visited({InitMD}), MainOS(OS) {}

5352

5353 void onWriteMetadataAsOperand(const Metadata *MD) override {

5354 if (!Visited.insert(MD).second)

5355 return;

5356

5357 std::string Str;

5358 raw_string_ostream SS(Str);

5360

5361

5362 Buffer.emplace_back(std::make_pair(Level, ""));

5363 unsigned InsertIdx = Buffer.size() - 1;

5364

5366 Buffer[InsertIdx].second = std::move(SS.str());

5368 }

5369

5370 ~MDTreeAsmWriterContext() override {

5371 for (const auto &Entry : Buffer) {

5372 MainOS << "\n";

5373 unsigned NumIndent = Entry.first * 2U;

5374 MainOS.indent(NumIndent) << Entry.second;

5375 }

5376 }

5377};

5378}

5379

5382 bool OnlyAsOperand, bool PrintAsTree = false) {

5384

5385 TypePrinting TypePrinter(M);

5386

5387 std::unique_ptr WriterCtx;

5388 if (PrintAsTree && !OnlyAsOperand)

5389 WriterCtx = std::make_unique(

5390 &TypePrinter, MST.getMachine(), M, OS, &MD);

5391 else

5392 WriterCtx =

5393 std::make_unique(&TypePrinter, MST.getMachine(), M);

5394

5396

5399 return;

5400

5401 OS << " = ";

5403}

5404

5409

5411 const Module *M) const {

5413}

5414

5420

5425

5431

5433 const Module *M) const {

5435 true);

5436}

5437

5441 AssemblyWriter W(OS, SlotTable, this, IsForDebug);

5442 W.printModuleSummaryIndex();

5443}

5444

5446 unsigned UB) const {

5448 if (!ST)

5449 return;

5450

5451 for (auto &I : llvm::make_range(ST->mdn_begin(), ST->mdn_end()))

5452 if (I.second >= LB && I.second < UB)

5453 L.push_back(std::make_pair(I.second, I.first));

5454}

5455

5456#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

5457

5460

5461

5467

5468

5471

5472

5475

5476

5482

5483

5486

5487

5490

5493

5499

5502

5506 dbgs() << '\n';

5507}

5508

5509

5512#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:2511

static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:1956

static void writeDIGlobalVariableExpression(raw_ostream &Out, const DIGlobalVariableExpression *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2663

static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2323

static void writeDIFixedPointType(raw_ostream &Out, const DIFixedPointType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2229

static void printDSOLocation(const GlobalValue &GV, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3836

static const char * getWholeProgDevirtResKindName(WholeProgramDevirtResolution::Kind K)

Definition AsmWriter.cpp:3258

static void writeDISubrangeType(raw_ostream &Out, const DISubrangeType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2303

static void writeAPFloatInternal(raw_ostream &Out, const APFloat &APF)

Definition AsmWriter.cpp:1536

static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD, ModuleSlotTracker &MST, const Module *M, bool OnlyAsOperand, bool PrintAsTree=false)

Definition AsmWriter.cpp:5380

static void writeDIStringType(raw_ostream &Out, const DIStringType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2252

static std::string getLinkageNameWithSpace(GlobalValue::LinkageTypes LT)

Definition AsmWriter.cpp:3467

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

static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2572

static void orderValue(const Value *V, OrderMap &OM)

Definition AsmWriter.cpp:135

static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2212

static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA)

Definition AsmWriter.cpp:3871

static const char * getWholeProgDevirtResByArgKindName(WholeProgramDevirtResolution::ByArg::Kind K)

Definition AsmWriter.cpp:3270

static void writeMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, AsmWriterContext &Ctx)

Definition AsmWriter.cpp:2701

static void writeDIModule(raw_ostream &Out, const DIModule *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2532

static void writeDIFile(raw_ostream &Out, const DIFile *N, AsmWriterContext &)

Definition AsmWriter.cpp:2376

static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2365

static cl::opt< bool > PrintAddrspaceName("print-addrspace-name", cl::Hidden, cl::init(false), cl::desc("Print address space names"))

static void writeOptimizationInfo(raw_ostream &Out, const User *U)

Definition AsmWriter.cpp:1496

static bool isReferencingMDNode(const Instruction &I)

Definition AsmWriter.cpp:5149

#define CC_VLS_CASE(ABI_VLEN)

static void writeDILabel(raw_ostream &Out, const DILabel *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2607

static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2270

static void printMetadataIdentifier(StringRef Name, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3783

static void printShuffleMask(raw_ostream &Out, Type *Ty, ArrayRef< int > Mask)

Definition AsmWriter.cpp:523

static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2687

static const Module * getModuleFromDPI(const DbgMarker *Marker)

Definition AsmWriter.cpp:339

static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType, ModuleSlotTracker &MST)

Definition AsmWriter.cpp:5292

static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2673

static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2437

static const char * getSummaryKindName(GlobalValueSummary::SummaryKind SK)

Definition AsmWriter.cpp:3390

static OrderMap orderModule(const Module *M)

Definition AsmWriter.cpp:155

static const char * getVisibilityName(GlobalValue::VisibilityTypes Vis)

Definition AsmWriter.cpp:3473

static void printCallingConv(unsigned cc, raw_ostream &Out)

Definition AsmWriter.cpp:349

static void printAddressSpace(const Module *M, unsigned AS, raw_ostream &OS, StringRef Prefix=" ", StringRef Suffix="", bool ForcePrint=false)

Definition AsmWriter.cpp:639

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

static SlotTracker * createSlotTracker(const Value *V)

Definition AsmWriter.cpp:1022

static void writeDILocation(raw_ostream &Out, const DILocation *DL, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2106

static void writeDINamespace(raw_ostream &Out, const DINamespace *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2489

DenseMap< const Function *, MapVector< const Value *, std::vector< unsigned > > > UseListOrderMap

Definition AsmWriter.cpp:123

static void writeDICommonBlock(raw_ostream &Out, const DICommonBlock *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2499

static UseListOrderMap predictUseListOrder(const Module *M)

Definition AsmWriter.cpp:288

static void printThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3851

static std::string getLinkageName(GlobalValue::LinkageTypes LT)

Definition AsmWriter.cpp:3436

static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2088

static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2591

static const char * getTTResKindName(TypeTestResolution::Kind K)

Definition AsmWriter.cpp:3285

static void writeDITemplateTypeParameter(raw_ostream &Out, const DITemplateTypeParameter *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2547

static const char * getImportTypeName(GlobalValueSummary::ImportKind IK)

Definition AsmWriter.cpp:3485

static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2392

static const Module * getModuleFromVal(const Value *V)

Definition AsmWriter.cpp:313

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

static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I, raw_ostream &Out)

Definition AsmWriter.cpp:4374

static void writeDIGenericSubrange(raw_ostream &Out, const DIGenericSubrange *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2152

static void writeDISubrange(raw_ostream &Out, const DISubrange *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2128

static void writeDILexicalBlockFile(raw_ostream &Out, const DILexicalBlockFile *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2477

static void writeConstantInternal(raw_ostream &Out, const Constant *CV, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:1629

static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N, AsmWriterContext &)

Definition AsmWriter.cpp:2200

static void writeAsOperandInternal(raw_ostream &Out, const Value *V, AsmWriterContext &WriterCtx, bool PrintType=false)

Definition AsmWriter.cpp:2721

static void printVisibility(GlobalValue::VisibilityTypes Vis, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3827

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

static void writeDIExpression(raw_ostream &Out, const DIExpression *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2623

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

static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2466

PrefixType

Definition AsmWriter.cpp:454

@ GlobalPrefix

Definition AsmWriter.cpp:455

@ LabelPrefix

Definition AsmWriter.cpp:457

@ LocalPrefix

Definition AsmWriter.cpp:458

@ NoPrefix

Definition AsmWriter.cpp:459

@ ComdatPrefix

Definition AsmWriter.cpp:456

static void maybePrintComdat(formatted_raw_ostream &Out, const GlobalObject &GO)

Definition AsmWriter.cpp:3883

static void printDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT, formatted_raw_ostream &Out)

Definition AsmWriter.cpp:3842

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

#define ST_DEBUG(X)

Definition AsmWriter.cpp:1051

static void writeDIArgList(raw_ostream &Out, const DIArgList *N, AsmWriterContext &WriterCtx, bool FromValue=false)

Definition AsmWriter.cpp:2648

static void writeDITemplateValueParameter(raw_ostream &Out, const DITemplateValueParameter *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2558

static const Value * skipMetadataWrapper(const Value *V)

Look for a value that might be wrapped as metadata, e.g.

Definition AsmWriter.cpp:128

static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N, AsmWriterContext &WriterCtx)

Definition AsmWriter.cpp:2522

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

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

LLVM_ABI void dump() const

Definition AsmWriter.cpp:5485

@ 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:5185

Per-instruction record of debug-info.

LLVM_ABI void dump() const

Definition AsmWriter.cpp:5463

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

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

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

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

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

LLVM_ABI void dumpTree() const

User-friendly dump in tree shape.

Definition AsmWriter.cpp:5501

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

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

void collectMDNodes(MachineMDNodeListType &L, unsigned LB, unsigned UB) const

Definition AsmWriter.cpp:5445

SlotTracker * getMachine()

Lazily creates a slot tracker.

Definition AsmWriter.cpp:976

void setProcessHook(std::function< void(AbstractSlotTrackerStorage *, const Module *, bool)>)

Definition AsmWriter.cpp:1010

void incorporateFunction(const Function &F)

Incorporate the given function.

Definition AsmWriter.cpp:991

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

LLVM_ABI void print(raw_ostream &OS, bool IsForDebug=false) const

Print to an output stream.

Definition AsmWriter.cpp:5438

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

void dump() const

Dump the module to stderr (for debugging).

Definition AsmWriter.cpp:5478

LLVM_ABI void dump() const

Definition AsmWriter.cpp:5489

LLVM_ABI StringRef getName() const

LLVM_ABI void print(raw_ostream &ROS, bool IsForDebug=false) const

Definition AsmWriter.cpp:5086

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

DenseMap< const Value *, unsigned > ValueMap

ValueMap - A mapping of Values to slot numbers.

Definition AsmWriter.cpp:790

bool mdn_empty() const

Definition AsmWriter.cpp:907

int getMetadataSlot(const MDNode *N) override

getMetadataSlot - Get the slot number of a MDNode.

Definition AsmWriter.cpp:1320

~SlotTracker() override=default

int getTypeIdCompatibleVtableSlot(StringRef Id)

Definition AsmWriter.cpp:1376

int getModulePathSlot(StringRef Path)

Definition AsmWriter.cpp:1349

bool as_empty() const

Definition AsmWriter.cpp:915

unsigned mdn_size() const

Definition AsmWriter.cpp:906

SlotTracker(const SlotTracker &)=delete

void purgeFunction()

After calling incorporateFunction, use this method to remove the most recently incorporated function ...

Definition AsmWriter.cpp:1286

mdn_iterator mdn_end()

Definition AsmWriter.cpp:905

int getTypeIdSlot(StringRef Id)

Definition AsmWriter.cpp:1367

void initializeIfNeeded()

These functions do the actual initialization.

Definition AsmWriter.cpp:1068

int getGlobalSlot(const GlobalValue *V)

getGlobalSlot - Get the slot number of a global value.

Definition AsmWriter.cpp:1295

as_iterator as_begin()

Definition AsmWriter.cpp:912

const Function * getFunction() const

Definition AsmWriter.cpp:894

unsigned getNextMetadataSlot() override

Definition AsmWriter.cpp:872

DenseMap< GlobalValue::GUID, unsigned >::iterator guid_iterator

GUID map iterators.

Definition AsmWriter.cpp:918

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

int getLocalSlot(const Value *V)

Return the slot number of the specified value in it's type plane.

Definition AsmWriter.cpp:1330

int getAttributeGroupSlot(AttributeSet AS)

Definition AsmWriter.cpp:1340

SlotTracker(const Module *M, bool ShouldInitializeAllMetadata=false)

Construct from a module.

Definition AsmWriter.cpp:1056

void createMetadataSlot(const MDNode *N) override

getMetadataSlot - Get the slot number of a MDNode.

Definition AsmWriter.cpp:1317

void setProcessHook(std::function< void(AbstractSlotTrackerStorage *, const Module *, bool)>)

Definition AsmWriter.cpp:1304

DenseMap< const MDNode *, unsigned >::iterator mdn_iterator

MDNode map iterators.

Definition AsmWriter.cpp:902

as_iterator as_end()

Definition AsmWriter.cpp:913

unsigned as_size() const

Definition AsmWriter.cpp:914

SlotTracker & operator=(const SlotTracker &)=delete

int getGUIDSlot(GlobalValue::GUID GUID)

Definition AsmWriter.cpp:1358

mdn_iterator mdn_begin()

Definition AsmWriter.cpp:904

int initializeIndexIfNeeded()

Definition AsmWriter.cpp:1078

DenseMap< AttributeSet, unsigned >::iterator as_iterator

AttributeSet map iterators.

Definition AsmWriter.cpp:910

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

LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const

Print the current type.

Definition AsmWriter.cpp:5134

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

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

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

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

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:462

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:...