ValueEnumerator.cpp Source File (original) (raw)

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

42#include

43#include

44#include

45#include

47using namespace llvm;

49namespace {

51struct OrderMap {

52 DenseMap<const Value *, std::pair<unsigned, bool>> IDs;

53 unsigned LastGlobalValueID = 0;

57 bool isGlobalValue(unsigned ID) const {

58 return ID <= LastGlobalValueID;

59 }

61 unsigned size() const { return IDs.size(); }

62 std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }

64 std::pair<unsigned, bool> lookup(const Value *V) const {

66 }

68 void index(const Value *V) {

70 unsigned ID = IDs.size() + 1;

71 IDs[V].first = ID;

72 }

73};

75}

78 if (OM.lookup(V).first)

79 return;

82 if (C->getNumOperands()) {

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

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

88 orderValue(CE->getShuffleMaskForBitcode(), OM);

89 }

90 }

94 OM.index(V);

95}

100 OrderMap OM;

101

102

103

104

105

106

107

108

109

118 OM.LastGlobalValueID = OM.size();

119

120 auto orderConstantValue = [&OM](const Value *V) {

123 };

124

126 if (F.isDeclaration())

127 continue;

128

129

130

133

134

135

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

140 orderConstantValue(VAM->getValue());

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

143 orderConstantValue(VAM->getValue());

144 }

145 };

146

148 OrderConstantFromMetadata(DVR.getRawLocation());

149 if (DVR.isDbgAssign())

150 OrderConstantFromMetadata(DVR.getRawAddress());

151 }

152

153 for (const Value *V : I.operands()) {

155 OrderConstantFromMetadata(MAV->getMetadata());

156 }

157 }

158

163 for (const Value *Op : I.operands())

164 orderConstantValue(Op);

166 orderValue(SVI->getShuffleMaskForBitcode(), OM);

168 for (const auto &Case : SI->cases())

170 }

172 }

173 }

174 return OM;

175}

176

178 unsigned ID, const OrderMap &OM,

180

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

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

184

185 if (OM.lookup(U.getUser()).first)

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

187

188 if (List.size() < 2)

189

190 return;

191

192 bool IsGlobalValue = OM.isGlobalValue(ID);

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

194 const Use *LU = L.first;

195 const Use *RU = R.first;

196 if (LU == RU)

197 return false;

198

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

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

201

202

203 if (LID < RID) {

204 if (RID <= ID)

205 if (!IsGlobalValue)

206 return true;

207 return false;

208 }

209 if (RID < LID) {

210 if (LID <= ID)

211 if (!IsGlobalValue)

212 return false;

213 return true;

214 }

215

216

217

218 if (LID <= ID)

219 if (!IsGlobalValue)

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

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

222 });

223

225

226 return;

227

228

229 Stack.emplace_back(V, F, List.size());

230 assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");

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

232 Stack.back().Shuffle[I] = List[I].second;

233}

234

237 if (!V->hasUseList())

238 return;

239

240 auto &IDPair = OM[V];

241 assert(IDPair.first && "Unmapped value");

242 if (IDPair.second)

243

244 return;

245

246

247 IDPair.second = true;

248 if (!V->use_empty() && std::next(V->use_begin()) != V->use_end())

250

251

253 if (C->getNumOperands()) {

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

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

260 Stack);

261 }

262 }

263}

264

267

268

269

270

271

272

274

275

276

277

279 auto PredictValueOrderFromMetadata = [&](Metadata *MD) {

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

285 }

286 };

287 if (F.isDeclaration())

288 continue;

296 PredictValueOrderFromMetadata(DVR.getRawLocation());

297 if (DVR.isDbgAssign())

298 PredictValueOrderFromMetadata(DVR.getRawAddress());

299 }

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

304 PredictValueOrderFromMetadata(MAV->getMetadata());

305 }

308 Stack);

310 }

311 }

312 }

313

314

315

325 if (G.hasInitializer())

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

334 }

335

336 return Stack;

337}

338

340 return V.first->getType()->isIntOrIntVectorTy();

341}

342

344 bool ShouldPreserveUseListOrder)

345 : ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {

346 if (ShouldPreserveUseListOrder)

348

349

351 EnumerateValue(&GV);

352 EnumerateType(GV.getValueType());

353 }

