1 /* 2 * Copyright (C) 2016 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_debug_writer.h" 18 19 #include <vector> 20 21 #include "debug/dwarf/dwarf_constants.h" 22 #include "debug/elf_compilation_unit.h" 23 #include "debug/elf_debug_frame_writer.h" 24 #include "debug/elf_debug_info_writer.h" 25 #include "debug/elf_debug_line_writer.h" 26 #include "debug/elf_debug_loc_writer.h" 27 #include "debug/elf_gnu_debugdata_writer.h" 28 #include "debug/elf_symtab_writer.h" 29 #include "debug/method_debug_info.h" 30 #include "elf_builder.h" 31 #include "linker/vector_output_stream.h" 32 #include "utils/array_ref.h" 33 34 namespace art { 35 namespace debug { 36 37 template <typename ElfTypes> 38 void WriteDebugInfo(ElfBuilder<ElfTypes>* builder, 39 const ArrayRef<const MethodDebugInfo>& method_infos, 40 dwarf::CFIFormat cfi_format, 41 bool write_oat_patches) { 42 // Write .strtab and .symtab. 43 WriteDebugSymbols(builder, method_infos, true /* with_signature */); 44 45 // Write .debug_frame. 46 WriteCFISection(builder, method_infos, cfi_format, write_oat_patches); 47 48 // Group the methods into compilation units based on source file. 49 std::vector<ElfCompilationUnit> compilation_units; 50 const char* last_source_file = nullptr; 51 for (const MethodDebugInfo& mi : method_infos) { 52 if (mi.dex_file != nullptr) { 53 auto& dex_class_def = mi.dex_file->GetClassDef(mi.class_def_index); 54 const char* source_file = mi.dex_file->GetSourceFile(dex_class_def); 55 if (compilation_units.empty() || source_file != last_source_file) { 56 compilation_units.push_back(ElfCompilationUnit()); 57 } 58 ElfCompilationUnit& cu = compilation_units.back(); 59 cu.methods.push_back(&mi); 60 // All methods must have the same addressing mode otherwise the min/max below does not work. 61 DCHECK_EQ(cu.methods.front()->is_code_address_text_relative, mi.is_code_address_text_relative); 62 cu.is_code_address_text_relative = mi.is_code_address_text_relative; 63 cu.code_address = std::min(cu.code_address, mi.code_address); 64 cu.code_end = std::max(cu.code_end, mi.code_address + mi.code_size); 65 last_source_file = source_file; 66 } 67 } 68 69 // Write .debug_line section. 70 if (!compilation_units.empty()) { 71 ElfDebugLineWriter<ElfTypes> line_writer(builder); 72 line_writer.Start(); 73 for (auto& compilation_unit : compilation_units) { 74 line_writer.WriteCompilationUnit(compilation_unit); 75 } 76 line_writer.End(write_oat_patches); 77 } 78 79 // Write .debug_info section. 80 if (!compilation_units.empty()) { 81 ElfDebugInfoWriter<ElfTypes> info_writer(builder); 82 info_writer.Start(); 83 for (const auto& compilation_unit : compilation_units) { 84 ElfCompilationUnitWriter<ElfTypes> cu_writer(&info_writer); 85 cu_writer.Write(compilation_unit); 86 } 87 info_writer.End(write_oat_patches); 88 } 89 } 90 91 std::vector<uint8_t> MakeMiniDebugInfo( 92 InstructionSet isa, 93 const InstructionSetFeatures* features, 94 size_t rodata_size, 95 size_t text_size, 96 const ArrayRef<const MethodDebugInfo>& method_infos) { 97 if (Is64BitInstructionSet(isa)) { 98 return MakeMiniDebugInfoInternal<ElfTypes64>(isa, 99 features, 100 rodata_size, 101 text_size, 102 method_infos); 103 } else { 104 return MakeMiniDebugInfoInternal<ElfTypes32>(isa, 105 features, 106 rodata_size, 107 text_size, 108 method_infos); 109 } 110 } 111 112 template <typename ElfTypes> 113 static std::vector<uint8_t> WriteDebugElfFileForMethodsInternal( 114 InstructionSet isa, 115 const InstructionSetFeatures* features, 116 const ArrayRef<const MethodDebugInfo>& method_infos) { 117 std::vector<uint8_t> buffer; 118 buffer.reserve(KB); 119 VectorOutputStream out("Debug ELF file", &buffer); 120 std::unique_ptr<ElfBuilder<ElfTypes>> builder(new ElfBuilder<ElfTypes>(isa, features, &out)); 121 // No program headers since the ELF file is not linked and has no allocated sections. 122 builder->Start(false /* write_program_headers */); 123 WriteDebugInfo(builder.get(), 124 method_infos, 125 dwarf::DW_DEBUG_FRAME_FORMAT, 126 false /* write_oat_patches */); 127 builder->End(); 128 CHECK(builder->Good()); 129 return buffer; 130 } 131 132 std::vector<uint8_t> WriteDebugElfFileForMethods( 133 InstructionSet isa, 134 const InstructionSetFeatures* features, 135 const ArrayRef<const MethodDebugInfo>& method_infos) { 136 if (Is64BitInstructionSet(isa)) { 137 return WriteDebugElfFileForMethodsInternal<ElfTypes64>(isa, features, method_infos); 138 } else { 139 return WriteDebugElfFileForMethodsInternal<ElfTypes32>(isa, features, method_infos); 140 } 141 } 142 143 template <typename ElfTypes> 144 static std::vector<uint8_t> WriteDebugElfFileForClassesInternal( 145 InstructionSet isa, 146 const InstructionSetFeatures* features, 147 const ArrayRef<mirror::Class*>& types) 148 SHARED_REQUIRES(Locks::mutator_lock_) { 149 std::vector<uint8_t> buffer; 150 buffer.reserve(KB); 151 VectorOutputStream out("Debug ELF file", &buffer); 152 std::unique_ptr<ElfBuilder<ElfTypes>> builder(new ElfBuilder<ElfTypes>(isa, features, &out)); 153 // No program headers since the ELF file is not linked and has no allocated sections. 154 builder->Start(false /* write_program_headers */); 155 ElfDebugInfoWriter<ElfTypes> info_writer(builder.get()); 156 info_writer.Start(); 157 ElfCompilationUnitWriter<ElfTypes> cu_writer(&info_writer); 158 cu_writer.Write(types); 159 info_writer.End(false /* write_oat_patches */); 160 161 builder->End(); 162 CHECK(builder->Good()); 163 return buffer; 164 } 165 166 std::vector<uint8_t> WriteDebugElfFileForClasses(InstructionSet isa, 167 const InstructionSetFeatures* features, 168 const ArrayRef<mirror::Class*>& types) { 169 if (Is64BitInstructionSet(isa)) { 170 return WriteDebugElfFileForClassesInternal<ElfTypes64>(isa, features, types); 171 } else { 172 return WriteDebugElfFileForClassesInternal<ElfTypes32>(isa, features, types); 173 } 174 } 175 176 std::vector<MethodDebugInfo> MakeTrampolineInfos(const OatHeader& header) { 177 std::map<const char*, uint32_t> trampolines = { 178 { "interpreterToInterpreterBridge", header.GetInterpreterToInterpreterBridgeOffset() }, 179 { "interpreterToCompiledCodeBridge", header.GetInterpreterToCompiledCodeBridgeOffset() }, 180 { "jniDlsymLookup", header.GetJniDlsymLookupOffset() }, 181 { "quickGenericJniTrampoline", header.GetQuickGenericJniTrampolineOffset() }, 182 { "quickImtConflictTrampoline", header.GetQuickImtConflictTrampolineOffset() }, 183 { "quickResolutionTrampoline", header.GetQuickResolutionTrampolineOffset() }, 184 { "quickToInterpreterBridge", header.GetQuickToInterpreterBridgeOffset() }, 185 }; 186 std::vector<MethodDebugInfo> result; 187 for (const auto& it : trampolines) { 188 if (it.second != 0) { 189 MethodDebugInfo info = MethodDebugInfo(); 190 info.trampoline_name = it.first; 191 info.isa = header.GetInstructionSet(); 192 info.is_code_address_text_relative = true; 193 info.code_address = it.second - header.GetExecutableOffset(); 194 info.code_size = 0; // The symbol lasts until the next symbol. 195 result.push_back(std::move(info)); 196 } 197 } 198 return result; 199 } 200 201 // Explicit instantiations 202 template void WriteDebugInfo<ElfTypes32>( 203 ElfBuilder<ElfTypes32>* builder, 204 const ArrayRef<const MethodDebugInfo>& method_infos, 205 dwarf::CFIFormat cfi_format, 206 bool write_oat_patches); 207 template void WriteDebugInfo<ElfTypes64>( 208 ElfBuilder<ElfTypes64>* builder, 209 const ArrayRef<const MethodDebugInfo>& method_infos, 210 dwarf::CFIFormat cfi_format, 211 bool write_oat_patches); 212 213 } // namespace debug 214 } // namespace art 215
