IRMover.cpp Source File (original) (raw)

32#include

33#include

34using namespace llvm;

46namespace {

49 DenseMap<Type *, Type *> MappedTypes;

51public:

52 TypeMapTy(IRMover::IdentifiedStructTypeSet &DstStructTypesSet)

53 : DstStructTypesSet(DstStructTypesSet) {}

55 IRMover::IdentifiedStructTypeSet &DstStructTypesSet;

58 void addTypeMapping(Type *DstTy, Type *SrcTy);

64 FunctionType *get(FunctionType *T) {

66 }

68private:

69 Type *remapType(Type *SrcTy) override { return get(SrcTy); }

71 bool recursivelyAddMappingIfTypesAreIsomorphic(Type *DstTy, Type *SrcTy);

72};

73}

75void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) {

76 recursivelyAddMappingIfTypesAreIsomorphic(DstTy, SrcTy);

77}

82bool TypeMapTy::recursivelyAddMappingIfTypesAreIsomorphic(Type *DstTy,

83 Type *SrcTy) {

86 return false;

89 Type *&Entry = MappedTypes[SrcTy];

90 if (Entry)

91 return Entry == DstTy;

95 if (DstTy == SrcTy) {

97 return true;

98 }

100

101

102

105 return false;

106 }

107

108

110 return false;

111

112

114 return false;

116 if (PT->getAddressSpace() != cast(SrcTy)->getAddressSpace())

117 return false;

120 return false;

123 if (DSTy->isLiteral() != SSTy->isLiteral() ||

124 DSTy->isPacked() != SSTy->isPacked())

125 return false;

127 if (DArrTy->getNumElements() != cast(SrcTy)->getNumElements())

128 return false;

130 if (DVecTy->getElementCount() != cast(SrcTy)->getElementCount())

131 return false;

132 }

133

134

136 if (!recursivelyAddMappingIfTypesAreIsomorphic(DstTy->getContainedType(I),

138 return false;

139

140

141 [[maybe_unused]] auto Res = MappedTypes.insert({SrcTy, DstTy});

142 assert(!Res.second && "Recursive type?");

143

145

146

147

148

149

150 if (STy->hasName())

151 STy->setName("");

152 }

153

154 return true;

155}

156

157Type *TypeMapTy::get(Type *Ty) {

158

160 if (*Entry)

162

163

165

166 if (!IsUniqued) {

167#ifndef NDEBUG

168 for (auto &Pair : MappedTypes) {

169 assert(!(Pair.first != Ty && Pair.second == Ty) &&

170 "mapping to a source type");

171 }

172#endif

173 }

174

175

176

178

179

180

182 return *Entry = Ty;

183

184

185 bool AnyChange = false;

190 }

191

192

193 Entry = &MappedTypes[Ty];

194 assert(!*Entry && "Recursive type!");

195

196

197

198 if (!AnyChange && IsUniqued)

199 return *Entry = Ty;

200

201

203 default:

205 case Type::ArrayTyID:

206 return *Entry = ArrayType::get(ElementTypes[0],

208 case Type::ScalableVectorTyID:

209 case Type::FixedVectorTyID:

210 return *Entry = VectorType::get(ElementTypes[0],

212 case Type::FunctionTyID:

213 return *Entry = FunctionType::get(ElementTypes[0],

214 ArrayRef(ElementTypes).slice(1),

216 case Type::StructTyID: {

218 bool IsPacked = STy->isPacked();

219 if (IsUniqued)

221

222

223 if (STy->isOpaque()) {

224 DstStructTypesSet.addOpaque(STy);

225 return *Entry = Ty;

226 }

227

228 if (StructType *OldT =

229 DstStructTypesSet.findNonOpaque(ElementTypes, IsPacked)) {

230 STy->setName("");

231 return *Entry = OldT;

232 }

233

234 if (!AnyChange) {

236 return *Entry = Ty;

237 }

238

239 StructType *DTy =

241

242

243 if (STy->hasName()) {

244 SmallString<16> TmpName = STy->getName();

245 STy->setName("");

247 }

248

250 return *Entry = DTy;

251 }

252 }

253}

254

259

260

261

262

263

264namespace {

265class IRLinker;

266

267

268

269

271 IRLinker &TheIRLinker;

272

273public:

274 GlobalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}

275 Value *materialize(Value *V) override;

276};

277

279 IRLinker &TheIRLinker;

280

281public:

282 LocalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}

283 Value *materialize(Value *V) override;

284};

285

286

288

289

290

291class IRLinker {

293 std::unique_ptr SrcM;

294

295

297

298

300

301 TypeMapTy TypeMap;

302 GlobalValueMaterializer GValMaterializer;

303 LocalValueMaterializer LValMaterializer;

304

305

306 MDMapT &SharedMDs;

307

308

309

310

311

314

315 DenseSet<GlobalValue *> ValuesToLink;

316 std::vector<GlobalValue *> Worklist;

317 std::vector<std::pair<GlobalValue *, Value*>> RAUWWorklist;

318

319

320

321 DenseSet<GlobalObject *> UnmappedMetadata;

322

323 void maybeAdd(GlobalValue *GV) {

324 if (ValuesToLink.insert(GV).second)

325 Worklist.push_back(GV);

326 }

327

328

329

330

331

332

333 bool IsPerformingImport;

334

335

336

337

338 bool DoneLinkingBodies = false;

339

340

341

342 std::optional FoundError;

343 void setError(Error E) {

344 if (E)

345 FoundError = std::move(E);

346 }

347

348

349 ValueMapper Mapper;

350 unsigned IndirectSymbolMCID;

351

352

353

354 GlobalValue *copyGlobalValueProto(const GlobalValue *SGV, bool ForDefinition);

355

356 void emitWarning(const Twine &Message) {

357 SrcM->getContext().diagnose(LinkDiagnosticInfo(DS_Warning, Message));

358 }

359

360

361

362 GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) {

363

364

366 return nullptr;

367

368

370 if (!DGV)

371 return nullptr;

372

373

374

376 return nullptr;

377

378

379

381 if (FDGV->isIntrinsic())

383 if (FDGV->getFunctionType() != TypeMap.get(FSrcGV->getFunctionType()))

384 return nullptr;

385

386

387 return DGV;

388 }