354

355

357 EnumerateValue(&F);

358 EnumerateType(F.getValueType());

359 EnumerateAttributes(F.getAttributes());

360 }

361

362

363 for (const GlobalAlias &GA : M.aliases()) {

364 EnumerateValue(&GA);

365 EnumerateType(GA.getValueType());

366 }

367

368

370 EnumerateValue(&GIF);

371 EnumerateType(GIF.getValueType());

372 }

373

374

375 unsigned FirstConstant = Values.size();

376

377

379 if (GV.hasInitializer())

380 EnumerateValue(GV.getInitializer());

381 if (GV.hasAttributes())

382 EnumerateAttributes(GV.getAttributesAsList(AttributeList::FunctionIndex));

383 }

384

385

387 EnumerateValue(GA.getAliasee());

388

389

391 EnumerateValue(GIF.getResolver());

392

393

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

396 EnumerateValue(U.get());

397

398

399

400

401

403

404

405

406 EnumerateValueSymbolTable(M.getValueSymbolTable());

407 EnumerateNamedMetadata(M);

408

411 MDs.clear();

412 GV.getAllMetadata(MDs);

413 for (const auto &I : MDs)

414

415

416

417 EnumerateMetadata(nullptr, I.second);

418 }

419

420

423 EnumerateType(A.getType());

424

425

426 MDs.clear();

427 F.getAllMetadata(MDs);

428 for (const auto &I : MDs)

429 EnumerateMetadata(F.isDeclaration() ? nullptr : &F, I.second);

430

433

434

435

436 auto EnumerateNonLocalValuesFromMetadata = [&](Metadata *MD) {

437 assert(MD && "Metadata unexpectedly null");

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

441 EnumerateMetadata(&F, VAM);

442 }

443 return;

444 }

445

447 EnumerateMetadata(&F, MD);

448 };

449

450 for (DbgRecord &DR : I.getDbgRecordRange()) {

452 EnumerateMetadata(&F, DLR->getLabel());

453 EnumerateMetadata(&F, &*DLR->getDebugLoc());

454 continue;

455 }

456

458 EnumerateNonLocalValuesFromMetadata(DVR.getRawLocation());

463 EnumerateNonLocalValuesFromMetadata(DVR.getRawAddress());

466 }

467 }

468 for (const Use &Op : I.operands()) {

470 if (!MD) {

471 EnumerateOperandType(Op);

472 continue;

473 }

474

475 EnumerateNonLocalValuesFromMetadata(MD->getMetadata());

476 }

478 EnumerateType(SVI->getShuffleMaskForBitcode()->getType());

480 EnumerateType(GEP->getSourceElementType());

482 EnumerateType(AI->getAllocatedType());

483 EnumerateType(I.getType());

485 EnumerateAttributes(Call->getAttributes());

486 EnumerateType(Call->getFunctionType());

487 }

488

489

490 MDs.clear();

491 I.getAllMetadataOtherThanDebugLoc(MDs);

492 for (const auto &MD : MDs)

493 EnumerateMetadata(&F, MD.second);

494

495

496

498 for (const Metadata *Op : L->operands())

499 EnumerateMetadata(&F, Op);

500 }

501 }

502 for (const GlobalIFunc &GIF : M.ifuncs()) {

503 MDs.clear();

504 GIF.getAllMetadata(MDs);

505 for (const auto &I : MDs)

506 EnumerateMetadata(nullptr, I.second);

507 }

508

509

510 OptimizeConstants(FirstConstant, Values.size());

511

512

513 organizeMetadata();

514}

515

518 assert(I != InstructionMap.end() && "Instruction is not mapped!");

519 return I->second;

520}

521

523 unsigned ComdatID = Comdats.idFor(C);

524 assert(ComdatID && "Comdat not found!");

525 return ComdatID;

526}

527

529 InstructionMap[I] = InstructionCount++;

530}

531

535

537 assert(I != ValueMap.end() && "Value not in slotcalculator!");

538 return I->second-1;

539}

540

541#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

548#endif

549

