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 "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-current-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: 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 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 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 PrepareDynamicSection(size_t rodata_size, 97 size_t text_size, 98 size_t bss_size, 99 size_t bss_methods_offset, 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 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 std::make_unique<ElfWriterQuick<ElfTypes64>>(instruction_set, 140 features, 141 compiler_options, 142 elf_file); 143 } else { 144 return std::make_unique<ElfWriterQuick<ElfTypes32>>(instruction_set, 145 features, 146 compiler_options, 147 elf_file); 148 } 149 } 150 151 template <typename ElfTypes> 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_( 164 std::make_unique<BufferedOutputStream>(std::make_unique<FileOutputStream>(elf_file))), 165 builder_(new ElfBuilder<ElfTypes>(instruction_set, features, output_stream_.get())) {} 166 167 template <typename ElfTypes> 168 ElfWriterQuick<ElfTypes>::~ElfWriterQuick() {} 169 170 template <typename ElfTypes> 171 void ElfWriterQuick<ElfTypes>::Start() { 172 builder_->Start(); 173 if (compiler_options_->GetGenerateBuildId()) { 174 builder_->WriteBuildIdSection(); 175 } 176 } 177 178 template <typename ElfTypes> 179 void ElfWriterQuick<ElfTypes>::PrepareDynamicSection(size_t rodata_size, 180 size_t text_size, 181 size_t bss_size, 182 size_t bss_methods_offset, 183 size_t bss_roots_offset) { 184 DCHECK_EQ(rodata_size_, 0u); 185 rodata_size_ = rodata_size; 186 DCHECK_EQ(text_size_, 0u); 187 text_size_ = text_size; 188 DCHECK_EQ(bss_size_, 0u); 189 bss_size_ = bss_size; 190 builder_->PrepareDynamicSection(elf_file_->GetPath(), 191 rodata_size_, 192 text_size_, 193 bss_size_, 194 bss_methods_offset, 195 bss_roots_offset); 196 } 197 198 template <typename ElfTypes> 199 OutputStream* ElfWriterQuick<ElfTypes>::StartRoData() { 200 auto* rodata = builder_->GetRoData(); 201 rodata->Start(); 202 return rodata; 203 } 204 205 template <typename ElfTypes> 206 void ElfWriterQuick<ElfTypes>::EndRoData(OutputStream* rodata) { 207 CHECK_EQ(builder_->GetRoData(), rodata); 208 builder_->GetRoData()->End(); 209 } 210 211 template <typename ElfTypes> 212 OutputStream* ElfWriterQuick<ElfTypes>::StartText() { 213 auto* text = builder_->GetText(); 214 text->Start(); 215 return text; 216 } 217 218 template <typename ElfTypes> 219 void ElfWriterQuick<ElfTypes>::EndText(OutputStream* text) { 220 CHECK_EQ(builder_->GetText(), text); 221 builder_->GetText()->End(); 222 } 223 224 template <typename ElfTypes> 225 void ElfWriterQuick<ElfTypes>::WriteDynamicSection() { 226 if (bss_size_ != 0u) { 227 builder_->GetBss()->WriteNoBitsSection(bss_size_); 228 } 229 if (builder_->GetIsa() == kMips || builder_->GetIsa() == kMips64) { 230 builder_->WriteMIPSabiflagsSection(); 231 } 232 builder_->WriteDynamicSection(); 233 } 234 235 template <typename ElfTypes> 236 void ElfWriterQuick<ElfTypes>::PrepareDebugInfo( 237 const ArrayRef<const debug::MethodDebugInfo>& method_infos) { 238 if (!method_infos.empty() && compiler_options_->GetGenerateMiniDebugInfo()) { 239 // Prepare the mini-debug-info in background while we do other I/O. 240 Thread* self = Thread::Current(); 241 debug_info_task_ = std::unique_ptr<DebugInfoTask>( 242 new DebugInfoTask(builder_->GetIsa(), 243 instruction_set_features_, 244 rodata_size_, 245 text_size_, 246 method_infos)); 247 debug_info_thread_pool_ = std::unique_ptr<ThreadPool>( 248 new ThreadPool("Mini-debug-info writer", 1)); 249 debug_info_thread_pool_->AddTask(self, debug_info_task_.get()); 250 debug_info_thread_pool_->StartWorkers(self); 251 } 252 } 253 254 template <typename ElfTypes> 255 void ElfWriterQuick<ElfTypes>::WriteDebugInfo( 256 const ArrayRef<const debug::MethodDebugInfo>& method_infos) { 257 if (!method_infos.empty()) { 258 if (compiler_options_->GetGenerateDebugInfo()) { 259 // Generate all the debug information we can. 260 debug::WriteDebugInfo(builder_.get(), method_infos, kCFIFormat, true /* write_oat_patches */); 261 } 262 if (compiler_options_->GetGenerateMiniDebugInfo()) { 263 // Wait for the mini-debug-info generation to finish and write it to disk. 264 Thread* self = Thread::Current(); 265 DCHECK(debug_info_thread_pool_ != nullptr); 266 debug_info_thread_pool_->Wait(self, true, false); 267 builder_->WriteSection(".gnu_debugdata", debug_info_task_->GetResult()); 268 } 269 } 270 } 271 272 template <typename ElfTypes> 273 bool ElfWriterQuick<ElfTypes>::End() { 274 builder_->End(); 275 if (compiler_options_->GetGenerateBuildId()) { 276 uint8_t build_id[ElfBuilder<ElfTypes>::kBuildIdLen]; 277 ComputeFileBuildId(&build_id); 278 builder_->WriteBuildId(build_id); 279 } 280 return builder_->Good(); 281 } 282 283 template <typename ElfTypes> 284 void ElfWriterQuick<ElfTypes>::ComputeFileBuildId( 285 uint8_t (*build_id)[ElfBuilder<ElfTypes>::kBuildIdLen]) { 286 constexpr int kBufSize = 8192; 287 std::vector<char> buffer(kBufSize); 288 int64_t offset = 0; 289 SHA_CTX ctx; 290 SHA1_Init(&ctx); 291 while (true) { 292 int64_t bytes_read = elf_file_->Read(buffer.data(), kBufSize, offset); 293 CHECK_GE(bytes_read, 0); 294 if (bytes_read == 0) { 295 // End of file. 296 break; 297 } 298 SHA1_Update(&ctx, buffer.data(), bytes_read); 299 offset += bytes_read; 300 } 301 SHA1_Final(*build_id, &ctx); 302 } 303 304 template <typename ElfTypes> 305 OutputStream* ElfWriterQuick<ElfTypes>::GetStream() { 306 return builder_->GetStream(); 307 } 308 309 template <typename ElfTypes> 310 size_t ElfWriterQuick<ElfTypes>::GetLoadedSize() { 311 return builder_->GetLoadedSize(); 312 } 313 314 // Explicit instantiations 315 template class ElfWriterQuick<ElfTypes32>; 316 template class ElfWriterQuick<ElfTypes64>; 317 318 } // namespace art 319
