1 |
61 |
Agner |
/**************************** linker.cpp ***********************************
|
2 |
|
|
* Author: Agner Fog
|
3 |
|
|
* date created: 2017-11-14
|
4 |
|
|
* Last modified: 2021-05-28
|
5 |
|
|
* Version: 1.11
|
6 |
|
|
* Project: Binary tools for ForwardCom instruction set
|
7 |
|
|
* Description:
|
8 |
|
|
* This module contains the linker.
|
9 |
|
|
*
|
10 |
|
|
* Copyright 2017-2021 GNU General Public License v. 3 http://www.gnu.org/licenses
|
11 |
|
|
*****************************************************************************/
|
12 |
|
|
|
13 |
|
|
/* Overview of data structures used during linking process
|
14 |
|
|
-------------------------------------------------------
|
15 |
|
|
symbolImports: List of imported symbols that need to be resolved.
|
16 |
|
|
Includes symbol name and source module
|
17 |
|
|
symbolExports: List of public symbols that can be targets for symbolImports.
|
18 |
|
|
Includes symbol name and module or library
|
19 |
|
|
libraries: Library files to include in symbol search
|
20 |
|
|
libmodules: List of library modules that will be extracted as object files
|
21 |
|
|
modules1: Metabuffer containing all the object files to add
|
22 |
|
|
modules2: Same. Also includes object files extracted from libraries
|
23 |
|
|
sections: Index to sections to be extracted from object files and library modules.
|
24 |
|
|
Sorted in the order in which they should occur in the executable file
|
25 |
|
|
sections2: Same as sections. Sorted by module and section index. Used for re-finding a section
|
26 |
|
|
communalSections: List of communal sections. Some of these will be copied to sections and
|
27 |
|
|
sections2 when needed
|
28 |
|
|
symbolXref: Cross reference between module-local symbol indexes and indexes in relinkable executable file
|
29 |
|
|
unresWeakSym: List of unresolved weak symbols. Includes indexes in relinkable executable file
|
30 |
|
|
eventData: List of event records
|
31 |
|
|
|
32 |
|
|
Each of the elements in modules1/2 is a complete CELF object containing its own data structures,
|
33 |
|
|
including sectionHeaders, symbols, stringBuffer, and relocations.
|
34 |
|
|
|
35 |
|
|
outFile is also a complete CELF object containing its own data structures, including
|
36 |
|
|
programHeaders, sectionHeaders, symbols, stringBuffer, and relocations.
|
37 |
|
|
|
38 |
|
|
*/
|
39 |
|
|
|
40 |
|
|
#include "stdafx.h"
|
41 |
|
|
|
42 |
|
|
// define code of dummy function for unresolved weak externals
|
43 |
|
|
// and unresolved functions of incomplete executable file:
|
44 |
|
|
static const uint32_t unresolvedFunctionN = 2;
|
45 |
|
|
static const uint32_t unresolvedFunction[unresolvedFunctionN] = {
|
46 |
|
|
0x79800200, // tiny instructions: int64 r0 = 0; double v0 = 0
|
47 |
|
|
// 0x78000200, // tiny instructions: int64 r0 = 0; v0 = clear()
|
48 |
|
|
0x67C00000 // instruction: return
|
49 |
|
|
};
|
50 |
|
|
static const uint32_t unresolvedReguse1 = 1;
|
51 |
|
|
static const uint32_t unresolvedReguse2 = 1;
|
52 |
|
|
|
53 |
|
|
// run the linker
|
54 |
|
|
void CLinker::go() {
|
55 |
|
|
// write text on stdout
|
56 |
|
|
feedBackText1();
|
57 |
|
|
|
58 |
|
|
if (cmd.job == CMDL_JOB_RELINK) {
|
59 |
|
|
// read pre-existing executable file
|
60 |
|
|
loadExeFile();
|
61 |
|
|
relinkable = true; relinking = true;
|
62 |
|
|
if (err.number()) return;
|
63 |
|
|
}
|
64 |
|
|
|
65 |
|
|
// read specified object files and library files
|
66 |
|
|
fillBuffers();
|
67 |
|
|
if (err.number()) return;
|
68 |
|
|
|
69 |
|
|
// make list of imported and exported symbols
|
70 |
|
|
makeSymbolList();
|
71 |
|
|
if (err.number()) return;
|
72 |
|
|
|
73 |
|
|
// match lists of imported and exported symbols
|
74 |
|
|
matchSymbols();
|
75 |
|
|
if (err.number()) return;
|
76 |
|
|
|
77 |
|
|
// search libraries for imported symbols
|
78 |
|
|
librarySearch();
|
79 |
|
|
if (err.number()) return;
|
80 |
|
|
|
81 |
|
|
// write feedback to console
|
82 |
|
|
feedBackText2();
|
83 |
|
|
|
84 |
|
|
// check for duplicate symbols
|
85 |
|
|
checkDuplicateSymbols();
|
86 |
|
|
if (err.number()) return;
|
87 |
|
|
|
88 |
|
|
// get imported library modules into modules2 buffer
|
89 |
|
|
readLibraryModules();
|
90 |
|
|
if (err.number()) return;
|
91 |
|
|
|
92 |
|
|
// make list of all sections
|
93 |
|
|
makeSectionList();
|
94 |
|
|
if (err.number()) return;
|
95 |
|
|
|
96 |
|
|
// make program headers and assign addresses to sections
|
97 |
|
|
makeProgramHeaders();
|
98 |
|
|
if (err.number()) return;
|
99 |
|
|
|
100 |
|
|
// put values into all cross references
|
101 |
|
|
relocate();
|
102 |
|
|
if (err.number()) return;
|
103 |
|
|
|
104 |
|
|
// make sorted event list
|
105 |
|
|
makeEventList();
|
106 |
|
|
|
107 |
|
|
// copy sections to output file
|
108 |
|
|
copySections();
|
109 |
|
|
|
110 |
|
|
// copy symbols to output file
|
111 |
|
|
copySymbols();
|
112 |
|
|
|
113 |
|
|
// copy relocation records to output file if needed
|
114 |
|
|
copyRelocations();
|
115 |
|
|
if (err.number()) return;
|
116 |
|
|
|
117 |
|
|
// make executable file header
|
118 |
|
|
makeFileHeader();
|
119 |
|
|
|
120 |
|
|
// join sections into executable file
|
121 |
|
|
outFile.join(&fileHeader);
|
122 |
|
|
if (err.number()) return;
|
123 |
|
|
|
124 |
|
|
// make link map
|
125 |
|
|
if (cmd.outputListFile) {
|
126 |
|
|
CELF exefile;
|
127 |
|
|
exefile.copy(outFile);
|
128 |
|
|
exefile.parseFile();
|
129 |
|
|
const char * listfilename = cmd.getFilename(cmd.outputListFile);
|
130 |
|
|
FILE * fp = fopen(listfilename, "w");
|
131 |
|
|
fprintf(fp, "\nLink map of %s\n", cmd.getFilename(cmd.outputFile));
|
132 |
|
|
exefile.makeLinkMap(fp);
|
133 |
|
|
fclose(fp);
|
134 |
|
|
}
|
135 |
|
|
|
136 |
|
|
if (cmd.outputType == FILETYPE_FWC_HEX) {
|
137 |
|
|
// make hexadecimal file
|
138 |
|
|
CFileBuffer hexfile;
|
139 |
|
|
outFile.makeHexBuffer() >> hexfile;
|
140 |
|
|
hexfile.write(cmd.getFilename(cmd.outputFile));
|
141 |
|
|
}
|
142 |
|
|
else {
|
143 |
|
|
// write output file
|
144 |
|
|
outFile.write(cmd.getFilename(cmd.outputFile));
|
145 |
|
|
}
|
146 |
|
|
}
|
147 |
|
|
|
148 |
|
|
CLinker::CLinker() {
|
149 |
|
|
// Constructor
|
150 |
|
|
zeroAllMembers(fileHeader); // initialize file header
|
151 |
|
|
relinking = false;
|
152 |
|
|
relinkable = (cmd.fileOptions & CMDL_FILE_RELINKABLE) != 0;
|
153 |
|
|
symbolNameBuffer.pushString(""); // make sure name = 0 gives empty string
|
154 |
|
|
}
|
155 |
|
|
|
156 |
|
|
// write feedback text on stdout
|
157 |
|
|
void CLinker::feedBackText1() {
|
158 |
|
|
if (cmd.verbose) { // tell what we are doing
|
159 |
|
|
if (cmd.verbose > 1) printf("\nForwardCom linker v. %i.%02i", FORWARDCOM_VERSION, FORWARDCOM_SUBVERSION);
|
160 |
|
|
if (cmd.job == CMDL_JOB_LINK) {
|
161 |
|
|
printf("\nLinking file %s", cmd.getFilename(cmd.outputFile));
|
162 |
|
|
}
|
163 |
|
|
else {
|
164 |
|
|
printf("\nRelinking file %s to file %s", cmd.getFilename(cmd.inputFile), cmd.getFilename(cmd.outputFile));
|
165 |
|
|
}
|
166 |
|
|
}
|
167 |
|
|
}
|
168 |
|
|
|
169 |
|
|
// load specified object files and library files into buffers
|
170 |
|
|
void CLinker::fillBuffers() {
|
171 |
|
|
uint32_t i; // loop counter
|
172 |
|
|
const char * fname; // file name
|
173 |
|
|
|
174 |
|
|
// count number of modules and libraries on command line, and number of relinkable modules and libraries
|
175 |
|
|
countModules();
|
176 |
|
|
|
177 |
|
|
// allocate metabuffers
|
178 |
|
|
modules1.setSize(numRelinkObjects + numObjects);
|
179 |
|
|
libraries.setSize(numLibraries + numRelinkLibraries + 1); // libraries[0] is not used
|
180 |
|
|
|
181 |
|
|
// get preserved modules if relinking
|
182 |
|
|
if (cmd.job == CMDL_JOB_RELINK) getRelinkObjects();
|
183 |
|
|
|
184 |
|
|
// read files into these buffers
|
185 |
|
|
uint32_t iObject = numRelinkObjects; // object file index
|
186 |
|
|
uint32_t iLibrary = 0; // library file index
|
187 |
|
|
|
188 |
|
|
if (cmd.verbose && numObjects) printf("\nAdding object files:");
|
189 |
|
|
|
190 |
|
|
// loop through commands. get object files and libraries
|
191 |
|
|
for (i = 0; i < cmd.lcommands.numEntries(); i++) {
|
192 |
|
|
if ((cmd.lcommands[i].command & 0xFF) == CMDL_LINK_ADDMODULE) {
|
193 |
|
|
// name of object file
|
194 |
|
|
fname = cmd.getFilename(cmd.lcommands[i].filename);
|
195 |
|
|
// write name
|
196 |
|
|
if (cmd.verbose) printf(" %s", fname);
|
197 |
|
|
// read object file
|
198 |
|
|
modules1[iObject].read(fname);
|
199 |
|
|
modules1[iObject].moduleName = cmd.fileNameBuffer.pushString(removePath(fname));
|
200 |
|
|
modules1[iObject].library = 0;
|
201 |
|
|
modules1[iObject].relinkable = (cmd.lcommands[i].command & CMDL_LINK_RELINKABLE) != 0;
|
202 |
|
|
|
203 |
|
|
// remove colons from name
|
204 |
|
|
char *nm = &cmd.fileNameBuffer.get<char>(modules1[iObject].moduleName);
|
205 |
|
|
for (int s = 0; s < (int)strlen(nm); s++) {
|
206 |
|
|
if (nm[s] == ':' || nm[s] <= ' ') nm[s] = '_';
|
207 |
|
|
}
|
208 |
|
|
if (err.number()) continue;
|
209 |
|
|
// check type
|
210 |
|
|
if (modules1[iObject].getFileType() != FILETYPE_FWC) {
|
211 |
|
|
err.submit(ERR_LINK_FILE_TYPE, fname);
|
212 |
|
|
return;
|
213 |
|
|
}
|
214 |
|
|
iObject++;
|
215 |
|
|
}
|
216 |
|
|
else if ((cmd.lcommands[i].command & 0xFF) == CMDL_LINK_ADDLIBRARY) {
|
217 |
|
|
iLibrary++;
|
218 |
|
|
// name of library file
|
219 |
|
|
fname = cmd.getFilename(cmd.lcommands[i].filename);
|
220 |
|
|
// read library file
|
221 |
|
|
libraries[iLibrary].read(fname);
|
222 |
|
|
libraries[iLibrary].relinkable = (cmd.lcommands[i].command & CMDL_LINK_RELINKABLE) != 0;
|
223 |
|
|
libraries[iLibrary].libraryName = cmd.fileNameBuffer.pushString(removePath(fname));
|
224 |
|
|
|
225 |
|
|
// remove colons and whitespace from name
|
226 |
|
|
char *nm = &cmd.fileNameBuffer.get<char>(libraries[iLibrary].libraryName);
|
227 |
|
|
for (int s = 0; s < (int)strlen(nm); s++) {
|
228 |
|
|
if (nm[s] == ':' || nm[s] <= ' ') nm[s] = '_';
|
229 |
|
|
}
|
230 |
|
|
if (err.number()) continue;
|
231 |
|
|
// check type
|
232 |
|
|
uint32_t ftype = libraries[iLibrary].getFileType();
|
233 |
|
|
if ((ftype != FILETYPE_LIBRARY && ftype != FILETYPE_FWC_LIB) || !libraries[iLibrary].isForwardCom()) {
|
234 |
|
|
err.submit(ERR_LINK_FILE_TYPE_LIB, fname);
|
235 |
|
|
return;
|
236 |
|
|
}
|
237 |
|
|
}
|
238 |
|
|
else if ((cmd.lcommands[i].command & 0xFF) == CMDL_LINK_ADDLIBMODULE) {
|
239 |
|
|
// add module explicitly from library
|
240 |
|
|
|
241 |
|
|
// name of module
|
242 |
|
|
fname = cmd.getFilename(cmd.lcommands[i].filename);
|
243 |
|
|
|
244 |
|
|
// extract module from last library
|
245 |
|
|
if (iLibrary == 0) { // no library specified
|
246 |
|
|
err.submit(ERR_LINK_MODULE_NOT_FOUND, fname, "none");
|
247 |
|
|
continue;
|
248 |
|
|
}
|
249 |
|
|
// library name
|
250 |
|
|
const char * libName = cmd.getFilename(libraries[iLibrary].libraryName);
|
251 |
|
|
// find module
|
252 |
|
|
uint32_t moduleOs = libraries[iLibrary].findMember(cmd.lcommands[i].filename);
|
253 |
|
|
if (moduleOs == 0) { // module not found in library
|
254 |
|
|
err.submit(ERR_LINK_MODULE_NOT_FOUND, fname, libName);
|
255 |
|
|
continue;
|
256 |
|
|
}
|
257 |
|
|
// write name
|
258 |
|
|
if (cmd.verbose) printf(" %s:%s", libName, fname);
|
259 |
|
|
|
260 |
|
|
// read object file
|
261 |
|
|
modules1[iObject].push(libraries[iLibrary].buf() + moduleOs + (uint32_t)sizeof(SUNIXLibraryHeader),
|
262 |
|
|
libraries[iLibrary].getMemberSize(moduleOs));
|
263 |
|
|
modules1[iObject].moduleName = cmd.lcommands[i].filename;
|
264 |
|
|
modules1[iObject].library = iLibrary;
|
265 |
|
|
modules1[iObject].relinkable = (cmd.lcommands[i].command & CMDL_LINK_RELINKABLE) != 0;
|
266 |
|
|
iObject++;
|
267 |
|
|
}
|
268 |
|
|
}
|
269 |
|
|
|
270 |
|
|
// get recovered libraries if relinking
|
271 |
|
|
if (numRelinkLibraries) getRelinkLibraries();
|
272 |
|
|
}
|
273 |
|
|
|
274 |
|
|
// count number of modules and libraries to add
|
275 |
|
|
void CLinker::countModules() {
|
276 |
|
|
uint32_t i; // loop counter
|
277 |
|
|
int32_t j; // loop counter
|
278 |
|
|
const char * fname; // file name
|
279 |
|
|
numObjects = 0; // number of object files
|
280 |
|
|
numLibraries = 0; // number of libraries
|
281 |
|
|
|
282 |
|
|
// count number of object files and library files on command line
|
283 |
|
|
for (i = 0; i < cmd.lcommands.numEntries(); i++) {
|
284 |
|
|
if ((uint8_t)cmd.lcommands[i].command == CMDL_LINK_ADDMODULE || (uint8_t)cmd.lcommands[i].command == CMDL_LINK_ADDLIBRARY) {
|
285 |
|
|
// name of module
|
286 |
|
|
fname = cmd.getFilename(cmd.lcommands[i].filename);
|
287 |
|
|
// is it a library?
|
288 |
|
|
for (j = (int32_t)strlen(fname) - 1; j > 0; j--) {
|
289 |
|
|
if (fname[j] == '.') break;
|
290 |
|
|
}
|
291 |
|
|
if ((j > 0 && strncasecmp_(fname + j, ".li", 3) == 0 ) || (fname[j+1] == 'a' && fname[j+2] == 0)) {
|
292 |
|
|
// this is a library
|
293 |
|
|
numLibraries++;
|
294 |
|
|
cmd.lcommands[i].command = CMDL_LINK_ADDLIBRARY | (cmd.lcommands[i].command & CMDL_LINK_RELINKABLE);
|
295 |
|
|
}
|
296 |
|
|
else {
|
297 |
|
|
// assume that this is an object file
|
298 |
|
|
numObjects++;
|
299 |
|
|
}
|
300 |
|
|
}
|
301 |
|
|
if ((cmd.lcommands[i].command & 0xFF) == CMDL_LINK_ADDLIBMODULE) {
|
302 |
|
|
// object module from library file
|
303 |
|
|
numObjects++;
|
304 |
|
|
}
|
305 |
|
|
if (cmd.lcommands[i].command & CMDL_LINK_RELINKABLE) {
|
306 |
|
|
// output file is relinkable
|
307 |
|
|
relinkable = true;
|
308 |
|
|
}
|
309 |
|
|
}
|
310 |
|
|
// count number of object files and libraries to reuse if relinking
|
311 |
|
|
countReusedModules();
|
312 |
|
|
}
|
313 |
|
|
|
314 |
|
|
// make list of imported and exported symbols
|
315 |
|
|
void CLinker::makeSymbolList() {
|
316 |
|
|
uint32_t modul; // module index
|
317 |
|
|
SSymbolEntry sym; // symbol record
|
318 |
|
|
zeroAllMembers(sym);
|
319 |
|
|
unresolvedWeak = 0; // unresolved weak imports: 1: constant, 2: readonly ip data, 4: writeable datap data, 8: function
|
320 |
|
|
unresolvedWeakNum = 0; // number of unresolved weak imports for writeable data
|
321 |
|
|
|
322 |
|
|
// loop through modules
|
323 |
|
|
for (modul = 0; modul < modules1.numEntries(); modul++) {
|
324 |
|
|
if (modules1[modul].dataSize() == 0) continue;
|
325 |
|
|
// get exported symbols
|
326 |
|
|
modules1[modul].listSymbols(&symbolNameBuffer, &symbolExports, modul, 0, 1);
|
327 |
|
|
// get imported symbols
|
328 |
|
|
modules1[modul].listSymbols(&symbolNameBuffer, &symbolImports, modul, 0, 2);
|
329 |
|
|
}
|
330 |
|
|
// add special symbols as weak. value will be set later
|
331 |
|
|
sym.name = symbolNameBuffer.pushString("__ip_base");
|
332 |
|
|
sym.st_bind = STB_WEAK;
|
333 |
|
|
sym.library = 0xFFFFFFFE;
|
334 |
|
|
sym.st_other = SHF_IP;
|
335 |
|
|
sym.symindex = 1;
|
336 |
|
|
sym.member = 0;
|
337 |
|
|
sym.status = 3;
|
338 |
|
|
symbolExports.push(sym);
|
339 |
|
|
symbolImports.push(sym);
|
340 |
|
|
sym.name = symbolNameBuffer.pushString("__datap_base");
|
341 |
|
|
sym.st_other = SHF_DATAP;
|
342 |
|
|
sym.symindex = 2;
|
343 |
|
|
symbolExports.push(sym);
|
344 |
|
|
symbolImports.push(sym);
|
345 |
|
|
sym.name = symbolNameBuffer.pushString("__threadp_base");
|
346 |
|
|
sym.st_other = SHF_THREADP;
|
347 |
|
|
sym.symindex = 3;
|
348 |
|
|
symbolExports.push(sym);
|
349 |
|
|
symbolImports.push(sym);
|
350 |
|
|
sym.name = symbolNameBuffer.pushString("__event_table");
|
351 |
|
|
sym.st_other = SHF_IP;
|
352 |
|
|
sym.symindex = 4;
|
353 |
|
|
symbolExports.push(sym);
|
354 |
|
|
symbolImports.push(sym);
|
355 |
|
|
sym.name = symbolNameBuffer.pushString("__event_table_num");
|
356 |
|
|
sym.st_other = 0;
|
357 |
|
|
sym.symindex = 5;
|
358 |
|
|
symbolExports.push(sym);
|
359 |
|
|
symbolImports.push(sym);
|
360 |
|
|
// make import symbol __entry_point
|
361 |
|
|
sym.name = symbolNameBuffer.pushString("__entry_point");
|
362 |
|
|
sym.st_other = 0;
|
363 |
|
|
sym.symindex = 6;
|
364 |
|
|
sym.status = 0;
|
365 |
|
|
sym.st_bind = STB_GLOBAL;
|
366 |
|
|
symbolImports.push(sym);
|
367 |
|
|
// sort symbols by name for easy search
|
368 |
|
|
symbolExports.sort();
|
369 |
|
|
#if 0 // debug: list exported symbols
|
370 |
|
|
for (uint32_t s = 0; s < symbolExports.numEntries(); s++) {
|
371 |
|
|
printf("\n>%s", symbolNameBuffer.buf() + symbolExports[s].name);
|
372 |
|
|
}
|
373 |
|
|
#endif
|
374 |
|
|
}
|
375 |
|
|
|
376 |
|
|
// match lists of imported and exported symbols
|
377 |
|
|
void CLinker::matchSymbols() {
|
378 |
|
|
uint32_t sym; // symbol index
|
379 |
|
|
int32_t found;
|
380 |
|
|
for (sym = 0; sym < symbolImports.numEntries(); sym++) {
|
381 |
|
|
// imported symbol name
|
382 |
|
|
if (!(symbolImports[sym].status & 2)) {
|
383 |
|
|
// symbol name not already resolved
|
384 |
|
|
// search for this name in list of exported symbols
|
385 |
|
|
SSymbolEntry sym1 = symbolImports[sym];
|
386 |
|
|
sym1.st_bind = STB_IGNORE; // ignore weak/strong difference
|
387 |
|
|
found = symbolExports.findFirst(sym1);
|
388 |
|
|
if (found >= 0) symbolImports[sym].status |= 2; // symbol has been matched
|
389 |
|
|
}
|
390 |
|
|
}
|
391 |
|
|
}
|
392 |
|
|
|
393 |
|
|
// search libraries for imported symbols
|
394 |
|
|
void CLinker::librarySearch() {
|
395 |
|
|
bool newImports = true; // new modules have additional imports to resolve
|
396 |
|
|
uint32_t sym; // symbol index
|
397 |
|
|
uint32_t lib; // library index
|
398 |
|
|
uint32_t m; // module index
|
399 |
|
|
const char * symname = 0; // name of symbol to find
|
400 |
|
|
uint32_t moduleOs; // offset to module in library
|
401 |
|
|
SLibraryModule modul; // identifyer of library module to add
|
402 |
|
|
// repeat search as long as new modules have additional imports to resolve
|
403 |
|
|
while (newImports) {
|
404 |
|
|
// loop through symbols
|
405 |
|
|
for (sym = 0; sym < symbolImports.numEntries(); sym++) {
|
406 |
|
|
if ((symbolImports[sym].status & 6) == 0 && !(symbolImports[sym].st_bind & STB_WEAK)) {
|
407 |
|
|
// symbol name
|
408 |
|
|
symname = symbolNameBuffer.getString(symbolImports[sym].name);
|
409 |
|
|
// symbol is unresolved and not weak. search for it in all libraries
|
410 |
|
|
for (lib = 1; lib < libraries.numEntries(); lib++) {
|
411 |
|
|
moduleOs = libraries[lib].findSymbol(symname);
|
412 |
|
|
if (moduleOs) {
|
413 |
|
|
// symbol found. add module to list if it is not already there
|
414 |
|
|
symbolImports[sym].status = 2;
|
415 |
|
|
modul.library = lib;
|
416 |
|
|
modul.offset = moduleOs;
|
417 |
|
|
libmodules.addUnique(modul);
|
418 |
|
|
break;
|
419 |
|
|
}
|
420 |
|
|
}
|
421 |
|
|
if (lib == libraries.numEntries()) {
|
422 |
|
|
// strong symbol not found. make error message
|
423 |
|
|
// get module name
|
424 |
|
|
const char * moduleName = "[fixed]";
|
425 |
|
|
uint32_t modul = symbolImports[sym].member;
|
426 |
|
|
if (modul > 0 && modul < modules1.numEntries()) {
|
427 |
|
|
uint32_t mn = modules1[modul].moduleName;
|
428 |
|
|
moduleName = cmd.getFilename(mn);
|
429 |
|
|
}
|
430 |
|
|
symbolImports[sym].status |= 4; // avoid reporting same unresolved symbol more than once
|
431 |
|
|
symbolImports[sym].st_bind = STB_UNRESOLVED;
|
432 |
|
|
fileHeader.e_flags |= EF_INCOMPLETE; // file is incomplete when there are unresolved symbols
|
433 |
|
|
if (cmd.fileOptions & CMDL_FILE_INCOMPLETE) { //incomplete file allowed. warn only
|
434 |
|
|
err.submit(ERR_LINK_UNRESOLVED_WARN, symname, moduleName);
|
435 |
|
|
}
|
436 |
|
|
else { //incomplete file not allowed. fatal error
|
437 |
|
|
err.submit(ERR_LINK_UNRESOLVED, symname, moduleName);
|
438 |
|
|
}
|
439 |
|
|
}
|
440 |
|
|
}
|
441 |
|
|
}
|
442 |
|
|
|
443 |
|
|
// loop through new library modules
|
444 |
|
|
newImports = false;
|
445 |
|
|
for (m = 0; m < libmodules.numEntries(); m++) {
|
446 |
|
|
if (!(libmodules[m].library & 0x80000000)) {
|
447 |
|
|
// this module has not been added before
|
448 |
|
|
libmodules[m].library |= 0x80000000;
|
449 |
|
|
// library and offset
|
450 |
|
|
lib = libmodules[m].library & 0x7FFFFFFF;
|
451 |
|
|
moduleOs = libmodules[m].offset;
|
452 |
|
|
// put member into buffer in order to extract symbols
|
453 |
|
|
memberBuffer.setSize(0);
|
454 |
|
|
memberBuffer.push(libraries[lib].buf() + moduleOs + (uint32_t)sizeof(SUNIXLibraryHeader),
|
455 |
|
|
libraries[lib].getMemberSize(moduleOs));
|
456 |
|
|
// check if this is a ForwardCom object file
|
457 |
|
|
int fileType = memberBuffer.getFileType();
|
458 |
|
|
if (fileType != FILETYPE_FWC) {
|
459 |
|
|
err.submit(ERR_LIBRARY_MEMBER_TYPE,
|
460 |
|
|
libraries[lib].getMemberName(moduleOs),
|
461 |
|
|
CFileBuffer::getFileFormatName(fileType));
|
462 |
|
|
return;
|
463 |
|
|
}
|
464 |
|
|
memberBuffer.relinkable = libraries[lib].relinkable;
|
465 |
|
|
// get names of exported symbols from ELF file
|
466 |
|
|
memberBuffer.listSymbols(&symbolNameBuffer, &symbolExports, moduleOs, lib, 1);
|
467 |
|
|
uint32_t numImports = symbolImports.numEntries();
|
468 |
|
|
// get names of imported symbols from ELF file
|
469 |
|
|
memberBuffer.listSymbols(&symbolNameBuffer, &symbolImports, moduleOs, lib, 2);
|
470 |
|
|
if (symbolImports.numEntries() > numImports) {
|
471 |
|
|
// this library module has new imports to resolve
|
472 |
|
|
newImports = true;
|
473 |
|
|
}
|
474 |
|
|
}
|
475 |
|
|
}
|
476 |
|
|
if (err.number()) return;
|
477 |
|
|
// new symbols have been added. sort list again
|
478 |
|
|
symbolExports.sort();
|
479 |
|
|
// match all new symbol exports to imports
|
480 |
|
|
matchSymbols();
|
481 |
|
|
}
|
482 |
|
|
// search for unresolved weak imports
|
483 |
|
|
for (sym = 0; sym < symbolImports.numEntries(); sym++) {
|
484 |
|
|
if ((symbolImports[sym].status & 3) == 0 && (symbolImports[sym].st_bind & STB_WEAK)) {
|
485 |
|
|
// weak symbol not resolved. make a zero dummy for it
|
486 |
|
|
symbolImports[sym].status |= 1; // avoid counting same unresolved symbol more than once
|
487 |
|
|
// unresolved weak imports:
|
488 |
|
|
// 1: constant, 2: readonly ip data, 4: writeable datap data,
|
489 |
|
|
// 8: threadp, 0x10: function
|
490 |
|
|
switch (symbolImports[sym].st_other & (SHF_BASEPOINTER | STV_EXEC)) {
|
491 |
|
|
case 0: // constant
|
492 |
|
|
unresolvedWeak |= 1; break;
|
493 |
|
|
case STV_IP:
|
494 |
|
|
unresolvedWeak |= 2; break;
|
495 |
|
|
case STV_DATAP:
|
496 |
|
|
unresolvedWeak |= 4; unresolvedWeakNum++;
|
497 |
|
|
break;
|
498 |
|
|
case STV_THREADP:
|
499 |
|
|
unresolvedWeak |= 8; break;
|
500 |
|
|
case STV_IP | STV_EXEC:
|
501 |
|
|
unresolvedWeak |= 0x10; break;
|
502 |
|
|
}
|
503 |
|
|
}
|
504 |
|
|
}
|
505 |
|
|
// remove check bit
|
506 |
|
|
for (m = 0; m < libmodules.numEntries(); m++) {
|
507 |
|
|
libmodules[m].library &= 0x7FFFFFFF;
|
508 |
|
|
}
|
509 |
|
|
symbolImports.sort();
|
510 |
|
|
}
|
511 |
|
|
|
512 |
|
|
// check for duplicate public symbols, except weak symbols
|
513 |
|
|
void CLinker::checkDuplicateSymbols() {
|
514 |
|
|
uint32_t sym1, sym2; // index into symbolExports
|
515 |
|
|
uint32_t text; // index to text in cmd.fileNameBuffer
|
516 |
|
|
const char * name1, * name2; // library and module names
|
517 |
|
|
for (sym1 = 0; sym1 < symbolExports.numEntries(); sym1++) {
|
518 |
|
|
if (!(symbolExports[sym1].st_bind & STB_WEAK)) {
|
519 |
|
|
sym2 = sym1 + 1;
|
520 |
|
|
while (sym2 < symbolExports.numEntries() && symbolExports[sym2] == symbolExports[sym1]) {
|
521 |
|
|
// symbol 2 has same name
|
522 |
|
|
if (!(symbolExports[sym2].st_bind & STB_WEAK)) {
|
523 |
|
|
// name clash. make complete list of modules containing this symbol name
|
524 |
|
|
text = cmd.fileNameBuffer.dataSize();
|
525 |
|
|
uint32_t num = symbolExports.findAll(0, symbolExports[sym1]);
|
526 |
|
|
for (sym2 = sym1; sym2 < sym1 + num; sym2++) {
|
527 |
|
|
if (!(symbolExports[sym2].st_bind & STB_WEAK)) {
|
528 |
|
|
if (sym2 != sym1) {
|
529 |
|
|
cmd.fileNameBuffer.push(", ", 2); // insert comma, except before first name
|
530 |
|
|
}
|
531 |
|
|
if (symbolExports[sym2].library) {
|
532 |
|
|
// symbol is in a library. get library name
|
533 |
|
|
uint32_t lib = symbolExports[sym2].library; // library number
|
534 |
|
|
name1 = cmd.getFilename(libraries[lib].libraryName);
|
535 |
|
|
cmd.fileNameBuffer.push(name1, (uint32_t)strlen(name1));
|
536 |
|
|
cmd.fileNameBuffer.push(":", 1);
|
537 |
|
|
// get module name
|
538 |
|
|
name2 = libraries[lib].getMemberName(symbolExports[sym2].member);
|
539 |
|
|
cmd.fileNameBuffer.push(name2, (uint32_t)strlen(name2));
|
540 |
|
|
}
|
541 |
|
|
else {
|
542 |
|
|
// object module. get name
|
543 |
|
|
uint32_t m = symbolExports[sym2].member;
|
544 |
|
|
if (m < modules2.numEntries()) {
|
545 |
|
|
name2 = cmd.getFilename(modules2[m].moduleName);
|
546 |
|
|
cmd.fileNameBuffer.push(name2, (uint32_t)strlen(name2));
|
547 |
|
|
}
|
548 |
|
|
else if (m < modules1.numEntries()) {
|
549 |
|
|
name2 = cmd.getFilename(modules1[m].moduleName);
|
550 |
|
|
cmd.fileNameBuffer.push(name2, (uint32_t)strlen(name2));
|
551 |
|
|
}
|
552 |
|
|
}
|
553 |
|
|
}
|
554 |
|
|
}
|
555 |
|
|
const char * symname = symbolNameBuffer.getString(symbolExports[sym1].name);
|
556 |
|
|
err.submit(ERR_LINK_DUPLICATE_SYMBOL, symname, cmd.getFilename(text));
|
557 |
|
|
// we are finished with this symbol name
|
558 |
|
|
sym1 += num - 1; // skip the rest in the for loop
|
559 |
|
|
break; // skip while sym2 loop
|
560 |
|
|
}
|
561 |
|
|
sym2++; // while sym2
|
562 |
|
|
}
|
563 |
|
|
}
|
564 |
|
|
}
|
565 |
|
|
}
|
566 |
|
|
|
567 |
|
|
|
568 |
|
|
// get imported library modules into modules2 buffer
|
569 |
|
|
void CLinker::readLibraryModules() {
|
570 |
|
|
uint32_t m1; // object file index
|
571 |
|
|
uint32_t m2; // library module index
|
572 |
|
|
uint32_t lib; // library index
|
573 |
|
|
uint32_t moduleOs; // offset to library module
|
574 |
|
|
|
575 |
|
|
// modules1 contains object files, libmodules contains index to library modules.
|
576 |
|
|
// we want to join these into the same buffer named modules2.
|
577 |
|
|
// The total number of object files and library modules is
|
578 |
|
|
uint32_t numModules = modules1.numEntries() + libmodules.numEntries();
|
579 |
|
|
// we cannot change the size of a metabuffer, so we will make a new
|
580 |
|
|
// bigger metabuffer and transfer everything from modules1 to modules2:
|
581 |
|
|
modules2.setSize(numModules);
|
582 |
|
|
for (m1 = 0; m1 < modules1.numEntries(); m1++) {
|
583 |
|
|
modules2[m1] << modules1[m1];
|
584 |
|
|
}
|
585 |
|
|
// now get the library modules
|
586 |
|
|
for (m2 = 0; m2 < libmodules.numEntries(); m2++) {
|
587 |
|
|
// library and offset
|
588 |
|
|
lib = libmodules[m2].library & 0x7FFFFFFF;
|
589 |
|
|
moduleOs = libmodules[m2].offset;
|
590 |
|
|
// put member into its own buffer
|
591 |
|
|
modules2[m1+m2].push(libraries[lib].buf() + moduleOs + (uint32_t)sizeof(SUNIXLibraryHeader),
|
592 |
|
|
libraries[lib].getMemberSize(moduleOs));
|
593 |
|
|
modules2[m1+m2].moduleName = cmd.fileNameBuffer.pushString(libraries[lib].getMemberName(moduleOs));
|
594 |
|
|
modules2[m1+m2].library = lib;
|
595 |
|
|
modules2[m1+m2].relinkable = libraries[lib].relinkable;
|
596 |
|
|
|
597 |
|
|
// put new module index into libmodules record
|
598 |
|
|
libmodules[m2].modul = m1 + m2;
|
599 |
|
|
}
|
600 |
|
|
}
|
601 |
|
|
|
602 |
|
|
// make list of all sections
|
603 |
|
|
void CLinker::makeSectionList() {
|
604 |
|
|
uint32_t m; // module index
|
605 |
|
|
uint32_t sh; // section header index
|
606 |
|
|
uint32_t sh_type; // section type
|
607 |
|
|
uint32_t secStringTableLen = 0; // length of section string table
|
608 |
|
|
const char * secStringTable = 0; // section string table in ELF module
|
609 |
|
|
const char * secName = 0; // section name
|
610 |
|
|
SLinkSection section; // section record
|
611 |
|
|
zeroAllMembers(section); // initialize
|
612 |
|
|
eventDataSize = 0; // total size of all event data sections
|
613 |
|
|
sections.push(section);
|
614 |
|
|
|
615 |
|
|
// loop through all modules to get all sections
|
616 |
|
|
for (m = 0; m < modules2.numEntries(); m++) {
|
617 |
|
|
if (modules2[m].dataSize() == 0) continue;
|
618 |
|
|
modules2[m].split(); // split module into components
|
619 |
|
|
secStringTable = (char*)modules2[m].stringBuffer.buf();
|
620 |
|
|
secStringTableLen = modules2[m].stringBuffer.dataSize();
|
621 |
|
|
for (sh = 0; sh < modules2[m].sectionHeaders.numEntries(); sh++) {
|
622 |
|
|
sh_type = modules2[m].sectionHeaders[sh].sh_type;
|
623 |
|
|
if (sh_type & (SHT_ALLOCATED | SHT_LIST)) {
|
624 |
|
|
section.sh_type = sh_type;
|
625 |
|
|
section.sh_flags = modules2[m].sectionHeaders[sh].sh_flags;
|
626 |
|
|
section.sh_size = modules2[m].sectionHeaders[sh].sh_size;
|
627 |
|
|
section.sh_align = modules2[m].sectionHeaders[sh].sh_align;
|
628 |
|
|
uint32_t namei = modules2[m].sectionHeaders[sh].sh_name;
|
629 |
|
|
if (namei >= secStringTableLen) secName = "?";
|
630 |
|
|
else secName = secStringTable + namei;
|
631 |
|
|
section.name = cmd.fileNameBuffer.pushString(secName);
|
632 |
|
|
section.sh_module = m;
|
633 |
|
|
section.sectioni = sh;
|
634 |
|
|
if (modules2[m].relinkable) section.sh_flags |= SHF_RELINK;
|
635 |
|
|
if (section.sh_flags & SHF_EVENT_HND) {
|
636 |
|
|
// check event data sections
|
637 |
|
|
eventDataSize += (uint32_t)section.sh_size;
|
638 |
|
|
// unsorted lists are preserved in executable file but not loaded into memory:
|
639 |
|
|
section.sh_type = SHT_LIST;
|
640 |
|
|
}
|
641 |
|
|
if (sh_type == SHT_COMDAT) {
|
642 |
|
|
communalSections.push(section); // communal section. sections with same name joined
|
643 |
|
|
}
|
644 |
|
|
else {
|
645 |
|
|
sections.push(section); // normal code, data, or bss section
|
646 |
|
|
}
|
647 |
|
|
}
|
648 |
|
|
}
|
649 |
|
|
}
|
650 |
|
|
// join communal sections with same name and add them to the sections list
|
651 |
|
|
joinCommunalSections();
|
652 |
|
|
|
653 |
|
|
// make dummy sections for unresolved weak external symbols
|
654 |
|
|
makeDummySections();
|
655 |
|
|
|
656 |
|
|
// sort the two section lists by the order in which it should occur in the executable
|
657 |
|
|
sortSections();
|
658 |
|
|
|
659 |
|
|
// add final index
|
660 |
|
|
for (uint32_t ix = 0; ix < sections.numEntries(); ix++) {
|
661 |
|
|
sections[ix].sectionx = ix + 1;
|
662 |
|
|
}
|
663 |
|
|
// copy the list
|
664 |
|
|
sections2.copy(sections);
|
665 |
|
|
// 'sections2' is sorted by module and section index for the purpose of finding back to the original
|
666 |
|
|
sections2.sort();
|
667 |
|
|
}
|
668 |
|
|
|
669 |
|
|
// sort sections in the order in which they should occur in the executable file
|
670 |
|
|
void CLinker::sortSections() {
|
671 |
|
|
uint32_t s; // section index
|
672 |
|
|
uint32_t order; // section sort order
|
673 |
|
|
uint32_t flags; // section flags
|
674 |
|
|
uint32_t type; // section type
|
675 |
|
|
|
676 |
|
|
/* The order is as listed below.
|
677 |
|
|
The base pointers are set to the limits where order changes from even to odd.
|
678 |
|
|
SHF_ALLOC:
|
679 |
|
|
0x02000002 SHT_ALLOCATED:
|
680 |
|
|
0x02000002 SHF_IP:
|
681 |
|
|
0x02101002 SHF_EVENT_HND
|
682 |
|
|
0x02202002 SHF_EXCEPTION_HND
|
683 |
|
|
0x02303002 SHF_DEBUG_INFO
|
684 |
|
|
0x02404002 SHF_COMMENT
|
685 |
|
|
0x02500002 SHF_WRITE
|
686 |
|
|
0x02600002 SHF_READ only !SHF_WRITE !SHF_EXEC (const)
|
687 |
|
|
0x02601002 SHF_AUTOGEN
|
688 |
|
|
0x02602002 SHF_RELINK
|
689 |
|
|
0x02603002 !SHF_RELINK !SHF_FIXED
|
690 |
|
|
0x02604002 SHF_FIXED
|
691 |
|
|
SHF_EXEC (code) (set ip_base)
|
692 |
|
|
0x02701003 SHF_FIXED !SHF_RELINK
|
693 |
|
|
0x02702003 !SHF_RELINK
|
694 |
|
|
0x02703003 SHF_RELINK
|
695 |
|
|
0x02704003 SHF_AUTOGEN
|
696 |
|
|
0x02800004 SHF_DATAP
|
697 |
|
|
SHT_PROGBITS (data)
|
698 |
|
|
0x02801004 SHF_RELINK
|
699 |
|
|
0x02802004 !SHF_FIXED
|
700 |
|
|
0x02803004 SHF_FIXED
|
701 |
|
|
SHT_NOBITS (bss) (set datap_base)
|
702 |
|
|
0x02806005 SHF_FIXED
|
703 |
|
|
0x02807005 !SHF_RELINK
|
704 |
|
|
0x02808005 SHF_RELINK
|
705 |
|
|
0x02809005 SHF_AUTOGEN
|
706 |
|
|
0x02A00006 SHF_THREADP
|
707 |
|
|
SHT_PROGBITS (data)
|
708 |
|
|
0x02A01006 SHF_RELINK
|
709 |
|
|
0x02A02006 !SHF_FIXED
|
710 |
|
|
0x02A03006 SHF_FIXED
|
711 |
|
|
SHT_NOBITS (bss) (set threadp_base)
|
712 |
|
|
0x02A06007 SHF_FIXED
|
713 |
|
|
0x02A07007 !SHF_RELINK
|
714 |
|
|
0x02A08007 SHF_RELINK
|
715 |
|
|
0x08000000 !SHT_ALLOCATED:
|
716 |
|
|
0x08100000 !SHF_ALLOC:
|
717 |
|
|
0x08110000 SHT_RELA
|
718 |
|
|
0x08120000 SHT_SYMTAB
|
719 |
|
|
0x08130000 SHT_STRTAB
|
720 |
|
|
0x08160000 other
|
721 |
|
|
*/
|
722 |
|
|
|
723 |
|
|
for (s = 0; s < sections.numEntries(); s++) {
|
724 |
|
|
flags = sections[s].sh_flags;
|
725 |
|
|
type = sections[s].sh_type;
|
726 |
|
|
if (flags & SHF_ALLOC) {
|
727 |
|
|
if (type & SHT_ALLOCATED) {
|
728 |
|
|
order = 0x02000000;
|
729 |
|
|
if (flags & SHF_IP) {
|
730 |
|
|
order = 0x02000002;
|
731 |
|
|
if (flags & SHF_EVENT_HND) order = 0x02101002;
|
732 |
|
|
else if (flags & SHF_EXCEPTION_HND) order = 0x02202002;
|
733 |
|
|
else if (flags & SHF_DEBUG_INFO) order = 0x02303002;
|
734 |
|
|
else if (flags & SHF_COMMENT) order = 0x02404002;
|
735 |
|
|
else if (flags & SHF_WRITE) order = 0x02500002;
|
736 |
|
|
else if ((flags & SHF_READ) && !(flags & SHF_EXEC)) {
|
737 |
|
|
order = 0x02600002;
|
738 |
|
|
if (flags & SHF_AUTOGEN) order = 0x02601002;
|
739 |
|
|
else if (flags & SHF_RELINK) order = 0x02602002;
|
740 |
|
|
else if (!(flags & SHF_FIXED)) order = 0x02603002;
|
741 |
|
|
else order = 0x02604002;
|
742 |
|
|
}
|
743 |
|
|
else if (flags & SHF_EXEC) {
|
744 |
|
|
if (!(flags & SHF_AUTOGEN)) {
|
745 |
|
|
if ((flags & SHF_FIXED) || !(flags & SHF_RELINK)) order = 0x02701003;
|
746 |
|
|
else if (!(flags & SHF_RELINK)) order = 0x02702003;
|
747 |
|
|
else order = 0x02703003;
|
748 |
|
|
}
|
749 |
|
|
else {
|
750 |
|
|
order = 0x02704003; // SHF_AUTOGEN
|
751 |
|
|
}
|
752 |
|
|
}
|
753 |
|
|
}
|
754 |
|
|
else if (flags & (SHF_DATAP | SHF_THREADP)) {
|
755 |
|
|
order = 0x02800004;
|
756 |
|
|
if (flags & SHF_THREADP) order = 0x02A00006;
|
757 |
|
|
if (type != SHT_NOBITS) {
|
758 |
|
|
if (flags & SHF_RELINK) order |= 0x1000;
|
759 |
|
|
else if (!(flags & SHF_FIXED)) order |= 0x2000;
|
760 |
|
|
else order |= 0x3000;
|
761 |
|
|
}
|
762 |
|
|
else { // SHT_NOBITS
|
763 |
|
|
order |= 1;
|
764 |
|
|
if (!(flags & SHF_AUTOGEN)) {
|
765 |
|
|
if (flags & SHF_FIXED) order |= 0x6000;
|
766 |
|
|
else if (!(flags & SHF_RELINK)) order |= 0x7000;
|
767 |
|
|
else order |= 0x8000;
|
768 |
|
|
}
|
769 |
|
|
else { // SHF_AUTOGEN
|
770 |
|
|
order |= 0x9000;
|
771 |
|
|
}
|
772 |
|
|
}
|
773 |
|
|
}
|
774 |
|
|
}
|
775 |
|
|
else { // !SHT_ALLOCATED
|
776 |
|
|
order = 0x08000000;
|
777 |
|
|
}
|
778 |
|
|
}
|
779 |
|
|
else { // !SHF_ALLOC
|
780 |
|
|
switch (type) {
|
781 |
|
|
case SHT_RELA:
|
782 |
|
|
order = 0x08110000; break;
|
783 |
|
|
case SHT_SYMTAB:
|
784 |
|
|
order = 0x08120000; break;
|
785 |
|
|
case SHT_STRTAB:
|
786 |
|
|
order = 0x08130000; break;
|
787 |
|
|
default:
|
788 |
|
|
order = 0x08160000; break;
|
789 |
|
|
}
|
790 |
|
|
}
|
791 |
|
|
sections[s].order = order;
|
792 |
|
|
}
|
793 |
|
|
sections.sort();
|
794 |
|
|
|
795 |
|
|
#if 0 // debug: list sections
|
796 |
|
|
for (s = 0; s < sections.numEntries(); s++) {
|
797 |
|
|
printf("\n* %8X %s", sections[s].order, cmd.getFilename(sections[s].name));
|
798 |
|
|
}
|
799 |
|
|
#endif
|
800 |
|
|
}
|
801 |
|
|
|
802 |
|
|
// join communal sections with same name
|
803 |
|
|
void CLinker::joinCommunalSections() {
|
804 |
|
|
uint32_t m; // module index
|
805 |
|
|
uint32_t s1 = 0, s2, s3, s4; // index into communalSections
|
806 |
|
|
uint32_t sym; // symbol index in module
|
807 |
|
|
uint32_t rel; // relocation index in module
|
808 |
|
|
const char * comname; // name of communal section
|
809 |
|
|
bool symbolsRemoved = false; // symbols in removed communal sections
|
810 |
|
|
|
811 |
|
|
communalSections.sort();
|
812 |
|
|
while (s1 < communalSections.numEntries()) {
|
813 |
|
|
comname = cmd.getFilename(communalSections[s1].name);
|
814 |
|
|
// find last entry with same name
|
815 |
|
|
s4 = s2 = s1;
|
816 |
|
|
while (s2 + 1 < communalSections.numEntries()
|
817 |
|
|
&& strcmp(comname, cmd.getFilename(communalSections[s2+1].name)) == 0) {
|
818 |
|
|
s2++;
|
819 |
|
|
}
|
820 |
|
|
|
821 |
|
|
// check that communal sections with same name have same size
|
822 |
|
|
bool differentSize = false;
|
823 |
|
|
for (s3 = s1+1; s3 <= s2; s3++) {
|
824 |
|
|
// a non-linkable communal section takes precedence
|
825 |
|
|
if (!(communalSections[s3].sh_flags & SHF_RELINK) && (communalSections[s4].sh_flags & SHF_RELINK)) {
|
826 |
|
|
s4 = s3;
|
827 |
|
|
}
|
828 |
|
|
else if (communalSections[s3].sh_size != communalSections[s1].sh_size) {
|
829 |
|
|
differentSize = true;
|
830 |
|
|
// find the biggest
|
831 |
|
|
if (communalSections[s3].sh_size > communalSections[s4].sh_size) s4 = s3;
|
832 |
|
|
}
|
833 |
|
|
}
|
834 |
|
|
if (differentSize) {
|
835 |
|
|
// make error message
|
836 |
|
|
CMemoryBuffer joinNames; // join section names for error message
|
837 |
|
|
joinNames.setSize(0);
|
838 |
|
|
m = communalSections[s1].sh_module;
|
839 |
|
|
const char * mname = cmd.getFilename(modules2[m].moduleName);
|
840 |
|
|
joinNames.push(mname, (uint32_t)strlen(mname));
|
841 |
|
|
for (s3 = s1 + 1; s3 <= s2; s3++) {
|
842 |
|
|
m = communalSections[s3].sh_module;
|
843 |
|
|
mname = cmd.getFilename(modules2[m].moduleName);
|
844 |
|
|
joinNames.push(", ", 2);
|
845 |
|
|
joinNames.push(mname, (uint32_t)strlen(mname));
|
846 |
|
|
}
|
847 |
|
|
err.submit(ERR_LINK_COMMUNAL, comname, (char*)joinNames.buf());
|
848 |
|
|
}
|
849 |
|
|
// check if there is any reference to this section. if not, purge it, except when debug level 2
|
850 |
|
|
bool keepSection = true;
|
851 |
|
|
if (cmd.debugOptions < 2) {
|
852 |
|
|
keepSection = false;
|
853 |
|
|
m = communalSections[s4].sh_module;
|
854 |
|
|
CELF * modul = &modules2[m];
|
855 |
|
|
// find symbols in this section
|
856 |
|
|
for (sym = 0; sym < modul->symbols.numEntries(); sym++) {
|
857 |
|
|
if (modul->symbols[sym].st_section == communalSections[s4].sectioni) {
|
858 |
|
|
const char * symname = (char*)modul->stringBuffer.buf() + modul->symbols[sym].st_name;
|
859 |
|
|
// search for this symbol name in symbolImports
|
860 |
|
|
SSymbolEntry symsearch;
|
861 |
|
|
symsearch.name = symbolNameBuffer.pushString(symname);
|
862 |
|
|
symsearch.st_bind = STB_IGNORE;
|
863 |
|
|
int32_t s = symbolImports.findFirst(symsearch);
|
864 |
|
|
if (s >= 0) {
|
865 |
|
|
keepSection = true; // there is a reference to this section. keep it
|
866 |
|
|
if (!(communalSections[s4].sh_flags & SHF_RELINK)) {
|
867 |
|
|
// communal section is not relinkable. Make the symbol non-weak
|
868 |
|
|
if (modul->symbols[sym].st_bind & STB_WEAK) {
|
869 |
|
|
modul->symbols[sym].st_bind = STB_GLOBAL;
|
870 |
|
|
}
|
871 |
|
|
}
|
872 |
|
|
break;
|
873 |
|
|
}
|
874 |
|
|
}
|
875 |
|
|
}
|
876 |
|
|
}
|
877 |
|
|
if (keepSection) {
|
878 |
|
|
// save one instance of the communal section
|
879 |
|
|
sections.push(communalSections[s4]);
|
880 |
|
|
}
|
881 |
|
|
// remove symbols and relocations from removed sections
|
882 |
|
|
for (s3 = s1; s3 <= s2; s3++) {
|
883 |
|
|
if (s3 != s4 || !keepSection) {
|
884 |
|
|
// this section is removed
|
885 |
|
|
m = communalSections[s3].sh_module;
|
886 |
|
|
CELF * modul = &modules2[m];
|
887 |
|
|
for (sym = 0; sym < modul->symbols.numEntries(); sym++) {
|
888 |
|
|
if (modul->symbols[sym].st_section == communalSections[s3].sectioni) {
|
889 |
|
|
const char * symname = (char*)modul->stringBuffer.buf() + modul->symbols[sym].st_name;
|
890 |
|
|
// search for this symbol name in symbolExports
|
891 |
|
|
SSymbolEntry symsearch;
|
892 |
|
|
symsearch.name = symbolNameBuffer.pushString(symname);
|
893 |
|
|
symsearch.st_bind = STB_IGNORE;
|
894 |
|
|
uint32_t firstMatch = 0;
|
895 |
|
|
uint32_t n = symbolExports.findAll(&firstMatch, symsearch);
|
896 |
|
|
// search through all symbols with this name
|
897 |
|
|
for (uint32_t i = firstMatch; i < firstMatch + n; i++) {
|
898 |
|
|
if (symbolExports[i].library == 0) {
|
899 |
|
|
if (symbolExports[i].member == m
|
900 |
|
|
&& symbolExports[i].sectioni == communalSections[s3].sectioni) {
|
901 |
|
|
// removed symbol found
|
902 |
|
|
symbolExports[i].name = 0;
|
903 |
|
|
symbolExports[i].st_bind = 0;
|
904 |
|
|
symbolsRemoved = true;
|
905 |
|
|
break;
|
906 |
|
|
}
|
907 |
|
|
}
|
908 |
|
|
else {
|
909 |
|
|
uint32_t m2 = findModule(symbolExports[i].library, symbolExports[i].member);
|
910 |
|
|
if (m2 == m && symbolExports[i].sectioni == communalSections[s4].sectioni) {
|
911 |
|
|
symbolExports[i].library = 0;
|
912 |
|
|
symbolExports[i].name = 0;
|
913 |
|
|
symbolExports[i].st_bind = 0;
|
914 |
|
|
symbolsRemoved = true;
|
915 |
|
|
break;
|
916 |
|
|
}
|
917 |
|
|
}
|
918 |
|
|
}
|
919 |
|
|
}
|
920 |
|
|
}
|
921 |
|
|
// search for relocations in removed section
|
922 |
|
|
for (rel = 0; rel < modul->relocations.numEntries(); rel++) {
|
923 |
|
|
if (modul->relocations[rel].r_section == communalSections[s3].sectioni) {
|
924 |
|
|
modul->relocations[rel].r_type = 0;
|
925 |
|
|
}
|
926 |
|
|
}
|
927 |
|
|
}
|
928 |
|
|
}
|
929 |
|
|
// continue with next communal name
|
930 |
|
|
s1 = s2 + 1;
|
931 |
|
|
}
|
932 |
|
|
if (symbolsRemoved) {
|
933 |
|
|
// entries have been removed from symbolExports. sort it again
|
934 |
|
|
symbolExports.sort();
|
935 |
|
|
}
|
936 |
|
|
}
|
937 |
|
|
|
938 |
|
|
// make dummy segments for event handler table and for unresolved weak externals
|
939 |
|
|
void CLinker::makeDummySections() {
|
940 |
|
|
SLinkSection section;
|
941 |
|
|
zeroAllMembers(section);
|
942 |
|
|
section.sh_type = SHT_PROGBITS;
|
943 |
|
|
section.sh_align = 3;
|
944 |
|
|
|
945 |
|
|
if (eventDataSize) {
|
946 |
|
|
section.sh_size = eventDataSize;
|
947 |
|
|
section.sh_flags = SHF_READ | SHF_IP | SHF_ALLOC | SHF_EVENT_HND | SHF_RELINK | SHF_AUTOGEN;
|
948 |
|
|
section.name = cmd.fileNameBuffer.pushString("eventhandlers_sorted");
|
949 |
|
|
section.sh_module = 0xFFFFFFF8;
|
950 |
|
|
sections.push(section);
|
951 |
|
|
}
|
952 |
|
|
|
953 |
|
|
// unresolved weak imports indicated by unresolvedWeak:
|
954 |
|
|
// 1: constant, 2: readonly ip data, 4: writeable datap data,
|
955 |
|
|
// 8: threadp, 0x10: function
|
956 |
|
|
if (unresolvedWeak & 2) {
|
957 |
|
|
section.sh_size = 8;
|
958 |
|
|
section.sh_flags = SHF_READ | SHF_IP | SHF_ALLOC | SHF_RELINK | SHF_AUTOGEN;
|
959 |
|
|
section.name = cmd.fileNameBuffer.pushString("zdummyconst");
|
960 |
|
|
section.sh_module = 0xFFFFFFF1;
|
961 |
|
|
sections.push(section);
|
962 |
|
|
}
|
963 |
|
|
if (unresolvedWeak & 4) {
|
964 |
|
|
section.sh_size = 8 * unresolvedWeakNum;
|
965 |
|
|
section.sh_flags = SHF_READ | SHF_WRITE | SHF_DATAP | SHF_ALLOC | SHF_RELINK | SHF_AUTOGEN;
|
966 |
|
|
section.name = cmd.fileNameBuffer.pushString("zdummydata");
|
967 |
|
|
section.sh_module = 0xFFFFFFF2;
|
968 |
|
|
sections.push(section);
|
969 |
|
|
}
|
970 |
|
|
if (unresolvedWeak & 8) {
|
971 |
|
|
section.sh_size = 8;
|
972 |
|
|
section.sh_flags = SHF_READ | SHF_WRITE | SHF_THREADP | SHF_ALLOC | SHF_RELINK | SHF_AUTOGEN;
|
973 |
|
|
section.name = cmd.fileNameBuffer.pushString("zdummythreaddata");
|
974 |
|
|
section.sh_module = 0xFFFFFFF3;
|
975 |
|
|
sections.push(section);
|
976 |
|
|
}
|
977 |
|
|
if (unresolvedWeak & 0x10) {
|
978 |
|
|
section.sh_size = 8;
|
979 |
|
|
section.sh_flags = SHF_EXEC | SHF_IP | SHF_ALLOC | SHF_RELINK | SHF_AUTOGEN;
|
980 |
|
|
section.name = cmd.fileNameBuffer.pushString("zdummyfunc");
|
981 |
|
|
section.sh_module = 0xFFFFFFF4;
|
982 |
|
|
sections.push(section);
|
983 |
|
|
}
|
984 |
|
|
}
|
985 |
|
|
|
986 |
|
|
// make sorted list of events
|
987 |
|
|
void CLinker::makeEventList() {
|
988 |
|
|
uint32_t sec; // section
|
989 |
|
|
|
990 |
|
|
// find event handler sections
|
991 |
|
|
for (sec = 0; sec < sections.numEntries(); sec++) {
|
992 |
|
|
if (sections[sec].sh_flags & SHF_EVENT_HND) {
|
993 |
|
|
uint32_t m = sections[sec].sh_module;
|
994 |
|
|
if (m < modules2.numEntries()) {
|
995 |
|
|
CELF * modul = &modules2[sections[sec].sh_module]; // find module
|
996 |
|
|
uint32_t offset = uint32_t(modul->sectionHeaders[sections[sec].sectioni].sh_offset);
|
997 |
|
|
uint32_t size = uint32_t(modul->sectionHeaders[sections[sec].sectioni].sh_size);
|
998 |
|
|
if (size & (sizeof(ElfFwcEvent)-1)) {
|
999 |
|
|
// event section size not divisible by event record size
|
1000 |
|
|
err.submit(ERR_EVENT_SIZE, cmd.getFilename(modul->moduleName));
|
1001 |
|
|
return;
|
1002 |
|
|
}
|
1003 |
|
|
// copy all event records
|
1004 |
|
|
for (uint32_t index = 0; index < size; index += sizeof(ElfFwcEvent)) {
|
1005 |
|
|
eventData.push(modul->dataBuffer.get<ElfFwcEvent>(offset + index));
|
1006 |
|
|
}
|
1007 |
|
|
}
|
1008 |
|
|
}
|
1009 |
|
|
}
|
1010 |
|
|
// sort event list
|
1011 |
|
|
eventData.sort();
|
1012 |
|
|
}
|
1013 |
|
|
|
1014 |
|
|
|
1015 |
|
|
// make program headers and assign addresses to sections
|
1016 |
|
|
void CLinker::makeProgramHeaders() {
|
1017 |
|
|
// Each program header can cover multiple sections with the same base pointer and
|
1018 |
|
|
// the same read/write/execute permissions
|
1019 |
|
|
uint32_t sec; // section index
|
1020 |
|
|
uint32_t ph; // program header index
|
1021 |
|
|
uint32_t lastFlags = 0; // p_flags of last program header
|
1022 |
|
|
uint64_t offset = 0; // address relative to begin of section group
|
1023 |
|
|
uint64_t * pBasePonter = 0; // pointer to base pointer
|
1024 |
|
|
uint32_t secOrder; // indicates 'order' as defined in sortSections()
|
1025 |
|
|
// secOrder & 0xF00000 indicates program header
|
1026 |
|
|
// secOrder & 0x0E indicates base pointer
|
1027 |
|
|
// Even values may have negative index relative to the base pointer,
|
1028 |
|
|
// odd values have positive index relative to the base pointer
|
1029 |
|
|
uint32_t lastSecOrder = 0; // secOrder of previous section
|
1030 |
|
|
uint64_t align; // section alignment
|
1031 |
|
|
uint8_t maxAlign = 0; // maximum alignment of all sections in group = (1 << maxAlign)
|
1032 |
|
|
bool basePointerAssigned = false; // a base pointer has been assigned for this group
|
1033 |
|
|
ElfFwcPhdr pHeader; // program header = segment definition
|
1034 |
|
|
zeroAllMembers(pHeader); // initialize
|
1035 |
|
|
|
1036 |
|
|
// initialize pointer bases. may change later
|
1037 |
|
|
ip_base = datap_base = threadp_base = 0;
|
1038 |
|
|
event_table = event_table_num = 0;
|
1039 |
|
|
|
1040 |
|
|
// loop through sections to assign sections to program headers, and
|
1041 |
|
|
// find the maximum alignment for each program header
|
1042 |
|
|
for (sec = 0; sec < sections.numEntries(); sec++) {
|
1043 |
|
|
// section order as defined by sortSections()
|
1044 |
|
|
secOrder = sections[sec].order;
|
1045 |
|
|
if (secOrder == 0 || !(sections[sec].sh_type & SHT_ALLOCATED)) {
|
1046 |
|
|
// relocation tables, symbol tables, string tables, etc. need no program header.
|
1047 |
|
|
// set address to zero
|
1048 |
|
|
sections[sec].sh_addr = 0;
|
1049 |
|
|
uint32_t mod = sections[sec].sh_module;
|
1050 |
|
|
uint32_t seci = sections[sec].sectioni;
|
1051 |
|
|
if (mod < modules2.numEntries() && seci < modules2[mod].sectionHeaders.numEntries()) {
|
1052 |
|
|
// find section header
|
1053 |
|
|
ElfFwcShdr & sectionHeader = modules2[mod].sectionHeaders[seci];
|
1054 |
|
|
sectionHeader.sh_addr = 0;
|
1055 |
|
|
}
|
1056 |
|
|
continue; // don't put in program header
|
1057 |
|
|
}
|
1058 |
|
|
|
1059 |
|
|
if ((secOrder & 0xF00000) != (lastSecOrder & 0xF00000)) {
|
1060 |
|
|
// new program header. save last program header
|
1061 |
|
|
if (pHeader.p_type != 0) {
|
1062 |
|
|
// finished with previous section group
|
1063 |
|
|
// check if alignment needs to be increased
|
1064 |
|
|
if (maxAlign > pHeader.p_align) {
|
1065 |
|
|
pHeader.p_align = maxAlign;
|
1066 |
|
|
}
|
1067 |
|
|
outFile.programHeaders.push(pHeader);
|
1068 |
|
|
}
|
1069 |
|
|
// start making new program header
|
1070 |
|
|
zeroAllMembers(pHeader);
|
1071 |
|
|
pHeader.p_type = PT_LOAD;
|
1072 |
|
|
pHeader.p_flags = sections[sec].sh_flags;
|
1073 |
|
|
maxAlign = sections[sec].sh_align;
|
1074 |
|
|
if (((sections[sec].sh_flags ^ lastFlags) & SHF_PERMISSIONS) || (secOrder & 0xE) != (lastSecOrder & 0xE)) {
|
1075 |
|
|
// different permissions or different base pointer. must align by at least 1 << MEMORY_MAP_ALIGN
|
1076 |
|
|
if (maxAlign < MEMORY_MAP_ALIGN) maxAlign = MEMORY_MAP_ALIGN;
|
1077 |
|
|
}
|
1078 |
|
|
// use low 32 bits of p_paddr to store index into sections and
|
1079 |
|
|
// high 32 bits to store number of sections
|
1080 |
|
|
pHeader.p_paddr = sec;
|
1081 |
|
|
}
|
1082 |
|
|
lastSecOrder = secOrder;
|
1083 |
|
|
lastFlags = sections[sec].sh_flags;
|
1084 |
|
|
// find the section with the highest alignment
|
1085 |
|
|
if (maxAlign < sections[sec].sh_align) maxAlign = sections[sec].sh_align;
|
1086 |
|
|
// count sections covered by this header
|
1087 |
|
|
pHeader.p_paddr += (uint64_t)1 << 32;
|
1088 |
|
|
}
|
1089 |
|
|
// finish last program header
|
1090 |
|
|
if (pHeader.p_type != 0) {
|
1091 |
|
|
// check if alignment needs to be increased
|
1092 |
|
|
if (maxAlign > pHeader.p_align) {
|
1093 |
|
|
pHeader.p_align = maxAlign;
|
1094 |
|
|
}
|
1095 |
|
|
// save last program header
|
1096 |
|
|
outFile.programHeaders.push(pHeader);
|
1097 |
|
|
}
|
1098 |
|
|
|
1099 |
|
|
// Divide program headers into groups of headers with the same base pointer and align the start of each
|
1100 |
|
|
// group with the maximum alignment for the group
|
1101 |
|
|
maxAlign = 0;
|
1102 |
|
|
uint32_t last_flags = 0;
|
1103 |
|
|
uint32_t group_ph = 0xFFFFFFFF; // first program header in group og program headers with same base pointer
|
1104 |
|
|
|
1105 |
|
|
// loop through program headers to find maximum alignment for each base pointer
|
1106 |
|
|
for (ph = 0; ph < outFile.programHeaders.numEntries(); ph++) {
|
1107 |
|
|
ElfFwcPhdr & rHeader = outFile.programHeaders[ph]; // reference to current program header
|
1108 |
|
|
if ((rHeader.p_flags ^ last_flags) & SHF_BASEPOINTER) {
|
1109 |
|
|
// new base pointer
|
1110 |
|
|
if (group_ph != 0xFFFFFFFF) {
|
1111 |
|
|
outFile.programHeaders[group_ph].p_align = maxAlign; // save maximum alignment to first program header in group
|
1112 |
|
|
}
|
1113 |
|
|
// start new header group
|
1114 |
|
|
group_ph = ph;
|
1115 |
|
|
maxAlign = 0;
|
1116 |
|
|
last_flags = rHeader.p_flags;
|
1117 |
|
|
}
|
1118 |
|
|
if (rHeader.p_align > maxAlign) maxAlign = rHeader.p_align;
|
1119 |
|
|
}
|
1120 |
|
|
|
1121 |
|
|
// loop through sections covered by each program header and assign addresses
|
1122 |
|
|
lastFlags = 0; offset = 0;
|
1123 |
|
|
for (ph = 0; ph < outFile.programHeaders.numEntries(); ph++) {
|
1124 |
|
|
ElfFwcPhdr & rHeader = outFile.programHeaders[ph]; // reference to current program header
|
1125 |
|
|
uint32_t fistSection = (uint32_t)rHeader.p_paddr;
|
1126 |
|
|
uint32_t numSections = (uint32_t)(rHeader.p_paddr >> 32);
|
1127 |
|
|
|
1128 |
|
|
if ((rHeader.p_flags ^ lastFlags) & SHF_BASEPOINTER) {
|
1129 |
|
|
// base pointer is different from last header. restart addressing
|
1130 |
|
|
offset = 0; basePointerAssigned = false;
|
1131 |
|
|
// get base pointer
|
1132 |
|
|
switch (rHeader.p_flags & SHF_BASEPOINTER) {
|
1133 |
|
|
case SHF_IP: // ip
|
1134 |
|
|
pBasePonter = &ip_base;
|
1135 |
|
|
break;
|
1136 |
|
|
case SHF_DATAP: // datap
|
1137 |
|
|
pBasePonter = &datap_base;
|
1138 |
|
|
break;
|
1139 |
|
|
case SHF_THREADP: // threadp
|
1140 |
|
|
pBasePonter = &threadp_base;
|
1141 |
|
|
break;
|
1142 |
|
|
default:
|
1143 |
|
|
pBasePonter = 0;
|
1144 |
|
|
}
|
1145 |
|
|
}
|
1146 |
|
|
// align start of segment
|
1147 |
|
|
align = (uint64_t)1 << rHeader.p_align;
|
1148 |
|
|
offset = (offset + align - 1) & -(int64_t)align;
|
1149 |
|
|
rHeader.p_vaddr = offset;
|
1150 |
|
|
|
1151 |
|
|
// find event_table
|
1152 |
|
|
if ((outFile.programHeaders[ph].p_flags & SHF_EVENT_HND) && !(lastFlags & SHF_EVENT_HND)) {
|
1153 |
|
|
event_table = (uint32_t)offset;
|
1154 |
|
|
event_table_num = uint32_t(sections[fistSection].sh_size / sizeof(ElfFwcEvent));
|
1155 |
|
|
}
|
1156 |
|
|
|
1157 |
|
|
// loop through sections covered by this program header
|
1158 |
|
|
for (sec = fistSection; sec < fistSection + numSections; sec++) {
|
1159 |
|
|
// get section start address
|
1160 |
|
|
if (relinking
|
1161 |
|
|
&& (sections[sec].sh_flags & SHF_FIXED)
|
1162 |
|
|
&& basePointerAssigned) {
|
1163 |
|
|
// this section belongs to the non-relinkable part of a relinkable file.
|
1164 |
|
|
// the address must be the same as in the input file, relative to the base pointer
|
1165 |
|
|
uint64_t offset2 = sections[sec].sh_addr + *pBasePonter;
|
1166 |
|
|
if (offset2 - offset > MAX_ALIGN) {
|
1167 |
|
|
err.submit(ERR_INDEX_OUT_OF_RANGE);
|
1168 |
|
|
return;
|
1169 |
|
|
}
|
1170 |
|
|
offset = offset2;
|
1171 |
|
|
}
|
1172 |
|
|
else {
|
1173 |
|
|
// align start of section
|
1174 |
|
|
align = (uint64_t)1 << sections[sec].sh_align;
|
1175 |
|
|
offset = (offset + align - 1) & -(int64_t)align;
|
1176 |
|
|
}
|
1177 |
|
|
// find base pointer
|
1178 |
|
|
if (!basePointerAssigned && pBasePonter) {
|
1179 |
|
|
if (relinking && (sections[sec].sh_flags & SHF_FIXED)) {
|
1180 |
|
|
// this section is the first in a the non-relinkable part of a relinkable file.
|
1181 |
|
|
// Place base pointer at the same position relative to this section as in the original
|
1182 |
|
|
*pBasePonter = offset - sections[sec].sh_addr;
|
1183 |
|
|
basePointerAssigned = true;
|
1184 |
|
|
if (int64_t(*pBasePonter) < 0) {
|
1185 |
|
|
err.submit(ERR_INDEX_OUT_OF_RANGE);
|
1186 |
|
|
return;
|
1187 |
|
|
}
|
1188 |
|
|
}
|
1189 |
|
|
else if (sections[sec].order & 1) {
|
1190 |
|
|
// changing from const to executable or from data to bss. place base pointer here
|
1191 |
|
|
offset = (offset + MEMORY_MAP_ALIGN - 1) & int64_t(-MEMORY_MAP_ALIGN);
|
1192 |
|
|
*pBasePonter = offset;
|
1193 |
|
|
basePointerAssigned = true;
|
1194 |
|
|
}
|
1195 |
|
|
else if (sec + 1 >= sections.numEntries() //fistSection + numSections
|
1196 |
|
|
|| uint8_t(sections[sec+1].order) >> 1 != uint8_t(sections[sec].order) >> 1) {
|
1197 |
|
|
// last section with this base pointer. place base pointer here
|
1198 |
|
|
// (alternatively, place base pointer at the end of this section)
|
1199 |
|
|
offset = (offset + MEMORY_MAP_ALIGN - 1) & int64_t(-MEMORY_MAP_ALIGN);
|
1200 |
|
|
*pBasePonter = offset;
|
1201 |
|
|
basePointerAssigned = true;
|
1202 |
|
|
}
|
1203 |
|
|
}
|
1204 |
|
|
// save address
|
1205 |
|
|
sections[sec].sh_addr = offset;
|
1206 |
|
|
|
1207 |
|
|
if (sections[sec].sh_module < 0xFFFFFFF0) {
|
1208 |
|
|
// find section header
|
1209 |
|
|
ElfFwcShdr & sectionHeader = modules2[sections[sec].sh_module].sectionHeaders[sections[sec].sectioni];
|
1210 |
|
|
sectionHeader.sh_addr = offset;
|
1211 |
|
|
offset += sectionHeader.sh_size;
|
1212 |
|
|
}
|
1213 |
|
|
else {
|
1214 |
|
|
// dummy section for unresolved weak externals
|
1215 |
|
|
switch (sections[sec].sh_module) {
|
1216 |
|
|
case 0xFFFFFFF1:
|
1217 |
|
|
dummyConst = (uint32_t)offset; break;
|
1218 |
|
|
case 0xFFFFFFF2:
|
1219 |
|
|
dummyData = (uint32_t)offset; break;
|
1220 |
|
|
case 0xFFFFFFF3:
|
1221 |
|
|
dummyThreadData = (uint32_t)offset; break;
|
1222 |
|
|
case 0xFFFFFFF4:
|
1223 |
|
|
dummyFunc = (uint32_t)offset; break;
|
1224 |
|
|
}
|
1225 |
|
|
offset += sections[sec].sh_size;
|
1226 |
|
|
}
|
1227 |
|
|
// align position in ELF file
|
1228 |
|
|
offset = (offset + (1<<FILE_DATA_ALIGN)-1) & -(1<<FILE_DATA_ALIGN);
|
1229 |
|
|
if ((rHeader.p_flags & SHF_READ) && ph+1 < outFile.programHeaders.numEntries()
|
1230 |
|
|
&& !(outFile.programHeaders[ph+1].p_flags & SHF_READ)
|
1231 |
|
|
&& rHeader.p_memsz <= rHeader.p_filesz) {
|
1232 |
|
|
// readable section followed by non-readable section. Add empty space
|
1233 |
|
|
offset += DATA_EXTRA_SPACE;
|
1234 |
|
|
}
|
1235 |
|
|
// update program header
|
1236 |
|
|
rHeader.p_memsz = offset - rHeader.p_vaddr;
|
1237 |
|
|
if (sections[sec].sh_type != SHT_NOBITS) {
|
1238 |
|
|
rHeader.p_filesz = rHeader.p_memsz;
|
1239 |
|
|
}
|
1240 |
|
|
}
|
1241 |
|
|
lastFlags = rHeader.p_flags;
|
1242 |
|
|
}
|
1243 |
|
|
|
1244 |
|
|
// check if special symbols have been overridden
|
1245 |
|
|
specialSymbolsOverride();
|
1246 |
|
|
}
|
1247 |
|
|
|
1248 |
|
|
|
1249 |
|
|
// check if automatic symbols have been overridden
|
1250 |
|
|
void CLinker::specialSymbolsOverride() {
|
1251 |
|
|
uint64_t addr;
|
1252 |
|
|
bool basePointerChanged = false;
|
1253 |
|
|
addr = findSymbolAddress("__ip_base");
|
1254 |
|
|
if ((int64_t)addr >= 0) {
|
1255 |
|
|
if (ip_base != addr) basePointerChanged = true;
|
1256 |
|
|
ip_base = addr;
|
1257 |
|
|
}
|
1258 |
|
|
addr = findSymbolAddress("__datap_base");
|
1259 |
|
|
if ((int64_t)addr >= 0) {
|
1260 |
|
|
if (datap_base != addr) basePointerChanged = true;
|
1261 |
|
|
datap_base = addr;
|
1262 |
|
|
}
|
1263 |
|
|
addr = findSymbolAddress("__threadp_base");
|
1264 |
|
|
if ((int64_t)addr >= 0) {
|
1265 |
|
|
if (threadp_base != addr) basePointerChanged = true;
|
1266 |
|
|
threadp_base = addr;
|
1267 |
|
|
}
|
1268 |
|
|
if (relinking && basePointerChanged && modules2[0].sectionHeaders.numEntries()) {
|
1269 |
|
|
// base pointer has been changed during relinking and there are fixed sections that
|
1270 |
|
|
// may contain addresses relative to the old value of the base pointers
|
1271 |
|
|
err.submit(ERR_RELINK_BASE_POINTER_MOD);
|
1272 |
|
|
}
|
1273 |
|
|
|
1274 |
|
|
// find entry point
|
1275 |
|
|
addr = findSymbolAddress("__entry_point");
|
1276 |
|
|
if ((int64_t)addr >= 0) entry_point = addr;
|
1277 |
|
|
else entry_point = ip_base;
|
1278 |
|
|
}
|
1279 |
|
|
|
1280 |
|
|
// find a module from a record in symbolExports.
|
1281 |
|
|
// the return value is an index into modules2
|
1282 |
|
|
int32_t CLinker::findModule(uint32_t library, uint32_t memberos) {
|
1283 |
|
|
if (library == 0) return memberos; // module not in a library
|
1284 |
|
|
if (library == 0xFFFFFFFE) return -2; // special symbol, not in any module
|
1285 |
|
|
SLibraryModule modu; // module is in a library
|
1286 |
|
|
modu.library = library;
|
1287 |
|
|
modu.offset = memberos;
|
1288 |
|
|
int32_t i = libmodules.findFirst(modu);
|
1289 |
|
|
if (i >= 0) return libmodules[i].modul;
|
1290 |
|
|
return -1;
|
1291 |
|
|
}
|
1292 |
|
|
|
1293 |
|
|
|
1294 |
|
|
// put values into all cross references
|
1295 |
|
|
void CLinker::relocate() {
|
1296 |
|
|
uint32_t modu; // module index
|
1297 |
|
|
uint32_t r; // relocation loop counter
|
1298 |
|
|
ElfFwcReloc * reloc; // relocation record
|
1299 |
|
|
uint32_t sourcePos; // relocation source position in file
|
1300 |
|
|
ElfFwcSym * targetSym; // target symbol record
|
1301 |
|
|
ElfFwcSym * externTargetSym; // external target symbol record
|
1302 |
|
|
ElfFwcSym * refSym; // reference symbol record
|
1303 |
|
|
uint64_t targetAddress; // address of target symbol
|
1304 |
|
|
uint64_t referenceAddress; // address of reference symbol
|
1305 |
|
|
int64_t value; // value of relocation
|
1306 |
|
|
uint32_t targetModule; // module containing target symbol
|
1307 |
|
|
uint32_t refsymModule; // module containing reference symbol
|
1308 |
|
|
SReloc2 rel2; // relocation record for executable file
|
1309 |
|
|
bool relink; // copy relocation to relinkable executable file
|
1310 |
|
|
|
1311 |
|
|
// loop through all modules to get all relocation records
|
1312 |
|
|
for (modu = 0; modu < modules2.numEntries(); modu++) {
|
1313 |
|
|
if (modules2[modu].dataSize() == 0) continue;
|
1314 |
|
|
relink = modules2[modu].relinkable;
|
1315 |
|
|
for (r = 0; r < modules2[modu].relocations.numEntries(); r++) {
|
1316 |
|
|
// loop through relocations
|
1317 |
|
|
reloc = &modules2[modu].relocations[r];
|
1318 |
|
|
if (reloc->r_type == 0) continue; // removed relocation
|
1319 |
|
|
// find source address
|
1320 |
|
|
if (reloc->r_section > modules2[modu].nSections) {
|
1321 |
|
|
err.submit(ERR_ELF_INDEX_RANGE); continue;
|
1322 |
|
|
}
|
1323 |
|
|
// source address in executable file
|
1324 |
|
|
// uint64_t sourceAddr = modules2[modu].sectionHeaders[reloc->r_section].sh_addr + reloc->r_offset;
|
1325 |
|
|
// source address in local module. This is where the binary data are currently stored
|
1326 |
|
|
sourcePos = uint32_t(modules2[modu].sectionHeaders[reloc->r_section].sh_offset + reloc->r_offset);
|
1327 |
|
|
if (sourcePos >= modules2[modu].dataBuffer.dataSize()) {
|
1328 |
|
|
err.submit(ERR_ELF_INDEX_RANGE); continue;
|
1329 |
|
|
}
|
1330 |
|
|
// find target symbol
|
1331 |
|
|
targetSym = &modules2[modu].symbols[reloc->r_sym];
|
1332 |
|
|
externTargetSym = findSymbolAddress(&targetAddress, &targetModule, targetSym, modu);
|
1333 |
|
|
if (externTargetSym == 0) {
|
1334 |
|
|
err.submit(ERR_ELF_INDEX_RANGE); continue;
|
1335 |
|
|
}
|
1336 |
|
|
// check if target symbol is in relinkable section
|
1337 |
|
|
if (externTargetSym->st_other & STV_RELINK) relink = true;
|
1338 |
|
|
if (relink) {
|
1339 |
|
|
// copy symbol records to executable file if necessary
|
1340 |
|
|
if (targetSym->st_section || (targetSym->st_bind & STB_WEAK)) {
|
1341 |
|
|
targetSym->st_bind |= STB_EXE;
|
1342 |
|
|
}
|
1343 |
|
|
}
|
1344 |
|
|
|
1345 |
|
|
// check register use
|
1346 |
|
|
checkRegisterUse(targetSym, externTargetSym, targetModule);
|
1347 |
|
|
|
1348 |
|
|
// find reference symbol
|
1349 |
|
|
if (reloc->r_refsym && (reloc->r_type & R_FORW_RELTYPEMASK) == R_FORW_REFP) {
|
1350 |
|
|
refSym = &modules2[modu].symbols[reloc->r_refsym];
|
1351 |
|
|
refSym = findSymbolAddress(&referenceAddress, &refsymModule, refSym, modu);
|
1352 |
|
|
if (refSym->st_other & STV_RELINK) relink = true;
|
1353 |
|
|
}
|
1354 |
|
|
else {
|
1355 |
|
|
refSym = 0;
|
1356 |
|
|
referenceAddress = 0;
|
1357 |
|
|
refsymModule = 0;
|
1358 |
|
|
}
|
1359 |
|
|
value = int64_t(targetAddress - referenceAddress);
|
1360 |
|
|
|
1361 |
|
|
// select relocation type
|
1362 |
|
|
switch (reloc->r_type >> 16 & 0xFF) {
|
1363 |
|
|
case R_FORW_ABS >> 16: // absolute symbol or absolute address
|
1364 |
|
|
if (externTargetSym->st_type != STT_CONSTANT && externTargetSym->st_type != 0) {
|
1365 |
|
|
// this is an absolute address to insert at load time. the code is not position-independent
|
1366 |
|
|
// char * nm = (char*)modules2[modu].stringBuffer.buf() + targetSym->st_name;
|
1367 |
|
|
reloc->r_type |= R_FORW_LOADTIME;
|
1368 |
|
|
fileHeader.e_flags |= EF_RELOCATE | EF_POSITION_DEPENDENT;
|
1369 |
|
|
}
|
1370 |
|
|
break;
|
1371 |
|
|
case R_FORW_SELFREL >> 16:
|
1372 |
|
|
value = int64_t(targetAddress - reloc->r_offset - modules2[modu].sectionHeaders[reloc->r_section].sh_addr);
|
1373 |
|
|
if ((modules2[modu].sectionHeaders[reloc->r_section].sh_flags
|
1374 |
|
|
^ externTargetSym->st_other) & SHF_BASEPOINTER) {
|
1375 |
|
|
// different base pointers
|
1376 |
|
|
DIFFERENTBASEPOINTERS:
|
1377 |
|
|
err.submit(ERR_LINK_DIFFERENT_BASE,
|
1378 |
|
|
cmd.getFilename(modules2[modu].moduleName),
|
1379 |
|
|
(char*)modules2[modu].stringBuffer.buf() + externTargetSym->st_name,
|
1380 |
|
|
cmd.getFilename(modules2[targetModule].moduleName));
|
1381 |
|
|
}
|
1382 |
|
|
break;
|
1383 |
|
|
case R_FORW_IP_BASE >> 16:
|
1384 |
|
|
value = int64_t(targetAddress - ip_base);
|
1385 |
|
|
if (!(externTargetSym->st_other & STV_IP)) goto DIFFERENTBASEPOINTERS;
|
1386 |
|
|
break;
|
1387 |
|
|
case R_FORW_DATAP >> 16:
|
1388 |
|
|
value = int64_t(targetAddress - datap_base);
|
1389 |
|
|
if (!(externTargetSym->st_other & STV_DATAP)) goto DIFFERENTBASEPOINTERS;
|
1390 |
|
|
break;
|
1391 |
|
|
case R_FORW_THREADP >> 16:
|
1392 |
|
|
if (!(externTargetSym->st_other & STV_THREADP)) goto DIFFERENTBASEPOINTERS;
|
1393 |
|
|
break;
|
1394 |
|
|
case R_FORW_REFP >> 16:
|
1395 |
|
|
if (refSym == 0 || ((externTargetSym->st_other ^ refSym->st_other) & SHF_BASEPOINTER)) {
|
1396 |
|
|
goto DIFFERENTBASEPOINTERS;
|
1397 |
|
|
}
|
1398 |
|
|
break;
|
1399 |
|
|
case R_FORW_SYSFUNC:
|
1400 |
|
|
case R_FORW_SYSMODUL:
|
1401 |
|
|
case R_FORW_SYSCALL:
|
1402 |
|
|
// system function ID inserted at load time
|
1403 |
|
|
reloc->r_type |= R_FORW_LOADTIME;
|
1404 |
|
|
fileHeader.e_flags |= EF_RELOCATE;
|
1405 |
|
|
break;
|
1406 |
|
|
}
|
1407 |
|
|
// add addend (sign extended)
|
1408 |
|
|
value += reloc->r_addend;
|
1409 |
|
|
// scale
|
1410 |
|
|
uint32_t scale = reloc->r_type & R_FORW_RELSCALEMASK;
|
1411 |
|
|
// check if divisible by scale
|
1412 |
|
|
if (value & ((1 << scale) - 1)) {
|
1413 |
|
|
// misaligned target. scaling of reference failed
|
1414 |
|
|
err.submit(ERR_LINK_MISALIGNED_TARGET,
|
1415 |
|
|
cmd.getFilename(modules2[modu].moduleName),
|
1416 |
|
|
(char*)modules2[modu].stringBuffer.buf() + externTargetSym->st_name,
|
1417 |
|
|
cmd.getFilename(modules2[targetModule].moduleName));
|
1418 |
|
|
}
|
1419 |
|
|
value >>= scale;
|
1420 |
|
|
|
1421 |
|
|
// check if overflow and insert value
|
1422 |
|
|
switch ((reloc->r_type >> 8) & 0xFF) {
|
1423 |
|
|
case R_FORW_8 >> 8:
|
1424 |
|
|
modules2[modu].dataBuffer.get<int8_t>((uint32_t)sourcePos) = (int8_t)value;
|
1425 |
|
|
if (value > 0x7F || value < -0x80) {
|
1426 |
|
|
RELOCATIONOVERFLOW:
|
1427 |
|
|
err.submit(ERR_LINK_OVERFLOW,
|
1428 |
|
|
cmd.getFilename(modules2[modu].moduleName),
|
1429 |
|
|
(char*)modules2[modu].stringBuffer.buf() + externTargetSym->st_name,
|
1430 |
|
|
cmd.getFilename(modules2[targetModule].moduleName));
|
1431 |
|
|
}
|
1432 |
|
|
break;
|
1433 |
|
|
case R_FORW_16 >> 8:
|
1434 |
|
|
modules2[modu].dataBuffer.get<int16_t>((uint32_t)sourcePos) = (int16_t)value;
|
1435 |
|
|
if (value > 0x7FFF || value < -0x8000) goto RELOCATIONOVERFLOW;
|
1436 |
|
|
break;
|
1437 |
|
|
case R_FORW_24 >> 8:
|
1438 |
|
|
modules2[modu].dataBuffer.get<int16_t>((uint32_t)sourcePos) = (int16_t)value;
|
1439 |
|
|
modules2[modu].dataBuffer.get<int8_t>((uint32_t)sourcePos + 2) = (int8_t)(value >> 16);
|
1440 |
|
|
if (value > 0x7FFFFF || value < -0x800000) goto RELOCATIONOVERFLOW;
|
1441 |
|
|
break;
|
1442 |
|
|
case R_FORW_32 >> 8:
|
1443 |
|
|
modules2[modu].dataBuffer.get<int32_t>((uint32_t)sourcePos) = (int32_t)value;
|
1444 |
|
|
if (value > 0x7FFFFFFF || value < -((int64_t)1 << 31)) goto RELOCATIONOVERFLOW;
|
1445 |
|
|
break;
|
1446 |
|
|
case R_FORW_32LO >> 8:
|
1447 |
|
|
modules2[modu].dataBuffer.get<int16_t>((uint32_t)sourcePos) = (int16_t)value;
|
1448 |
|
|
if (value > 0x7FFFFFFF || value < -((int64_t)1 << 31)) goto RELOCATIONOVERFLOW;
|
1449 |
|
|
break;
|
1450 |
|
|
case R_FORW_32HI >> 8:
|
1451 |
|
|
if (value > 0x7FFFFFFF || value < -((int64_t)1 << 31)) goto RELOCATIONOVERFLOW;
|
1452 |
|
|
modules2[modu].dataBuffer.get<int16_t>((uint32_t)sourcePos) = (int16_t)(value >> 16);
|
1453 |
|
|
if (value > 0x7FFFFFFF || value < -((int64_t)1 << 31)) goto RELOCATIONOVERFLOW;
|
1454 |
|
|
break;
|
1455 |
|
|
case R_FORW_64 >> 8:
|
1456 |
|
|
modules2[modu].dataBuffer.get<int64_t>((uint32_t)sourcePos) = value;
|
1457 |
|
|
break;
|
1458 |
|
|
case R_FORW_64LO >> 8:
|
1459 |
|
|
modules2[modu].dataBuffer.get<int32_t>((uint32_t)sourcePos) = (int32_t)value;
|
1460 |
|
|
break;
|
1461 |
|
|
case R_FORW_64HI >> 8:
|
1462 |
|
|
modules2[modu].dataBuffer.get<int32_t>((uint32_t)sourcePos) = (int32_t)(value >> 32);
|
1463 |
|
|
break;
|
1464 |
|
|
}
|
1465 |
|
|
// mark reference to unresolved and autogenerated symbols for copy to executable
|
1466 |
|
|
if (relinkable) {
|
1467 |
|
|
if (externTargetSym->st_section == 0 && (externTargetSym->st_bind & STB_WEAK)) relink = true;
|
1468 |
|
|
if (refSym && refSym->st_section == 0 && (refSym->st_bind & STB_WEAK)) relink = true;
|
1469 |
|
|
if (externTargetSym->st_other & STV_AUTOGEN) relink = true;
|
1470 |
|
|
if (refSym && refSym->st_other & STV_AUTOGEN) relink = true;
|
1471 |
|
|
}
|
1472 |
|
|
// copy symbols and relocation record to executable file if target symbol or reference symbol are in relinkable sections
|
1473 |
|
|
if (relink || (reloc->r_type & R_FORW_LOADTIME)) {
|
1474 |
|
|
externTargetSym->st_bind |= STB_EXE;
|
1475 |
|
|
if (refSym) refSym->st_bind |= STB_EXE;
|
1476 |
|
|
memcpy(&rel2, reloc, sizeof(ElfFwcReloc));
|
1477 |
|
|
rel2.modul = modu;
|
1478 |
|
|
rel2.symLocal = (targetModule == modu) // symbol is local
|
1479 |
|
|
|| ((targetSym->st_bind & STB_EXE) && targetSym->st_section == 0); // keep local record for weak external so that it can be replaced by relinking
|
1480 |
|
|
rel2.refSymLocal = (refsymModule == modu);
|
1481 |
|
|
relocations2.push(rel2);
|
1482 |
|
|
}
|
1483 |
|
|
}
|
1484 |
|
|
}
|
1485 |
|
|
}
|
1486 |
|
|
|
1487 |
|
|
// Check if external function call has compatible register use
|
1488 |
|
|
void CLinker::checkRegisterUse(ElfFwcSym * sym1, ElfFwcSym * sym2, uint32_t modul) {
|
1489 |
|
|
if ((sym1->st_other | sym1->st_other) & STV_REGUSE) {
|
1490 |
|
|
// register use specified for source or target or both
|
1491 |
|
|
uint32_t tregusea1 = sym1->st_reguse1;
|
1492 |
|
|
uint32_t tregusea2 = sym1->st_reguse2;
|
1493 |
|
|
uint32_t treguseb1 = sym2->st_reguse1;
|
1494 |
|
|
uint32_t treguseb2 = sym2->st_reguse2;
|
1495 |
|
|
if (!(sym1->st_other & STV_REGUSE)) {
|
1496 |
|
|
tregusea1 = tregusea2 = 0x0000FFFF; // register use not specified for source. assume default
|
1497 |
|
|
}
|
1498 |
|
|
if (sym1 == sym2 && sym1->st_section == 0 && (sym1->st_bind & STB_WEAK)) {
|
1499 |
|
|
// unresolved weak. will set r0 = 0 and v0 = 0
|
1500 |
|
|
treguseb1 = unresolvedReguse1;
|
1501 |
|
|
treguseb2 = unresolvedReguse2;
|
1502 |
|
|
}
|
1503 |
|
|
else if (!(sym2->st_other & STV_REGUSE)) {
|
1504 |
|
|
// register use not specified for external target. assume default
|
1505 |
|
|
treguseb1 = treguseb2 = 0x0000FFFF;
|
1506 |
|
|
}
|
1507 |
|
|
uint32_t tregusem1 = treguseb1 & ~tregusea1; // registers in target and not in source
|
1508 |
|
|
uint32_t tregusem2 = treguseb2 & ~tregusea2;
|
1509 |
|
|
if (tregusem1 | tregusem2) {
|
1510 |
|
|
// mismatched register use
|
1511 |
|
|
const char * symname = modules2[modul].stringBuffer.getString(sym2->st_name);
|
1512 |
|
|
char text[30];
|
1513 |
|
|
sprintf(text, "0x%X, 0x%X", tregusem1, tregusem2);
|
1514 |
|
|
err.submit(ERR_LINK_REGUSE, cmd.getFilename(modules2[modul].moduleName), symname,text);
|
1515 |
|
|
// avoid reporting multiple times if there are multiple references from a module to the same symbol
|
1516 |
|
|
sym1->st_reguse1 = treguseb1;
|
1517 |
|
|
sym1->st_reguse2 = treguseb2;
|
1518 |
|
|
}
|
1519 |
|
|
}
|
1520 |
|
|
}
|
1521 |
|
|
|
1522 |
|
|
// find a symbol and its address
|
1523 |
|
|
// the return value is a pointer to a remote symbol record. The address is returned in 'a'
|
1524 |
|
|
ElfFwcSym * CLinker::findSymbolAddress(uint64_t * a, uint32_t * targetMod, ElfFwcSym * sym, uint32_t modul) {
|
1525 |
|
|
if (targetMod) *targetMod = modul;
|
1526 |
|
|
if (sym->st_section && (sym->st_bind & ~STB_EXE) != STB_WEAK2) {
|
1527 |
|
|
// target is in same module
|
1528 |
|
|
if (sym->st_type == STT_CONSTANT) {
|
1529 |
|
|
// absolute symbol
|
1530 |
|
|
*a = sym->st_value;
|
1531 |
|
|
}
|
1532 |
|
|
else if (sym->st_section >= modules2[modul].nSections) {
|
1533 |
|
|
err.submit(ERR_ELF_INDEX_RANGE); return sym;
|
1534 |
|
|
}
|
1535 |
|
|
else { // section address + offset into section
|
1536 |
|
|
// check if section is included in exe file.
|
1537 |
|
|
// This will fail if there is a reference to a non-weak symbol in a replaced local communal section
|
1538 |
|
|
SLinkSection2 secSearch;
|
1539 |
|
|
secSearch.sh_module = modul;
|
1540 |
|
|
secSearch.sectioni = sym->st_section;
|
1541 |
|
|
int32_t x = sections2.findFirst(secSearch);
|
1542 |
|
|
if (x < 0) {
|
1543 |
|
|
const char * symname = (char*)modules2[modul].stringBuffer.buf() + sym->st_name;
|
1544 |
|
|
err.submit(ERR_LINK_UNRESOLVED, symname, "(relocation)");
|
1545 |
|
|
return sym;
|
1546 |
|
|
}
|
1547 |
|
|
*a = modules2[modul].sectionHeaders[sym->st_section].sh_addr + sym->st_value;
|
1548 |
|
|
}
|
1549 |
|
|
return sym;
|
1550 |
|
|
}
|
1551 |
|
|
else {
|
1552 |
|
|
// target is external. find it in symbolExports
|
1553 |
|
|
SSymbolEntry symSearch; // record for searching for symbol
|
1554 |
|
|
zeroAllMembers(symSearch); // initialize
|
1555 |
|
|
if (sym->st_name > modules2[modul].stringBuffer.dataSize()) {
|
1556 |
|
|
err.submit(ERR_ELF_INDEX_RANGE); return sym;
|
1557 |
|
|
}
|
1558 |
|
|
const char * symname = (char*)modules2[modul].stringBuffer.buf() + sym->st_name;
|
1559 |
|
|
symSearch.name = symbolNameBuffer.pushString(symname);
|
1560 |
|
|
symSearch.st_bind = STB_IGNORE; // find both strong and weak symbols
|
1561 |
|
|
uint32_t firstMatch = 0;
|
1562 |
|
|
uint32_t numMatch = symbolExports.findAll(&firstMatch, symSearch);
|
1563 |
|
|
if (numMatch == 0) {
|
1564 |
|
|
// symbol name not found
|
1565 |
|
|
if (!(sym->st_bind & STB_WEAK)) {
|
1566 |
|
|
sym->st_bind = STB_UNRESOLVED; // not weak. mark as unresolved
|
1567 |
|
|
if (sym->st_type == STT_FUNC) sym->st_other |= SHF_EXEC;
|
1568 |
|
|
}
|
1569 |
|
|
// give it a dummy
|
1570 |
|
|
*targetMod = 0;
|
1571 |
|
|
switch (sym->st_other & (SHF_BASEPOINTER | SHF_EXEC)) {
|
1572 |
|
|
case 0: // constant
|
1573 |
|
|
*a = 0; break;
|
1574 |
|
|
case STV_IP: // read-only data
|
1575 |
|
|
*a = dummyConst; break;
|
1576 |
|
|
case STV_DATAP: // writeable data. Make one address for each unresolved reference
|
1577 |
|
|
*a = dummyData + (--unresolvedWeakNum) * 8;
|
1578 |
|
|
break;
|
1579 |
|
|
case STV_THREADP: // thread-local. this is rare
|
1580 |
|
|
*a = dummyThreadData; break;
|
1581 |
|
|
case STV_IP | STV_EXEC: // unresolved function
|
1582 |
|
|
*a = dummyFunc; break;
|
1583 |
|
|
}
|
1584 |
|
|
return sym;
|
1585 |
|
|
}
|
1586 |
|
|
|
1587 |
|
|
// one or more matching symbols found
|
1588 |
|
|
int32_t targetModule = findModule(symbolExports[firstMatch].library, symbolExports[firstMatch].member);
|
1589 |
|
|
if (targetModule == -2) {
|
1590 |
|
|
// special symbol
|
1591 |
|
|
switch (symbolExports[firstMatch].symindex) {
|
1592 |
|
|
case 1:
|
1593 |
|
|
*a = ip_base; break;
|
1594 |
|
|
case 2:
|
1595 |
|
|
*a = datap_base; break;
|
1596 |
|
|
case 3:
|
1597 |
|
|
*a = threadp_base; break;
|
1598 |
|
|
case 4:
|
1599 |
|
|
*a = event_table; break;
|
1600 |
|
|
case 5:
|
1601 |
|
|
*a = event_table_num; break;
|
1602 |
|
|
default:
|
1603 |
|
|
err.submit(ERR_LINK_UNRESOLVED, symname, "relocation");
|
1604 |
|
|
}
|
1605 |
|
|
sym->st_other |= STV_AUTOGEN; // symbol is autogenerated
|
1606 |
|
|
return sym;
|
1607 |
|
|
}
|
1608 |
|
|
if (targetMod) *targetMod = targetModule;
|
1609 |
|
|
if (targetModule < 0) {
|
1610 |
|
|
// unexpected error
|
1611 |
|
|
err.submit(ERR_LINK_UNRESOLVED, symname, "relocation");
|
1612 |
|
|
return sym;
|
1613 |
|
|
}
|
1614 |
|
|
// find external target symbol
|
1615 |
|
|
ElfFwcSym * targetSym = &modules2[targetModule].symbols[symbolExports[firstMatch].symindex];
|
1616 |
|
|
if (modules2[targetModule].relinkable) {
|
1617 |
|
|
targetSym->st_other |= STV_RELINK;
|
1618 |
|
|
}
|
1619 |
|
|
if (targetSym->st_type == STT_CONSTANT) {
|
1620 |
|
|
// absolute symbol
|
1621 |
|
|
*a = targetSym->st_value;
|
1622 |
|
|
}
|
1623 |
|
|
else if (targetSym->st_section >= modules2[targetModule].nSections) {
|
1624 |
|
|
err.submit(ERR_ELF_INDEX_RANGE); return sym;
|
1625 |
|
|
}
|
1626 |
|
|
else { // section address + offset into section
|
1627 |
|
|
// check if target section is included in exe file. This will fail only if there is a reference to a non-weak symbol in a replaced local communal section
|
1628 |
|
|
SLinkSection2 secSearch;
|
1629 |
|
|
secSearch.sh_module = targetModule;
|
1630 |
|
|
secSearch.sectioni = targetSym->st_section;
|
1631 |
|
|
int32_t x = sections2.findFirst(secSearch);
|
1632 |
|
|
if (x < 0) {
|
1633 |
|
|
const char * symname = (char*)modules2[modul].stringBuffer.buf() + sym->st_name;
|
1634 |
|
|
err.submit(ERR_LINK_UNRESOLVED, symname, "(removed)");
|
1635 |
|
|
return sym;
|
1636 |
|
|
}
|
1637 |
|
|
*a = modules2[targetModule].sectionHeaders[targetSym->st_section].sh_addr + targetSym->st_value;
|
1638 |
|
|
}
|
1639 |
|
|
return targetSym;
|
1640 |
|
|
}
|
1641 |
|
|
}
|
1642 |
|
|
|
1643 |
|
|
// find the final address of a symbol from its name
|
1644 |
|
|
uint64_t CLinker::findSymbolAddress(const char * name) {
|
1645 |
|
|
SSymbolEntry symSearch; // record for symbol search
|
1646 |
|
|
int32_t symi; // symbol index
|
1647 |
|
|
int32_t modul; // module containing symbol
|
1648 |
|
|
ElfFwcSym * sym; // pointer to symbol record
|
1649 |
|
|
uint64_t addr = 0xFFFFFFFFFFFFFFFF; // return value
|
1650 |
|
|
symSearch.name = symbolNameBuffer.pushString(name);
|
1651 |
|
|
symSearch.st_bind = STB_GLOBAL; // search for strong symbols only
|
1652 |
|
|
symi = symbolExports.findFirst(symSearch);
|
1653 |
|
|
if (symi >= 0) { // strong symbol found
|
1654 |
|
|
modul = findModule(symbolExports[symi].library, symbolExports[symi].member);
|
1655 |
|
|
if (modul >= 0) {
|
1656 |
|
|
sym = &modules2[modul].symbols[symbolExports[symi].symindex];
|
1657 |
|
|
findSymbolAddress(&addr, 0, sym, modul);
|
1658 |
|
|
}
|
1659 |
|
|
}
|
1660 |
|
|
return addr;
|
1661 |
|
|
}
|
1662 |
|
|
|
1663 |
|
|
// copy sections to output file
|
1664 |
|
|
void CLinker::copySections() {
|
1665 |
|
|
ElfFwcShdr header; // section header
|
1666 |
|
|
zeroAllMembers(header); // initialize
|
1667 |
|
|
uint32_t s; // section index
|
1668 |
|
|
CELF * modul; // module containing section
|
1669 |
|
|
uint32_t sectionx = 0; // section index in executable file
|
1670 |
|
|
uint32_t progheadi = 0; // program header index
|
1671 |
|
|
uint32_t lastprogheadi = 0xFFFFFFFF; // program header index of previous section
|
1672 |
|
|
CMemoryBuffer dummyBuffer; // buffer for dummy symbols
|
1673 |
|
|
CMemoryBuffer * dataBuf; // pointer to data buffer
|
1674 |
|
|
uint64_t dummyValue; // value of unresolved weak external symbols
|
1675 |
|
|
uint32_t lastFlags = 0; // previous section flags
|
1676 |
|
|
uint8_t type, lastType = 0; // section type
|
1677 |
|
|
uint32_t pHfistSection = 0; // first section covered by program header
|
1678 |
|
|
uint32_t pHlastSection = 0; // last section covered by program header
|
1679 |
|
|
uint32_t pHnumSections = 0; // number of sections covered by program header
|
1680 |
|
|
ElfFwcPhdr * pPHead = 0; // pointer to program header
|
1681 |
|
|
|
1682 |
|
|
// find program header
|
1683 |
|
|
if (outFile.programHeaders.numEntries()) {
|
1684 |
|
|
pPHead = &outFile.programHeaders[progheadi];
|
1685 |
|
|
pHfistSection = (uint32_t)pPHead->p_paddr;
|
1686 |
|
|
pHnumSections = (uint32_t)(pPHead->p_paddr >> 32);
|
1687 |
|
|
}
|
1688 |
|
|
|
1689 |
|
|
// loop through sections
|
1690 |
|
|
for (s = 0; s < sections.numEntries(); s++) {
|
1691 |
|
|
// make section header
|
1692 |
|
|
header.sh_type = sections[s].sh_type;
|
1693 |
|
|
if (header.sh_type == 0) continue;
|
1694 |
|
|
header.sh_name = sections[s].name;
|
1695 |
|
|
header.sh_flags = sections[s].sh_flags;
|
1696 |
|
|
header.sh_size = sections[s].sh_size;
|
1697 |
|
|
header.sh_align = sections[s].sh_align;
|
1698 |
|
|
header.sh_module = sections[s].sh_module;
|
1699 |
|
|
if (header.sh_module < modules2.numEntries()) {
|
1700 |
|
|
modul = &modules2[sections[s].sh_module]; // find module
|
1701 |
|
|
header.sh_library = modul->library;
|
1702 |
|
|
header.sh_offset = modul->sectionHeaders[sections[s].sectioni].sh_offset;
|
1703 |
|
|
header.sh_addr = modul->sectionHeaders[sections[s].sectioni].sh_addr;
|
1704 |
|
|
dataBuf = &modul->dataBuffer;
|
1705 |
|
|
}
|
1706 |
|
|
else {
|
1707 |
|
|
header.sh_library = 0;
|
1708 |
|
|
// make section for dummy symbol
|
1709 |
|
|
switch (sections[s].sh_module) {
|
1710 |
|
|
case 0xFFFFFFF1: default: // read only data
|
1711 |
|
|
dummyValue = 0;
|
1712 |
|
|
header.sh_offset = dummyBuffer.push(&dummyValue, 8);
|
1713 |
|
|
header.sh_addr = dummyConst;
|
1714 |
|
|
break;
|
1715 |
|
|
case 0xFFFFFFF2: // writeable data
|
1716 |
|
|
dummyValue = 0;
|
1717 |
|
|
header.sh_offset = dummyBuffer.dataSize();
|
1718 |
|
|
header.sh_addr = dummyData;
|
1719 |
|
|
for (uint32_t i = 0; i < unresolvedWeakNum; i++) dummyBuffer.push(&dummyValue, 8);
|
1720 |
|
|
break;
|
1721 |
|
|
case 0xFFFFFFF3: // thread-local data
|
1722 |
|
|
dummyValue = 0;
|
1723 |
|
|
header.sh_offset = dummyBuffer.push(&dummyValue, 8);
|
1724 |
|
|
header.sh_addr = dummyThreadData;
|
1725 |
|
|
break;
|
1726 |
|
|
case 0xFFFFFFF4: // unresolved weak function. return zero
|
1727 |
|
|
header.sh_addr = dummyFunc;
|
1728 |
|
|
header.sh_offset = dummyBuffer.dataSize();
|
1729 |
|
|
for (uint32_t i = 0; i < unresolvedFunctionN; i++) {
|
1730 |
|
|
dummyBuffer.push(&unresolvedFunction[i], 4);
|
1731 |
|
|
}
|
1732 |
|
|
break;
|
1733 |
|
|
case 0xFFFFFFF8: // event list
|
1734 |
|
|
header.sh_offset = dummyBuffer.push(eventData.buf(), eventData.dataSize());
|
1735 |
|
|
break;
|
1736 |
|
|
}
|
1737 |
|
|
dataBuf = &dummyBuffer;
|
1738 |
|
|
}
|
1739 |
|
|
// find correcponding program header, if any
|
1740 |
|
|
while (s >= pHfistSection + pHnumSections && progheadi+1 < outFile.programHeaders.numEntries()) {
|
1741 |
|
|
progheadi++;
|
1742 |
|
|
pPHead = &outFile.programHeaders[progheadi];
|
1743 |
|
|
pHfistSection = (uint32_t)pPHead->p_paddr;
|
1744 |
|
|
pHnumSections = (uint32_t)(pPHead->p_paddr >> 32);
|
1745 |
|
|
}
|
1746 |
|
|
// is this section covered by a program header?
|
1747 |
|
|
bool hasProgHead = s >= pHfistSection && s < pHfistSection + pHnumSections;
|
1748 |
|
|
|
1749 |
|
|
if (hasProgHead && progheadi == lastprogheadi && s > 0 && sections[s].sh_type != SHT_NOBITS) {
|
1750 |
|
|
// this section is covered by same program header as last section
|
1751 |
|
|
// insert any necessary filler
|
1752 |
|
|
uint64_t fill = sections[s].sh_addr - (sections[s-1].sh_addr + sections[s-1].sh_size);
|
1753 |
|
|
if (fill > MAX_ALIGN) err.submit(ERR_LINK_OVERFLOW, "","","");
|
1754 |
|
|
if (fill > 0) {
|
1755 |
|
|
// insert alignment filler in dataBuffer
|
1756 |
|
|
outFile.insertFiller(fill);
|
1757 |
|
|
}
|
1758 |
|
|
}
|
1759 |
|
|
type = header.sh_type;
|
1760 |
|
|
if (type == SHT_COMDAT) type = SHT_PROGBITS; // communal and normal data can be joined together
|
1761 |
|
|
|
1762 |
|
|
// add section to outFile
|
1763 |
|
|
if (hasProgHead
|
1764 |
|
|
&& progheadi == lastprogheadi
|
1765 |
|
|
&& type == lastType
|
1766 |
|
|
&& !cmd.debugOptions
|
1767 |
|
|
&& !(header.sh_flags & SHF_RELINK)
|
1768 |
|
|
&& !(lastFlags & SHF_RELINK)
|
1769 |
|
|
&& sections[s].sh_module < 0xFFFFFFF0) {
|
1770 |
|
|
outFile.extendSection(header, *dataBuf);
|
1771 |
|
|
}
|
1772 |
|
|
else {
|
1773 |
|
|
sectionx = outFile.addSection(header, cmd.fileNameBuffer, *dataBuf);
|
1774 |
|
|
}
|
1775 |
|
|
// remember new section index
|
1776 |
|
|
sections[s].sectionx = sectionx;
|
1777 |
|
|
lastprogheadi = progheadi;
|
1778 |
|
|
lastType = type;
|
1779 |
|
|
lastFlags = header.sh_flags;
|
1780 |
|
|
|
1781 |
|
|
#if 0 // testing only: list sections
|
1782 |
|
|
ElfFwcShdr header3 = outFile.sectionHeaders[sectionx];
|
1783 |
|
|
printf("\n%2i %X os=%X, sz=%X %s", outFile.sectionHeaders.numEntries(), header3.sh_type, header3.sh_offset, header3.sh_size, cmd.getFilename(header.sh_name));
|
1784 |
|
|
#endif
|
1785 |
|
|
}
|
1786 |
|
|
|
1787 |
|
|
// update section indexes in segment headers.
|
1788 |
|
|
// indexes may have changed if some sections are joined together.
|
1789 |
|
|
// p_paddr contains first section index and number of sections
|
1790 |
|
|
for (uint32_t ph = 0; ph < outFile.programHeaders.numEntries(); ph++) {
|
1791 |
|
|
pHfistSection = (uint32_t)outFile.programHeaders[ph].p_paddr;
|
1792 |
|
|
pHnumSections = (uint32_t)(outFile.programHeaders[ph].p_paddr >> 32);
|
1793 |
|
|
pHlastSection = pHfistSection + pHnumSections - 1;
|
1794 |
|
|
if (pHlastSection < sections.numEntries()) {
|
1795 |
|
|
uint32_t sx1 = sections[pHfistSection].sectionx; // first new section index
|
1796 |
|
|
uint32_t sx2 = sections[pHlastSection].sectionx; // last new section index
|
1797 |
|
|
uint32_t numsx = sx2 - sx1 + 1; // number of new sections
|
1798 |
|
|
outFile.programHeaders[ph].p_paddr = sx1 | (uint64_t)numsx << 32;
|
1799 |
|
|
}
|
1800 |
|
|
}
|
1801 |
|
|
|
1802 |
|
|
// sections list has been modified. update sections2
|
1803 |
|
|
sections2.copy(sections);
|
1804 |
|
|
sections2.sort();
|
1805 |
|
|
|
1806 |
|
|
// make lists of module names and library names
|
1807 |
|
|
CDynamicArray<uint32_t> moduleNames, libraryNames;
|
1808 |
|
|
moduleNames.setNum(modules2.numEntries());
|
1809 |
|
|
for (uint32_t m = 0; m < modules2.numEntries(); m++) {
|
1810 |
|
|
moduleNames[m] = modules2[m].moduleName;
|
1811 |
|
|
}
|
1812 |
|
|
libraryNames.setNum(libraries.numEntries());
|
1813 |
|
|
for (uint32_t lib = 0; lib < libraries.numEntries(); lib++) {
|
1814 |
|
|
libraryNames[lib] = libraries[lib].libraryName;
|
1815 |
|
|
}
|
1816 |
|
|
|
1817 |
|
|
// copy module names and library names to relinkable sections
|
1818 |
|
|
outFile.addModuleNames(moduleNames, libraryNames);
|
1819 |
|
|
}
|
1820 |
|
|
|
1821 |
|
|
// copy symbols to output file
|
1822 |
|
|
void CLinker::copySymbols() {
|
1823 |
|
|
uint32_t s; // symbol index
|
1824 |
|
|
ElfFwcSym sym; // symbol record
|
1825 |
|
|
uint32_t modul; // module containing symbol
|
1826 |
|
|
SSymbolXref2 xref; // symbol cross reference record
|
1827 |
|
|
SLinkSection2 searchSection; // record to search for section
|
1828 |
|
|
char const * name; // symbol name
|
1829 |
|
|
int32_t sx; // section index in sections2
|
1830 |
|
|
char text[12]; // temporary text
|
1831 |
|
|
CDynamicArray<SSymbolXref2> xreflist; // list of cross reference records, sorted by name
|
1832 |
|
|
// make symbol number 0 empty
|
1833 |
|
|
zeroAllMembers(sym);
|
1834 |
|
|
outFile.addSymbol(sym, cmd.fileNameBuffer);
|
1835 |
|
|
|
1836 |
|
|
for (s = 0; s < symbolExports.numEntries(); s++) {
|
1837 |
|
|
// skip weak public symbols if overridden and not relinkable
|
1838 |
|
|
while (s+1 < symbolExports.numEntries() && symbolExports[s] == symbolExports[s+1]) {
|
1839 |
|
|
// next symbol has same name
|
1840 |
|
|
modul = findModule(symbolExports[s].library, symbolExports[s].member);
|
1841 |
|
|
if (modules2[modul].relinkable) break; // relinkable. preserve both symbols
|
1842 |
|
|
if (symbolExports[s+1].st_bind & STB_WEAK) {
|
1843 |
|
|
modul = findModule(symbolExports[s+1].library, symbolExports[s+1].member);
|
1844 |
|
|
modules2[modul].symbols[symbolExports[s+1].symindex].st_bind |= STB_IGNORE;
|
1845 |
|
|
}
|
1846 |
|
|
s++;
|
1847 |
|
|
}
|
1848 |
|
|
// if (symbolExports[s].library == 0xFFFFFFFE)
|
1849 |
|
|
// The special symbols __ip_base, etc are not copied to the executable file.
|
1850 |
|
|
// If we want them then we need to find the corresponding sections
|
1851 |
|
|
}
|
1852 |
|
|
|
1853 |
|
|
// loop through all modules to get all symbols
|
1854 |
|
|
for (modul = 0; modul < modules2.numEntries(); modul++) {
|
1855 |
|
|
for (s = 0; s < modules2[modul].symbols.numEntries(); s++) {
|
1856 |
|
|
sym = modules2[modul].symbols[s];
|
1857 |
|
|
if (sym.st_section || (sym.st_bind & STB_EXE)) {
|
1858 |
|
|
if ((sym.st_bind & (STB_EXE | STB_IGNORE)) == STB_EXE
|
1859 |
|
|
|| ((sym.st_bind & (STB_GLOBAL | STB_WEAK)))
|
1860 |
|
|
|| (cmd.debugOptions && sym.st_bind != STB_IGNORE)) {
|
1861 |
|
|
name = (char*)modules2[modul].stringBuffer.buf() + modules2[modul].symbols[s].st_name;
|
1862 |
|
|
xref.modul = modul;
|
1863 |
|
|
xref.name = symbolNameBuffer.pushString(name);
|
1864 |
|
|
xref.symi = s;
|
1865 |
|
|
xref.symx = 0;
|
1866 |
|
|
xref.isPublic = sym.st_section != 0;
|
1867 |
|
|
xref.isWeak = (sym.st_bind & STB_WEAK) != 0;
|
1868 |
|
|
xreflist.push(xref);
|
1869 |
|
|
}
|
1870 |
|
|
}
|
1871 |
|
|
}
|
1872 |
|
|
}
|
1873 |
|
|
// sort by name
|
1874 |
|
|
xreflist.sort();
|
1875 |
|
|
bool changed = false;
|
1876 |
|
|
// remove any $$number and subsequent text from all symbol names
|
1877 |
|
|
for (s = 0; s < xreflist.numEntries(); s++) {
|
1878 |
|
|
char * name1 = (char*)symbolNameBuffer.buf() + xreflist[s].name;
|
1879 |
|
|
char * p = strchr(name1, '$');
|
1880 |
|
|
if (p && p[1] == '$' && p[2] >= '0' && p[2] <= '9') {
|
1881 |
|
|
*p = 0;
|
1882 |
|
|
changed = true;
|
1883 |
|
|
}
|
1884 |
|
|
}
|
1885 |
|
|
// sort again
|
1886 |
|
|
if (changed) xreflist.sort();
|
1887 |
|
|
|
1888 |
|
|
// search for duplicate names
|
1889 |
|
|
for (s = 0; s < xreflist.numEntries(); s++) {
|
1890 |
|
|
uint32_t num = 0;
|
1891 |
|
|
name = symbolNameBuffer.getString(xreflist[s].name);
|
1892 |
|
|
if (xreflist[s].isPublic && !xreflist[s].isWeak) {
|
1893 |
|
|
// local or public non-weak symbol. check if duplicate names
|
1894 |
|
|
while (s+1 < xreflist.numEntries() && !(xreflist[s] < xreflist[s+1])) {
|
1895 |
|
|
// next symbol has same name
|
1896 |
|
|
s++;
|
1897 |
|
|
if (xreflist[s].isPublic && !xreflist[s].isWeak) {
|
1898 |
|
|
// this symbol is local or public and non-weak. there is a name clash
|
1899 |
|
|
// change duplicate name to name$$number
|
1900 |
|
|
xreflist[s].name = symbolNameBuffer.push(name, (uint32_t)strlen(name));
|
1901 |
|
|
sprintf(text, "$$%u", ++num);
|
1902 |
|
|
symbolNameBuffer.pushString(text);
|
1903 |
|
|
const char * name2 = symbolNameBuffer.getString(xreflist[s].name);
|
1904 |
|
|
// also change name of original symbol
|
1905 |
|
|
SSymbolXref2 & x2 = xreflist[s];
|
1906 |
|
|
ElfFwcSym & s2 = modules2[x2.modul].symbols[x2.symi];
|
1907 |
|
|
s2.st_name = modules2[x2.modul].stringBuffer.pushString(name2);
|
1908 |
|
|
}
|
1909 |
|
|
}
|
1910 |
|
|
}
|
1911 |
|
|
}
|
1912 |
|
|
// sort cross references by module
|
1913 |
|
|
symbolXref << xreflist;
|
1914 |
|
|
symbolXref.sort();
|
1915 |
|
|
|
1916 |
|
|
// copy symbols to outFile
|
1917 |
|
|
for (s = 0; s < symbolXref.numEntries(); s++) {
|
1918 |
|
|
modul = symbolXref[s].modul;
|
1919 |
|
|
sym = modules2[modul].symbols[symbolXref[s].symi];
|
1920 |
|
|
if (sym.st_section != 0) {
|
1921 |
|
|
// translate local section index to final section index
|
1922 |
|
|
searchSection.sh_module = modul;
|
1923 |
|
|
searchSection.sectioni = sym.st_section;
|
1924 |
|
|
sx = sections2.findFirst(searchSection);
|
1925 |
|
|
if (sx < 0) {
|
1926 |
|
|
continue; // symbol is in a discarded communal section. drop it
|
1927 |
|
|
}
|
1928 |
|
|
// adjust address
|
1929 |
|
|
uint32_t newsection = sections2[sx].sectionx;
|
1930 |
|
|
sym.st_value += sections2[sx].sh_addr - outFile.sectionHeaders[newsection].sh_addr;
|
1931 |
|
|
sym.st_section = newsection;
|
1932 |
|
|
}
|
1933 |
|
|
sym.st_bind &= ~ STB_EXE;
|
1934 |
|
|
symbolXref[s].symx = outFile.addSymbol(sym, modules2[modul].stringBuffer);
|
1935 |
|
|
}
|
1936 |
|
|
// make records for unresolved weak symbols
|
1937 |
|
|
if (relinkable) {
|
1938 |
|
|
zeroAllMembers(sym);
|
1939 |
|
|
for (s = 0; s < symbolImports.numEntries(); s++) {
|
1940 |
|
|
if ((symbolImports[s].status & 5) && (symbolImports[s].st_bind & STB_WEAK)) {
|
1941 |
|
|
// unresolved weak. make a symbol record
|
1942 |
|
|
sym.st_name = symbolImports[s].name;
|
1943 |
|
|
sym.st_type = symbolImports[s].st_type;
|
1944 |
|
|
sym.st_bind = symbolImports[s].st_bind;
|
1945 |
|
|
sym.st_other = symbolImports[s].st_other;
|
1946 |
|
|
// skip any additional unresolved symbols with same name
|
1947 |
|
|
while (s+1 < symbolImports.numEntries() && symbolImports[s] == symbolImports[s+1]) s++;
|
1948 |
|
|
// put record in output file
|
1949 |
|
|
xref.symx = outFile.addSymbol(sym, symbolNameBuffer);
|
1950 |
|
|
xref.name = sym.st_name;
|
1951 |
|
|
xref.modul = symbolImports[s].library;
|
1952 |
|
|
xref.symi = symbolImports[s].symindex;
|
1953 |
|
|
// put new index into list of unresolved weak symbols
|
1954 |
|
|
unresWeakSym.push(xref); // this list will be sorted by name because symbolImports is sorted by name
|
1955 |
|
|
}
|
1956 |
|
|
}
|
1957 |
|
|
}
|
1958 |
|
|
}
|
1959 |
|
|
|
1960 |
|
|
// copy relocation records to output file if needed
|
1961 |
|
|
void CLinker::copyRelocations() {
|
1962 |
|
|
uint32_t r; // relocation index
|
1963 |
|
|
int32_t s; // symbol index
|
1964 |
|
|
SReloc2 rel2; // extended relocation record
|
1965 |
|
|
SSymbolXref symx; // record for searching for symbol in symbolXref
|
1966 |
|
|
CDynamicArray<SReloc2> relocations3; // extended relocation records. load-time relocations first
|
1967 |
|
|
relocations3.setSize(relocations2.dataSize());
|
1968 |
|
|
|
1969 |
|
|
// get load-time relocations first
|
1970 |
|
|
for (r = 0; r < relocations2.numEntries(); r++) {
|
1971 |
|
|
if (relocations2[r].r_type & R_FORW_LOADTIME) {
|
1972 |
|
|
relocations3.push(relocations2[r]);
|
1973 |
|
|
}
|
1974 |
|
|
}
|
1975 |
|
|
// get remaining relocations, used only for relinking
|
1976 |
|
|
for (r = 0; r < relocations2.numEntries(); r++) {
|
1977 |
|
|
if (!(relocations2[r].r_type & R_FORW_LOADTIME)) {
|
1978 |
|
|
relocations3.push(relocations2[r]);
|
1979 |
|
|
}
|
1980 |
|
|
}
|
1981 |
|
|
|
1982 |
|
|
// relocations3 contains list of relocations that need to be copied to executable file
|
1983 |
|
|
for (r = 0; r < relocations3.numEntries(); r++) {
|
1984 |
|
|
rel2 = relocations3[r];
|
1985 |
|
|
if (rel2.r_type == 0) continue; // removed
|
1986 |
|
|
if (rel2.modul >= modules2.numEntries()) {
|
1987 |
|
|
err.submit(ERR_ELF_INDEX_RANGE); continue;
|
1988 |
|
|
}
|
1989 |
|
|
// translate section index
|
1990 |
|
|
SLinkSection2 secSearch;
|
1991 |
|
|
secSearch.sh_module = rel2.modul;
|
1992 |
|
|
secSearch.sectioni = rel2.r_section;
|
1993 |
|
|
int32_t x = sections2.findFirst(secSearch);
|
1994 |
|
|
if (x < 0) continue; // section not found. ignore
|
1995 |
|
|
rel2.r_section = sections2[x].sectionx;
|
1996 |
|
|
// adjust offset
|
1997 |
|
|
rel2.r_offset += sections2[x].sh_addr - outFile.sectionHeaders[rel2.r_section].sh_addr;
|
1998 |
|
|
|
1999 |
|
|
// translate symbol index
|
2000 |
|
|
if (rel2.symLocal) {
|
2001 |
|
|
// symbol is local. reference by ID
|
2002 |
|
|
symx.modul = rel2.modul;
|
2003 |
|
|
symx.symi = rel2.r_sym;
|
2004 |
|
|
s = symbolXref.findFirst(symx);
|
2005 |
|
|
if (s < 0) {
|
2006 |
|
|
// unresolved weak
|
2007 |
|
|
rel2.r_sym = resolveRelocationTarget(rel2.modul, rel2.r_sym);
|
2008 |
|
|
}
|
2009 |
|
|
else rel2.r_sym = symbolXref[s].symx;
|
2010 |
|
|
}
|
2011 |
|
|
else {
|
2012 |
|
|
// symbol is remote. search by name
|
2013 |
|
|
rel2.r_sym = resolveRelocationTarget(rel2.modul, rel2.r_sym);
|
2014 |
|
|
}
|
2015 |
|
|
|
2016 |
|
|
// translate reference symbol index
|
2017 |
|
|
if (rel2.r_refsym) {
|
2018 |
|
|
if (rel2.refSymLocal) {
|
2019 |
|
|
// reference symbol is local. reference by ID
|
2020 |
|
|
symx.modul = rel2.modul;
|
2021 |
|
|
symx.symi = rel2.r_refsym;
|
2022 |
|
|
s = symbolXref.findFirst(symx);
|
2023 |
|
|
if (s < 0) {
|
2024 |
|
|
rel2.r_refsym = resolveRelocationTarget(rel2.modul, rel2.r_refsym);
|
2025 |
|
|
}
|
2026 |
|
|
else rel2.r_refsym = symbolXref[s].symx;
|
2027 |
|
|
}
|
2028 |
|
|
else {
|
2029 |
|
|
// reference symbol is remote. search by name
|
2030 |
|
|
rel2.r_refsym = resolveRelocationTarget(rel2.modul, rel2.r_refsym);
|
2031 |
|
|
}
|
2032 |
|
|
}
|
2033 |
|
|
// put relocation in outFile
|
2034 |
|
|
outFile.addRelocation(rel2);
|
2035 |
|
|
}
|
2036 |
|
|
}
|
2037 |
|
|
|
2038 |
|
|
// resolve relocation target for executable file record
|
2039 |
|
|
uint32_t CLinker::resolveRelocationTarget(uint32_t modul, uint32_t symi) {
|
2040 |
|
|
CELF * modulp; // pointer to module
|
2041 |
|
|
const char * symname; // symbol name
|
2042 |
|
|
int32_t ie; // index into symbolExports
|
2043 |
|
|
int32_t iu; // index into unresWeakSym
|
2044 |
|
|
int32_t is; // index into symbolXref
|
2045 |
|
|
uint32_t modt; // target module
|
2046 |
|
|
SSymbolEntry syms; // record for searching for symbol in symbolExports
|
2047 |
|
|
SSymbolXref2 symu; // record for searching for symbol in unresWeakSym
|
2048 |
|
|
SSymbolXref symx; // record for searching for symbol in symbolXref
|
2049 |
|
|
|
2050 |
|
|
modulp = &modules2[modul]; // module
|
2051 |
|
|
// search by name
|
2052 |
|
|
if (symi >= modulp->symbols.numEntries()) {
|
2053 |
|
|
err.submit(ERR_ELF_INDEX_RANGE); return 0;
|
2054 |
|
|
}
|
2055 |
|
|
symname = (char*)modulp->stringBuffer.buf() + modulp->symbols[symi].st_name;
|
2056 |
|
|
syms.name = symbolNameBuffer.pushString(symname);
|
2057 |
|
|
syms.st_bind = STB_IGNORE; // find both strong and weak symbols
|
2058 |
|
|
ie = symbolExports.findFirst(syms);
|
2059 |
|
|
if (ie < 0) {
|
2060 |
|
|
// symbol name not found
|
2061 |
|
|
if (modulp->symbols[symi].st_bind & STB_WEAK) {
|
2062 |
|
|
// weak symbol not found
|
2063 |
|
|
symu.name = symbolNameBuffer.pushString(symname);
|
2064 |
|
|
iu = unresWeakSym.findFirst(symu);
|
2065 |
|
|
if (iu >= 0) {
|
2066 |
|
|
return unresWeakSym[iu].symx;
|
2067 |
|
|
}
|
2068 |
|
|
// strong symbol not found
|
2069 |
|
|
err.submit(ERR_REL_SYMBOL_NOT_FOUND); return 0; // should not occur
|
2070 |
|
|
}
|
2071 |
|
|
}
|
2072 |
|
|
if (symbolExports[ie].library > 0xFFFFFFF0) {
|
2073 |
|
|
symu.name = symbolNameBuffer.pushString(symname);
|
2074 |
|
|
iu = unresWeakSym.findFirst(symu);
|
2075 |
|
|
if (iu >= 0) {
|
2076 |
|
|
return unresWeakSym[iu].symx;
|
2077 |
|
|
}
|
2078 |
|
|
}
|
2079 |
|
|
// module containing target symbol
|
2080 |
|
|
modt = symbolExports[ie].member;
|
2081 |
|
|
uint32_t symlib = symbolExports[ie].library;
|
2082 |
|
|
if (symlib != 0 && symlib < 0xFFFFFFF0) {
|
2083 |
|
|
modt = (uint32_t)findModule(symbolExports[ie].library, modt);
|
2084 |
|
|
if ((int32_t)modt < 0) {
|
2085 |
|
|
err.submit(ERR_REL_SYMBOL_NOT_FOUND); return 0; // should not occur
|
2086 |
|
|
}
|
2087 |
|
|
}
|
2088 |
|
|
else if (symlib) {
|
2089 |
|
|
modt = symlib;
|
2090 |
|
|
}
|
2091 |
|
|
symx.modul = modt;
|
2092 |
|
|
symx.symi = symbolExports[ie].symindex;
|
2093 |
|
|
// find new index for this symbol
|
2094 |
|
|
is = symbolXref.findFirst(symx);
|
2095 |
|
|
if (is < 0) {
|
2096 |
|
|
err.submit(ERR_REL_SYMBOL_NOT_FOUND); return 0; // should not occur
|
2097 |
|
|
}
|
2098 |
|
|
return symbolXref[is].symx;
|
2099 |
|
|
}
|
2100 |
|
|
|
2101 |
|
|
// make executable file header
|
2102 |
|
|
void CLinker::makeFileHeader() {
|
2103 |
|
|
fileHeader.e_type = ET_EXEC; // executable file
|
2104 |
|
|
fileHeader.e_ip_base = ip_base; // __ip_base relative to first ip based segment
|
2105 |
|
|
fileHeader.e_datap_base = datap_base; // __datap_base relative to first datap based segment
|
2106 |
|
|
fileHeader.e_threadp_base = 0; // __threadp_base relative to first threadp based segment
|
2107 |
|
|
fileHeader.e_entry = entry_point; // entry point for startup code
|
2108 |
|
|
if (relinkable) fileHeader.e_flags |= EF_RELINKABLE; // relinking allowed
|
2109 |
|
|
}
|