551 const char *Name) const {

552 OS << "Map Name: " << Name << "\n";

553 OS << "Size: " << Map.size() << "\n";

554 for (const auto &I : Map) {

555 const Value *V = I.first;

556 if (V->hasName())

557 OS << "Value: " << V->getName();

558 else

559 OS << "Value: [null]\n";

560 V->print(errs());

561 errs() << '\n';

562

563 OS << " Uses(" << V->getNumUses() << "):";

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

565 if (&U != &*V->use_begin())

566 OS << ",";

567 if(U->hasName())

568 OS << " " << U->getName();

569 else

570 OS << " [null]";

571

572 }

573 OS << "\n\n";

574 }

575}

576

578 const char *Name) const {

579 OS << "Map Name: " << Name << "\n";

580 OS << "Size: " << Map.size() << "\n";

581 for (const auto &I : Map) {

583 OS << "Metadata: slot = " << I.second.ID << "\n";

584 OS << "Metadata: function = " << I.second.F << "\n";

586 OS << "\n";

587 }

588}

589

590

591void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {

592 if (CstStart == CstEnd || CstStart+1 == CstEnd) return;

593

594 if (ShouldPreserveUseListOrder)

595

596

597 return;

598

599 std::stable_sort(Values.begin() + CstStart, Values.begin() + CstEnd,

600 [this](const std::pair<const Value *, unsigned> &LHS,

601 const std::pair<const Value *, unsigned> &RHS) {

602

603 if (LHS.first->getType() != RHS.first->getType())

604 return getTypeID(LHS.first->getType()) < getTypeID(RHS.first->getType());

605

606 return LHS.second > RHS.second;

607 });

608

609

610

611

612 std::stable_partition(Values.begin() + CstStart, Values.begin() + CstEnd,

614

615

616 for (; CstStart != CstEnd; ++CstStart)

617 ValueMap[Values[CstStart].first] = CstStart+1;

618}

619

620

621

622void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {

623 for (const auto &VI : VST)

624 EnumerateValue(VI.getValue());

625}

626

627

628

629void ValueEnumerator::EnumerateNamedMetadata(const Module &M) {

630 for (const auto &I : M.named_metadata())

631 EnumerateNamedMDNode(&I);

632}

633

634void ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) {

635 for (const MDNode *N : MD->operands())

636 EnumerateMetadata(nullptr, N);

637}

638

639unsigned ValueEnumerator::getMetadataFunctionID(const Function *F) const {

641}

642

643void ValueEnumerator::EnumerateMetadata(const Function *F, const Metadata *MD) {

644 EnumerateMetadata(getMetadataFunctionID(F), MD);

645}

646

647void ValueEnumerator::EnumerateFunctionLocalMetadata(

649 EnumerateFunctionLocalMetadata(getMetadataFunctionID(&F), Local);

650}

651

652void ValueEnumerator::EnumerateFunctionLocalListMetadata(

654 EnumerateFunctionLocalListMetadata(getMetadataFunctionID(&F), ArgList);

655}

656

657void ValueEnumerator::dropFunctionFromMetadata(

658 MetadataMapType::value_type &FirstMD) {

661 auto &Entry = MD.second;

662

663

665 return;

666

667

669

670

671

675 };

676 push(FirstMD);

677 while (!Worklist.empty())

679 if ()

680 continue;

681 auto MD = MetadataMap.find(Op);

682 if (MD != MetadataMap.end())

683 push(*MD);

684 }

685}

686

687void ValueEnumerator::EnumerateMetadata(unsigned F, const Metadata *MD) {

688

689

690

691

693

694

695

697 if (const MDNode *N = enumerateMetadataImpl(F, MD))

698 Worklist.push_back(std::make_pair(N, N->op_begin()));

699

700 while (!Worklist.empty()) {

701 const MDNode *N = Worklist.back().first;

702

703

704

706 Worklist.back().second, N->op_end(),

707 [&](const Metadata *MD) { return enumerateMetadataImpl(F, MD); });

708 if (I != N->op_end()) {

710 Worklist.back().second = ++I;

711

712

713 if (Op->isDistinct() && ->isDistinct())

715 else

716 Worklist.push_back(std::make_pair(Op, Op->op_begin()));

717 continue;

718 }

719

720

722 MDs.push_back(N);

723 MetadataMap[N].ID = MDs.size();

724

725

726

727 if (Worklist.empty() || Worklist.back().first->isDistinct()) {

728 for (const MDNode *N : DelayedDistinctNodes)

729 Worklist.push_back(std::make_pair(N, N->op_begin()));

730 DelayedDistinctNodes.clear();

731 }

732 }