389

390 void computeTypeMapping();

391

392 Expected<Constant *> linkAppendingVarProto(GlobalVariable *DstGV,

393 const GlobalVariable *SrcGV);

394

395

396

397

398

399

400 bool shouldLink(GlobalValue *DGV, GlobalValue &SGV);

401 Expected<Constant *> linkGlobalValueProto(GlobalValue *GV,

402 bool ForIndirectSymbol);

403

404 Error linkModuleFlagsMetadata();

405

406 void linkGlobalVariable(GlobalVariable &Dst, GlobalVariable &Src);

407 Error linkFunctionBody(Function &Dst, Function &Src);

408 void linkAliasAliasee(GlobalAlias &Dst, GlobalAlias &Src);

409 void linkIFuncResolver(GlobalIFunc &Dst, GlobalIFunc &Src);

410 Error linkGlobalValueBody(GlobalValue &Dst, GlobalValue &Src);

411

412

413

414 AttributeList mapAttributeTypes(LLVMContext &C, AttributeList Attrs);

415

416

417

418 GlobalVariable *copyGlobalVariableProto(const GlobalVariable *SGVar);

419 Function *copyFunctionProto(const Function *SF);

420 GlobalValue *copyIndirectSymbolProto(const GlobalValue *SGV);

421

422

423

424

425

426

427

428 void flushRAUWWorklist();

429

430

431

432

433 void prepareCompileUnitsForImport();

434 void linkNamedMDNodes();

435

436

437 void updateAttributes(GlobalValue &GV);

438

439public:

440 IRLinker(Module &DstM, MDMapT &SharedMDs,

441 IRMover::IdentifiedStructTypeSet &Set, std::unique_ptr SrcM,

445 : DstM(DstM), SrcM(std::move(SrcM)), NamedMDNodes(NamedMDNodes),

446 AddLazyFor(std::move(AddLazyFor)), TypeMap(Set),

447 GValMaterializer(*this), LValMaterializer(*this), SharedMDs(SharedMDs),

448 IsPerformingImport(IsPerformingImport),

450 &TypeMap, &GValMaterializer),

451 IndirectSymbolMCID(Mapper.registerAlternateMappingContext(

452 IndirectSymbolValueMap, &LValMaterializer)) {

453 ValueMap.getMDMap() = std::move(SharedMDs);

454 for (GlobalValue *GV : ValuesToLink)

455 maybeAdd(GV);

456 if (IsPerformingImport)

457 prepareCompileUnitsForImport();

458 }

459 ~IRLinker() { SharedMDs = std::move(*ValueMap.getMDMap()); }

460

462 Value *materialize(Value *V, bool ForIndirectSymbol);

463};

464}

465

466

467

468

470

471

473 return;

474

476

477

478 if (GlobalValue *ConflictGV = M->getNamedValue(Name)) {

480 ConflictGV->setName(Name);

481 assert(ConflictGV->getName() != Name && "forceRenaming didn't work");

482 } else {

483 GV->setName(Name);

484 }

485}

486

487Value *GlobalValueMaterializer::materialize(Value *SGV) {

488 return TheIRLinker.materialize(SGV, false);

489}

490

491Value *LocalValueMaterializer::materialize(Value *SGV) {

492 return TheIRLinker.materialize(SGV, true);

493}

494

495Value *IRLinker::materialize(Value *V, bool ForIndirectSymbol) {

497 if (!SGV)

498 return nullptr;

499

500

501 if (SGV->getParent() == &DstM)

502 return nullptr;

503

504

505

506

507

508 if (SGV->getParent() != SrcM.get())

509 return nullptr;

510

511 Expected<Constant *> NewProto = linkGlobalValueProto(SGV, ForIndirectSymbol);

512 if (!NewProto) {

514 return nullptr;

515 }

516 if (!*NewProto)

517 return nullptr;

518

520 if (!New)

521 return *NewProto;

522

523

525 if (->isDeclaration())

526 return New;

528 if (V->hasInitializer() || V->hasAppendingLinkage())

529 return New;

531 if (GA->getAliasee())

532 return New;

534 if (GI->getResolver())

535 return New;

536 } else {

538 }

539

540

541

542

543

544

545

546

547

548 if ((ForIndirectSymbol && ValueMap.lookup(SGV) == New) ||

549 (!ForIndirectSymbol && IndirectSymbolValueMap.lookup(SGV) == New))

550 return New;

551

552 if (ForIndirectSymbol || shouldLink(New, *SGV))

553 setError(linkGlobalValueBody(*New, *SGV));

554

555 updateAttributes(*New);

556 return New;

557}

558

559

560

562

563

564

568 nullptr, SGVar->getName(),

573 return NewDGV;

574}

575

576AttributeList IRLinker::mapAttributeTypes(LLVMContext &C, AttributeList Attrs) {

577 for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {

578 for (int AttrIdx = Attribute::FirstTypeAttr;

579 AttrIdx <= Attribute::LastTypeAttr; AttrIdx++) {

581 if (Attrs.hasAttributeAtIndex(i, TypedAttr)) {

582 if (Type *Ty =

583 Attrs.getAttributeAtIndex(i, TypedAttr).getValueAsType()) {

584 Attrs = Attrs.replaceAttributeTypeAtIndex(C, i, TypedAttr,

585 TypeMap.get(Ty));

586 break;

587 }

588 }

589 }

590 }

592}

