1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ecmascript/compiler/aot_file/elf_builder.h"
17
18 #include "ecmascript/ecma_macros.h"
19 #include "securec.h"
20
21 namespace panda::ecmascript {
AddShStrTabSection()22 void ElfBuilder::AddShStrTabSection()
23 {
24 std::map<ElfSecName, std::pair<uint64_t, uint32_t>> §ions =
25 des_[ShStrTableModuleDesIndex].GetSectionsInfo();
26
27 uint32_t size = 1;
28 for (auto &s : sections_) {
29 std::string str = ModuleSectionDes::GetSecName(s);
30 size = size + str.size() + 1;
31 }
32
33 shStrTabPtr_ = std::make_unique<char []>(size);
34 char *dst = shStrTabPtr_.get();
35 dst[0] = 0x0;
36 uint32_t i = 1;
37 for (auto &s: sections_) {
38 std::string str = ModuleSectionDes::GetSecName(s);
39 uint32_t copySize = str.size();
40 if (copySize == 0) {
41 UNREACHABLE();
42 }
43 if ((copySize != 0) && ((memcpy_s(dst + i, size - i + 1, str.data(), copySize)) != EOK)) {
44 UNREACHABLE();
45 }
46 dst[i + copySize] = 0x0;
47 i = i + copySize + 1;
48 }
49 if (sections.find(ElfSecName::SHSTRTAB) != sections.end()) {
50 sections.erase(ElfSecName::SHSTRTAB);
51 }
52 sections[ElfSecName::SHSTRTAB] = std::make_pair(reinterpret_cast<uint64_t>(shStrTabPtr_.get()), size);
53 if (enableSecDump_) {
54 DumpSection();
55 }
56 }
57
DumpSection() const58 void ElfBuilder::DumpSection() const
59 {
60 const std::map<ElfSecName, std::pair<uint64_t, uint32_t>> §ions = GetFullSecInfo();
61 // dump
62 for (auto &s : sections) {
63 ElfSection section = ElfSection(s.first);
64 if (!section.ShouldDumpToAOTFile()) {
65 continue;
66 }
67 LOG_COMPILER(INFO) << "secname :" << std::dec << static_cast<int>(s.first)
68 << " addr:0x" << std::hex << s.second.first << " size:0x" << s.second.second << std::endl;
69 }
70 }
71
ElfBuilder(const std::vector<ModuleSectionDes> & des,const std::vector<ElfSecName> & sections)72 ElfBuilder::ElfBuilder(const std::vector<ModuleSectionDes> &des,
73 const std::vector<ElfSecName> §ions): des_(des), sections_(sections)
74 {
75 Initialize();
76 AddShStrTabSection();
77 RemoveNotNeedSection();
78 }
79
Initialize()80 void ElfBuilder::Initialize()
81 {
82 for (size_t i = 0; i < des_.size(); i++) {
83 des_[i].AddArkStackMapSection();
84 }
85 sectionToAlign_ = {
86 {ElfSecName::TEXT, AOTFileInfo::PAGE_ALIGN},
87 {ElfSecName::STRTAB, 1},
88 {ElfSecName::SYMTAB, AOTFileInfo::DATA_SEC_ALIGN},
89 {ElfSecName::SHSTRTAB, AOTFileInfo::DATA_SEC_ALIGN},
90 {ElfSecName::ARK_STACKMAP, AOTFileInfo::DATA_SEC_ALIGN},
91 {ElfSecName::ARK_FUNCENTRY, AOTFileInfo::DATA_SEC_ALIGN},
92 {ElfSecName::ARK_ASMSTUB, AOTFileInfo::DATA_SEC_ALIGN},
93 {ElfSecName::ARK_MODULEINFO, AOTFileInfo::DATA_SEC_ALIGN},
94 };
95
96 sectionToSegment_ = {
97 {ElfSecName::RODATA, ElfSecName::TEXT},
98 {ElfSecName::RODATA_CST4, ElfSecName::TEXT},
99 {ElfSecName::RODATA_CST8, ElfSecName::TEXT},
100 {ElfSecName::RODATA_CST16, ElfSecName::TEXT},
101 {ElfSecName::RODATA_CST32, ElfSecName::TEXT},
102 {ElfSecName::TEXT, ElfSecName::TEXT},
103 {ElfSecName::STRTAB, ElfSecName::DATA},
104 {ElfSecName::SYMTAB, ElfSecName::DATA},
105 {ElfSecName::SHSTRTAB, ElfSecName::DATA},
106 {ElfSecName::ARK_STACKMAP, ElfSecName::DATA},
107 {ElfSecName::ARK_FUNCENTRY, ElfSecName::DATA},
108 {ElfSecName::ARK_ASMSTUB, ElfSecName::TEXT},
109 {ElfSecName::ARK_MODULEINFO, ElfSecName::DATA},
110 };
111
112 segmentToFlag_ = {
113 {ElfSecName::TEXT, llvm::ELF::PF_X | llvm::ELF::PF_R},
114 {ElfSecName::DATA, llvm::ELF::PF_R},
115 };
116
117 SetLastSection();
118 }
119
RemoveNotNeedSection()120 void ElfBuilder::RemoveNotNeedSection()
121 {
122 const std::map<ElfSecName, std::pair<uint64_t, uint32_t>> §ions = GetFullSecInfo();
123 for (size_t i = 0; i < sections_.size();) {
124 if (sections.find(sections_[i]) == sections.end()) {
125 auto it = sections_.begin() + i;
126 sections_.erase(it);
127 continue;
128 }
129 i++;
130 }
131 }
132
~ElfBuilder()133 ElfBuilder::~ElfBuilder()
134 {
135 shStrTabPtr_ = nullptr;
136 }
137
GetShIndex(ElfSecName section) const138 uint32_t ElfBuilder::GetShIndex(ElfSecName section) const
139 {
140 std::set<ElfSecName> secSet(sections_.begin(), sections_.end());
141 uint32_t idx = 1;
142 for (ElfSecName sec : secSet) {
143 if (sec == section) {
144 return idx;
145 }
146 idx++;
147 }
148 return -1;
149 }
150
GetSecNum() const151 int ElfBuilder::GetSecNum() const
152 {
153 return sections_.size();
154 }
155
156 /*
157 ELF Header as follow:
158 ELF Header:
159 Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
160 Class: ELF64
161 Data: 2's complement, little endian
162 Version: 1 (current)
163 OS/ABI: UNIX - System V
164 ABI Version: 0
165 Type: DYN (Shared object file)
166 Machine: Advanced Micro Devices X86-64
167 Version: 0x4000001
168 Entry point address: 0x0
169 Start of program headers: 16384 (bytes into file)
170 Start of section headers: 64 (bytes into file)
171 Flags: 0x0
172 Size of this header: 64 (bytes)
173 Size of program headers: 56 (bytes)
174 Number of program headers: 2
175 Size of section headers: 64 (bytes)
176 Number of section headers: 7
177 Section header string table index: 3
178 */
PackELFHeader(llvm::ELF::Elf64_Ehdr & header,uint32_t version,Triple triple)179 void ElfBuilder::PackELFHeader(llvm::ELF::Elf64_Ehdr &header, uint32_t version, Triple triple)
180 {
181 if (memset_s(reinterpret_cast<void *>(&header), sizeof(llvm::ELF::Elf64_Ehdr), 0,
182 sizeof(llvm::ELF::Elf64_Ehdr)) != EOK) {
183 UNREACHABLE();
184 }
185 header.e_ident[llvm::ELF::EI_MAG0] = llvm::ELF::ElfMagic[llvm::ELF::EI_MAG0];
186 header.e_ident[llvm::ELF::EI_MAG1] = llvm::ELF::ElfMagic[llvm::ELF::EI_MAG1];
187 header.e_ident[llvm::ELF::EI_MAG2] = llvm::ELF::ElfMagic[llvm::ELF::EI_MAG2];
188 header.e_ident[llvm::ELF::EI_MAG3] = llvm::ELF::ElfMagic[llvm::ELF::EI_MAG3];
189 header.e_ident[llvm::ELF::EI_CLASS] = llvm::ELF::ELFCLASS64;
190 header.e_ident[llvm::ELF::EI_DATA] = llvm::ELF::ELFDATA2LSB;
191 header.e_ident[llvm::ELF::EI_VERSION] = 1;
192
193 header.e_type = llvm::ELF::ET_DYN;
194 switch (triple) {
195 case Triple::TRIPLE_AMD64:
196 header.e_machine = llvm::ELF::EM_X86_64;
197 break;
198 case Triple::TRIPLE_ARM32:
199 header.e_machine = llvm::ELF::EM_ARM;
200 break;
201 case Triple::TRIPLE_AARCH64:
202 header.e_machine = llvm::ELF::EM_AARCH64;
203 break;
204 default:
205 UNREACHABLE();
206 break;
207 }
208 header.e_version = version;
209 // start of section headers
210 header.e_shoff = sizeof(llvm::ELF::Elf64_Ehdr);
211 // size of ehdr
212 header.e_ehsize = sizeof(llvm::ELF::Elf64_Ehdr);
213 // size of section headers
214 header.e_shentsize = sizeof(llvm::ELF::Elf64_Shdr);
215 // number of section headers
216 header.e_shnum = GetSecNum() + 1; // 1: skip null section and ark stackmap
217 // section header string table index
218 header.e_shstrndx = static_cast<llvm::ELF::Elf64_Half>(GetShIndex(ElfSecName::SHSTRTAB));
219 // section header stub sec info index
220 header.e_flags = static_cast<llvm::ELF::Elf64_Word>(GetShIndex(ElfSecName::ARK_MODULEINFO));
221 // phr
222 header.e_phentsize = sizeof(llvm::ELF::Elf64_Phdr);
223 header.e_phnum = GetSegmentNum();
224 }
225
GetSegmentNum() const226 int ElfBuilder::GetSegmentNum() const
227 {
228 const std::map<ElfSecName, std::pair<uint64_t, uint32_t>> §ions = GetFullSecInfo();
229 std::set<ElfSecName> segments;
230 for (auto &s: sections) {
231 ElfSection section = ElfSection(s.first);
232 if (!section.ShouldDumpToAOTFile()) {
233 continue;
234 }
235 auto it = sectionToSegment_.find(s.first);
236 ASSERT(it != sectionToSegment_.end());
237 ElfSecName name = it->second;
238 segments.insert(name);
239 }
240 return segments.size();
241 }
242
SetLastSection()243 void ElfBuilder::SetLastSection()
244 {
245 const std::map<ElfSecName, std::pair<uint64_t, uint32_t>> §ions = GetFullSecInfo();
246 for (auto &s: sections) {
247 ElfSection section = ElfSection(s.first);
248 if (!section.ShouldDumpToAOTFile()) {
249 continue;
250 }
251 auto it = sectionToSegment_.find(s.first);
252 ASSERT(it != sectionToSegment_.end());
253 ElfSecName name = it->second;
254 if (name == ElfSecName::TEXT) {
255 lastCodeSection = std::max(lastCodeSection, s.first);
256 } else {
257 lastDataSection = std::max(lastDataSection, s.first);
258 }
259 }
260 }
261
FindShName(std::string name,uintptr_t strTabPtr,int strTabSize)262 llvm::ELF::Elf64_Word ElfBuilder::FindShName(std::string name, uintptr_t strTabPtr, int strTabSize)
263 {
264 llvm::ELF::Elf64_Word ans = -1;
265 int len = static_cast<int>(name.size());
266 if (strTabSize < len + 1) {
267 return ans;
268 }
269 LOG_ECMA(DEBUG) << " FindShName name:" << name.c_str() << std::endl;
270 for (int i = 0; i < strTabSize - len + 1; ++i) {
271 char *dst = reinterpret_cast<char *>(strTabPtr) + i;
272 if (name.compare(dst) == 0) {
273 return i;
274 }
275 }
276 return ans;
277 }
278
FindShStrTab() const279 std::pair<uint64_t, uint32_t> ElfBuilder::FindShStrTab() const
280 {
281 const std::map<ElfSecName, std::pair<uint64_t, uint32_t>> §ions = GetFullSecInfo();
282 uint64_t shStrTabAddr = 0;
283 uint32_t shStrTabSize = 0;
284 for (auto &s: sections) {
285 uint32_t curSecSize = des_[ShStrTableModuleDesIndex].GetSecSize(s.first);
286 uint64_t curSecAddr = des_[ShStrTableModuleDesIndex].GetSecAddr(s.first);
287 if (s.first == ElfSecName::SHSTRTAB) {
288 shStrTabSize = curSecSize;
289 shStrTabAddr = curSecAddr;
290 break;
291 }
292 }
293 return std::make_pair(shStrTabAddr, shStrTabSize);
294 }
295
AllocateShdr(std::unique_ptr<llvm::ELF::Elf64_Shdr[]> & shdr,const uint32_t & secNum)296 void ElfBuilder::AllocateShdr(std::unique_ptr<llvm::ELF::Elf64_Shdr []> &shdr, const uint32_t &secNum)
297 {
298 shdr = std::make_unique<llvm::ELF::Elf64_Shdr []>(secNum);
299 if (memset_s(reinterpret_cast<void *>(&shdr[0]), sizeof(llvm::ELF::Elf64_Shdr),
300 0, sizeof(llvm::ELF::Elf64_Shdr)) != EOK) {
301 UNREACHABLE();
302 }
303 }
304
ComputeEndAddrOfShdr(const uint32_t & secNum) const305 llvm::ELF::Elf64_Off ElfBuilder::ComputeEndAddrOfShdr(const uint32_t &secNum) const
306 {
307 llvm::ELF::Elf64_Off curSecOffset = sizeof(llvm::ELF::Elf64_Ehdr) + secNum * sizeof(llvm::ELF::Elf64_Shdr);
308 curSecOffset = AlignUp(curSecOffset, PageSize()); // not pagesize align will cause performance degradation
309 return curSecOffset;
310 }
311
GetSegmentName(const ElfSecName & secName) const312 ElfSecName ElfBuilder::GetSegmentName(const ElfSecName &secName) const
313 {
314 auto it = sectionToSegment_.find(secName);
315 ASSERT(it != sectionToSegment_.end());
316 ElfSecName segName = it->second;
317 return segName;
318 }
319
MergeTextSections(std::ofstream & file,std::vector<ModuleSectionDes::ModuleRegionInfo> & moduleInfo,llvm::ELF::Elf64_Off & curSecOffset)320 void ElfBuilder::MergeTextSections(std::ofstream &file,
321 std::vector<ModuleSectionDes::ModuleRegionInfo> &moduleInfo,
322 llvm::ELF::Elf64_Off &curSecOffset)
323 {
324 for (size_t i = 0; i < des_.size(); ++i) {
325 ModuleSectionDes &des = des_[i];
326 ModuleSectionDes::ModuleRegionInfo &curInfo = moduleInfo[i];
327 uint32_t curSecSize = des.GetSecSize(ElfSecName::TEXT);
328 uint64_t curSecAddr = des.GetSecAddr(ElfSecName::TEXT);
329 curSecOffset = AlignUp(curSecOffset, AOTFileInfo::PAGE_ALIGN);
330 file.seekp(curSecOffset);
331 auto curModuleSec = des.GetSectionsInfo();
332 uint32_t rodataSize = 0;
333 uint64_t rodataAddr = 0;
334 curInfo.rodataAfterText = 0;
335 std::tie(rodataAddr, rodataSize) = des.GetMergedRODataAddrAndSize();
336 if (rodataSize != 0 && rodataAddr < curSecAddr) {
337 file.write(reinterpret_cast<char *>(rodataAddr), rodataSize);
338 curInfo.rodataSize = rodataSize;
339 curSecOffset += rodataSize;
340 curSecOffset = AlignUp(curSecOffset, AOTFileInfo::TEXT_SEC_ALIGN);
341 file.seekp(curSecOffset);
342 }
343 file.write(reinterpret_cast<char *>(curSecAddr), curSecSize);
344 curInfo.textSize = curSecSize;
345 curSecOffset += curSecSize;
346 if (rodataSize != 0 && rodataAddr > curSecAddr) {
347 curSecOffset = AlignUp(curSecOffset, AOTFileInfo::DATA_SEC_ALIGN);
348 file.seekp(curSecOffset);
349 file.write(reinterpret_cast<char *>(rodataAddr), rodataSize);
350 curInfo.rodataSize = rodataSize;
351 curSecOffset += rodataSize;
352 // .rodata is written after .text
353 curInfo.rodataAfterText = 1;
354 }
355 }
356 }
357
MergeArkStackMapSections(std::ofstream & file,std::vector<ModuleSectionDes::ModuleRegionInfo> & moduleInfo,llvm::ELF::Elf64_Off & curSecOffset)358 void ElfBuilder::MergeArkStackMapSections(std::ofstream &file,
359 std::vector<ModuleSectionDes::ModuleRegionInfo> &moduleInfo,
360 llvm::ELF::Elf64_Off &curSecOffset)
361 {
362 for (size_t i = 0; i < des_.size(); ++i) {
363 ModuleSectionDes &des = des_[i];
364 ModuleSectionDes::ModuleRegionInfo &curInfo = moduleInfo[i];
365 uint32_t curSecSize = des.GetSecSize(ElfSecName::ARK_STACKMAP);
366 uint64_t curSecAddr = des.GetSecAddr(ElfSecName::ARK_STACKMAP);
367 uint32_t index = des.GetStartIndex();
368 uint32_t cnt = des.GetFuncCount();
369 curInfo.startIndex = index;
370 curInfo.funcCount = cnt;
371 curInfo.stackMapSize = curSecSize;
372 file.write(reinterpret_cast<char *>(curSecAddr), curSecSize);
373 curSecOffset += curSecSize;
374 }
375 }
376
377 /*
378
379 section of aot.an layout as follows:
380 There are 7 section headers, starting at offset 0x40:
381
382 Section Headers:
383 [Nr] Name Type Address Offset Size EntSize Flags Link Info Align
384 [ 0] NULL 0000000000000000 00000000 0000000000000000 0000000000000000 0 0 0
385 [ 1] .text PROGBITS 0000000000001000 00001000 0000000000000f61 0000000000000000 AX 0 0 16
386 [ 2] .strtab STRTAB 0000000000002000 00002000 0000000000000187 0000000000000000 A 0 0 1
387 [ 3] .symtab SYMTAB 0000000000002188 00002188 00000000000001c8 0000000000000018 A 1 0 8
388 [ 4] .shstrtab STRTAB 0000000000002350 00002350 000000000000003f 0000000000000000 A 0 0 8
389 [ 5] .ark_funcentry PROGBITS 0000000000002390 00002390 00000000000006c0 0000000000000000 A 0 0 8
390 [ 6] .ark_stackmaps PROGBITS 0000000000002a50 00002a50 000000000000070e 0000000000000000 A 0 0 8
391
392 section of stub.an layout as follows:
393 There are 7 section headers, starting at offset 0x40:
394
395 [Nr] Name Type Address Offset Size EntSize Flags Link Info Align
396 [ 0] NULL 0000000000000000 00000000 0000000000000000 0000000000000000 0 0 0
397 [ 1] .text PROGBITS 0000000000001000 00001000 000000000008225e 0000000000000000 AX 0 0 16
398 [ 2] .ark_asmstub PROGBITS 0000000000083260 00083260 0000000000002dc0 0000000000000000 AX 0 0 8
399 [ 3] .shstrtab STRTAB 0000000000087000 00087000 000000000000004c 0000000000000000 A 0 0 8
400 [ 4] .ark_funcentry PROGBITS 0000000000087050 00087050 0000000000023ca0 0000000000000000 A 0 0 8
401 [ 5] .ark_stackmaps PROGBITS 00000000000aacf0 000aacf0 0000000000011e90 0000000000000000 A 0 0 8
402 [ 6] .ark_moduleinfo PROGBITS 00000000000bcb80 000bcb80 000000000000003c 0000000000000000 A 0 0 8
403
404 Key to Flags:
405 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
406 L (link order), O (extra OS processing required), G (group), T (TLS),
407 C (compressed), x (unknown), o (OS specific), E (exclude),
408 D (mbind), l (large), p (processor specific)
409 */
PackELFSections(std::ofstream & file)410 void ElfBuilder::PackELFSections(std::ofstream &file)
411 {
412 uint32_t moduleNum = des_.size();
413 const std::map<ElfSecName, std::pair<uint64_t, uint32_t>> §ions = GetFullSecInfo();
414 uint32_t secNum = sections.size() + 1; // 1 : section id = 0 is null section
415 std::unique_ptr<llvm::ELF::Elf64_Shdr []> shdr;
416 AllocateShdr(shdr, secNum);
417 std::vector<ModuleSectionDes::ModuleRegionInfo> moduleInfo(moduleNum);
418 llvm::ELF::Elf64_Off curSecOffset = ComputeEndAddrOfShdr(secNum);
419 file.seekp(curSecOffset);
420
421 int i = 1; // 1: skip null section
422 auto shStrTab = FindShStrTab();
423
424 for (auto const &[secName, secInfo] : sections) {
425 auto &curShdr = shdr[i];
426 ElfSection section = ElfSection(secName);
427 if (!section.ShouldDumpToAOTFile()) {
428 continue;
429 }
430 curShdr.sh_addralign = sectionToAlign_[secName];
431 curSecOffset = AlignUp(curSecOffset, curShdr.sh_addralign);
432 file.seekp(curSecOffset);
433 ElfSecName segName = GetSegmentName(secName);
434 segments_.insert(segName);
435 std::string secNameStr = ModuleSectionDes::GetSecName(secName);
436 // text section address needs 16 bytes alignment
437 if (secName == ElfSecName::TEXT) {
438 curSecOffset = AlignUp(curSecOffset, AOTFileInfo::PAGE_ALIGN);
439 file.seekp(curSecOffset);
440 }
441 llvm::ELF::Elf64_Word shName = FindShName(secNameStr, shStrTab.first, shStrTab.second);
442 ASSERT(shName != static_cast<llvm::ELF::Elf64_Word>(-1));
443 curShdr.sh_name = shName;
444 curShdr.sh_type = section.Type();
445 curShdr.sh_flags = section.Flag();
446 curShdr.sh_addr = curSecOffset;
447 curShdr.sh_offset = static_cast<uint64_t>(curSecOffset);
448 sectionToFileOffset_[secName] = static_cast<uintptr_t>(file.tellp());
449 switch (secName) {
450 case ElfSecName::ARK_MODULEINFO: {
451 uint32_t curSecSize = sizeof(ModuleSectionDes::ModuleRegionInfo) * moduleInfo.size();
452 file.write(reinterpret_cast<char *>(moduleInfo.data()), curSecSize);
453 curSecOffset += curSecSize;
454 curShdr.sh_size = curSecSize;
455 break;
456 }
457 case ElfSecName::TEXT: {
458 uint32_t curSize = curSecOffset;
459 MergeTextSections(file, moduleInfo, curSecOffset);
460 curShdr.sh_size = curSecOffset - curSize;
461 break;
462 }
463 case ElfSecName::ARK_STACKMAP: {
464 uint32_t curSize = curSecOffset;
465 MergeArkStackMapSections(file, moduleInfo, curSecOffset);
466 curShdr.sh_size = curSecOffset - curSize;
467 break;
468 }
469 case ElfSecName::STRTAB:
470 case ElfSecName::SYMTAB:
471 case ElfSecName::SHSTRTAB:
472 case ElfSecName::ARK_FUNCENTRY:
473 case ElfSecName::ARK_ASMSTUB: {
474 uint32_t curSecSize = des_[FullSecIndex].GetSecSize(secName);
475 uint64_t curSecAddr = des_[FullSecIndex].GetSecAddr(secName);
476 file.write(reinterpret_cast<char *>(curSecAddr), curSecSize);
477 curSecOffset += curSecSize;
478 curShdr.sh_size = curSecSize;
479 break;
480 }
481 default: {
482 LOG_ECMA(FATAL) << "this section should not dump to an file";
483 break;
484 }
485 }
486 if (secName == lastDataSection || secName == lastCodeSection) {
487 curSecOffset = AlignUp(curSecOffset, PageSize());
488 file.seekp(curSecOffset);
489 }
490 curShdr.sh_link = static_cast<uint32_t>(section.Link());
491 curShdr.sh_info = 0;
492 curShdr.sh_entsize = static_cast<uint64_t>(section.Entsize());
493 sectionToShdr_[secName] = curShdr;
494 LOG_COMPILER(DEBUG) << " shdr[i].sh_entsize " << std::hex << curShdr.sh_entsize << std::endl;
495 ++i;
496 }
497 uint32_t secEnd = static_cast<uint32_t>(file.tellp());
498 file.seekp(sizeof(llvm::ELF::Elf64_Ehdr));
499 file.write(reinterpret_cast<char *>(shdr.get()), secNum * sizeof(llvm::ELF::Elf64_Shdr));
500 file.seekp(secEnd);
501 }
502
GetPFlag(ElfSecName segment) const503 unsigned ElfBuilder::GetPFlag(ElfSecName segment) const
504 {
505 return segmentToFlag_.at(segment);
506 }
507
508 /*
509 segment layout as follows:
510 An Elf file
511 Entry point 0x0
512 There are 2 program headers, starting at offset 16384
513
514 Program Headers:
515 Type Offset VirtAddr PhysAddr FileSiz MemSiz Flags Align
516 LOAD 0x0000000000001000 0x0000000000001000 0x0000000000001000 0x0000000000000f61 0x0000000000001000 R E 0x1000
517 LOAD 0x0000000000002000 0x0000000000002000 0x0000000000002000 0x000000000000115e 0x0000000000002000 R 0x1000
518
519 Section to Segment mapping:
520 Segment Sections...
521 00 .text
522 01 .strtab .symtab .shstrtab .ark_funcentry .ark_stackmaps
523 ------------------------------------------------------------------------------------------------------------------------------
524 Stub Elf file
525 Entry point 0x0
526 There are 2 program headers, starting at offset 770048
527
528 Program Headers:
529 Type Offset VirtAddr PhysAddr FileSiz MemSiz Flags Align
530 LOAD 0x0000000000001000 0x0000000000001000 0x0000000000001000 0x0000000000085020 0x0000000000086000 R E 0x1000
531 LOAD 0x0000000000087000 0x0000000000087000 0x0000000000087000 0x0000000000035bbc 0x0000000000036000 R 0x1000
532
533 Section to Segment mapping:
534 Segment Sections...
535 00 .text .ark_asmstub
536 01 .shstrtab .ark_funcentry .ark_stackmaps .ark_moduleinfo
537 */
PackELFSegment(std::ofstream & file)538 void ElfBuilder::PackELFSegment(std::ofstream &file)
539 {
540 llvm::ELF::Elf64_Off e_phoff = static_cast<uint64_t>(file.tellp());
541 long phoff = (long)offsetof(struct llvm::ELF::Elf64_Ehdr, e_phoff);
542 // write Elf32_Off e_phoff
543 file.seekp(phoff);
544 file.write(reinterpret_cast<char *>(&e_phoff), sizeof(e_phoff));
545 file.seekp(static_cast<long>(e_phoff));
546
547 int segNum = GetSegmentNum();
548 auto phdrs = std::make_unique<llvm::ELF::Elf64_Phdr []>(segNum);
549 std::map<ElfSecName, llvm::ELF::Elf64_Off> segmentToMaxOffset;
550 std::map<ElfSecName, llvm::ELF::Elf64_Off> segmentToMaxAddress;
551 std::set<ElfSecName> segments;
552 // SecName -> addr & size
553 const std::map<ElfSecName, std::pair<uint64_t, uint32_t>> §ions = GetFullSecInfo();
554 llvm::ELF::Elf64_Off offset = e_phoff;
555 for (auto &s: sections) {
556 ElfSection section = ElfSection(s.first);
557 if (!section.ShouldDumpToAOTFile()) {
558 continue;
559 }
560 auto it = sectionToSegment_.find(s.first);
561 ASSERT(it != sectionToSegment_.end());
562 ElfSecName segName = it->second;
563 segments.insert(segName);
564 if (segmentToMaxOffset.find(segName) == segmentToMaxOffset.end()) {
565 segmentToMaxOffset[segName] = 0;
566 }
567 segmentToMaxOffset[segName] =
568 std::max(segmentToMaxOffset[segName], sectionToShdr_[s.first].sh_offset + sectionToShdr_[s.first].sh_size);
569 segmentToMaxAddress[segName] =
570 std::max(segmentToMaxAddress[segName], sectionToShdr_[s.first].sh_addr + sectionToShdr_[s.first].sh_size);
571 offset = std::min(offset, sectionToShdr_[s.first].sh_offset);
572 }
573 int phdrIndex = 0;
574 llvm::ELF::Elf64_Addr addr = offset;
575 for (auto &it: segments) {
576 ElfSecName name = it;
577 phdrs[phdrIndex].p_align = PageSize();
578 phdrs[phdrIndex].p_type = llvm::ELF::PT_LOAD;
579 phdrs[phdrIndex].p_flags = GetPFlag(name);
580 offset = AlignUp(offset, PageSize());
581 phdrs[phdrIndex].p_offset = offset;
582 phdrs[phdrIndex].p_vaddr = addr % phdrs[phdrIndex].p_align == 0 ?
583 addr : (addr / phdrs[phdrIndex].p_align + 1) * phdrs[phdrIndex].p_align;
584 phdrs[phdrIndex].p_paddr = phdrs[phdrIndex].p_vaddr;
585
586 phdrs[phdrIndex].p_filesz = segmentToMaxOffset[name] - phdrs[phdrIndex].p_offset;
587 phdrs[phdrIndex].p_memsz = segmentToMaxAddress[name] - phdrs[phdrIndex].p_vaddr;
588 phdrs[phdrIndex].p_memsz = AlignUp(phdrs[phdrIndex].p_memsz, PageSize());
589 addr = phdrs[phdrIndex].p_vaddr + phdrs[phdrIndex].p_memsz;
590 offset += phdrs[phdrIndex].p_filesz;
591 ++phdrIndex;
592 }
593 file.write(reinterpret_cast<char *>(phdrs.get()), sizeof(llvm::ELF::Elf64_Phdr) * segNum);
594 }
595 } // namespace panda::ecmascript
596