733}

734

735const MDNode *ValueEnumerator::enumerateMetadataImpl(unsigned F, const Metadata *MD) {

736 if (!MD)

737 return nullptr;

738

741 "Invalid metadata kind");

742

743 auto Insertion = MetadataMap.insert(std::make_pair(MD, MDIndex(F)));

744 MDIndex &Entry = Insertion.first->second;

745 if (!Insertion.second) {

746

747 if (Entry.hasDifferentFunction(F))

748 dropFunctionFromMetadata(*Insertion.first);

749 return nullptr;

750 }

751

752

754 return N;

755

756

757 MDs.push_back(MD);

758 Entry.ID = MDs.size();

759

760

762 EnumerateValue(C->getValue());

763

764 return nullptr;

765}

766

767

768

769void ValueEnumerator::EnumerateFunctionLocalMetadata(

771 assert(F && "Expected a function");

772

773

776 assert(Index.F == F && "Expected the same function");

777 return;

778 }

779

780 MDs.push_back(Local);

782 Index.ID = MDs.size();

783

784 EnumerateValue(Local->getValue());

785}

786

787

788

789void ValueEnumerator::EnumerateFunctionLocalListMetadata(

790 unsigned F, const DIArgList *ArgList) {

791 assert(F && "Expected a function");

792

793

794 MDIndex &Index = MetadataMap[ArgList];

796 assert(Index.F == F && "Expected the same function");

797 return;

798 }

799

800 for (ValueAsMetadata *VAM : ArgList->getArgs()) {

802 assert(MetadataMap.count(VAM) &&

803 "LocalAsMetadata should be enumerated before DIArgList");

804 assert(MetadataMap[VAM].F == F &&

805 "Expected LocalAsMetadata in the same function");

806 } else {

808 "Expected LocalAsMetadata or ConstantAsMetadata");

809 assert(ValueMap.count(VAM->getValue()) &&

810 "Constant should be enumerated beforeDIArgList");

811 EnumerateMetadata(F, VAM);

812 }

813 }

814

815 MDs.push_back(ArgList);

817 Index.ID = MDs.size();

818}

819

821

823 return 0;

824

825

826

828 if ()

829 return 1;

830

831

832

833 return N->isDistinct() ? 2 : 3;

834}

835

836void ValueEnumerator::organizeMetadata() {

837 assert(MetadataMap.size() == MDs.size() &&

838 "Metadata map and vector out of sync");

839

840 if (MDs.empty())

841 return;

842

843

844

846 Order.reserve(MetadataMap.size());

847 for (const Metadata *MD : MDs)

848 Order.push_back(MetadataMap.lookup(MD));

849

850

851

852

853

854

855

859 });

860

861

862

863 std::vector<const Metadata *> OldMDs;

864 MDs.swap(OldMDs);

865 MDs.reserve(OldMDs.size());

866 for (unsigned I = 0, E = Order.size(); I != E && !Order[I].F; ++I) {

867 auto *MD = Order[I].get(OldMDs);

869 MetadataMap[MD].ID = I + 1;

871 ++NumMDStrings;

872 }

873

874

875 if (MDs.size() == Order.size())

876 return;

877

878

879 MDRange R;

880 FunctionMDs.reserve(OldMDs.size());

881 unsigned PrevF = 0;

882 for (unsigned I = MDs.size(), E = Order.size(), ID = MDs.size(); I != E;

883 ++I) {

884 unsigned F = Order[I].F;

885 if (!PrevF) {

886 PrevF = F;

887 } else if (PrevF != F) {

888 R.Last = FunctionMDs.size();

889 std::swap(R, FunctionMDInfo[PrevF]);

890 R.First = FunctionMDs.size();

891

892 ID = MDs.size();

893 PrevF = F;

894 }

895

896 auto *MD = Order[I].get(OldMDs);

898 MetadataMap[MD].ID = ++ID;

900 ++R.NumStrings;

901 }