593

594

595

597

598

602 F->copyAttributesFrom(SF);

603 F->setAttributes(mapAttributeTypes(F->getContext(), F->getAttributes()));

604 return F;

605}

606

607

608

610

611

613

618 DGA->copyAttributesFrom(GA);

619 return DGA;

620 }

621

625 SGV->getName(), nullptr, &DstM);

626 DGI->copyAttributesFrom(GI);

627 return DGI;

628 }

629

631}

632

634 bool ForDefinition) {

637 NewGV = copyGlobalVariableProto(SGVar);

639 NewGV = copyFunctionProto(SF);

640 } else {

641 if (ForDefinition)

642 NewGV = copyIndirectSymbolProto(SGV);

644 NewGV =

648 else

649 NewGV =

652 nullptr, SGV->getName(),

653 nullptr,

655 }

656

657 if (ForDefinition)

661

663

666 if (SGV->isDeclaration() && NewGO->hasMetadata())

667 UnmappedMetadata.insert(NewGO);

668 }

669 }

670

671

672

673

675 NewF->setPersonalityFn(nullptr);

676 NewF->setPrefixData(nullptr);

677 NewF->setPrologueData(nullptr);

678 }

679

680 return NewGV;

681}

682

684 size_t DotPos = Name.rfind('.');

685 return (DotPos == 0 || DotPos == StringRef::npos || Name.back() == '.' ||

686 !isdigit(static_cast<unsigned char>(Name[DotPos + 1])))

687 ? Name

688 : Name.substr(0, DotPos);

689}

690

691

692

693

694

695void IRLinker::computeTypeMapping() {

696 for (GlobalValue &SGV : SrcM->globals()) {

697 GlobalValue *DGV = getLinkedToGlobal(&SGV);

698 if (!DGV)

699 continue;

700

702 TypeMap.addTypeMapping(DGV->getType(), SGV.getType());

703 continue;

704 }

705

706

709 TypeMap.addTypeMapping(DAT->getElementType(), SAT->getElementType());

710 }

711

713 if (GlobalValue *DGV = getLinkedToGlobal(&SGV)) {

715

716

717

718

719

720 continue;

721 }

722

723 TypeMap.addTypeMapping(DGV->getType(), SGV.getType());

724 }

725

727 if (GlobalValue *DGV = getLinkedToGlobal(&SGV))

728 TypeMap.addTypeMapping(DGV->getType(), SGV.getType());

729

730

731

732

733

734 std::vector<StructType *> Types = SrcM->getIdentifiedStructTypes();

736 if (->hasName())

737 continue;

738

739 if (TypeMap.DstStructTypesSet.hasType(ST)) {

740

741

742

743

744 continue;

745 }

746

748 if (STTypePrefix.size() == ST->getName().size())

749 continue;

750

751

753 if (!DST)

754 continue;

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773 if (TypeMap.DstStructTypesSet.hasType(DST))

774 TypeMap.addTypeMapping(DST, ST);

775 }

776}

777

780 unsigned NumElements = cast(C->getType())->getNumElements();

781

782 for (unsigned i = 0; i != NumElements; ++i)

783 Dest.push_back(C->getAggregateElement(i));

784}

785

786

788IRLinker::linkAppendingVarProto(GlobalVariable *DstGV,

790

794 "Linking globals named '" + SrcGV->getName() +

795 "': can only link appending global with another appending "

796 "global!");

797

799 return stringErr("Appending variables linked with different const'ness!");

800

803 "Appending variables with different alignment need to be linked!");

804

807 "Appending variables with different visibility need to be linked!");

808

811 "Appending variables with different unnamed_addr need to be linked!");

812

815 "Appending variables with different section name need to be linked!");

816

818 return stringErr("Appending variables with different address spaces need "

819 "to be linked!");

820 }

821

822

824 return DstGV;

825

827 ->getElementType();

828

829

830

831

832

834 bool IsNewStructor = false;

835 bool IsOldStructor = false;

836 if (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") {

838 IsNewStructor = true;

839 else

840 IsOldStructor = true;

841 }

842

844 if (IsOldStructor) {

846 Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};

848 }

849

850 uint64_t DstNumElements = 0;

853 DstNumElements = DstTy->getNumElements();

854

855

856 if (EltTy != DstTy->getElementType())

857 return stringErr("Appending variables with different element types!");

858 }

859

862

863 if (IsNewStructor) {

865 auto *Key =

867 if ( Key )

868 return false;

870 return !shouldLink(DGV, *Key);

871 });

872 }

873 uint64_t NewSize = DstNumElements + SrcElements.size();

875

876

881

884

886

887

888

889 if (DstGV) {

890 RAUWWorklist.push_back(std::make_pair(DstGV, NG));

891 }

892

893 return NG;

894}

895

898 return true;

899

901 return false;

902

904 return false;

905

906

907

908 bool LazilyAdded = false;

909 if (AddLazyFor)

910 AddLazyFor(SGV, [this, &LazilyAdded](GlobalValue &GV) {

911 maybeAdd(&GV);

912 LazilyAdded = true;

913 });

914 return LazilyAdded;

915}

916

