Skip to content

Commit f483da0

Browse files
rui314rui314
committed
Rename replaceBody -> replaceSymbol.
llvm-svn: 317383
1 parent d21a53f commit f483da0

File tree

9 files changed

+37
-36
lines changed

9 files changed

+37
-36
lines changed

‎lld/COFF/LTO.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -88,7 +88,7 @@ BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {}
8888

8989
BitcodeCompiler::~BitcodeCompiler() = default;
9090

91-
static void undefine(Symbol *S) { replaceBody<Undefined>(S, S->getName()); }
91+
static void undefine(Symbol *S) { replaceSymbol<Undefined>(S, S->getName()); }
9292

9393
void BitcodeCompiler::add(BitcodeFile &F) {
9494
lto::InputFile &Obj = *F.Obj;

‎lld/COFF/SymbolTable.cpp‎

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -126,7 +126,7 @@ void SymbolTable::reportRemainingUndefines() {
126126
Symbol *Imp = find(Name.substr(strlen("__imp_")));
127127
if (Imp && isa<Defined>(Imp)) {
128128
auto *D = cast<Defined>(Imp);
129-
replaceBody<DefinedLocalImport>(Sym, Name, D);
129+
replaceSymbol<DefinedLocalImport>(Sym, Name, D);
130130
LocalImportChunks.push_back(cast<DefinedLocalImport>(Sym)->getChunk());
131131
continue;
132132
}
@@ -135,7 +135,7 @@ void SymbolTable::reportRemainingUndefines() {
135135
// Remaining undefined symbols are not fatal if /force is specified.
136136
// They are replaced with dummy defined symbols.
137137
if (Config->Force)
138-
replaceBody<DefinedAbsolute>(Sym, Name, 0);
138+
replaceSymbol<DefinedAbsolute>(Sym, Name, 0);
139139
Undefs.insert(Sym);
140140
}
141141

@@ -170,7 +170,7 @@ Symbol *SymbolTable::addUndefined(StringRef Name, InputFile *F,
170170
if (!F || !isa<BitcodeFile>(F))
171171
S->IsUsedInRegularObj = true;
172172
if (WasInserted || (isa<Lazy>(S) && IsWeakAlias)) {
173-
replaceBody<Undefined>(S, Name);
173+
replaceSymbol<Undefined>(S, Name);
174174
return S;
175175
}
176176
if (auto *L = dyn_cast<Lazy>(S)) {
@@ -188,7 +188,7 @@ void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol Sym) {
188188
bool WasInserted;
189189
std::tie(S, WasInserted) = insert(Name);
190190
if (WasInserted) {
191-
replaceBody<Lazy>(S, F, Sym);
191+
replaceSymbol<Lazy>(S, F, Sym);
192192
return;
193193
}
194194
auto *U = dyn_cast<Undefined>(S);
@@ -210,7 +210,7 @@ Symbol *SymbolTable::addAbsolute(StringRef N, COFFSymbolRef Sym) {
210210
std::tie(S, WasInserted) = insert(N);
211211
S->IsUsedInRegularObj = true;
212212
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S))
213-
replaceBody<DefinedAbsolute>(S, N, Sym);
213+
replaceSymbol<DefinedAbsolute>(S, N, Sym);
214214
else if (!isa<DefinedCOFF>(S))
215215
reportDuplicate(S, nullptr);
216216
return S;
@@ -222,7 +222,7 @@ Symbol *SymbolTable::addAbsolute(StringRef N, uint64_t VA) {
222222
std::tie(S, WasInserted) = insert(N);
223223
S->IsUsedInRegularObj = true;
224224
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S))
225-
replaceBody<DefinedAbsolute>(S, N, VA);
225+
replaceSymbol<DefinedAbsolute>(S, N, VA);
226226
else if (!isa<DefinedCOFF>(S))
227227
reportDuplicate(S, nullptr);
228228
return S;
@@ -234,7 +234,7 @@ Symbol *SymbolTable::addSynthetic(StringRef N, Chunk *C) {
234234
std::tie(S, WasInserted) = insert(N);
235235
S->IsUsedInRegularObj = true;
236236
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S))
237-
replaceBody<DefinedSynthetic>(S, N, C);
237+
replaceSymbol<DefinedSynthetic>(S, N, C);
238238
else if (!isa<DefinedCOFF>(S))
239239
reportDuplicate(S, nullptr);
240240
return S;
@@ -252,7 +252,8 @@ Symbol *SymbolTable::addRegular(InputFile *F, StringRef N, bool IsCOMDAT,
252252
if (SP == SP_CONFLICT) {
253253
reportDuplicate(S, F);
254254
} else if (SP == SP_NEW) {
255-
replaceBody<DefinedRegular>(S, F, N, IsCOMDAT, /*IsExternal*/ true, Sym, C);
255+
replaceSymbol<DefinedRegular>(S, F, N, IsCOMDAT, /*IsExternal*/ true, Sym,
256+
C);
256257
} else if (SP == SP_EXISTING && IsCOMDAT && C) {
257258
C->markDiscarded();
258259
// Discard associative chunks that we've parsed so far. No need to recurse
@@ -271,10 +272,10 @@ Symbol *SymbolTable::addCommon(InputFile *F, StringRef N, uint64_t Size,
271272
if (!isa<BitcodeFile>(F))
272273
S->IsUsedInRegularObj = true;
273274
if (WasInserted || !isa<DefinedCOFF>(S))
274-
replaceBody<DefinedCommon>(S, F, N, Size, Sym, C);
275+
replaceSymbol<DefinedCommon>(S, F, N, Size, Sym, C);
275276
else if (auto *DC = dyn_cast<DefinedCommon>(S))
276277
if (Size > DC->getSize())
277-
replaceBody<DefinedCommon>(S, F, N, Size, Sym, C);
278+
replaceSymbol<DefinedCommon>(S, F, N, Size, Sym, C);
278279
return S;
279280
}
280281

@@ -284,7 +285,7 @@ DefinedImportData *SymbolTable::addImportData(StringRef N, ImportFile *F) {
284285
std::tie(S, WasInserted) = insert(N);
285286
S->IsUsedInRegularObj = true;
286287
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) {
287-
replaceBody<DefinedImportData>(S, N, F);
288+
replaceSymbol<DefinedImportData>(S, N, F);
288289
return cast<DefinedImportData>(S);
289290
}
290291

@@ -300,7 +301,7 @@ DefinedImportThunk *SymbolTable::addImportThunk(StringRef Name,
300301
std::tie(S, WasInserted) = insert(Name);
301302
S->IsUsedInRegularObj = true;
302303
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) {
303-
replaceBody<DefinedImportThunk>(S, Name, ID, Machine);
304+
replaceSymbol<DefinedImportThunk>(S, Name, ID, Machine);
304305
return cast<DefinedImportThunk>(S);
305306
}
306307

‎lld/COFF/Symbols.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -412,7 +412,7 @@ union SymbolUnion {
412412
};
413413

414414
template <typename T, typename... ArgT>
415-
void replaceBody(Symbol *S, ArgT &&... Arg) {
415+
void replaceSymbol(Symbol *S, ArgT &&... Arg) {
416416
static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
417417
static_assert(alignof(T) <= alignof(SymbolUnion),
418418
"SymbolUnion not aligned enough");

‎lld/COFF/Writer.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -806,7 +806,7 @@ void Writer::fixSafeSEHSymbols() {
806806
// section relative relocations.
807807
Symbol *T = Symtab->find("___safe_se_handler_table");
808808
Symbol *C = Symtab->find("___safe_se_handler_count");
809-
replaceBody<DefinedSynthetic>(T, T->getName(), SEHTable);
809+
replaceSymbol<DefinedSynthetic>(T, T->getName(), SEHTable);
810810
cast<DefinedAbsolute>(C)->setVA(SEHTable->getSize() / 4);
811811
}
812812

‎lld/ELF/LTO.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -119,8 +119,8 @@ BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {
119119
BitcodeCompiler::~BitcodeCompiler() = default;
120120

121121
static void undefine(Symbol *S) {
122-
replaceBody<Undefined>(S, nullptr, S->getName(), /*IsLocal=*/false,
123-
STV_DEFAULT, S->Type);
122+
replaceSymbol<Undefined>(S, nullptr, S->getName(), /*IsLocal=*/false,
123+
STV_DEFAULT, S->Type);
124124
}
125125

126126
void BitcodeCompiler::add(BitcodeFile &F) {

‎lld/ELF/LinkerScript.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -149,8 +149,8 @@ void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
149149
// write expressions like this: `alignment = 16; . = ALIGN(., alignment)`.
150150
uint64_t SymValue = Value.Sec ? 0 : Value.getValue();
151151

152-
replaceBody<DefinedRegular>(Sym, nullptr, Cmd->Name, /*IsLocal=*/false,
153-
Visibility, STT_NOTYPE, SymValue, 0, Sec);
152+
replaceSymbol<DefinedRegular>(Sym, nullptr, Cmd->Name, /*IsLocal=*/false,
153+
Visibility, STT_NOTYPE, SymValue, 0, Sec);
154154
Cmd->Sym = cast<DefinedRegular>(Sym);
155155
}
156156

‎lld/ELF/SymbolTable.cpp‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -315,7 +315,7 @@ Symbol *SymbolTable::addUndefined(StringRef Name, bool IsLocal, uint8_t Binding,
315315
// in the same DSO.
316316
if (WasInserted || (isa<SharedSymbol>(S) && Visibility != STV_DEFAULT)) {
317317
S->Binding = Binding;
318-
replaceBody<Undefined>(S, File, Name, IsLocal, StOther, Type);
318+
replaceSymbol<Undefined>(S, File, Name, IsLocal, StOther, Type);
319319
return S;
320320
}
321321
if (Binding != STB_WEAK) {
@@ -404,7 +404,7 @@ Symbol *SymbolTable::addCommon(StringRef N, uint64_t Size, uint32_t Alignment,
404404
int Cmp = compareDefined(S, WasInserted, Binding, N);
405405
if (Cmp > 0) {
406406
S->Binding = Binding;
407-
replaceBody<DefinedCommon>(S, File, N, Size, Alignment, StOther, Type);
407+
replaceSymbol<DefinedCommon>(S, File, N, Size, Alignment, StOther, Type);
408408
} else if (Cmp == 0) {
409409
auto *C = dyn_cast<DefinedCommon>(S);
410410
if (!C) {
@@ -419,7 +419,7 @@ Symbol *SymbolTable::addCommon(StringRef N, uint64_t Size, uint32_t Alignment,
419419

420420
Alignment = C->Alignment = std::max(C->Alignment, Alignment);
421421
if (Size > C->Size)
422-
replaceBody<DefinedCommon>(S, File, N, Size, Alignment, StOther, Type);
422+
replaceSymbol<DefinedCommon>(S, File, N, Size, Alignment, StOther, Type);
423423
}
424424
return S;
425425
}
@@ -480,8 +480,8 @@ Symbol *SymbolTable::addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
480480
int Cmp = compareDefinedNonCommon(S, WasInserted, Binding, Section == nullptr,
481481
Value, Name);
482482
if (Cmp > 0)
483-
replaceBody<DefinedRegular>(S, File, Name, /*IsLocal=*/false, StOther, Type,
484-
Value, Size, Section);
483+
replaceSymbol<DefinedRegular>(S, File, Name, /*IsLocal=*/false, StOther,
484+
Type, Value, Size, Section);
485485
else if (Cmp == 0)
486486
reportDuplicate<ELFT>(S, dyn_cast_or_null<InputSectionBase>(Section),
487487
Value);
@@ -507,8 +507,8 @@ void SymbolTable::addShared(StringRef Name, SharedFile<ELFT> *File,
507507
// in the same DSO.
508508
if (WasInserted || ((S->isUndefined() || S->isLazy()) &&
509509
S->getVisibility() == STV_DEFAULT)) {
510-
replaceBody<SharedSymbol>(S, File, Name, Sym.st_other, Sym.getType(),
511-
Sym.st_value, Sym.st_size, Alignment, Verdef);
510+
replaceSymbol<SharedSymbol>(S, File, Name, Sym.st_other, Sym.getType(),
511+
Sym.st_value, Sym.st_size, Alignment, Verdef);
512512
if (!S->isWeak())
513513
File->IsUsed = true;
514514
}
@@ -524,8 +524,8 @@ Symbol *SymbolTable::addBitcode(StringRef Name, uint8_t Binding,
524524
int Cmp = compareDefinedNonCommon(S, WasInserted, Binding,
525525
/*IsAbs*/ false, /*Value*/ 0, Name);
526526
if (Cmp > 0)
527-
replaceBody<DefinedRegular>(S, F, Name, /*IsLocal=*/false, StOther, Type, 0,
528-
0, nullptr);
527+
replaceSymbol<DefinedRegular>(S, F, Name, /*IsLocal=*/false, StOther, Type,
528+
0, 0, nullptr);
529529
else if (Cmp == 0)
530530
reportDuplicate(S, F);
531531
return S;
@@ -559,7 +559,7 @@ Symbol *SymbolTable::addLazyArchive(StringRef Name, ArchiveFile *F,
559559
bool WasInserted;
560560
std::tie(S, WasInserted) = insert(Name);
561561
if (WasInserted) {
562-
replaceBody<LazyArchive>(S, F, Sym, Symbol::UnknownType);
562+
replaceSymbol<LazyArchive>(S, F, Sym, Symbol::UnknownType);
563563
return S;
564564
}
565565
if (!S->isUndefined())
@@ -568,7 +568,7 @@ Symbol *SymbolTable::addLazyArchive(StringRef Name, ArchiveFile *F,
568568
// An undefined weak will not fetch archive members. See comment on Lazy in
569569
// Symbols.h for the details.
570570
if (S->isWeak()) {
571-
replaceBody<LazyArchive>(S, F, Sym, S->Type);
571+
replaceSymbol<LazyArchive>(S, F, Sym, S->Type);
572572
return S;
573573
}
574574
std::pair<MemoryBufferRef, uint64_t> MBInfo = F->getMember(&Sym);
@@ -583,15 +583,15 @@ void SymbolTable::addLazyObject(StringRef Name, LazyObjFile &Obj) {
583583
bool WasInserted;
584584
std::tie(S, WasInserted) = insert(Name);
585585
if (WasInserted) {
586-
replaceBody<LazyObject>(S, &Obj, Name, Symbol::UnknownType);
586+
replaceSymbol<LazyObject>(S, &Obj, Name, Symbol::UnknownType);
587587
return;
588588
}
589589
if (!S->isUndefined())
590590
return;
591591

592592
// See comment for addLazyArchive above.
593593
if (S->isWeak())
594-
replaceBody<LazyObject>(S, &Obj, Name, S->Type);
594+
replaceSymbol<LazyObject>(S, &Obj, Name, S->Type);
595595
else if (InputFile *F = Obj.fetch())
596596
addFile<ELFT>(F);
597597
}

‎lld/ELF/Symbols.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -388,7 +388,7 @@ union SymbolUnion {
388388
void printTraceSymbol(Symbol *Sym);
389389

390390
template <typename T, typename... ArgT>
391-
void replaceBody(Symbol *S, InputFile *File, ArgT &&... Arg) {
391+
void replaceSymbol(Symbol *S, InputFile *File, ArgT &&... Arg) {
392392
static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
393393
static_assert(alignof(T) <= alignof(SymbolUnion),
394394
"SymbolUnion not aligned enough");

‎lld/ELF/SyntheticSections.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -80,9 +80,9 @@ template <class ELFT> void elf::createCommonSections() {
8080

8181
// Replace all DefinedCommon symbols with DefinedRegular symbols so that we
8282
// don't have to care about DefinedCommon symbols beyond this point.
83-
replaceBody<DefinedRegular>(S, Sym->getFile(), Sym->getName(),
84-
static_cast<bool>(Sym->isLocal()), Sym->StOther,
85-
Sym->Type, 0, Sym->getSize(), Section);
83+
replaceSymbol<DefinedRegular>(
84+
S, Sym->getFile(), Sym->getName(), static_cast<bool>(Sym->isLocal()),
85+
Sym->StOther, Sym->Type, 0, Sym->getSize(), Section);
8686
}
8787
}
8888

0 commit comments

Comments
 (0)