902 R.Last = FunctionMDs.size();

903 FunctionMDInfo[PrevF] = R;

904}

905

906void ValueEnumerator::incorporateFunctionMetadata(const Function &F) {

907 NumModuleMDs = MDs.size();

908

909 auto R = FunctionMDInfo.lookup(getValueID(&F) + 1);

910 NumMDStrings = R.NumStrings;

911 MDs.insert(MDs.end(), FunctionMDs.begin() + R.First,

912 FunctionMDs.begin() + R.Last);

913}

914

915void ValueEnumerator::EnumerateValue(const Value *V) {

916 assert(->getType()->isVoidTy() && "Can't insert void values!");

918

919

920 unsigned &ValueID = ValueMap[V];

921 if (ValueID) {

922

923 Values[ValueID-1].second++;

924 return;

925 }

926

928 if (const Comdat *C = GO->getComdat())

929 Comdats.insert(C);

930

931

932 EnumerateType(V->getType());

933

936

937 } else if (C->getNumOperands()) {

938

939

940

941

942

943

944

945

946 for (const Use &U : C->operands())

947 if ( isa<BasicBlock> (U))

948 EnumerateValue(U);

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

951 EnumerateValue(CE->getShuffleMaskForBitcode());

953 EnumerateType(GEP->getSourceElementType());

954 }

955

956

957

958 Values.push_back(std::make_pair(V, 1U));

959 ValueMap[V] = Values.size();

960 return;

961 }

962 }

963

964

965 Values.push_back(std::make_pair(V, 1U));

966 ValueID = Values.size();

967}

968

969

970void ValueEnumerator::EnumerateType(Type *Ty) {

971 unsigned *TypeID = &TypeMap[Ty];

972

973

975 return;

976

977

978

979

981 if (!STy->isLiteral())

983

984

985

987 EnumerateType(SubTy);

988

989

990 TypeID = &TypeMap[Ty];

991

992

993

994

995

996

998 return;

999

1000

1001 Types.push_back(Ty);

1002

1003 *TypeID = Types.size();

1004}

1005

1006

1007

1008void ValueEnumerator::EnumerateOperandType(const Value *V) {

1009 EnumerateType(V->getType());

1010

1012

1014 if ()

1015 return;

1016

1017

1018

1019 if (ValueMap.count(C))

1020 return;

1021

1022

1023

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

1025

1026

1028 continue;

1029

1030 EnumerateOperandType(Op);

1031 }

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

1034 EnumerateOperandType(CE->getShuffleMaskForBitcode());

1035 if (CE->getOpcode() == Instruction::GetElementPtr)

1037 }

1038}

1039

1040void ValueEnumerator::EnumerateAttributes(AttributeList PAL) {

1041 if (PAL.isEmpty()) return;

1042

1043

1044 unsigned &Entry = AttributeListMap[PAL];

1045 if (Entry == 0) {

1046

1047 AttributeLists.push_back(PAL);

1048 Entry = AttributeLists.size();

1049 }

1050

1051

1052 for (unsigned i : PAL.indexes()) {

1053 AttributeSet AS = PAL.getAttributes(i);

1055 continue;

1057 unsigned &Entry = AttributeGroupMap[Pair];

1058 if (Entry == 0) {

1059 AttributeGroups.push_back(Pair);

1060 Entry = AttributeGroups.size();

1061

1063 if (Attr.isTypeAttribute())

1064 EnumerateType(Attr.getValueAsType());

1065 }

1066 }

1067 }

1068}

1069

1071 InstructionCount = 0;

1072 NumModuleValues = Values.size();

1073

1074

1075

1076 incorporateFunctionMetadata(F);

1077

1078

1079 for (const auto &I : F.args()) {

1080 EnumerateValue(&I);

1081 if (I.hasAttribute(Attribute::ByVal))

1082 EnumerateType(I.getParamByValType());

1083 else if (I.hasAttribute(Attribute::StructRet))

1084 EnumerateType(I.getParamStructRetType());

1085 else if (I.hasAttribute(Attribute::ByRef))

1086 EnumerateType(I.getParamByRefType());

1087 }

