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: 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 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 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 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> 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> 167 ElfWriterQuick<ElfTypes>::~ElfWriterQuick() {} 168 169 template <typename ElfTypes> 170 void ElfWriterQuick<ElfTypes>::Start() { 171 builder_->Start(); 172 if (compiler_options_->GetGenerateBuildId()) { 173 builder_->WriteBuildIdSection(); 174 } 175 } 176 177 template <typename ElfTypes> 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> 196 OutputStream* ElfWriterQuick<ElfTypes>::StartRoData() { 197 auto* rodata = builder_->GetRoData(); 198 rodata->Start(); 199 return rodata; 200 } 201 202 template <typename ElfTypes> 203 void ElfWriterQuick<ElfTypes>::EndRoData(OutputStream* rodata) { 204 CHECK_EQ(builder_->GetRoData(), rodata); 205 builder_->GetRoData()->End(); 206 } 207 208 template <typename ElfTypes> 209 OutputStream* ElfWriterQuick<ElfTypes>::StartText() { 210 auto* text = builder_->GetText(); 211 text->Start(); 212 return text; 213 } 214 215 template <typename ElfTypes> 216 void ElfWriterQuick<ElfTypes>::EndText(OutputStream* text) { 217 CHECK_EQ(builder_->GetText(), text); 218 builder_->GetText()->End(); 219 } 220 221 template <typename ElfTypes> 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> 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> 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> 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> 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> 302 OutputStream* ElfWriterQuick<ElfTypes>::GetStream() { 303 return builder_->GetStream(); 304 } 305 306 template <typename ElfTypes> 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
