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: 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 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 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> 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> 162 ElfWriterQuick<ElfTypes>::~ElfWriterQuick() {} 163 164 template <typename ElfTypes> 165 void ElfWriterQuick<ElfTypes>::Start() { 166 builder_->Start(); 167 } 168 169 template <typename ElfTypes> 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> 183 OutputStream* ElfWriterQuick<ElfTypes>::StartRoData() { 184 auto* rodata = builder_->GetRoData(); 185 rodata->Start(); 186 return rodata; 187 } 188 189 template <typename ElfTypes> 190 void ElfWriterQuick<ElfTypes>::EndRoData(OutputStream* rodata) { 191 CHECK_EQ(builder_->GetRoData(), rodata); 192 builder_->GetRoData()->End(); 193 } 194 195 template <typename ElfTypes> 196 OutputStream* ElfWriterQuick<ElfTypes>::StartText() { 197 auto* text = builder_->GetText(); 198 text->Start(); 199 return text; 200 } 201 202 template <typename ElfTypes> 203 void ElfWriterQuick<ElfTypes>::EndText(OutputStream* text) { 204 CHECK_EQ(builder_->GetText(), text); 205 builder_->GetText()->End(); 206 } 207 208 template <typename ElfTypes> 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> 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> 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> 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> 268 bool ElfWriterQuick<ElfTypes>::End() { 269 builder_->End(); 270 271 return builder_->Good(); 272 } 273 274 template <typename ElfTypes> 275 OutputStream* ElfWriterQuick<ElfTypes>::GetStream() { 276 return builder_->GetStream(); 277 } 278 279 template <typename ElfTypes> 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