1088 FirstFuncConstantID = Values.size();

1089

1090

1093 for (const Use &OI : I.operands()) {

1095 EnumerateValue(OI);

1096 }

1098 EnumerateValue(SVI->getShuffleMaskForBitcode());

1100 for (const auto &Case : SI->cases())

1101 EnumerateValue(Case.getCaseValue());

1102 }

1103 }

1104 BasicBlocks.push_back(&BB);

1105 ValueMap[&BB] = BasicBlocks.size();

1106 }

1107

1108

1109 OptimizeConstants(FirstFuncConstantID, Values.size());

1110

1111

1112

1113 EnumerateAttributes(F.getAttributes());

1114

1115 FirstInstID = Values.size();

1116

1119

1120 auto AddFnLocalMetadata = [&](Metadata *MD) {

1121 if (!MD)

1122 return;

1124

1127 ArgListMDVector.push_back(ArgList);

1130

1131

1133 }

1134 }

1135 }

1136 };

1137

1138

1141 for (const Use &OI : I.operands()) {

1143 AddFnLocalMetadata(MD->getMetadata());

1144 }

1145

1147 assert(DVR.getRawLocation() &&

1148 "DbgVariableRecord location unexpectedly null");

1149 AddFnLocalMetadata(DVR.getRawLocation());

1150 if (DVR.isDbgAssign()) {

1151 assert(DVR.getRawAddress() &&

1152 "DbgVariableRecord location unexpectedly null");

1153 AddFnLocalMetadata(DVR.getRawAddress());

1154 }

1155 }

1156 if (.getType()->isVoidTy())

1157 EnumerateValue(&I);

1158 }

1159 }

1160

1161

1163

1164

1165 assert(ValueMap.count(Local->getValue()) &&

1166 "Missing value for metadata operand");

1167 EnumerateFunctionLocalMetadata(F, Local);

1168 }

1169

1170

1171 for (const DIArgList *ArgList : ArgListMDVector)

1172 EnumerateFunctionLocalListMetadata(F, ArgList);

1173}

1174

1176

1177 for (const auto &V : llvm::drop_begin(Values, NumModuleValues))

1178 ValueMap.erase(V.first);

1180 MetadataMap.erase(MD);

1181 for (const BasicBlock *BB : BasicBlocks)

1182 ValueMap.erase(BB);

1183

1184 Values.resize(NumModuleValues);

1185 MDs.resize(NumModuleMDs);

1186 BasicBlocks.clear();

1187 NumMDStrings = 0;

1188}

1189

1192 unsigned Counter = 0;

1194 IDMap[&BB] = ++Counter;

1195}

1196

1197

1198

1199

1201 unsigned &Idx = GlobalBasicBlockIDs[BB];

1202 if (Idx != 0)

1203 return Idx-1;

1204

1207}

1208

for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))

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

MapVector< const Value *, unsigned > OrderMap

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 declaration of the GlobalIFunc class, which represents a single indirect funct...

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

This defines the Use class.

static bool lookup(const GsymReader &GR, DataExtractor &Data, uint64_t &Offset, uint64_t BaseAddr, uint64_t Addr, SourceLocations &SrcLocs, llvm::Error &Err)

A Lookup helper functions.

This file defines the SmallVector class.

static void predictValueUseListOrderImpl(const Value *V, const Function *F, unsigned ID, const OrderMap &OM, UseListOrderStack &Stack)

Definition ValueEnumerator.cpp:177

static unsigned getMetadataTypeOrder(const Metadata *MD)

Definition ValueEnumerator.cpp:820

static void orderValue(const Value *V, OrderMap &OM)

Definition ValueEnumerator.cpp:77

static void predictValueUseListOrder(const Value *V, const Function *F, OrderMap &OM, UseListOrderStack &Stack)

Definition ValueEnumerator.cpp:235

static UseListOrderStack predictUseListOrder(const Module &M)

Definition ValueEnumerator.cpp:265

static void IncorporateFunctionInfoGlobalBBIDs(const Function *F, DenseMap< const BasicBlock *, unsigned > &IDMap)

Definition ValueEnumerator.cpp:1190

static bool isIntOrIntVectorValue(const std::pair< const Value *, unsigned > &V)