918 bool ForIndirectSymbol) {

919 GlobalValue *DGV = getLinkedToGlobal(SGV);

920

921 bool ShouldLink = shouldLink(DGV, *SGV);

922

923

924 if (ShouldLink) {

928

929 I = IndirectSymbolValueMap.find(SGV);

930 if (I != IndirectSymbolValueMap.end())

932 }

933

934 if (!ShouldLink && ForIndirectSymbol)

935 DGV = nullptr;

936

937

941

942 bool NeedsRenaming = false;

944 if (DGV && !ShouldLink) {

945 NewGV = DGV;

946 } else {

947

948

949

950 if (DoneLinkingBodies)

951 return nullptr;

952

953 NewGV = copyGlobalValueProto(SGV, ShouldLink || ForIndirectSymbol);

954 if (ShouldLink || !ForIndirectSymbol)

955 NeedsRenaming = true;

956 }

957

958

959

960

963

964

965

966 assert(!UnmappedMetadata.count(F) && "intrinsic has unmapped metadata");

968 NewGV = *Remangled;

969 NeedsRenaming = false;

970 }

971

972 if (NeedsRenaming)

974

975 if (ShouldLink || ForIndirectSymbol) {

980 GO->setComdat(DC);

981 }

982 }

983 }

984

985 if (!ShouldLink && ForIndirectSymbol)

987

989

990

991

992

993

994 if (DGV && NewGV != SGV) {

996 NewGV, TypeMap.get(SGV->getType()));

997 }

998

999 if (DGV && NewGV != DGV) {

1000

1001

1002

1003 RAUWWorklist.push_back(std::make_pair(

1004 DGV,

1006 }

1007

1008 return C;

1009}

1010

1011

1012

1014

1016}

1017

1018

1019

1020

1022 assert(Dst.isDeclaration() && !Src.isDeclaration());

1023

1024

1025 if (Error Err = Src.materialize())

1026 return Err;

1027

1028

1029 if (Src.hasPrefixData())

1030 Dst.setPrefixData(Src.getPrefixData());

1031 if (Src.hasPrologueData())

1032 Dst.setPrologueData(Src.getPrologueData());

1033 if (Src.hasPersonalityFn())

1034 Dst.setPersonalityFn(Src.getPersonalityFn());

1035

1036

1037 Dst.copyMetadata(&Src, 0);

1038

1039

1040 Dst.stealArgumentListFrom(Src);

1041 Dst.splice(Dst.end(), &Src);

1042

1043

1046}

1047

1050}

1051

1054}

1055

1062 }

1066 }

1069}

1070

1071void IRLinker::flushRAUWWorklist() {

1072 for (const auto &Elem : RAUWWorklist) {

1075 std::tie(Old, New) = Elem;

1076

1079 }

1080 RAUWWorklist.clear();

1081}

1082

1083void IRLinker::prepareCompileUnitsForImport() {

1084 NamedMDNode *SrcCompileUnits = SrcM->getNamedMetadata("llvm.dbg.cu");

1085 if (!SrcCompileUnits)

1086 return;

1087

1088

1089

1092 assert(CU && "Expected valid compile unit");

1093

1094

1095

1096 CU->replaceEnumTypes(nullptr);

1097 CU->replaceMacros(nullptr);

1098 CU->replaceRetainedTypes(nullptr);

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109 CU->replaceGlobalVariables(nullptr);

1110

1111 CU->replaceImportedEntities(nullptr);

1112 }

1113}

1114

1115

1116void IRLinker::linkNamedMDNodes() {

1117 const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();

1118 for (const NamedMDNode &NMD : SrcM->named_metadata()) {

1119

1120 if (&NMD == SrcModFlags)

1121 continue;

1122

1123

1126 emitWarning("Pseudo-probe ignored: source module '" +

1127 SrcM->getModuleIdentifier() +

1128 "' is compiled with -fpseudo-probe-for-profiling while "

1129 "destination module '" +

1131 continue;

1132 }

1133

1134

1135 if (IsPerformingImport && NMD.getName() == "llvm.stats")

1136 continue;

1137

1139

1140 auto &Inserted = NamedMDNodes[DestNMD];

1142

1144 }

1145

1146

1147 for (const MDNode *Op : NMD.operands()) {

1149 if (Inserted.insert(MD).second)

1151 }

1152 }

1153}

1154

1155

1156Error IRLinker::linkModuleFlagsMetadata() {

1157

1158 const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();

1159 if (!SrcModFlags)

1161

1162

1165

1166

1167

1172

1174 }

1175

1176

1183 uint64_t Behavior =

1186

1189 } else {

1193 }

1194 }

1195

1196

1197

1204 unsigned DstIndex;

1205 std::tie(DstOp, DstIndex) = Flags.lookup(ID);

1206 unsigned SrcBehaviorValue = SrcBehavior->getZExtValue();

1208

1209

1211

1212

1215 }

1216 continue;

1217 }

1218

1219

1224 }

1227 continue;

1228 }

1229

1230

1233 unsigned DstBehaviorValue = DstBehavior->getZExtValue();

1234

1235 auto overrideDstValue = [&]() {

1238 };

1239

1240

1242

1244 SrcOp->getOperand(2) != DstOp->getOperand(2))

1245 return stringErr("linking module flags '" + ID->getString() +

1246 "': IDs have conflicting override values in '" +

1247 SrcM->getModuleIdentifier() + "' and '" +

1249 continue;

1251

1252 overrideDstValue();

1253 continue;

1254 }

1255

1256

