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