1 /*
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 <openssl/sha.h>
20 #include <unordered_map>
21 #include <unordered_set>
22 
23 #include "base/casts.h"
24 #include "base/logging.h"
25 #include "base/stl_util.h"
26 #include "compiled_method.h"
27 #include "debug/elf_debug_writer.h"
28 #include "debug/method_debug_info.h"
29 #include "driver/compiler_options.h"
30 #include "elf.h"
31 #include "elf_builder.h"
32 #include "elf_utils.h"
33 #include "globals.h"
34 #include "leb128.h"
35 #include "linker/buffered_output_stream.h"
36 #include "linker/file_output_stream.h"
37 #include "thread-inl.h"
38 #include "thread_pool.h"
39 #include "utils.h"
40 
41 namespace art {
42 
43 // .eh_frame and .debug_frame are almost identical.
44 // Except for some minor formatting differences, the main difference
45 // is that .eh_frame is allocated within the running program because
46 // it is used by C++ exception handling (which we do not use so we
47 // can choose either).  C++ compilers generally tend to use .eh_frame
48 // because if they need it sometimes, they might as well always use it.
49 // Let's use .debug_frame because it is easier to strip or compress.
50 constexpr dwarf::CFIFormat kCFIFormat = dwarf::DW_DEBUG_FRAME_FORMAT;
51 
52 class DebugInfoTask : public Task {
53  public:
DebugInfoTask(InstructionSet isa,const InstructionSetFeatures * features,size_t rodata_section_size,size_t text_section_size,const ArrayRef<const debug::MethodDebugInfo> & method_infos)54   DebugInfoTask(InstructionSet isa,
55                 const InstructionSetFeatures* features,
56                 size_t rodata_section_size,
57                 size_t text_section_size,
58                 const ArrayRef<const debug::MethodDebugInfo>& method_infos)
59       : isa_(isa),
60         instruction_set_features_(features),
61         rodata_section_size_(rodata_section_size),
62         text_section_size_(text_section_size),
63         method_infos_(method_infos) {
64   }
65 
Run(Thread *)66   void Run(Thread*) {
67     result_ = debug::MakeMiniDebugInfo(isa_,
68                                        instruction_set_features_,
69                                        rodata_section_size_,
70                                        text_section_size_,
71                                        method_infos_);
72   }
73 
GetResult()74   std::vector<uint8_t>* GetResult() {
75     return &result_;
76   }
77 
78  private:
79   InstructionSet isa_;
80   const InstructionSetFeatures* instruction_set_features_;
81   size_t rodata_section_size_;
82   size_t text_section_size_;
83   const ArrayRef<const debug::MethodDebugInfo>& method_infos_;
84   std::vector<uint8_t> result_;
85 };
86 
87 template <typename ElfTypes>
88 class ElfWriterQuick FINAL : public ElfWriter {
89  public:
90   ElfWriterQuick(InstructionSet instruction_set,
91                  const InstructionSetFeatures* features,
92                  const CompilerOptions* compiler_options,
93                  File* elf_file);
94   ~ElfWriterQuick();
95 
96   void Start() OVERRIDE;
97   void PrepareDynamicSection(size_t rodata_size,
98                              size_t text_size,
99                              size_t bss_size,
100                              size_t bss_roots_offset) OVERRIDE;
101   void PrepareDebugInfo(const ArrayRef<const debug::MethodDebugInfo>& method_infos) OVERRIDE;
102   OutputStream* StartRoData() OVERRIDE;
103   void EndRoData(OutputStream* rodata) OVERRIDE;
104   OutputStream* StartText() OVERRIDE;
105   void EndText(OutputStream* text) OVERRIDE;
106   void WriteDynamicSection() OVERRIDE;
107   void WriteDebugInfo(const ArrayRef<const debug::MethodDebugInfo>& method_infos) OVERRIDE;
108   bool End() OVERRIDE;
109 
110   virtual OutputStream* GetStream() OVERRIDE;
111 
112   size_t GetLoadedSize() OVERRIDE;
113 
114   static void EncodeOatPatches(const std::vector<uintptr_t>& locations,
115                                std::vector<uint8_t>* buffer);
116 
117  private:
118   const InstructionSetFeatures* instruction_set_features_;
119   const CompilerOptions* const compiler_options_;
120   File* const elf_file_;
121   size_t rodata_size_;
122   size_t text_size_;
123   size_t bss_size_;
124   std::unique_ptr<BufferedOutputStream> output_stream_;
125   std::unique_ptr<ElfBuilder<ElfTypes>> builder_;
126   std::unique_ptr<DebugInfoTask> debug_info_task_;
127   std::unique_ptr<ThreadPool> debug_info_thread_pool_;
128 
129   void ComputeFileBuildId(uint8_t (*build_id)[ElfBuilder<ElfTypes>::kBuildIdLen]);
130 
131   DISALLOW_IMPLICIT_CONSTRUCTORS(ElfWriterQuick);
132 };
133 
CreateElfWriterQuick(InstructionSet instruction_set,const InstructionSetFeatures * features,const CompilerOptions * compiler_options,File * elf_file)134 std::unique_ptr<ElfWriter> CreateElfWriterQuick(InstructionSet instruction_set,
135                                                 const InstructionSetFeatures* features,
136                                                 const CompilerOptions* compiler_options,
137                                                 File* elf_file) {
138   if (Is64BitInstructionSet(instruction_set)) {
139     return MakeUnique<ElfWriterQuick<ElfTypes64>>(instruction_set,
140                                                   features,
141                                                   compiler_options,
142                                                   elf_file);
143   } else {
144     return MakeUnique<ElfWriterQuick<ElfTypes32>>(instruction_set,
145                                                   features,
146                                                   compiler_options,
147                                                   elf_file);
148   }
149 }
150 
151 template <typename ElfTypes>
ElfWriterQuick(InstructionSet instruction_set,const InstructionSetFeatures * features,const CompilerOptions * compiler_options,File * elf_file)152 ElfWriterQuick<ElfTypes>::ElfWriterQuick(InstructionSet instruction_set,
153                                          const InstructionSetFeatures* features,
154                                          const CompilerOptions* compiler_options,
155                                          File* elf_file)
156     : ElfWriter(),
157       instruction_set_features_(features),
158       compiler_options_(compiler_options),
159       elf_file_(elf_file),
160       rodata_size_(0u),
161       text_size_(0u),
162       bss_size_(0u),
163       output_stream_(MakeUnique<BufferedOutputStream>(MakeUnique<FileOutputStream>(elf_file))),
164       builder_(new ElfBuilder<ElfTypes>(instruction_set, features, output_stream_.get())) {}
165 
166 template <typename ElfTypes>
~ElfWriterQuick()167 ElfWriterQuick<ElfTypes>::~ElfWriterQuick() {}
168 
169 template <typename ElfTypes>
Start()170 void ElfWriterQuick<ElfTypes>::Start() {
171   builder_->Start();
172   if (compiler_options_->GetGenerateBuildId()) {
173     builder_->WriteBuildIdSection();
174   }
175 }
176 
177 template <typename ElfTypes>
PrepareDynamicSection(size_t rodata_size,size_t text_size,size_t bss_size,size_t bss_roots_offset)178 void ElfWriterQuick<ElfTypes>::PrepareDynamicSection(size_t rodata_size,
179                                                      size_t text_size,
180                                                      size_t bss_size,
181                                                      size_t bss_roots_offset) {
182   DCHECK_EQ(rodata_size_, 0u);
183   rodata_size_ = rodata_size;
184   DCHECK_EQ(text_size_, 0u);
185   text_size_ = text_size;
186   DCHECK_EQ(bss_size_, 0u);
187   bss_size_ = bss_size;
188   builder_->PrepareDynamicSection(elf_file_->GetPath(),
189                                   rodata_size_,
190                                   text_size_,
191                                   bss_size_,
192                                   bss_roots_offset);
193 }
194 
195 template <typename ElfTypes>
StartRoData()196 OutputStream* ElfWriterQuick<ElfTypes>::StartRoData() {
197   auto* rodata = builder_->GetRoData();
198   rodata->Start();
199   return rodata;
200 }
201 
202 template <typename ElfTypes>
EndRoData(OutputStream * rodata)203 void ElfWriterQuick<ElfTypes>::EndRoData(OutputStream* rodata) {
204   CHECK_EQ(builder_->GetRoData(), rodata);
205   builder_->GetRoData()->End();
206 }
207 
208 template <typename ElfTypes>
StartText()209 OutputStream* ElfWriterQuick<ElfTypes>::StartText() {
210   auto* text = builder_->GetText();
211   text->Start();
212   return text;
213 }
214 
215 template <typename ElfTypes>
EndText(OutputStream * text)216 void ElfWriterQuick<ElfTypes>::EndText(OutputStream* text) {
217   CHECK_EQ(builder_->GetText(), text);
218   builder_->GetText()->End();
219 }
220 
221 template <typename ElfTypes>
WriteDynamicSection()222 void ElfWriterQuick<ElfTypes>::WriteDynamicSection() {
223   if (bss_size_ != 0u) {
224     builder_->GetBss()->WriteNoBitsSection(bss_size_);
225   }
226   if (builder_->GetIsa() == kMips || builder_->GetIsa() == kMips64) {
227     builder_->WriteMIPSabiflagsSection();
228   }
229   builder_->WriteDynamicSection();
230 }
231 
232 template <typename ElfTypes>
PrepareDebugInfo(const ArrayRef<const debug::MethodDebugInfo> & method_infos)233 void ElfWriterQuick<ElfTypes>::PrepareDebugInfo(
234     const ArrayRef<const debug::MethodDebugInfo>& method_infos) {
235   if (!method_infos.empty() && compiler_options_->GetGenerateMiniDebugInfo()) {
236     // Prepare the mini-debug-info in background while we do other I/O.
237     Thread* self = Thread::Current();
238     debug_info_task_ = std::unique_ptr<DebugInfoTask>(
239         new DebugInfoTask(builder_->GetIsa(),
240                           instruction_set_features_,
241                           rodata_size_,
242                           text_size_,
243                           method_infos));
244     debug_info_thread_pool_ = std::unique_ptr<ThreadPool>(
245         new ThreadPool("Mini-debug-info writer", 1));
246     debug_info_thread_pool_->AddTask(self, debug_info_task_.get());
247     debug_info_thread_pool_->StartWorkers(self);
248   }
249 }
250 
251 template <typename ElfTypes>
WriteDebugInfo(const ArrayRef<const debug::MethodDebugInfo> & method_infos)252 void ElfWriterQuick<ElfTypes>::WriteDebugInfo(
253     const ArrayRef<const debug::MethodDebugInfo>& method_infos) {
254   if (!method_infos.empty()) {
255     if (compiler_options_->GetGenerateDebugInfo()) {
256       // Generate all the debug information we can.
257       debug::WriteDebugInfo(builder_.get(), method_infos, kCFIFormat, true /* write_oat_patches */);
258     }
259     if (compiler_options_->GetGenerateMiniDebugInfo()) {
260       // Wait for the mini-debug-info generation to finish and write it to disk.
261       Thread* self = Thread::Current();
262       DCHECK(debug_info_thread_pool_ != nullptr);
263       debug_info_thread_pool_->Wait(self, true, false);
264       builder_->WriteSection(".gnu_debugdata", debug_info_task_->GetResult());
265     }
266   }
267 }
268 
269 template <typename ElfTypes>
End()270 bool ElfWriterQuick<ElfTypes>::End() {
271   builder_->End();
272   if (compiler_options_->GetGenerateBuildId()) {
273     uint8_t build_id[ElfBuilder<ElfTypes>::kBuildIdLen];
274     ComputeFileBuildId(&build_id);
275     builder_->WriteBuildId(build_id);
276   }
277   return builder_->Good();
278 }
279 
280 template <typename ElfTypes>
ComputeFileBuildId(uint8_t (* build_id)[ElfBuilder<ElfTypes>::kBuildIdLen])281 void ElfWriterQuick<ElfTypes>::ComputeFileBuildId(
282     uint8_t (*build_id)[ElfBuilder<ElfTypes>::kBuildIdLen]) {
283   constexpr int kBufSize = 8192;
284   std::vector<char> buffer(kBufSize);
285   int64_t offset = 0;
286   SHA_CTX ctx;
287   SHA1_Init(&ctx);
288   while (true) {
289     int64_t bytes_read = elf_file_->Read(buffer.data(), kBufSize, offset);
290     CHECK_GE(bytes_read, 0);
291     if (bytes_read == 0) {
292       // End of file.
293       break;
294     }
295     SHA1_Update(&ctx, buffer.data(), bytes_read);
296     offset += bytes_read;
297   }
298   SHA1_Final(*build_id, &ctx);
299 }
300 
301 template <typename ElfTypes>
GetStream()302 OutputStream* ElfWriterQuick<ElfTypes>::GetStream() {
303   return builder_->GetStream();
304 }
305 
306 template <typename ElfTypes>
GetLoadedSize()307 size_t ElfWriterQuick<ElfTypes>::GetLoadedSize() {
308   return builder_->GetLoadedSize();
309 }
310 
311 // Explicit instantiations
312 template class ElfWriterQuick<ElfTypes32>;
313 template class ElfWriterQuick<ElfTypes64>;
314 
315 }  // namespace art
316