blob: 4b416a0d4ffef989ba226d8e935f6eca38455bec [file] [log] [blame]
Brian Carlstrom7940e442013-07-12 13:46:57 -07001/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "elf_writer_quick.h"
18
19#include "base/logging.h"
20#include "base/unix_file/fd_file.h"
Brian Carlstromc6dfdac2013-08-26 18:57:31 -070021#include "buffered_output_stream.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070022#include "driver/compiler_driver.h"
Nicolas Geoffray50cfe742014-02-19 13:27:42 +000023#include "elf_utils.h"
Brian Carlstromc50d8e12013-07-23 22:35:16 -070024#include "file_output_stream.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070025#include "globals.h"
26#include "oat.h"
Brian Carlstromc50d8e12013-07-23 22:35:16 -070027#include "oat_writer.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070028#include "utils.h"
29
30namespace art {
31
Brian Carlstrom7940e442013-07-12 13:46:57 -070032bool ElfWriterQuick::Create(File* elf_file,
Ian Rogers3d504072014-03-01 09:16:49 -080033 OatWriter* oat_writer,
Brian Carlstrom7940e442013-07-12 13:46:57 -070034 const std::vector<const DexFile*>& dex_files,
35 const std::string& android_root,
36 bool is_host,
37 const CompilerDriver& driver) {
38 ElfWriterQuick elf_writer(driver, elf_file);
Brian Carlstromc50d8e12013-07-23 22:35:16 -070039 return elf_writer.Write(oat_writer, dex_files, android_root, is_host);
Brian Carlstrom7940e442013-07-12 13:46:57 -070040}
41
Ian Rogers3d504072014-03-01 09:16:49 -080042bool ElfWriterQuick::Write(OatWriter* oat_writer,
Brian Carlstrom7940e442013-07-12 13:46:57 -070043 const std::vector<const DexFile*>& dex_files_unused,
44 const std::string& android_root_unused,
45 bool is_host_unused) {
46 const bool debug = false;
47 // +-------------------------+
48 // | Elf32_Ehdr |
49 // +-------------------------+
50 // | Elf32_Phdr PHDR |
51 // | Elf32_Phdr LOAD R | .dynsym .dynstr .hash .rodata
52 // | Elf32_Phdr LOAD R X | .text
53 // | Elf32_Phdr LOAD RW | .dynamic
54 // | Elf32_Phdr DYNAMIC | .dynamic
55 // +-------------------------+
56 // | .dynsym |
57 // | Elf32_Sym STN_UNDEF |
58 // | Elf32_Sym oatdata |
59 // | Elf32_Sym oatexec |
60 // | Elf32_Sym oatlastword |
61 // +-------------------------+
62 // | .dynstr |
63 // | \0 |
64 // | oatdata\0 |
65 // | oatexec\0 |
66 // | oatlastword\0 |
67 // | boot.oat\0 |
68 // +-------------------------+
69 // | .hash |
70 // | Elf32_Word nbucket = 1 |
71 // | Elf32_Word nchain = 3 |
72 // | Elf32_Word bucket[0] = 0|
73 // | Elf32_Word chain[0] = 1|
74 // | Elf32_Word chain[1] = 2|
75 // | Elf32_Word chain[2] = 3|
76 // +-------------------------+
77 // | .rodata |
78 // | oatdata..oatexec-4 |
79 // +-------------------------+
80 // | .text |
81 // | oatexec..oatlastword |
82 // +-------------------------+
83 // | .dynamic |
84 // | Elf32_Dyn DT_SONAME |
85 // | Elf32_Dyn DT_HASH |
86 // | Elf32_Dyn DT_SYMTAB |
87 // | Elf32_Dyn DT_SYMENT |
88 // | Elf32_Dyn DT_STRTAB |
89 // | Elf32_Dyn DT_STRSZ |
90 // | Elf32_Dyn DT_NULL |
91 // +-------------------------+
92 // | .shstrtab |
93 // | \0 |
94 // | .dynamic\0 |
95 // | .dynsym\0 |
96 // | .dynstr\0 |
97 // | .hash\0 |
98 // | .rodata\0 |
99 // | .text\0 |
100 // | .shstrtab\0 |
101 // +-------------------------+
102 // | Elf32_Shdr NULL |
103 // | Elf32_Shdr .dynsym |
104 // | Elf32_Shdr .dynstr |
105 // | Elf32_Shdr .hash |
106 // | Elf32_Shdr .text |
107 // | Elf32_Shdr .rodata |
108 // | Elf32_Shdr .dynamic |
109 // | Elf32_Shdr .shstrtab |
110 // +-------------------------+
111
112 // phase 1: computing offsets
113 uint32_t expected_offset = 0;
114
115 // Elf32_Ehdr
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000116 expected_offset += sizeof(Elf32_Ehdr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700117
118 // PHDR
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000119 uint32_t phdr_alignment = sizeof(Elf32_Word);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700120 uint32_t phdr_offset = expected_offset;
121 const uint8_t PH_PHDR = 0;
122 const uint8_t PH_LOAD_R__ = 1;
123 const uint8_t PH_LOAD_R_X = 2;
124 const uint8_t PH_LOAD_RW_ = 3;
125 const uint8_t PH_DYNAMIC = 4;
126 const uint8_t PH_NUM = 5;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000127 uint32_t phdr_size = sizeof(Elf32_Phdr) * PH_NUM;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700128 expected_offset += phdr_size;
129 if (debug) {
130 LOG(INFO) << "phdr_offset=" << phdr_offset << std::hex << " " << phdr_offset;
131 LOG(INFO) << "phdr_size=" << phdr_size << std::hex << " " << phdr_size;
132 }
133
134 // .dynsym
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000135 uint32_t dynsym_alignment = sizeof(Elf32_Word);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700136 uint32_t dynsym_offset = expected_offset = RoundUp(expected_offset, dynsym_alignment);
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700137 const uint8_t SYM_UNDEF = 0; // aka STN_UNDEF
Brian Carlstrom7940e442013-07-12 13:46:57 -0700138 const uint8_t SYM_OATDATA = 1;
139 const uint8_t SYM_OATEXEC = 2;
140 const uint8_t SYM_OATLASTWORD = 3;
141 const uint8_t SYM_NUM = 4;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000142 uint32_t dynsym_size = sizeof(Elf32_Sym) * SYM_NUM;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700143 expected_offset += dynsym_size;
144 if (debug) {
145 LOG(INFO) << "dynsym_offset=" << dynsym_offset << std::hex << " " << dynsym_offset;
146 LOG(INFO) << "dynsym_size=" << dynsym_size << std::hex << " " << dynsym_size;
147 }
148
149 // .dynstr
150 uint32_t dynstr_alignment = 1;
151 uint32_t dynstr_offset = expected_offset = RoundUp(expected_offset, dynstr_alignment);
152 std::string dynstr;
153 dynstr += '\0';
154 uint32_t dynstr_oatdata_offset = dynstr.size();
155 dynstr += "oatdata";
156 dynstr += '\0';
157 uint32_t dynstr_oatexec_offset = dynstr.size();
158 dynstr += "oatexec";
159 dynstr += '\0';
160 uint32_t dynstr_oatlastword_offset = dynstr.size();
161 dynstr += "oatlastword";
162 dynstr += '\0';
163 uint32_t dynstr_soname_offset = dynstr.size();
164 std::string file_name(elf_file_->GetPath());
165 size_t directory_separator_pos = file_name.rfind('/');
166 if (directory_separator_pos != std::string::npos) {
167 file_name = file_name.substr(directory_separator_pos + 1);
168 }
169 dynstr += file_name;
170 dynstr += '\0';
171 uint32_t dynstr_size = dynstr.size();
172 expected_offset += dynstr_size;
173 if (debug) {
174 LOG(INFO) << "dynstr_offset=" << dynstr_offset << std::hex << " " << dynstr_offset;
175 LOG(INFO) << "dynstr_size=" << dynstr_size << std::hex << " " << dynstr_size;
176 }
177
178 // .hash
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000179 uint32_t hash_alignment = sizeof(Elf32_Word); // Even for 64-bit
Brian Carlstrom7940e442013-07-12 13:46:57 -0700180 uint32_t hash_offset = expected_offset = RoundUp(expected_offset, hash_alignment);
181 const uint8_t HASH_NBUCKET = 0;
182 const uint8_t HASH_NCHAIN = 1;
183 const uint8_t HASH_BUCKET0 = 2;
184 const uint8_t HASH_NUM = HASH_BUCKET0 + 1 + SYM_NUM;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000185 uint32_t hash_size = sizeof(Elf32_Word) * HASH_NUM;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700186 expected_offset += hash_size;
187 if (debug) {
188 LOG(INFO) << "hash_offset=" << hash_offset << std::hex << " " << hash_offset;
189 LOG(INFO) << "hash_size=" << hash_size << std::hex << " " << hash_size;
190 }
191
192 // .rodata
193 uint32_t oat_data_alignment = kPageSize;
194 uint32_t oat_data_offset = expected_offset = RoundUp(expected_offset, oat_data_alignment);
Ian Rogers3d504072014-03-01 09:16:49 -0800195 const OatHeader& oat_header = oat_writer->GetOatHeader();
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700196 CHECK(oat_header.IsValid());
197 uint32_t oat_data_size = oat_header.GetExecutableOffset();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700198 expected_offset += oat_data_size;
199 if (debug) {
200 LOG(INFO) << "oat_data_offset=" << oat_data_offset << std::hex << " " << oat_data_offset;
201 LOG(INFO) << "oat_data_size=" << oat_data_size << std::hex << " " << oat_data_size;
202 }
203
204 // .text
205 uint32_t oat_exec_alignment = kPageSize;
206 CHECK_ALIGNED(expected_offset, kPageSize);
207 uint32_t oat_exec_offset = expected_offset = RoundUp(expected_offset, oat_exec_alignment);
Ian Rogers3d504072014-03-01 09:16:49 -0800208 uint32_t oat_exec_size = oat_writer->GetSize() - oat_data_size;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700209 expected_offset += oat_exec_size;
Ian Rogers3d504072014-03-01 09:16:49 -0800210 CHECK_EQ(oat_data_offset + oat_writer->GetSize(), expected_offset);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700211 if (debug) {
212 LOG(INFO) << "oat_exec_offset=" << oat_exec_offset << std::hex << " " << oat_exec_offset;
213 LOG(INFO) << "oat_exec_size=" << oat_exec_size << std::hex << " " << oat_exec_size;
214 }
215
216 // .dynamic
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000217 // alignment would naturally be sizeof(Elf32_Word), but we want this in a new segment
Brian Carlstrom7940e442013-07-12 13:46:57 -0700218 uint32_t dynamic_alignment = kPageSize;
219 uint32_t dynamic_offset = expected_offset = RoundUp(expected_offset, dynamic_alignment);
220 const uint8_t DH_SONAME = 0;
221 const uint8_t DH_HASH = 1;
222 const uint8_t DH_SYMTAB = 2;
223 const uint8_t DH_SYMENT = 3;
224 const uint8_t DH_STRTAB = 4;
225 const uint8_t DH_STRSZ = 5;
226 const uint8_t DH_NULL = 6;
227 const uint8_t DH_NUM = 7;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000228 uint32_t dynamic_size = sizeof(Elf32_Dyn) * DH_NUM;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700229 expected_offset += dynamic_size;
230 if (debug) {
231 LOG(INFO) << "dynamic_offset=" << dynamic_offset << std::hex << " " << dynamic_offset;
232 LOG(INFO) << "dynamic_size=" << dynamic_size << std::hex << " " << dynamic_size;
233 }
234
235 // .shstrtab
236 uint32_t shstrtab_alignment = 1;
237 uint32_t shstrtab_offset = expected_offset = RoundUp(expected_offset, shstrtab_alignment);
238 std::string shstrtab;
239 shstrtab += '\0';
240 uint32_t shstrtab_dynamic_offset = shstrtab.size();
241 CHECK_EQ(1U, shstrtab_dynamic_offset);
242 shstrtab += ".dynamic";
243 shstrtab += '\0';
244 uint32_t shstrtab_dynsym_offset = shstrtab.size();
245 shstrtab += ".dynsym";
246 shstrtab += '\0';
247 uint32_t shstrtab_dynstr_offset = shstrtab.size();
248 shstrtab += ".dynstr";
249 shstrtab += '\0';
250 uint32_t shstrtab_hash_offset = shstrtab.size();
251 shstrtab += ".hash";
252 shstrtab += '\0';
253 uint32_t shstrtab_rodata_offset = shstrtab.size();
254 shstrtab += ".rodata";
255 shstrtab += '\0';
256 uint32_t shstrtab_text_offset = shstrtab.size();
257 shstrtab += ".text";
258 shstrtab += '\0';
259 uint32_t shstrtab_shstrtab_offset = shstrtab.size();
260 shstrtab += ".shstrtab";
261 shstrtab += '\0';
262 uint32_t shstrtab_size = shstrtab.size();
263 expected_offset += shstrtab_size;
264 if (debug) {
265 LOG(INFO) << "shstrtab_offset=" << shstrtab_offset << std::hex << " " << shstrtab_offset;
266 LOG(INFO) << "shstrtab_size=" << shstrtab_size << std::hex << " " << shstrtab_size;
267 }
268
269 // section headers (after all sections)
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000270 uint32_t shdr_alignment = sizeof(Elf32_Word);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700271 uint32_t shdr_offset = expected_offset = RoundUp(expected_offset, shdr_alignment);
272 const uint8_t SH_NULL = 0;
273 const uint8_t SH_DYNSYM = 1;
274 const uint8_t SH_DYNSTR = 2;
275 const uint8_t SH_HASH = 3;
276 const uint8_t SH_RODATA = 4;
277 const uint8_t SH_TEXT = 5;
278 const uint8_t SH_DYNAMIC = 6;
279 const uint8_t SH_SHSTRTAB = 7;
280 const uint8_t SH_NUM = 8;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000281 uint32_t shdr_size = sizeof(Elf32_Shdr) * SH_NUM;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700282 expected_offset += shdr_size;
283 if (debug) {
284 LOG(INFO) << "shdr_offset=" << shdr_offset << std::hex << " " << shdr_offset;
285 LOG(INFO) << "shdr_size=" << shdr_size << std::hex << " " << shdr_size;
286 }
287
288 // phase 2: initializing data
289
290 // Elf32_Ehdr
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000291 Elf32_Ehdr elf_header;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700292 memset(&elf_header, 0, sizeof(elf_header));
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000293 elf_header.e_ident[EI_MAG0] = ELFMAG0;
294 elf_header.e_ident[EI_MAG1] = ELFMAG1;
295 elf_header.e_ident[EI_MAG2] = ELFMAG2;
296 elf_header.e_ident[EI_MAG3] = ELFMAG3;
297 elf_header.e_ident[EI_CLASS] = ELFCLASS32;
298 elf_header.e_ident[EI_DATA] = ELFDATA2LSB;
299 elf_header.e_ident[EI_VERSION] = EV_CURRENT;
300 elf_header.e_ident[EI_OSABI] = ELFOSABI_LINUX;
301 elf_header.e_ident[EI_ABIVERSION] = 0;
302 elf_header.e_type = ET_DYN;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700303 switch (compiler_driver_->GetInstructionSet()) {
304 case kThumb2: {
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000305 elf_header.e_machine = EM_ARM;
306 elf_header.e_flags = EF_ARM_EABI_VER5;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700307 break;
308 }
309 case kX86: {
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000310 elf_header.e_machine = EM_386;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700311 elf_header.e_flags = 0;
312 break;
313 }
314 case kMips: {
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000315 elf_header.e_machine = EM_MIPS;
316 elf_header.e_flags = (EF_MIPS_NOREORDER |
317 EF_MIPS_PIC |
318 EF_MIPS_CPIC |
319 EF_MIPS_ABI_O32 |
320 EF_MIPS_ARCH_32R2);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700321 break;
322 }
323 case kArm:
324 default: {
325 LOG(FATAL) << "Unknown instruction set: " << compiler_driver_->GetInstructionSet();
326 break;
327 }
328 }
329 elf_header.e_version = 1;
330 elf_header.e_entry = 0;
331 elf_header.e_phoff = phdr_offset;
332 elf_header.e_shoff = shdr_offset;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000333 elf_header.e_ehsize = sizeof(Elf32_Ehdr);
334 elf_header.e_phentsize = sizeof(Elf32_Phdr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700335 elf_header.e_phnum = PH_NUM;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000336 elf_header.e_shentsize = sizeof(Elf32_Shdr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700337 elf_header.e_shnum = SH_NUM;
338 elf_header.e_shstrndx = SH_SHSTRTAB;
339
340 // PHDR
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000341 Elf32_Phdr program_headers[PH_NUM];
Brian Carlstrom7940e442013-07-12 13:46:57 -0700342 memset(&program_headers, 0, sizeof(program_headers));
343
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000344 program_headers[PH_PHDR].p_type = PT_PHDR;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700345 program_headers[PH_PHDR].p_offset = phdr_offset;
346 program_headers[PH_PHDR].p_vaddr = phdr_offset;
347 program_headers[PH_PHDR].p_paddr = phdr_offset;
348 program_headers[PH_PHDR].p_filesz = sizeof(program_headers);
349 program_headers[PH_PHDR].p_memsz = sizeof(program_headers);
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000350 program_headers[PH_PHDR].p_flags = PF_R;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700351 program_headers[PH_PHDR].p_align = phdr_alignment;
352
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000353 program_headers[PH_LOAD_R__].p_type = PT_LOAD;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700354 program_headers[PH_LOAD_R__].p_offset = 0;
355 program_headers[PH_LOAD_R__].p_vaddr = 0;
356 program_headers[PH_LOAD_R__].p_paddr = 0;
357 program_headers[PH_LOAD_R__].p_filesz = oat_data_offset + oat_data_size;
358 program_headers[PH_LOAD_R__].p_memsz = oat_data_offset + oat_data_size;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000359 program_headers[PH_LOAD_R__].p_flags = PF_R;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700360 program_headers[PH_LOAD_R__].p_align = oat_data_alignment;
361
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000362 program_headers[PH_LOAD_R_X].p_type = PT_LOAD;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700363 program_headers[PH_LOAD_R_X].p_offset = oat_exec_offset;
364 program_headers[PH_LOAD_R_X].p_vaddr = oat_exec_offset;
365 program_headers[PH_LOAD_R_X].p_paddr = oat_exec_offset;
366 program_headers[PH_LOAD_R_X].p_filesz = oat_exec_size;
367 program_headers[PH_LOAD_R_X].p_memsz = oat_exec_size;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000368 program_headers[PH_LOAD_R_X].p_flags = PF_R | PF_X;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700369 program_headers[PH_LOAD_R_X].p_align = oat_exec_alignment;
370
371 // TODO: PF_W for DYNAMIC is considered processor specific, do we need it?
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000372 program_headers[PH_LOAD_RW_].p_type = PT_LOAD;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700373 program_headers[PH_LOAD_RW_].p_offset = dynamic_offset;
374 program_headers[PH_LOAD_RW_].p_vaddr = dynamic_offset;
375 program_headers[PH_LOAD_RW_].p_paddr = dynamic_offset;
376 program_headers[PH_LOAD_RW_].p_filesz = dynamic_size;
377 program_headers[PH_LOAD_RW_].p_memsz = dynamic_size;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000378 program_headers[PH_LOAD_RW_].p_flags = PF_R | PF_W;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700379 program_headers[PH_LOAD_RW_].p_align = dynamic_alignment;
380
381 // TODO: PF_W for DYNAMIC is considered processor specific, do we need it?
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000382 program_headers[PH_DYNAMIC].p_type = PT_DYNAMIC;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700383 program_headers[PH_DYNAMIC].p_offset = dynamic_offset;
384 program_headers[PH_DYNAMIC].p_vaddr = dynamic_offset;
385 program_headers[PH_DYNAMIC].p_paddr = dynamic_offset;
386 program_headers[PH_DYNAMIC].p_filesz = dynamic_size;
387 program_headers[PH_DYNAMIC].p_memsz = dynamic_size;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000388 program_headers[PH_DYNAMIC].p_flags = PF_R | PF_W;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700389 program_headers[PH_DYNAMIC].p_align = dynamic_alignment;
390
391 // .dynsym
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000392 Elf32_Sym dynsym[SYM_NUM];
Brian Carlstrom7940e442013-07-12 13:46:57 -0700393 memset(&dynsym, 0, sizeof(dynsym));
394
395 dynsym[SYM_UNDEF].st_name = 0;
396 dynsym[SYM_UNDEF].st_value = 0;
397 dynsym[SYM_UNDEF].st_size = 0;
398 dynsym[SYM_UNDEF].st_info = 0;
399 dynsym[SYM_UNDEF].st_other = 0;
400 dynsym[SYM_UNDEF].st_shndx = 0;
401
402 dynsym[SYM_OATDATA].st_name = dynstr_oatdata_offset;
403 dynsym[SYM_OATDATA].st_value = oat_data_offset;
404 dynsym[SYM_OATDATA].st_size = oat_data_size;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000405 SetBindingAndType(&dynsym[SYM_OATDATA], STB_GLOBAL, STT_OBJECT);
406 dynsym[SYM_OATDATA].st_other = STV_DEFAULT;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700407 dynsym[SYM_OATDATA].st_shndx = SH_RODATA;
408
409 dynsym[SYM_OATEXEC].st_name = dynstr_oatexec_offset;
410 dynsym[SYM_OATEXEC].st_value = oat_exec_offset;
411 dynsym[SYM_OATEXEC].st_size = oat_exec_size;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000412 SetBindingAndType(&dynsym[SYM_OATEXEC], STB_GLOBAL, STT_OBJECT);
413 dynsym[SYM_OATEXEC].st_other = STV_DEFAULT;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700414 dynsym[SYM_OATEXEC].st_shndx = SH_TEXT;
415
416 dynsym[SYM_OATLASTWORD].st_name = dynstr_oatlastword_offset;
417 dynsym[SYM_OATLASTWORD].st_value = oat_exec_offset + oat_exec_size - 4;
418 dynsym[SYM_OATLASTWORD].st_size = 4;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000419 SetBindingAndType(&dynsym[SYM_OATLASTWORD], STB_GLOBAL, STT_OBJECT);
420 dynsym[SYM_OATLASTWORD].st_other = STV_DEFAULT;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700421 dynsym[SYM_OATLASTWORD].st_shndx = SH_TEXT;
422
423 // .dynstr initialized above as dynstr
424
425 // .hash
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000426 Elf32_Word hash[HASH_NUM]; // Note this is Elf32_Word even on 64-bit
Brian Carlstrom7940e442013-07-12 13:46:57 -0700427 hash[HASH_NBUCKET] = 1;
428 hash[HASH_NCHAIN] = SYM_NUM;
429 hash[HASH_BUCKET0] = SYM_OATDATA;
430 hash[HASH_BUCKET0 + 1 + SYM_UNDEF] = SYM_UNDEF;
431 hash[HASH_BUCKET0 + 1 + SYM_OATDATA] = SYM_OATEXEC;
432 hash[HASH_BUCKET0 + 1 + SYM_OATEXEC] = SYM_OATLASTWORD;
433 hash[HASH_BUCKET0 + 1 + SYM_OATLASTWORD] = SYM_UNDEF;
434
435 // .rodata and .text content come from oat_contents
436
437 // .dynamic
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000438 Elf32_Dyn dynamic_headers[DH_NUM];
Brian Carlstrom7940e442013-07-12 13:46:57 -0700439 memset(&dynamic_headers, 0, sizeof(dynamic_headers));
440
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000441 dynamic_headers[DH_SONAME].d_tag = DT_SONAME;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700442 dynamic_headers[DH_SONAME].d_un.d_val = dynstr_soname_offset;
443
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000444 dynamic_headers[DH_HASH].d_tag = DT_HASH;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700445 dynamic_headers[DH_HASH].d_un.d_ptr = hash_offset;
446
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000447 dynamic_headers[DH_SYMTAB].d_tag = DT_SYMTAB;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700448 dynamic_headers[DH_SYMTAB].d_un.d_ptr = dynsym_offset;
449
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000450 dynamic_headers[DH_SYMENT].d_tag = DT_SYMENT;
451 dynamic_headers[DH_SYMENT].d_un.d_val = sizeof(Elf32_Sym);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700452
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000453 dynamic_headers[DH_STRTAB].d_tag = DT_STRTAB;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700454 dynamic_headers[DH_STRTAB].d_un.d_ptr = dynstr_offset;
455
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000456 dynamic_headers[DH_STRSZ].d_tag = DT_STRSZ;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700457 dynamic_headers[DH_STRSZ].d_un.d_val = dynstr_size;
458
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000459 dynamic_headers[DH_NULL].d_tag = DT_NULL;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700460 dynamic_headers[DH_NULL].d_un.d_val = 0;
461
462 // .shstrtab initialized above as shstrtab
463
464 // section headers (after all sections)
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000465 Elf32_Shdr section_headers[SH_NUM];
Brian Carlstrom7940e442013-07-12 13:46:57 -0700466 memset(&section_headers, 0, sizeof(section_headers));
467
468 section_headers[SH_NULL].sh_name = 0;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000469 section_headers[SH_NULL].sh_type = SHT_NULL;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700470 section_headers[SH_NULL].sh_flags = 0;
471 section_headers[SH_NULL].sh_addr = 0;
472 section_headers[SH_NULL].sh_offset = 0;
473 section_headers[SH_NULL].sh_size = 0;
474 section_headers[SH_NULL].sh_link = 0;
475 section_headers[SH_NULL].sh_info = 0;
476 section_headers[SH_NULL].sh_addralign = 0;
477 section_headers[SH_NULL].sh_entsize = 0;
478
479 section_headers[SH_DYNSYM].sh_name = shstrtab_dynsym_offset;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000480 section_headers[SH_DYNSYM].sh_type = SHT_DYNSYM;
481 section_headers[SH_DYNSYM].sh_flags = SHF_ALLOC;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700482 section_headers[SH_DYNSYM].sh_addr = dynsym_offset;
483 section_headers[SH_DYNSYM].sh_offset = dynsym_offset;
484 section_headers[SH_DYNSYM].sh_size = dynsym_size;
485 section_headers[SH_DYNSYM].sh_link = SH_DYNSTR;
486 section_headers[SH_DYNSYM].sh_info = 1; // 1 because we have not STB_LOCAL symbols
487 section_headers[SH_DYNSYM].sh_addralign = dynsym_alignment;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000488 section_headers[SH_DYNSYM].sh_entsize = sizeof(Elf32_Sym);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700489
490 section_headers[SH_DYNSTR].sh_name = shstrtab_dynstr_offset;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000491 section_headers[SH_DYNSTR].sh_type = SHT_STRTAB;
492 section_headers[SH_DYNSTR].sh_flags = SHF_ALLOC;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700493 section_headers[SH_DYNSTR].sh_addr = dynstr_offset;
494 section_headers[SH_DYNSTR].sh_offset = dynstr_offset;
495 section_headers[SH_DYNSTR].sh_size = dynstr_size;
496 section_headers[SH_DYNSTR].sh_link = 0;
497 section_headers[SH_DYNSTR].sh_info = 0;
498 section_headers[SH_DYNSTR].sh_addralign = dynstr_alignment;
499 section_headers[SH_DYNSTR].sh_entsize = 0;
500
501 section_headers[SH_HASH].sh_name = shstrtab_hash_offset;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000502 section_headers[SH_HASH].sh_type = SHT_HASH;
503 section_headers[SH_HASH].sh_flags = SHF_ALLOC;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700504 section_headers[SH_HASH].sh_addr = hash_offset;
505 section_headers[SH_HASH].sh_offset = hash_offset;
506 section_headers[SH_HASH].sh_size = hash_size;
507 section_headers[SH_HASH].sh_link = SH_DYNSYM;
508 section_headers[SH_HASH].sh_info = 0;
509 section_headers[SH_HASH].sh_addralign = hash_alignment;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000510 section_headers[SH_HASH].sh_entsize = sizeof(Elf32_Word); // This is Elf32_Word even on 64-bit
Brian Carlstrom7940e442013-07-12 13:46:57 -0700511
512 section_headers[SH_RODATA].sh_name = shstrtab_rodata_offset;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000513 section_headers[SH_RODATA].sh_type = SHT_PROGBITS;
514 section_headers[SH_RODATA].sh_flags = SHF_ALLOC;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700515 section_headers[SH_RODATA].sh_addr = oat_data_offset;
516 section_headers[SH_RODATA].sh_offset = oat_data_offset;
517 section_headers[SH_RODATA].sh_size = oat_data_size;
518 section_headers[SH_RODATA].sh_link = 0;
519 section_headers[SH_RODATA].sh_info = 0;
520 section_headers[SH_RODATA].sh_addralign = oat_data_alignment;
521 section_headers[SH_RODATA].sh_entsize = 0;
522
523 section_headers[SH_TEXT].sh_name = shstrtab_text_offset;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000524 section_headers[SH_TEXT].sh_type = SHT_PROGBITS;
525 section_headers[SH_TEXT].sh_flags = SHF_ALLOC | SHF_EXECINSTR;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700526 section_headers[SH_TEXT].sh_addr = oat_exec_offset;
527 section_headers[SH_TEXT].sh_offset = oat_exec_offset;
528 section_headers[SH_TEXT].sh_size = oat_exec_size;
529 section_headers[SH_TEXT].sh_link = 0;
530 section_headers[SH_TEXT].sh_info = 0;
531 section_headers[SH_TEXT].sh_addralign = oat_exec_alignment;
532 section_headers[SH_TEXT].sh_entsize = 0;
533
534 // TODO: SHF_WRITE for .dynamic is considered processor specific, do we need it?
535 section_headers[SH_DYNAMIC].sh_name = shstrtab_dynamic_offset;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000536 section_headers[SH_DYNAMIC].sh_type = SHT_DYNAMIC;
537 section_headers[SH_DYNAMIC].sh_flags = SHF_WRITE | SHF_ALLOC;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700538 section_headers[SH_DYNAMIC].sh_addr = dynamic_offset;
539 section_headers[SH_DYNAMIC].sh_offset = dynamic_offset;
540 section_headers[SH_DYNAMIC].sh_size = dynamic_size;
541 section_headers[SH_DYNAMIC].sh_link = SH_DYNSTR;
542 section_headers[SH_DYNAMIC].sh_info = 0;
543 section_headers[SH_DYNAMIC].sh_addralign = dynamic_alignment;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000544 section_headers[SH_DYNAMIC].sh_entsize = sizeof(Elf32_Dyn);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700545
546 section_headers[SH_SHSTRTAB].sh_name = shstrtab_shstrtab_offset;
Nicolas Geoffray50cfe742014-02-19 13:27:42 +0000547 section_headers[SH_SHSTRTAB].sh_type = SHT_STRTAB;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700548 section_headers[SH_SHSTRTAB].sh_flags = 0;
549 section_headers[SH_SHSTRTAB].sh_addr = shstrtab_offset;
550 section_headers[SH_SHSTRTAB].sh_offset = shstrtab_offset;
551 section_headers[SH_SHSTRTAB].sh_size = shstrtab_size;
552 section_headers[SH_SHSTRTAB].sh_link = 0;
553 section_headers[SH_SHSTRTAB].sh_info = 0;
554 section_headers[SH_SHSTRTAB].sh_addralign = shstrtab_alignment;
555 section_headers[SH_SHSTRTAB].sh_entsize = 0;
556
557 // phase 3: writing file
558
559 // Elf32_Ehdr
560 if (!elf_file_->WriteFully(&elf_header, sizeof(elf_header))) {
561 PLOG(ERROR) << "Failed to write ELF header for " << elf_file_->GetPath();
562 return false;
563 }
564
565 // PHDR
566 if (static_cast<off_t>(phdr_offset) != lseek(elf_file_->Fd(), 0, SEEK_CUR)) {
567 PLOG(ERROR) << "Failed to be at expected ELF program header offset phdr_offset "
568 << " for " << elf_file_->GetPath();
569 return false;
570 }
571 if (!elf_file_->WriteFully(program_headers, sizeof(program_headers))) {
572 PLOG(ERROR) << "Failed to write ELF program headers for " << elf_file_->GetPath();
573 return false;
574 }
575
576 // .dynsym
577 DCHECK_LE(phdr_offset + phdr_size, dynsym_offset);
578 if (static_cast<off_t>(dynsym_offset) != lseek(elf_file_->Fd(), dynsym_offset, SEEK_SET)) {
579 PLOG(ERROR) << "Failed to seek to .dynsym offset location " << dynsym_offset
580 << " for " << elf_file_->GetPath();
581 return false;
582 }
583 if (!elf_file_->WriteFully(dynsym, sizeof(dynsym))) {
584 PLOG(ERROR) << "Failed to write .dynsym for " << elf_file_->GetPath();
585 return false;
586 }
587
588 // .dynstr
589 DCHECK_LE(dynsym_offset + dynsym_size, dynstr_offset);
590 if (static_cast<off_t>(dynstr_offset) != lseek(elf_file_->Fd(), dynstr_offset, SEEK_SET)) {
591 PLOG(ERROR) << "Failed to seek to .dynstr offset " << dynstr_offset
592 << " for " << elf_file_->GetPath();
593 return false;
594 }
Mathieu Chartiere2be9da2013-08-26 11:38:54 -0700595 if (!elf_file_->WriteFully(&dynstr[0], dynstr_size)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700596 PLOG(ERROR) << "Failed to write .dynsym for " << elf_file_->GetPath();
597 return false;
598 }
599
600 // .hash
601 DCHECK_LE(dynstr_offset + dynstr_size, hash_offset);
602 if (static_cast<off_t>(hash_offset) != lseek(elf_file_->Fd(), hash_offset, SEEK_SET)) {
603 PLOG(ERROR) << "Failed to seek to .hash offset " << hash_offset
604 << " for " << elf_file_->GetPath();
605 return false;
606 }
607 if (!elf_file_->WriteFully(hash, sizeof(hash))) {
608 PLOG(ERROR) << "Failed to write .dynsym for " << elf_file_->GetPath();
609 return false;
610 }
611
612 // .rodata .text
613 DCHECK_LE(hash_offset + hash_size, oat_data_offset);
614 if (static_cast<off_t>(oat_data_offset) != lseek(elf_file_->Fd(), oat_data_offset, SEEK_SET)) {
615 PLOG(ERROR) << "Failed to seek to .rodata offset " << oat_data_offset
616 << " for " << elf_file_->GetPath();
617 return false;
618 }
Brian Carlstromc6dfdac2013-08-26 18:57:31 -0700619 BufferedOutputStream output_stream(new FileOutputStream(elf_file_));
Ian Rogers3d504072014-03-01 09:16:49 -0800620 if (!oat_writer->Write(&output_stream)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700621 PLOG(ERROR) << "Failed to write .rodata and .text for " << elf_file_->GetPath();
622 return false;
623 }
624
625 // .dynamic
Ian Rogers3d504072014-03-01 09:16:49 -0800626 DCHECK_LE(oat_data_offset + oat_writer->GetSize(), dynamic_offset);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700627 if (static_cast<off_t>(dynamic_offset) != lseek(elf_file_->Fd(), dynamic_offset, SEEK_SET)) {
628 PLOG(ERROR) << "Failed to seek to .dynamic offset " << dynamic_offset
629 << " for " << elf_file_->GetPath();
630 return false;
631 }
632 if (!elf_file_->WriteFully(&dynamic_headers[0], dynamic_size)) {
633 PLOG(ERROR) << "Failed to write .dynamic for " << elf_file_->GetPath();
634 return false;
635 }
636
637 // .shstrtab
638 DCHECK_LE(dynamic_offset + dynamic_size, shstrtab_offset);
639 if (static_cast<off_t>(shstrtab_offset) != lseek(elf_file_->Fd(), shstrtab_offset, SEEK_SET)) {
640 PLOG(ERROR) << "Failed to seek to .shstrtab offset " << shstrtab_offset
641 << " for " << elf_file_->GetPath();
642 return false;
643 }
644 if (!elf_file_->WriteFully(&shstrtab[0], shstrtab_size)) {
645 PLOG(ERROR) << "Failed to write .shstrtab for " << elf_file_->GetPath();
646 return false;
647 }
648
649 // section headers (after all sections)
650 DCHECK_LE(shstrtab_offset + shstrtab_size, shdr_offset);
651 if (static_cast<off_t>(shdr_offset) != lseek(elf_file_->Fd(), shdr_offset, SEEK_SET)) {
652 PLOG(ERROR) << "Failed to seek to ELF section headers offset " << shdr_offset
653 << " for " << elf_file_->GetPath();
654 return false;
655 }
656 if (!elf_file_->WriteFully(section_headers, sizeof(section_headers))) {
657 PLOG(ERROR) << "Failed to write ELF section headers for " << elf_file_->GetPath();
658 return false;
659 }
660
Anwar Ghuloum87183592013-08-14 12:12:19 -0700661 VLOG(compiler) << "ELF file written successfully: " << elf_file_->GetPath();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700662 return true;
663}
664
665} // namespace art