1257 if (SrcBehaviorValue != DstBehaviorValue) {

1258 bool MinAndWarn = (SrcBehaviorValue == Module::Min &&

1262 bool MaxAndWarn = (SrcBehaviorValue == Module::Max &&

1266 if (!(MaxAndWarn || MinAndWarn))

1267 return stringErr("linking module flags '" + ID->getString() +

1268 "': IDs have conflicting behaviors in '" +

1269 SrcM->getModuleIdentifier() + "' and '" +

1271 }

1272

1273 auto ensureDistinctOp = [&](MDNode *DstValue) {

1275 "Expected MDTuple when appending module flags");

1276 if (DstValue->isDistinct())

1283 DstModFlags->setOperand(DstIndex, Flag);

1285 return New;

1286 };

1287

1288

1289

1292 SrcOp->getOperand(2) != DstOp->getOperand(2)) {

1293 std::string Str;

1295 << "linking module flags '" << ID->getString()

1296 << "': IDs have conflicting values ('" << *SrcOp->getOperand(2)

1297 << "' from " << SrcM->getModuleIdentifier() << " with '"

1299 << ')';

1300 emitWarning(Str);

1301 }

1302

1303

1309

1310

1311

1315 ->getOperand(2)};

1317 DstModFlags->setOperand(DstIndex, Flag);

1319 continue;

1320 }

1321

1322

1328

1329

1330

1334 ->getOperand(2)};

1336 DstModFlags->setOperand(DstIndex, Flag);

1338 continue;

1339 }

1340

1341

1342 switch (SrcBehaviorValue) {

1347

1348 if (SrcOp->getOperand(2) != DstOp->getOperand(2)) {

1349 std::string Str;

1351 << "linking module flags '" << ID->getString()

1352 << "': IDs have conflicting values: '" << *SrcOp->getOperand(2)

1353 << "' from " << SrcM->getModuleIdentifier() << ", and '"

1356 }

1357 continue;

1358 }

1360 break;

1361 }

1363 break;

1364 }

1368 for (const auto &O : SrcValue->operands())

1370 break;

1371 }

1380 break;

1381 }

1382 }

1383

1384 }

1385

1386

1387

1388 for (auto Idx : Mins) {

1391 if (!SeenMin.count(ID)) {

1394 Op->getOperand(0), ID,

1397 }

1398 }

1399

1400

1401 for (MDNode *Requirement : Requirements) {

1403 Metadata *ReqValue = Requirement->getOperand(1);

1404

1406 if ( || Op->getOperand(2) != ReqValue)

1407 return stringErr("linking module flags '" + Flag->getString() +

1408 "': does not have the required value");

1409 }

1411}

1412

1413

1414

1415

1419 return ".text\n.balign 2\n.thumb\n" + InlineAsm;

1421 return ".text\n.balign 4\n.arm\n" + InlineAsm;

1423}

1424

1425void IRLinker::updateAttributes(GlobalValue &GV) {

1426

1427

1428

1429

1430

1431

1432

1433

1434

1435

1436

1437

1438

1439

1441 if (->isIntrinsic())

1442 F->removeFnAttr(llvm::Attribute::NoCallback);

1443

1444

1448 CI->removeFnAttr(Attribute::NoCallback);

1449 }

1450}

1451

1452Error IRLinker::run() {

1453

1454 if (SrcM->getMaterializer())

1455 if (Error Err = SrcM->getMaterializer()->materializeMetadata())

1456 return Err;

1457

1458

1459

1462

1463

1466

1468

1469

1470

1471

1472

1473

1474 bool EnableDLWarning = true;

1475 bool EnableTripleWarning = true;

1476 if (SrcTriple.isNVPTX() && DstTriple.isNVPTX()) {

1477 bool SrcHasLibDeviceDL =

1478 (SrcM->getDataLayoutStr().empty() ||

1479 SrcM->getDataLayoutStr() == "e-i64:64-v16:16-v32:32-n16:32:64");

1480

1481

1482

1483 bool SrcHasLibDeviceTriple = (SrcTriple.getVendor() == Triple::NVIDIA &&

1484 SrcTriple.getOSName() == "gpulibs") ||

1485 (SrcTriple.getVendorName() == "unknown" &&

1486 SrcTriple.getOSName() == "unknown");

1487 EnableTripleWarning = !SrcHasLibDeviceTriple;

1488 EnableDLWarning = !(SrcHasLibDeviceTriple && SrcHasLibDeviceDL);

1489 }

1490

1491 if (EnableDLWarning && (SrcM->getDataLayout() != DstM.getDataLayout())) {

1492 emitWarning("Linking two modules of different data layouts: '" +

1493 SrcM->getModuleIdentifier() + "' is '" +

1494 SrcM->getDataLayoutStr() + "' whereas '" +

1497 }

1498

1499 if (EnableTripleWarning && !SrcM->getTargetTriple().empty() &&

1500 !SrcTriple.isCompatibleWith(DstTriple))

1501 emitWarning("Linking two modules of different target triples: '" +

1502 SrcM->getModuleIdentifier() + "' is '" +

1503 SrcM->getTargetTriple().str() + "' whereas '" +

1506

1508

1509

1510 computeTypeMapping();

1511

1512

1513

1514

1516

1517 std::reverse(Worklist.begin(), Worklist.end());

1518 while (!Worklist.empty()) {

1520 Worklist.pop_back();

1521

1522

1524 IndirectSymbolValueMap.find(GV) != IndirectSymbolValueMap.end())

1525 continue;

1526

1529 if (FoundError)

1530 return std::move(*FoundError);

1531 flushRAUWWorklist();

1532 }

1533

1534

1535

1536 DoneLinkingBodies = true;

1538

1539

1540

1541

1542 linkNamedMDNodes();

1543

1544

1545

1546 for (GlobalObject *NGO : UnmappedMetadata) {

1547 if (NGO->isDeclaration())

1549 }

1550

1551 if (!IsPerformingImport && !SrcM->getModuleInlineAsm().empty()) {

1552

1554 SrcTriple));

1555 } else if (IsPerformingImport) {

1556

1562 S += ", ";

1563 S += Alias;

1565 }

1566 });

1567 }

1568

1569

1570