Definition ValueEnumerator.cpp:339

static OrderMap orderModule(const Module &M)

Definition ValueEnumerator.cpp:97

This class represents an incoming formal argument to a Function.

bool hasAttributes() const

Return true if attributes exists in this set.

LLVM Basic Block Representation.

const Function * getParent() const

Return the enclosing method, or null if none.

This is an important base class in LLVM.

List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.

ArrayRef< ValueAsMetadata * > getArgs() const

Records a position in IR for a source label (DILabel).

Base class for non-instruction debug metadata records that have positions within IR.

DebugLoc getDebugLoc() const

Record of a variable value-assignment, aka a non instruction representation of the dbg....

LLVM_ABI DIAssignID * getAssignID() const

DIExpression * getExpression() const

DILocalVariable * getVariable() const

Metadata * getRawLocation() const

Returns the metadata operand for the first location description.

Metadata * getRawAddress() const

DIExpression * getAddressExpression() const

ValueT lookup(const_arg_type_t< KeyT > Val) const

lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...

DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT, true > const_iterator

const MDOperand * op_iterator

unsigned & operator[](const const Value *&Key)

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

iterator_range< op_iterator > operands()

void reserve(size_type N)

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

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

static LLVM_ABI Type * getMetadataTy(LLVMContext &C)

ArrayRef< Type * > subtypes() const

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

unsigned getMetadataID(const Metadata *MD) const

UseListOrderStack UseListOrders

void print(raw_ostream &OS, const ValueMapType &Map, const char *Name) const

Definition ValueEnumerator.cpp:550

unsigned getInstructionID(const Instruction *I) const

Definition ValueEnumerator.cpp:516

void incorporateFunction(const Function &F)

incorporateFunction/purgeFunction - If you'd like to deal with a function, use these two methods to g...

Definition ValueEnumerator.cpp:1070

ValueEnumerator(const Module &M, bool ShouldPreserveUseListOrder)

Definition ValueEnumerator.cpp:343

unsigned getComdatID(const Comdat *C) const

Definition ValueEnumerator.cpp:522

uint64_t computeBitsRequiredForTypeIndices() const

Definition ValueEnumerator.cpp:1209

unsigned getValueID(const Value *V) const

Definition ValueEnumerator.cpp:532

void dump() const

Definition ValueEnumerator.cpp:542

unsigned getGlobalBasicBlockID(const BasicBlock *BB) const

getGlobalBasicBlockID - This returns the function-specific ID for the specified basic block.

Definition ValueEnumerator.cpp:1200

void setInstructionID(const Instruction *I)

Definition ValueEnumerator.cpp:528

void purgeFunction()

Definition ValueEnumerator.cpp:1175

std::pair< unsigned, AttributeSet > IndexAndAttrSet

Attribute groups as encoded in bitcode are almost AttributeSets, but they include the AttributeList i...

const TypeList & getTypes() const

This class provides a symbol table of name/value pairs.

LLVM Value Representation.

iterator_range< use_iterator > uses()

This class implements an extremely fast bulk output stream that can only output to a stream.

unsigned ID

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

@ C

The default llvm calling convention, compatible with C.

@ CE

Windows NT (Windows on ARM)

This is an optimization pass for GlobalISel generic memory operations.

auto drop_begin(T &&RangeOrContainer, size_t N=1)

Return a range covering RangeOrContainer with the first N elements excluded.

unsigned Log2_32_Ceil(uint32_t Value)

Return the ceil log base 2 of the specified value, 32 if the value is zero.

FunctionAddr VTableAddr Value

auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)

Get the size of a range.

decltype(auto) dyn_cast(const From &Val)

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

auto reverse(ContainerTy &&C)

void sort(IteratorTy Start, IteratorTy End)

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

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

bool isa(const From &Val)

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

std::vector< UseListOrder > UseListOrderStack

LLVM_ABI raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

DWARFExpression::Operation Op

decltype(auto) cast(const From &Val)

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

static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)

Filter the DbgRecord range to DbgVariableRecord types only and downcast.

void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)

Implement std::swap in terms of BitVector swap.

Function object to check whether the second component of a container supported by std::get (like std:...