1573 continue;

1575 if (FoundError)

1576 return std::move(*FoundError);

1577 if (NewValue) {

1579 if (NewGV) {

1582 }

1583 }

1584 }

1585

1586

1587 return linkModuleFlagsMetadata();

1588}

1589

1592

1595

1599

1603

1604StructType *IRMover::StructTypeKeyInfo::getEmptyKey() {

1606}

1607

1608StructType *IRMover::StructTypeKeyInfo::getTombstoneKey() {

1610}

1611

1612unsigned IRMover::StructTypeKeyInfo::getHashValue(const KeyTy &Key) {

1614}

1615

1616unsigned IRMover::StructTypeKeyInfo::getHashValue(const StructType *ST) {

1617 return getHashValue(KeyTy(ST));

1618}

1619

1620bool IRMover::StructTypeKeyInfo::isEqual(const KeyTy &LHS,

1621 const StructType *RHS) {

1622 if (RHS == getEmptyKey() || RHS == getTombstoneKey())

1623 return false;

1625}

1626

1627bool IRMover::StructTypeKeyInfo::isEqual(const StructType *LHS,

1628 const StructType *RHS) {

1629 if (RHS == getEmptyKey() || RHS == getTombstoneKey())

1632}

1633

1635 assert(!Ty->isOpaque());

1636 NonOpaqueStructTypes.insert(Ty);

1637}

1638

1640 assert(!Ty->isOpaque());

1641 NonOpaqueStructTypes.insert(Ty);

1642 bool Removed = OpaqueStructTypes.erase(Ty);

1643 (void)Removed;

1645}

1646

1648 assert(Ty->isOpaque());

1649 OpaqueStructTypes.insert(Ty);

1650}

1651

1654 bool IsPacked) {

1656 auto I = NonOpaqueStructTypes.find_as(Key);

1657 return I == NonOpaqueStructTypes.end() ? nullptr : *I;

1658}

1659

1661 if (Ty->isOpaque())

1662 return OpaqueStructTypes.count(Ty);

1663 auto I = NonOpaqueStructTypes.find(Ty);

1664 return I == NonOpaqueStructTypes.end() ? false : *I == Ty;

1665}

1666

1669 StructTypes.run(M, false);

1670 for (StructType *Ty : StructTypes) {

1671 if (Ty->isOpaque())

1672 IdentifiedStructTypes.addOpaque(Ty);

1673 else

1674 IdentifiedStructTypes.addNonOpaque(Ty);

1675 }

1676

1677

1678

1680 SharedMDs[MD].reset(const_cast<MDNode *>(MD));

1681 }

1682

1683

1684

1685

1687}

1688

1691 LazyCallback AddLazyFor, bool IsPerformingImport) {

1692 IRLinker TheIRLinker(Composite, SharedMDs, IdentifiedStructTypes,

1693 std::move(Src), ValuesToLink, std::move(AddLazyFor),

1694 IsPerformingImport, NamedMDNodes);

1695 return TheIRLinker.run();

1696}

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

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

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

This file defines the DenseMap class.

This file defines the DenseSet and SmallDenseSet classes.

static void forceRenaming(GlobalValue *GV, StringRef Name)

The LLVM SymbolTable class autorenames globals that conflict in the symbol table.

Definition IRMover.cpp:469

static void getArrayElements(const Constant *C, SmallVectorImpl< Constant * > &Dest)

Definition IRMover.cpp:778

static std::string adjustInlineAsm(const std::string &InlineAsm, const Triple &Triple)

Return InlineAsm adjusted with target-specific directives if required.

Definition IRMover.cpp:1416

static StringRef getTypeNamePrefix(StringRef Name)

Definition IRMover.cpp:683

static Error stringErr(const Twine &T)

Most of the errors produced by this module are inconvertible StringErrors.

Definition IRMover.cpp:38

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

Machine Check Debug Module

static unsigned getNumElements(Type *Ty)

This file implements a set that has insertion order iteration characteristics.

This file defines the SmallString class.

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

Class to represent array types.

static LLVM_ABI ArrayType * get(Type *ElementType, uint64_t NumElements)

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

AttrKind

This enumeration lists the attributes that can be associated with parameters, function results,...

LLVM Basic Block Representation.

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

void setSelectionKind(SelectionKind Val)

static LLVM_ABI Constant * getPointerBitCastOrAddrSpaceCast(Constant *C, Type *Ty)

Create a BitCast or AddrSpaceCast for a pointer type depending on the address space.

This is the shared class of boolean and integer constants.

uint64_t getZExtValue() const

Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...

This is an important base class in LLVM.

bool isDefault() const

Test if the DataLayout was constructed from an empty string.

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

Implements a dense probed hash-table based set.

DiagnosticInfo(int Kind, DiagnosticSeverity Severity)

Interface for custom diagnostic printing.

Lightweight error class with error context and mandatory checking.

static ErrorSuccess success()

Create a success value.

Tagged union holding either a T or a Error.

Error takeError()

Take ownership of the stored error.

static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)

FunctionType * getFunctionType() const

Returns the FunctionType for me.

static LLVM_ABI GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)

If a parent module is specified, the alias is automatically inserted into the end of the specified mo...

static LLVM_ABI GlobalIFunc * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Resolver, Module *Parent)

If a parent module is specified, the ifunc is automatically inserted into the end of the specified mo...

StringRef getSection() const

Get the custom section of this global if it has one.

VisibilityTypes getVisibility() const

LLVM_ABI bool isDeclaration() const

Return true if the primary definition of this global value is outside of the current translation unit...

LinkageTypes getLinkage() const

bool hasLocalLinkage() const

LLVM_ABI const Comdat * getComdat() const

bool hasExternalWeakLinkage() const

ThreadLocalMode getThreadLocalMode() const

void setLinkage(LinkageTypes LT)

bool isDeclarationForLinker() const

unsigned getAddressSpace() const

Module * getParent()

Get the module that this global value is contained inside of...

LLVM_ABI void eraseFromParent()

This method unlinks 'this' from the containing module and deletes it.

PointerType * getType() const

Global values are always pointers.

bool hasGlobalUnnamedAddr() const

bool hasAppendingLinkage() const

LLVM_ABI void removeFromParent()

This method unlinks 'this' from the containing module, but does not delete it.

@ InternalLinkage

Rename collisions when linking (static functions).

@ ExternalLinkage

Externally visible function.

@ ExternalWeakLinkage

ExternalWeak linkage description.

Type * getValueType() const

const Constant * getInitializer() const

getInitializer - Return the initializer for this global variable.

MaybeAlign getAlign() const

Returns the alignment of the given variable.

LLVM_ABI void copyAttributesFrom(const GlobalVariable *Src)

copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...

bool isConstant() const

If the value is a global constant, its value is immutable throughout the runtime execution of the pro...

void setAlignment(Align Align)

Sets the alignment attribute of the GlobalVariable.

LLVM_ABI void addNonOpaque(StructType *Ty)

Definition IRMover.cpp:1634

LLVM_ABI bool hasType(StructType *Ty)

Definition IRMover.cpp:1660

LLVM_ABI void switchToNonOpaque(StructType *Ty)

Definition IRMover.cpp:1639

LLVM_ABI void addOpaque(StructType *Ty)

Definition IRMover.cpp:1647

LLVM_ABI StructType * findNonOpaque(ArrayRef< Type * > ETypes, bool IsPacked)

Definition IRMover.cpp:1653

LLVM_ABI IRMover(Module &M)

Definition IRMover.cpp:1667

LLVM_ABI Error move(std::unique_ptr< Module > Src, ArrayRef< GlobalValue * > ValuesToLink, LazyCallback AddLazyFor, bool IsPerformingImport)

Move in the provide values in ValuesToLink from Src.

Definition IRMover.cpp:1689

DenseMap< const NamedMDNode *, SmallPtrSet< const MDNode *, 8 > > NamedMDNodesT

llvm::unique_function< void(GlobalValue &GV, ValueAdder Add)> LazyCallback

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

LinkDiagnosticInfo(DiagnosticSeverity Severity, const Twine &Msg LLVM_LIFETIME_BOUND)

Definition IRMover.cpp:255

void print(DiagnosticPrinter &DP) const override

Print using the given DP a user-friendly message.

Definition IRMover.cpp:258

ArrayRef< MDOperand > operands() const

op_iterator op_end() const

static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)

unsigned getNumOperands() const

Return number of MDNode operands.

op_iterator op_begin() const

static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)

Return a distinct node.

void push_back(Metadata *MD)

Append an element to the tuple. This will resize the node.

static LLVM_ABI void CollectAsmSymvers(const Module &M, function_ref< void(StringRef, StringRef)> AsmSymver)

Parse inline ASM and collect the symvers directives that are defined in the current module.

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

const Triple & getTargetTriple() const

Get the target triple which is a string describing the target host.

NamedMDNode * getNamedMetadata(StringRef Name) const

Return the first NamedMDNode in the module with the specified name.

@ AppendUnique

Appends the two values, which are required to be metadata nodes.

@ Override

Uses the specified value, regardless of the behavior or value of the other module.

@ Warning

Emits a warning if two values disagree.

@ Error

Emits an error if two values disagree, otherwise the resulting value is that of the operands.

@ Min

Takes the min of the two values, which are required to be integers.

@ Append

Appends the two values, which are required to be metadata nodes.

@ Max

Takes the max of the two values, which are required to be integers.

@ Require

Adds a requirement that another module flag be present and have a specified value after linking is pe...

LLVMContext & getContext() const

Get the global data context.

void setTargetTriple(Triple T)

Set the target triple.

NamedMDNode * getOrInsertModuleFlagsMetadata()

Returns the NamedMDNode in the module that represents module-level flags.

const std::string & getModuleIdentifier() const

Get the module identifier which is, essentially, the name of the module.

void setDataLayout(StringRef Desc)

Set the data layout.

void insertGlobalVariable(GlobalVariable *GV)

Insert global variable GV at the end of the global variable list and take ownership.

GlobalValue * getNamedValue(StringRef Name) const

Return the global value in the module with the specified name, of arbitrary type.

NamedMDNode * getOrInsertNamedMetadata(StringRef Name)

Return the named MDNode in the module with the specified name.

Comdat * getOrInsertComdat(StringRef Name)

Return the Comdat in the module with the specified name.

const DataLayout & getDataLayout() const

Get the data layout for the module's target platform.

const std::string & getDataLayoutStr() const

Get the data layout string for the module's target platform.

void appendModuleInlineAsm(StringRef Asm)

Append to the module-scope inline assembly blocks.

LLVM_ABI void setOperand(unsigned I, MDNode *New)

LLVM_ABI MDNode * getOperand(unsigned i) const

LLVM_ABI unsigned getNumOperands() const

iterator_range< op_iterator > operands()

LLVM_ABI void addOperand(MDNode *M)

Class to represent pointers.

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

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

size_type size() const

Determine the number of elements in the SetVector.

bool insert(const value_type &X)

Insert a new element into the SetVector.

A SetVector that performs no allocations if smaller than a certain size.

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

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

void push_back(const T &Elt)

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

StringRef - Represent a constant reference to a string, i.e.

static constexpr size_t npos

Class to represent struct types.

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

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

static LLVM_ABI StructType * getTypeByName(LLVMContext &C, StringRef Name)

Return the type with the specified name, or null if there is none by that name.

static LLVM_ABI StructType * create(LLVMContext &Context, StringRef Name)

This creates an identified struct.

LLVM_ABI void setName(StringRef Name)

Change the name of this type to the specified name, or to a name with a suffix if there is a collisio...

bool isLiteral() const

Return true if this type is uniqued by structural equivalence, false if it is a struct definition.

Triple - Helper class for working with autoconf configuration names.

ArchType getArch() const

Get the parsed architecture type of this triple.

const std::string & str() const

bool empty() const

Whether the triple is empty / default constructed.

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

TypeFinder - Walk over a module, identifying all of the types that are used by the module.

DenseSet< const MDNode * > & getVisitedMetadata()

void run(const Module &M, bool onlyNamed)

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

unsigned getNumContainedTypes() const

Return the number of types in the derived type.

LLVMContext & getContext() const

Return the LLVMContext in which this type was uniqued.

bool isFunctionTy() const

True if this is an instance of FunctionType.

TypeID getTypeID() const

Return the type id for the type.

Type * getContainedType(unsigned i) const

This method is used to implement the type iterator (defined at the end of the file).

This is a class that can be implemented by clients to remap types when cloning constants and instruct...

ValueT lookup(const KeyT &Val) const

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

std::optional< MDMapT > & getMDMap()

iterator find(const KeyT &Val)

LLVM_ABI MDNode * mapMDNode(const MDNode &N)

LLVM_ABI void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init, unsigned MappingContextID=0)

LLVM_ABI void scheduleRemapFunction(Function &F, unsigned MappingContextID=0)

LLVM_ABI void scheduleMapGlobalIFunc(GlobalIFunc &GI, Constant &Resolver, unsigned MappingContextID=0)

LLVM_ABI void scheduleMapGlobalAlias(GlobalAlias &GA, Constant &Aliasee, unsigned MappingContextID=0)

LLVM_ABI void remapGlobalObjectMetadata(GlobalObject &GO)

LLVM_ABI Value * mapValue(const Value &V)

LLVM_ABI void scheduleMapAppendingVariable(GlobalVariable &GV, GlobalVariable *OldGV, bool IsOldCtorDtor, ArrayRef< Constant * > NewMembers, unsigned MappingContextID=0)

LLVM_ABI void addFlags(RemapFlags Flags)

Add to the current RemapFlags.

This is a class that can be implemented by clients to materialize Values on demand.

LLVM Value Representation.

LLVM_ABI void setName(const Twine &Name)

Change the name of the value.

LLVM_ABI void replaceAllUsesWith(Value *V)

Change all uses of this to point to a new Value.

LLVM_ABI const Value * stripPointerCasts() const

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

LLVM_ABI LLVMContext & getContext() const

All values hold a context through their type.

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

LLVM_ABI void takeName(Value *V)

Transfer the name from V to this value.

std::pair< iterator, bool > insert(const ValueT &V)

bool erase(const ValueT &V)

size_type count(const_arg_type_t< ValueT > V) const

Return 1 if the specified key is in the set, 0 otherwise.

A raw_ostream that writes to an std::string.

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

@ C

The default llvm calling convention, compatible with C.

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

Flag

These should be considered private to the implementation of the MCInstrDesc class.

PointerTypeMap run(const Module &M)

Compute the PointerTypeMap for the module M.

std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)

Extract a Value from Metadata.

This is an optimization pass for GlobalISel generic memory operations.

FunctionAddr VTableAddr Value

decltype(auto) dyn_cast(const From &Val)

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

LLVM_ABI std::error_code inconvertibleErrorCode()

The value returned by this function can be returned from convertToErrorCode for Error values where no...

LLVM_ABI void UpgradeNVVMAnnotations(Module &M)

Convert legacy nvvm.annotations metadata to appropriate function attributes.

auto cast_or_null(const Y &Val)

LLVM_ABI bool UpgradeModuleFlags(Module &M)

This checks for module flags which should be upgraded.

void copyModuleAttrToFunctions(Module &M)

Copies module attributes to the functions in the module.

bool operator==(const AddressRangeValuePair &LHS, const AddressRangeValuePair &RHS)

decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)

@ RF_IgnoreMissingLocals

If this flag is set, the remapper ignores missing function-local entries (Argument,...

@ RF_NullMapMissingGlobalValues

Any global values not in value map are mapped to null instead of mapping to self.

@ RF_ReuseAndMutateDistinctMDs

Instruct the remapper to reuse and mutate distinct metadata (remapping them in place) instead of clon...

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

LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key

Error make_error(ArgTs &&... Args)

Make a Error instance representing failure using the given error info type.

DWARFExpression::Operation Op

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

ValueMap< const Value *, WeakTrackingVH > ValueToValueMapTy

OutputIt move(R &&Range, OutputIt Out)

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

DiagnosticSeverity

Defines the different supported severity of a diagnostic.

decltype(auto) cast(const From &Val)

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

void erase_if(Container &C, UnaryPredicate P)

Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...

hash_code hash_combine(const Ts &...args)

Combine values into a single hash_code.

hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)

Compute a hash_code for a sequence of values.

constexpr const char * PseudoProbeDescMetadataName

An information struct used to provide DenseMap with the various necessary components for a given valu...

LLVM_ABI KeyTy(ArrayRef< Type * > E, bool P)

Definition IRMover.cpp:1590

LLVM_ABI bool operator==(const KeyTy &that) const

Definition IRMover.cpp:1596

ArrayRef< Type * > ETypes

LLVM_ABI bool operator!=(const KeyTy &that) const

Definition IRMover.cpp:1600