From 68004c84d6b852cfd4096cd211d2f8d3ff1d9f48 Mon Sep 17 00:00:00 2001 From: mmentovai Date: Fri, 28 Sep 2007 18:14:48 +0000 Subject: [PATCH] Solaris version of symbol dumper (#207). Patch by Alfred Peng. r=me http://groups.google.com/group/google-breakpad-dev/browse_thread/thread/e4cbdbf7ddaf7f51 git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@218 4c0a9323-5329-0410-9bdc-e9ce6186880e --- Makefile.am | 22 +- Makefile.in | 22 +- src/client/linux/handler/Makefile | 2 +- src/client/solaris/handler/Makefile | 1 + src/common/linux/dump_symbols.cc | 2 +- src/common/linux/file_id.cc | 2 +- src/common/{linux => }/md5.c | 2 +- src/common/{linux => }/md5.h | 6 +- src/common/solaris/dump_symbols.cc | 587 ++++++++++++++++++ src/common/solaris/dump_symbols.h | 49 ++ src/common/solaris/file_id.cc | 13 +- src/tools/linux/dump_syms/Makefile | 2 +- src/tools/solaris/dump_syms/Makefile | 64 ++ src/tools/solaris/dump_syms/dump_syms.cc | 54 ++ src/tools/solaris/dump_syms/run_regtest.sh | 51 ++ .../dump_syms/testdata/dump_syms_regtest.cc | 64 ++ .../dump_syms/testdata/dump_syms_regtest.o | Bin 0 -> 14204 bytes .../testdata/dump_syms_regtest.stabs | 129 ++++ .../dump_syms/testdata/dump_syms_regtest.sym | 33 + 19 files changed, 1078 insertions(+), 27 deletions(-) rename src/common/{linux => }/md5.c (99%) rename src/common/{linux => }/md5.h (84%) create mode 100644 src/common/solaris/dump_symbols.cc create mode 100644 src/common/solaris/dump_symbols.h create mode 100644 src/tools/solaris/dump_syms/Makefile create mode 100644 src/tools/solaris/dump_syms/dump_syms.cc create mode 100644 src/tools/solaris/dump_syms/run_regtest.sh create mode 100644 src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc create mode 100644 src/tools/solaris/dump_syms/testdata/dump_syms_regtest.o create mode 100644 src/tools/solaris/dump_syms/testdata/dump_syms_regtest.stabs create mode 100644 src/tools/solaris/dump_syms/testdata/dump_syms_regtest.sym diff --git a/Makefile.am b/Makefile.am index 9986560f..2edfd94e 100644 --- a/Makefile.am +++ b/Makefile.am @@ -61,20 +61,21 @@ src_libbreakpad_la_SOURCES = \ src/google_breakpad/processor/minidump.h \ src/google_breakpad/processor/minidump_processor.h \ src/google_breakpad/processor/process_state.h \ + src/google_breakpad/processor/source_line_resolver_interface.h \ src/google_breakpad/processor/stack_frame.h \ src/google_breakpad/processor/stack_frame_cpu.h \ src/google_breakpad/processor/stackwalker.h \ src/google_breakpad/processor/symbol_supplier.h \ src/google_breakpad/processor/system_info.h \ - src/processor/address_map.h \ src/processor/address_map-inl.h \ + src/processor/address_map.h \ src/processor/basic_code_module.h \ src/processor/basic_code_modules.cc \ src/processor/basic_code_modules.h \ src/processor/basic_source_line_resolver.cc \ src/processor/call_stack.cc \ - src/processor/contained_range_map.h \ src/processor/contained_range_map-inl.h \ + src/processor/contained_range_map.h \ src/processor/linked_ptr.h \ src/processor/logging.h \ src/processor/logging.cc \ @@ -82,11 +83,11 @@ src_libbreakpad_la_SOURCES = \ src/processor/minidump_processor.cc \ src/processor/pathname_stripper.cc \ src/processor/pathname_stripper.h \ - src/processor/postfix_evaluator.h \ src/processor/postfix_evaluator-inl.h \ + src/processor/postfix_evaluator.h \ src/processor/process_state.cc \ - src/processor/range_map.h \ src/processor/range_map-inl.h \ + src/processor/range_map.h \ src/processor/scoped_ptr.h \ src/processor/simple_symbol_supplier.cc \ src/processor/simple_symbol_supplier.h \ @@ -284,8 +285,6 @@ EXTRA_DIST = \ src/common/linux/guid_creator.h \ src/common/linux/http_upload.cc \ src/common/linux/http_upload.h \ - src/common/linux/md5.c \ - src/common/linux/md5.h \ src/common/mac/HTTPMultipartUpload.h \ src/common/mac/HTTPMultipartUpload.m \ src/common/mac/dump_syms.h \ @@ -300,6 +299,10 @@ EXTRA_DIST = \ src/common/mac/macho_walker.h \ src/common/mac/string_utilities.cc \ src/common/mac/string_utilities.h \ + src/common/md5.c \ + src/common/md5.h \ + src/common/solaris/dump_symbols.cc \ + src/common/solaris/dump_symbols.h \ src/common/solaris/file_id.cc \ src/common/solaris/file_id.h \ src/common/solaris/guid_creator.cc \ @@ -340,6 +343,13 @@ EXTRA_DIST = \ src/tools/mac/symupload/minidump_upload.m \ src/tools/mac/symupload/symupload.m \ src/tools/mac/symupload/symupload.xcodeproj/project.pbxproj \ + src/tools/solaris/dump_syms/Makefile \ + src/tools/solaris/dump_syms/dump_syms.cc \ + src/tools/solaris/dump_syms/run_regtest.sh \ + src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc \ + src/tools/solaris/dump_syms/testdata/dump_syms_regtest.o \ + src/tools/solaris/dump_syms/testdata/dump_syms_regtest.stabs \ + src/tools/solaris/dump_syms/testdata/dump_syms_regtest.sym \ src/tools/windows/converter/ms_symbol_server_converter.cc \ src/tools/windows/converter/ms_symbol_server_converter.h \ src/tools/windows/converter/ms_symbol_server_converter.vcproj \ diff --git a/Makefile.in b/Makefile.in index aa517b34..f4a81182 100644 --- a/Makefile.in +++ b/Makefile.in @@ -393,20 +393,21 @@ src_libbreakpad_la_SOURCES = \ src/google_breakpad/processor/minidump.h \ src/google_breakpad/processor/minidump_processor.h \ src/google_breakpad/processor/process_state.h \ + src/google_breakpad/processor/source_line_resolver_interface.h \ src/google_breakpad/processor/stack_frame.h \ src/google_breakpad/processor/stack_frame_cpu.h \ src/google_breakpad/processor/stackwalker.h \ src/google_breakpad/processor/symbol_supplier.h \ src/google_breakpad/processor/system_info.h \ - src/processor/address_map.h \ src/processor/address_map-inl.h \ + src/processor/address_map.h \ src/processor/basic_code_module.h \ src/processor/basic_code_modules.cc \ src/processor/basic_code_modules.h \ src/processor/basic_source_line_resolver.cc \ src/processor/call_stack.cc \ - src/processor/contained_range_map.h \ src/processor/contained_range_map-inl.h \ + src/processor/contained_range_map.h \ src/processor/linked_ptr.h \ src/processor/logging.h \ src/processor/logging.cc \ @@ -414,11 +415,11 @@ src_libbreakpad_la_SOURCES = \ src/processor/minidump_processor.cc \ src/processor/pathname_stripper.cc \ src/processor/pathname_stripper.h \ - src/processor/postfix_evaluator.h \ src/processor/postfix_evaluator-inl.h \ + src/processor/postfix_evaluator.h \ src/processor/process_state.cc \ - src/processor/range_map.h \ src/processor/range_map-inl.h \ + src/processor/range_map.h \ src/processor/scoped_ptr.h \ src/processor/simple_symbol_supplier.cc \ src/processor/simple_symbol_supplier.h \ @@ -594,8 +595,6 @@ EXTRA_DIST = \ src/common/linux/guid_creator.h \ src/common/linux/http_upload.cc \ src/common/linux/http_upload.h \ - src/common/linux/md5.c \ - src/common/linux/md5.h \ src/common/mac/HTTPMultipartUpload.h \ src/common/mac/HTTPMultipartUpload.m \ src/common/mac/dump_syms.h \ @@ -610,6 +609,10 @@ EXTRA_DIST = \ src/common/mac/macho_walker.h \ src/common/mac/string_utilities.cc \ src/common/mac/string_utilities.h \ + src/common/md5.c \ + src/common/md5.h \ + src/common/solaris/dump_symbols.cc \ + src/common/solaris/dump_symbols.h \ src/common/solaris/file_id.cc \ src/common/solaris/file_id.h \ src/common/solaris/guid_creator.cc \ @@ -650,6 +653,13 @@ EXTRA_DIST = \ src/tools/mac/symupload/minidump_upload.m \ src/tools/mac/symupload/symupload.m \ src/tools/mac/symupload/symupload.xcodeproj/project.pbxproj \ + src/tools/solaris/dump_syms/Makefile \ + src/tools/solaris/dump_syms/dump_syms.cc \ + src/tools/solaris/dump_syms/run_regtest.sh \ + src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc \ + src/tools/solaris/dump_syms/testdata/dump_syms_regtest.o \ + src/tools/solaris/dump_syms/testdata/dump_syms_regtest.stabs \ + src/tools/solaris/dump_syms/testdata/dump_syms_regtest.sym \ src/tools/windows/converter/ms_symbol_server_converter.cc \ src/tools/windows/converter/ms_symbol_server_converter.h \ src/tools/windows/converter/ms_symbol_server_converter.vcproj \ diff --git a/src/client/linux/handler/Makefile b/src/client/linux/handler/Makefile index b28cc908..4609c75b 100644 --- a/src/client/linux/handler/Makefile +++ b/src/client/linux/handler/Makefile @@ -48,7 +48,7 @@ $(BIN_DIR)/minidump_test:$(MINIDUMP_TEST_OBJ) $(BIN_DIR)/exception_handler_test:$(EXCEPTION_TEST_OBJ) $(CXX) $(CXXFLAGS) $(LDFLAGS) $^ -o $@ -md5.o:../../../common/linux/md5.c +md5.o:../../../common/md5.c $(CC) $(CXXFLAGS) -c $^ clean: diff --git a/src/client/solaris/handler/Makefile b/src/client/solaris/handler/Makefile index 318ac8e5..9b642865 100644 --- a/src/client/solaris/handler/Makefile +++ b/src/client/solaris/handler/Makefile @@ -40,6 +40,7 @@ BIN_DIR=. THREAD_SRC=solaris_lwp.cc SHARE_SRC=../../minidump_file_writer.cc\ + ../../../common/md5.c\ ../../../common/string_conversion.cc\ ../../../common/solaris/file_id.cc\ minidump_generator.cc diff --git a/src/common/linux/dump_symbols.cc b/src/common/linux/dump_symbols.cc index 8c211579..bb3f81e9 100644 --- a/src/common/linux/dump_symbols.cc +++ b/src/common/linux/dump_symbols.cc @@ -494,7 +494,7 @@ bool WriteModuleInfo(int fd, ElfW(Half) arch, const std::string &obj_file) { size_t slash_pos = obj_file.find_last_of("/"); if (slash_pos != std::string::npos) filename = obj_file.substr(slash_pos + 1); - return WriteFormat(fd, "MODULE Linux %s %s %s\n", arch_name, + return WriteFormat(fd, "MODULE linux %s %s %s\n", arch_name, id_no_dash, filename.c_str()); } return false; diff --git a/src/common/linux/file_id.cc b/src/common/linux/file_id.cc index f8bb586e..d69d45a9 100644 --- a/src/common/linux/file_id.cc +++ b/src/common/linux/file_id.cc @@ -42,7 +42,7 @@ #include #include "common/linux/file_id.h" -#include "common/linux/md5.h" +#include "common/md5.h" namespace google_breakpad { diff --git a/src/common/linux/md5.c b/src/common/md5.c similarity index 99% rename from src/common/linux/md5.c rename to src/common/md5.c index 60c1a782..7fc198af 100644 --- a/src/common/linux/md5.c +++ b/src/common/md5.c @@ -15,7 +15,7 @@ #include -#include "common/linux/md5.h" +#include "common/md5.h" #ifndef WORDS_BIGENDIAN #define byteReverse(buf, len) /* Nothing */ diff --git a/src/common/linux/md5.h b/src/common/md5.h similarity index 84% rename from src/common/linux/md5.h rename to src/common/md5.h index 03a13d6f..dbf4893c 100644 --- a/src/common/linux/md5.h +++ b/src/common/md5.h @@ -1,7 +1,7 @@ // Copyright 2007 Google Inc. All Rights Reserved. // Author: liuli@google.com (Liu Li) -#ifndef COMMON_LINUX_MD5_H__ -#define COMMON_LINUX_MD5_H__ +#ifndef COMMON_MD5_H__ +#define COMMON_MD5_H__ #include @@ -28,4 +28,4 @@ void MD5Final(unsigned char digest[16], struct MD5Context *ctx); } #endif -#endif // COMMON_LINUX_MD5_H__ +#endif // COMMON_MD5_H__ diff --git a/src/common/solaris/dump_symbols.cc b/src/common/solaris/dump_symbols.cc new file mode 100644 index 00000000..b9fc74f6 --- /dev/null +++ b/src/common/solaris/dump_symbols.cc @@ -0,0 +1,587 @@ +// Copyright (c) 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: Alfred Peng + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "common/solaris/dump_symbols.h" +#include "common/solaris/file_id.h" +#include "common/solaris/guid_creator.h" +#include "processor/scoped_ptr.h" + +// This namespace contains helper functions. +namespace { + +// Symbol table entry for stabs. Sun CC specific. +struct slist { + // String table index. + unsigned int n_strx; + // Stab type. + unsigned char n_type; + char n_other; + short n_desc; + unsigned long n_value; +}; + +// Infomation of a line. +struct LineInfo { + // Offset from start of the function. + // Load from stab symbol. + GElf_Off rva_to_func; + // Offset from base of the loading binary. + GElf_Off rva_to_base; + // Size of the line. + // The first line: equals to rva_to_func. + // The other lines: the difference of rva_to_func of the line and + // rva_to_func of the previous N_SLINE. + uint32_t size; + // Line number. + uint32_t line_num; +}; + +// Information of a function. +struct FuncInfo { + // Name of the function. + const char *name; + // Offset from the base of the loading address. + GElf_Off rva_to_base; + // Virtual address of the function. + // Load from stab symbol. + GElf_Addr addr; + // Size of the function. + // Equal to rva_to_func of the last function line. + uint32_t size; + // Total size of stack parameters. + uint32_t stack_param_size; + // Line information array. + std::vector line_info; +}; + +// Information of a source file. +struct SourceFileInfo { + // Name of the source file. + const char *name; + // Starting address of the source file. + GElf_Addr addr; + // Id of the source file. + int source_id; + // Functions information. + std::vector func_info; +}; + +// Information of a symbol table. +// This is the root of all types of symbol. +struct SymbolInfo { + std::vector source_file_info; +}; + +// Stab section name. +const char *kStabName = ".stab"; + +// Stab str section name. +const char *kStabStrName = ".stabstr"; + +// Default buffer lenght for demangle. +const int demangleLen = 2000; + +// Demangle using demangle library on Solaris. +std::string Demangle(const char *mangled) { + int status = 0; + char *demangled = (char *)malloc(demangleLen); + if (!demangled) { + fprintf(stderr, "no enough memory.\n"); + goto out; + } + + if ((status = cplus_demangle(mangled, demangled, demangleLen)) == + DEMANGLE_ESPACE) { + fprintf(stderr, "incorrect demangle.\n"); + goto out; + } + + std::string str(demangled); + free(demangled); + return str; + +out: + return std::string(mangled); +} + +// Find the prefered loading address of the binary. +GElf_Addr GetLoadingAddress(const GElf_Phdr *program_headers, int nheader) { + for (int i = 0; i < nheader; ++i) { + const GElf_Phdr &header = program_headers[i]; + // For executable, it is the PT_LOAD segment with offset to zero. + if (header.p_type == PT_LOAD && header.p_offset == 0) + return header.p_vaddr; + } + // For other types of ELF, return 0. + return 0; +} + +bool WriteFormat(int fd, const char *fmt, ...) { + va_list list; + char buffer[4096]; + ssize_t expected, written; + va_start(list, fmt); + vsnprintf(buffer, sizeof(buffer), fmt, list); + expected = strlen(buffer); + written = write(fd, buffer, strlen(buffer)); + va_end(list); + return expected == written; +} + +bool IsValidElf(const GElf_Ehdr *elf_header) { + return memcmp(elf_header, ELFMAG, SELFMAG) == 0; +} + +static bool FindSectionByName(Elf *elf, const char *name, + int shstrndx, + GElf_Shdr *shdr) { + assert(name != NULL); + + if (strlen(name) == 0) + return false; + + Elf_Scn *scn = NULL; + + while ((scn = elf_nextscn(elf, scn)) != NULL) { + if (gelf_getshdr(scn, shdr) == (GElf_Shdr *)0) { + fprintf(stderr, "failed to read section header: %s\n", elf_errmsg(0)); + return false; + } + + const char *section_name = elf_strptr(elf, shstrndx, shdr->sh_name); + if (!section_name) { + fprintf(stderr, "Section name error: %s\n", elf_errmsg(-1)); + continue; + } + + if (strcmp(section_name, name) == 0) + return true; + } + + return false; +} + +// The parameter size is used for FPO-optimized code, and +// this is all tied up with the debugging data for Windows x86. +// Set it to 0 on Solaris. +int LoadStackParamSize(struct slist *list, + struct slist *list_end, + struct FuncInfo *func_info) { + struct slist *cur_list = list; + int step = 1; + while (cur_list < list_end && cur_list->n_type == N_PSYM) { + ++cur_list; + ++step; + } + + func_info->stack_param_size = 0; + return step; +} + +int LoadLineInfo(struct slist *list, + struct slist *list_end, + struct FuncInfo *func_info) { + struct slist *cur_list = list; + do { + // Skip non line information. + while (cur_list < list_end && cur_list->n_type != N_SLINE) { + // Only exit when got another function, or source file. + if (cur_list->n_type == N_FUN || cur_list->n_type == N_SO) + return cur_list - list; + ++cur_list; + } + struct LineInfo line; + while (cur_list < list_end && cur_list->n_type == N_SLINE) { + line.rva_to_func = cur_list->n_value; + // n_desc is a signed short + line.line_num = (unsigned short)cur_list->n_desc; + func_info->line_info.push_back(line); + ++cur_list; + } + if (cur_list == list_end && cur_list->n_type == N_ENDM) + break; + } while (list < list_end); + + return cur_list - list; +} + +int LoadFuncSymbols(struct slist *list, + struct slist *list_end, + const GElf_Shdr *stabstr_section, + GElf_Word base, + struct SourceFileInfo *source_file_info) { + struct slist *cur_list = list; + assert(cur_list->n_type == N_SO); + ++cur_list; + + source_file_info->func_info.clear(); + while (cur_list < list_end) { + // Go until the function symbol. + while (cur_list < list_end && cur_list->n_type != N_FUN) { + if (cur_list->n_type == N_SO) { + return cur_list - list; + } + ++cur_list; + continue; + } + while (cur_list->n_type == N_FUN) { + struct FuncInfo func_info; + memset(&func_info, 0, sizeof(func_info)); + func_info.name = + reinterpret_cast(cur_list->n_strx + + stabstr_section->sh_offset + base); + // The n_value field is always 0 from stab generated by Sun CC. + // TODO(Alfred): Find the correct value. + func_info.addr = cur_list->n_value; + ++cur_list; + if (cur_list->n_type != N_ESYM && cur_list->n_type != N_ISYM && + cur_list->n_type != N_FUN) { + // Stack parameter size. + cur_list += LoadStackParamSize(cur_list, list_end, &func_info); + // Line info. + cur_list += LoadLineInfo(cur_list, list_end, &func_info); + } + // Functions in this module should have address bigger than the module + // starting address. + // + // These two values are always 0 with Sun CC. + // TODO(Alfred): Get the correct value or remove the condition statement. + if (func_info.addr >= source_file_info->addr) { + source_file_info->func_info.push_back(func_info); + } + } + } + return cur_list - list; +} + +// Compute size and rva information based on symbols loaded from stab section. +bool ComputeSizeAndRVA(GElf_Addr loading_addr, struct SymbolInfo *symbols) { + std::vector *sorted_files = + &(symbols->source_file_info); + for (size_t i = 0; i < sorted_files->size(); ++i) { + struct SourceFileInfo &source_file = (*sorted_files)[i]; + std::vector *sorted_functions = &(source_file.func_info); + for (size_t j = 0; j < sorted_functions->size(); ++j) { + struct FuncInfo &func_info = (*sorted_functions)[j]; + assert(func_info.addr >= loading_addr); + func_info.rva_to_base = func_info.addr - loading_addr; + int line_count = func_info.line_info.size(); + func_info.size = + (line_count == 0) ? 0 : + func_info.line_info[line_count - 1].rva_to_func; + // Compute function and line size. + for (size_t k = 0; k < line_count; ++k) { + struct LineInfo &line_info = func_info.line_info[k]; + if (k == 0) { + line_info.size = line_info.rva_to_func; + } else { + line_info.size = + line_info.rva_to_func - func_info.line_info[k - 1].rva_to_func; + } + line_info.rva_to_base = line_info.rva_to_func + func_info.rva_to_base; + } // for each line. + } // for each function. + } // for each source file. + return true; +} + +bool LoadAllSymbols(const GElf_Shdr *stab_section, + const GElf_Shdr *stabstr_section, + GElf_Addr loading_addr, + GElf_Word base, + struct SymbolInfo *symbols) { + if (stab_section == NULL || stabstr_section == NULL) + return false; + + struct slist *lists = + reinterpret_cast(stab_section->sh_offset + base); + int nstab = stab_section->sh_size / sizeof(struct slist); + int source_id = 0; + // First pass, load all symbols from the object file. + for (int i = 0; i < nstab; ) { + int step = 1; + struct slist *cur_list = lists + i; + if (cur_list->n_type == N_SO) { + // FUNC
+ struct SourceFileInfo source_file_info; + source_file_info.name = + reinterpret_cast(cur_list->n_strx + + stabstr_section->sh_offset + base); + // The n_value field is always 0 from stab generated by Sun CC. + // TODO(Alfred): Find the correct value. + source_file_info.addr = cur_list->n_value; + if (strchr(source_file_info.name, '.')) + source_file_info.source_id = source_id++; + else + source_file_info.source_id = -1; + step = LoadFuncSymbols(cur_list, lists + nstab - 1, + stabstr_section, base, &source_file_info); + symbols->source_file_info.push_back(source_file_info); + } + i += step; + } + // Second pass, compute the size of functions and lines. + return ComputeSizeAndRVA(loading_addr, symbols); +} + +bool LoadSymbols(Elf *elf, GElf_Ehdr *elf_header, struct SymbolInfo *symbols, + void *obj_base) { + GElf_Word base = reinterpret_cast(obj_base); + GElf_Addr loading_addr = GetLoadingAddress( + reinterpret_cast(elf_header->e_phoff + base), + elf_header->e_phnum); + + const GElf_Shdr *sections = + reinterpret_cast(elf_header->e_shoff + base); + GElf_Shdr stab_section; + if (!FindSectionByName(elf, kStabName, elf_header->e_shstrndx, + &stab_section)) { + fprintf(stderr, "Stab section not found.\n"); + return false; + } + GElf_Shdr stabstr_section; + if (!FindSectionByName(elf, kStabStrName, elf_header->e_shstrndx, + &stabstr_section)) { + fprintf(stderr, "Stabstr section not found.\n"); + return false; + } + + // Load symbols. + return LoadAllSymbols(&stab_section, &stabstr_section, loading_addr, base, symbols); +} + +bool WriteModuleInfo(int fd, GElf_Half arch, const std::string &obj_file) { + const char *arch_name = NULL; + if (arch == EM_386) + arch_name = "x86"; + else if (arch == EM_X86_64) + arch_name = "x86_64"; + else + return false; + + unsigned char identifier[16]; + google_breakpad::FileID file_id(obj_file.c_str()); + if (file_id.ElfFileIdentifier(identifier)) { + char identifier_str[40]; + file_id.ConvertIdentifierToString(identifier, + identifier_str, sizeof(identifier_str)); + std::string filename = obj_file; + size_t slash_pos = obj_file.find_last_of("/"); + if (slash_pos != std::string::npos) + filename = obj_file.substr(slash_pos + 1); + return WriteFormat(fd, "MODULE solaris %s %s %s\n", arch_name, + identifier_str, filename.c_str()); + } + return false; +} + +bool WriteSourceFileInfo(int fd, const struct SymbolInfo &symbols) { + for (size_t i = 0; i < symbols.source_file_info.size(); ++i) { + if (symbols.source_file_info[i].source_id != -1) { + const char *name = symbols.source_file_info[i].name; + if (!WriteFormat(fd, "FILE %d %s\n", + symbols.source_file_info[i].source_id, name)) + return false; + } + } + return true; +} + +bool WriteOneFunction(int fd, int source_id, + const struct FuncInfo &func_info){ + // Discard the ending part of the name. + std::string func_name(func_info.name); + std::string::size_type last_colon = func_name.find_last_of(':'); + if (last_colon != std::string::npos) + func_name = func_name.substr(0, last_colon); + func_name = Demangle(func_name.c_str()); + + if (func_info.size < 0) + return true; + + // rva_to_base could be unsigned long(32 bit) or unsigned long long(64 bit). + if (WriteFormat(fd, "FUNC %llx %d %d %s\n", + (long long)func_info.rva_to_base, + func_info.size, + func_info.stack_param_size, + func_name.c_str())) { + for (size_t i = 0; i < func_info.line_info.size(); ++i) { + const struct LineInfo &line_info = func_info.line_info[i]; + if (!WriteFormat(fd, "%llx %d %d %d\n", + (long long)line_info.rva_to_base, + line_info.size, + line_info.line_num, + source_id)) + return false; + } + return true; + } + return false; +} + +bool WriteFunctionInfo(int fd, const struct SymbolInfo &symbols) { + for (size_t i = 0; i < symbols.source_file_info.size(); ++i) { + const struct SourceFileInfo &file_info = symbols.source_file_info[i]; + for (size_t j = 0; j < file_info.func_info.size(); ++j) { + const struct FuncInfo &func_info = file_info.func_info[j]; + if (!WriteOneFunction(fd, file_info.source_id, func_info)) + return false; + } + } + return true; +} + +bool DumpStabSymbols(int fd, const struct SymbolInfo &symbols) { + return WriteSourceFileInfo(fd, symbols) && + WriteFunctionInfo(fd, symbols); +} + +// +// FDWrapper +// +// Wrapper class to make sure opened file is closed. +// +class FDWrapper { + public: + explicit FDWrapper(int fd) : + fd_(fd) { + } + ~FDWrapper() { + if (fd_ != -1) + close(fd_); + } + int get() { + return fd_; + } + int release() { + int fd = fd_; + fd_ = -1; + return fd; + } + private: + int fd_; +}; + +// +// MmapWrapper +// +// Wrapper class to make sure mapped regions are unmapped. +// +class MmapWrapper { + public: + MmapWrapper(void *mapped_address, size_t mapped_size) : + base_(mapped_address), size_(mapped_size) { + } + ~MmapWrapper() { + if (base_ != NULL) { + assert(size_ > 0); + munmap((char *)base_, size_); + } + } + void release() { + base_ = NULL; + size_ = 0; + } + + private: + void *base_; + size_t size_; +}; + +} // namespace + +namespace google_breakpad { + +class AutoElfEnder { + public: + AutoElfEnder(Elf *elf) : elf_(elf) {} + ~AutoElfEnder() { if (elf_) elf_end(elf_); } + private: + Elf *elf_; +}; + + +bool DumpSymbols::WriteSymbolFile(const std::string &obj_file, int sym_fd) { + if (elf_version(EV_CURRENT) == EV_NONE) { + fprintf(stderr, "elf_version() failed: %s\n", elf_errmsg(0)); + return false; + } + + int obj_fd = open(obj_file.c_str(), O_RDONLY); + if (obj_fd < 0) + return false; + FDWrapper obj_fd_wrapper(obj_fd); + struct stat st; + if (fstat(obj_fd, &st) != 0 && st.st_size <= 0) + return false; + void *obj_base = mmap(NULL, st.st_size, + PROT_READ, MAP_PRIVATE, obj_fd, 0); + if (!obj_base) + return false; + MmapWrapper map_wrapper(obj_base, st.st_size); + GElf_Ehdr elf_header; + Elf *elf = elf_begin(obj_fd, ELF_C_READ, NULL); + AutoElfEnder elfEnder(elf); + + if (gelf_getehdr(elf, &elf_header) == (GElf_Ehdr *)NULL) { + fprintf(stderr, "failed to read elf header: %s\n", elf_errmsg(-1)); + return false; + } + + if (!IsValidElf(&elf_header)) { + fprintf(stderr, "header magic doesn't match\n"); + return false; + } + struct SymbolInfo symbols; + if (!LoadSymbols(elf, &elf_header, &symbols, obj_base)) + return false; + // Write to symbol file. + if (WriteModuleInfo(sym_fd, elf_header.e_machine, obj_file) && + DumpStabSymbols(sym_fd, symbols)) + return true; + + return false; +} + +} // namespace google_breakpad diff --git a/src/common/solaris/dump_symbols.h b/src/common/solaris/dump_symbols.h new file mode 100644 index 00000000..7f4baadc --- /dev/null +++ b/src/common/solaris/dump_symbols.h @@ -0,0 +1,49 @@ +// Copyright (c) 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// dump_symbols.cc: Implements a Solaris stab debugging format dumper. +// +// Author: Alfred Peng + +#ifndef COMMON_SOLARIS_DUMP_SYMBOLS_H__ +#define COMMON_SOLARIS_DUMP_SYMBOLS_H__ + +#include + +namespace google_breakpad { + +class DumpSymbols { + public: + bool WriteSymbolFile(const std::string &obj_file, + int sym_fd); +}; + +} // namespace google_breakpad + +#endif // COMMON_SOLARIS_DUMP_SYMBOLS_H__ diff --git a/src/common/solaris/file_id.cc b/src/common/solaris/file_id.cc index 4bec3ed8..92e7f71f 100644 --- a/src/common/solaris/file_id.cc +++ b/src/common/solaris/file_id.cc @@ -36,8 +36,6 @@ #include #include #include -#include -#include #include #include #include @@ -47,6 +45,7 @@ #include #include +#include "common/md5.h" #include "common/solaris/file_id.h" #include "common/solaris/message_output.h" #include "google_breakpad/common/minidump_format.h" @@ -130,7 +129,7 @@ static bool FindElfTextSection(int fd, const void *elf_base, } FileID::FileID(const char *path) { - strncpy(path_, path, strlen(path)); + strcpy(path_, path); } class AutoCloser { @@ -160,10 +159,10 @@ bool FileID::ElfFileIdentifier(unsigned char identifier[16]) { int text_size = 0; if (FindElfTextSection(fd, base, &text_section, &text_size)) { - MD5_CTX md5; - MD5_Init(&md5); - MD5_Update(&md5, text_section, text_size); - MD5_Final(identifier, &md5); + MD5Context md5; + MD5Init(&md5); + MD5Update(&md5, (const unsigned char *)text_section, text_size); + MD5Final(identifier, &md5); success = true; } diff --git a/src/tools/linux/dump_syms/Makefile b/src/tools/linux/dump_syms/Makefile index 8e969586..7d74abad 100644 --- a/src/tools/linux/dump_syms/Makefile +++ b/src/tools/linux/dump_syms/Makefile @@ -23,7 +23,7 @@ guid_creator.o:../../../common/linux/guid_creator.cc file_id.o:../../../common/linux/file_id.cc $(CXX) $(CXXFLAGS) -c $^ -md5.o:../../../common/linux/md5.c +md5.o:../../../common/md5.c $(CC) $(CXXFLAGS) -c $^ clean: diff --git a/src/tools/solaris/dump_syms/Makefile b/src/tools/solaris/dump_syms/Makefile new file mode 100644 index 00000000..f0a4c11a --- /dev/null +++ b/src/tools/solaris/dump_syms/Makefile @@ -0,0 +1,64 @@ +# Copyright (c) 2007, Google Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# Author: Alfred Peng + +CXX=CC +CC=cc + +CXXFLAGS=-g -xs -xdebugformat=stabs -I../../.. -I../../../common/solaris -lelf -ldemangle -D_REENTRANT + +.PHONY:all clean + +BIN=dump_syms + +all:$(BIN) + +DUMP_OBJ=dump_symbols.o guid_creator.o dump_syms.o file_id.o md5.o + +dump_syms:$(DUMP_OBJ) + $(CXX) $(CXXFLAGS) -o $@ $^ + +dump_symbols.o:../../../common/solaris/dump_symbols.cc + $(CXX) $(CXXFLAGS) -c $^ + +guid_creator.o:../../../common/solaris/guid_creator.cc + $(CXX) $(CXXFLAGS) -c $^ + +file_id.o:../../../common/solaris/file_id.cc + $(CXX) $(CXXFLAGS) -c $^ + +md5.o:../../../common/md5.c + $(CC) $(CXXFLAGS) -c $^ + +test:all + ./run_regtest.sh + +clean: + rm -f $(BIN) $(DUMP_OBJ) diff --git a/src/tools/solaris/dump_syms/dump_syms.cc b/src/tools/solaris/dump_syms/dump_syms.cc new file mode 100644 index 00000000..54cea57e --- /dev/null +++ b/src/tools/solaris/dump_syms/dump_syms.cc @@ -0,0 +1,54 @@ +// Copyright (c) 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: Alfred Peng + +#include +#include + +#include "common/solaris/dump_symbols.h" + +using namespace google_breakpad; + +int main(int argc, char **argv) { + if (argc != 2) { + fprintf(stderr, "Usage: %s \n", argv[0]); + return 1; + } + + const char *binary = argv[1]; + + DumpSymbols dumper; + if (!dumper.WriteSymbolFile(binary, fileno(stdout))) { + fprintf(stderr, "Failed to write symbol file.\n"); + return 1; + } + + return 0; +} diff --git a/src/tools/solaris/dump_syms/run_regtest.sh b/src/tools/solaris/dump_syms/run_regtest.sh new file mode 100644 index 00000000..ffb34330 --- /dev/null +++ b/src/tools/solaris/dump_syms/run_regtest.sh @@ -0,0 +1,51 @@ +#!/bin/sh + +# Copyright (c) 2007, Google Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +./dump_syms testdata/dump_syms_regtest.o > testdata/dump_syms_regtest.new +status=$? + +if [ $status -ne 0 ] ; then + echo "FAIL, dump_syms failed" + exit $status +fi + +diff -u testdata/dump_syms_regtest.new testdata/dump_syms_regtest.sym > \ + testdata/dump_syms_regtest.diff +status=$? + +if [ $status -eq 0 ] ; then + rm testdata/dump_syms_regtest.diff testdata/dump_syms_regtest.new + echo "PASS" +else + echo "FAIL, see testdata/dump_syms_regtest.[new|diff]" +fi + +exit $status diff --git a/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc b/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc new file mode 100644 index 00000000..e617a23b --- /dev/null +++ b/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc @@ -0,0 +1,64 @@ +// Copyright (c) 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// ./dump_syms dump_syms_regtest.pdb > dump_syms_regtest.sym + +namespace google_breakpad { + +class C { + public: + C() : member_(1) {} + virtual ~C() {} + + void set_member(int value) { member_ = value; } + int member() const { return member_; } + + void f() { member_ = g(); } + virtual int g() { return 2; } + static char* h(const C &that) { return 0; } + + private: + int member_; +}; + +static int i() { + return 3; +} + +} // namespace google_breakpad + +int main(int argc, char **argv) { + google_breakpad::C object; + object.set_member(google_breakpad::i()); + object.f(); + int value = object.g(); + char *nothing = object.h(object); + + return 0; +} diff --git a/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.o b/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.o new file mode 100644 index 0000000000000000000000000000000000000000..a1c61b2dfd09c52168660fdf5b060b969a72006d GIT binary patch literal 14204 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 rUjR1kdm3`JnrX>;G=.XAB6Z2hOiL$Gl1b.;A=2",N_OPT,0x0,0x0,0x46fcb88e + 6: .stabs "dump_syms_regtest.cc",N_SOL,0x0,0x0,0x0 + 7: .stabs "char:t(0,1)=bsc1;0;8",N_ISYM,0x0,0x0,0x0 + 8: .stabs "short:t(0,2)=bs2;0;16",N_ISYM,0x0,0x0,0x0 + 9: .stabs "int:t(0,3)=bs4;0;32",N_ISYM,0x0,0x0,0x0 + 10: .stabs "long:t(0,4)=bs4;0;32",N_ISYM,0x0,0x0,0x0 + 11: .stabs "long long:t(0,5)=bs8;0;64",N_ISYM,0x0,0x0,0x0 + 12: .stabs "unsigned char:t(0,6)=buc1;0;8",N_ISYM,0x0,0x0,0x0 + 13: .stabs "unsigned short:t(0,7)=bu2;0;16",N_ISYM,0x0,0x0,0x0 + 14: .stabs "unsigned:t(0,8)=bu4;0;32",N_ISYM,0x0,0x0,0x0 + 15: .stabs "unsigned long:t(0,9)=bu4;0;32",N_ISYM,0x0,0x0,0x0 + 16: .stabs "unsigned long long:t(0,10)=bu8;0;64",N_ISYM,0x0,0x0,0x0 + 17: .stabs "signed char:t(0,11)=bsc1;0;8",N_ISYM,0x0,0x0,0x0 + 18: .stabs "wchar_t:t(0,12)=buc4;0;32",N_ISYM,0x0,0x0,0x0 + 19: .stabs "void:t(0,13)=bs0;0;0",N_ISYM,0x0,0x0,0x0 + 20: .stabs "float:t(0,14)=R1;4",N_ISYM,0x0,0x0,0x0 + 21: .stabs "double:t(0,15)=R2;8",N_ISYM,0x0,0x0,0x0 + 22: .stabs "long double:t(0,16)=R6;12",N_ISYM,0x0,0x0,0x0 + 23: .stabs "...:t(0,17)=buv4;0;32",N_ISYM,0x0,0x0,0x0 + 24: .stabs "bool:t(0,18)=bub1;0;8",N_ISYM,0x0,0x0,0x0 + 25: .stabs "__1nPgoogle_breakpad_:T(0,19)=Yn0google_breakpad;",N_ISYM,0x0,0x0,0x0 + 26: .stabs "nBC(0,19):U(0,20)",N_ESYM,0x0,0x0,0x0 + 27: .stabs "nBC(0,19):T(0,20)=Yc8C;;AcHmember_:(0,3),32,32;;Cc2t6M_v K2c2T6M_v CcKset_member6Mi_v CcGmember6kM_i CcBf6M_v K3cBg6M_i GcBh6Frk1_pc;;;2 0;;;;110;",N_ESYM,0x0,0x8,0x0 + 28: .stabs "main:F(0,3);(0,3);(0,21)=*(0,22)=*(0,1)",N_FUN,0x0,0x38,0x0 + 29: .stabs "main",N_MAIN,0x0,0x0,0x0 + 30: .stabs "argc:p(0,3)",N_PSYM,0x0,0x4,0x8 + 31: .stabs "argv:p(0,21)",N_PSYM,0x0,0x4,0xc + 32: .stabn N_LBRAC,0x0,0x1,0x12 + 33: .stabs "object:(0,20)",N_LSYM,0x0,0x8,0xfffffff4 + 34: .stabs "value:(0,3)",N_LSYM,0x0,0x4,0xfffffff0 + 35: .stabs "nothing:(0,22)",N_LSYM,0x0,0x4,0xffffffec + 36: .stabn N_SLINE,0x0,0x39,0x12 + 37: .stabs "object:2",N_CONSTRUCT,0x0,0xc,0x12 + 38: .stabn N_SLINE,0x2,0x3a,0x1e + 39: .stabn N_SLINE,0x0,0x3b,0x36 + 40: .stabn N_SLINE,0x0,0x3c,0x42 + 41: .stabn N_SLINE,0x0,0x3d,0x57 + 42: .stabn N_SLINE,0x0,0x3f,0x6c + 43: .stabs "2:0",N_DESTRUCT,0x0,0xc,0x73 + 44: .stabn N_SLINE,0xfffffffe,0x40,0x9c + 45: .stabn N_RBRAC,0x0,0x1,0x9c + 46: .stabs "__1cPgoogle_breakpadBi6F_i_:f(0,3)",N_FUN,0x0,0x32,0x0 + 47: .stabn N_LBRAC,0x0,0x1,0x6 + 48: .stabn N_SLINE,0x0,0x33,0x6 + 49: .stabn N_SLINE,0x0,0x34,0x10 + 50: .stabn N_RBRAC,0x0,0x1,0x10 + 51: .stabs "__1cPgoogle_breakpadBC2t6M_v_:F(0,13);(0,23)=*(0,20)",N_FUN,0x0,0x24,0x0 + 52: .stabs "this:p(0,23)",N_PSYM,0x0,0x4,0x8 + 53: .stabn N_LBRAC,0x0,0x1,0x3 + 54: .stabn N_SLINE,0x0,0x24,0x25 + 55: .stabn N_RBRAC,0x0,0x1,0x25 + 56: .stabs "__1cPgoogle_breakpadBC2T6M_v_:F(0,13);(0,23)",N_FUN,0x0,0x25,0x0 + 57: .stabs "this:p(0,23)",N_PSYM,0x0,0x4,0x8 + 58: .stabn N_LBRAC,0x0,0x1,0x3 + 59: .stabn N_SLINE,0x0,0x25,0x3 + 60: .stabn N_RBRAC,0x0,0x1,0x3 + 61: .stabs "__1cPgoogle_breakpadBCKset_member6Mi_v_:F(0,13);(0,23);(0,3)",N_FUN,0x0,0x27,0x0 + 62: .stabs "this:p(0,23)",N_PSYM,0x0,0x4,0x8 + 63: .stabs "value:p(0,3)",N_PSYM,0x0,0x4,0xc + 64: .stabn N_LBRAC,0x0,0x1,0x3 + 65: .stabn N_SLINE,0x0,0x27,0x3 + 66: .stabn N_SLINE,0x0,0x27,0xc + 67: .stabn N_RBRAC,0x0,0x1,0xc + 68: .stabs "__1cPgoogle_breakpadBCBf6M_v_:F(0,13);(0,23)",N_FUN,0x0,0x2a,0x0 + 69: .stabs "this:p(0,23)",N_PSYM,0x0,0x4,0x8 + 70: .stabn N_LBRAC,0x0,0x1,0x3 + 71: .stabn N_SLINE,0x0,0x2a,0x3 + 72: .stabn N_SLINE,0x0,0x2a,0x1d + 73: .stabn N_RBRAC,0x0,0x1,0x1d + 74: .stabs "__1cPgoogle_breakpadBCBg6M_i_:F(0,3);(0,23)",N_FUN,0x0,0x2b,0x0 + 75: .stabs "this:p(0,23)",N_PSYM,0x0,0x4,0x8 + 76: .stabn N_LBRAC,0x0,0x1,0x6 + 77: .stabn N_SLINE,0x0,0x2b,0x6 + 78: .stabn N_SLINE,0x0,0x2b,0x10 + 79: .stabn N_RBRAC,0x0,0x1,0x10 + 80: .stabs "__1cPgoogle_breakpadBCBh6Frk1_pc_:F(0,22);(0,24)=&(0,25)=k(0,20)",N_FUN,0x0,0x2c,0x0 + 81: .stabs "that:p(0,24)",N_PSYM,0x0,0x4,0x8 + 82: .stabn N_LBRAC,0x0,0x1,0x6 + 83: .stabn N_SLINE,0x0,0x2c,0x6 + 84: .stabn N_SLINE,0x0,0x2c,0x10 + 85: .stabn N_RBRAC,0x0,0x1,0x10 + 86: .stabs "__1cPgoogle_breakpadBC2T5B6M_v_:F(0,13);(0,23)",N_FUN,0x0,0x25,0x0 + 87: .stabs "this:p(0,23)",N_PSYM,0x0,0x4,0x8 + 88: .stabn N_LBRAC,0x0,0x1,0x3 + 89: .stabn N_SLINE,0x0,0x25,0xf + 90: .stabn N_RBRAC,0x0,0x1,0xf + 91: .stabs "__SLIP.DELETER__A:f(0,13);(0,23);(0,3)",N_FUN,0x0,0x25,0x0 + 92: .stabs "this:p(0,23)",N_PSYM,0x0,0x4,0x8 + 93: .stabs "delete:p(0,3)",N_PSYM,0x0,0x4,0xc + 94: .stabn N_LBRAC,0x0,0x1,0x3 + 95: .stabn N_LBRAC,0x0,0x2,0x3 + 96: .stabn N_RBRAC,0x0,0x2,0x28 + 97: .stabn N_RBRAC,0x0,0x1,0x28 + 98: .stabs "true:l(0,18);1",N_LSYM,0x0,0x4,0x0 + 99: .stabs "false:l(0,18);0",N_LSYM,0x0,0x4,0x0 + 100: .stabs "__1c2k6Fpv_v_:P(0,13);(0,26)=*(0,13)",N_FUN,0x0,0x0,0x0 + 101: .stabs "__1cPgoogle_breakpadBC2t5B6M_v_:F__1cPgoogle_breakpadBC2t6M_v_",N_ALIAS,0x0,0x0,0x0 + 102: .stabs "cbD__RTTI__1nPgoogle_breakpadBC_(0,19):YR(0,20)",N_LSYM,0x0,0x0,0x0 + 103: .stabn N_ENDM,0x0,0x0,0x0 + + +Index Stab table -- 17 entries + + 0: .stabs "dump_syms_regtest.cc",N_UNDF,0x0,0x10,0x3b1 + 1: .stabs "/export/home/alfred/cvs/breakpad/google-breakpad20070927/src/tools/solaris/dump_syms/testdata/",N_SO,0x0,0x0,0x0 + 2: .stabs "dump_syms_regtest.cc",N_SO,0x0,0x4,0x0 + 3: .stabs "/export/home/alfred/cvs/breakpad/google-breakpad20070927/src/tools/solaris/dump_syms/testdata",N_OBJ,0x0,0x0,0x0 + 4: .stabs "dump_syms_regtest.o",N_OBJ,0x0,0x0,0x0 + 5: .stabs "V=9.0;DBG_GEN=5.0.8;dm;cd;backend;ptf;ptx;ptk;s;g;R=5.8<>;G=.XAB6Z2hOiL$Gl1b.;A=2",N_OPT,0x0,0x0,0x46fcb88e + 6: .stabs "/export/home/alfred/cvs/breakpad/google-breakpad20070927/src/tools/solaris/dump_syms/testdata/; /ws/on10-tools-prc/SUNWspro/SS11/prod/bin/CC -g -xs -xdebugformat=stabs -I../../.. -I../../../common/solaris -D_REENTRANT -xs dump_syms_regtest.cc -Qoption ccfe -prefix -Qoption ccfe .XAB6Z2hOiL\$Gl1b.",N_CMDLINE,0x0,0x0,0x0 + 7: .stabs "__1nPgoogle_breakpadBC_:U",N_ESYM,0x0,0x0,0x0 + 8: .stabs "main",N_MAIN,0x0,0x0,0x0 + 9: .stabs "main",N_FUN,0x0,0x0,0x0 + 10: .stabs "__1cPgoogle_breakpadBC2t6M_v_",N_FUN,0x0,0x0,0x0 + 11: .stabs "__1cPgoogle_breakpadBC2T6M_v_",N_FUN,0x0,0x0,0x0 + 12: .stabs "__1cPgoogle_breakpadBCKset_member6Mi_v_",N_FUN,0x0,0x0,0x0 + 13: .stabs "__1cPgoogle_breakpadBCBf6M_v_",N_FUN,0x0,0x0,0x0 + 14: .stabs "__1cPgoogle_breakpadBCBg6M_i_",N_FUN,0x0,0x0,0x0 + 15: .stabs "__1cPgoogle_breakpadBCBh6Frk1_pc_",N_FUN,0x0,0x0,0x0 + 16: .stabs "__1cPgoogle_breakpadBC2T5B6M_v_",N_FUN,0x0,0x0,0x0 diff --git a/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.sym b/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.sym new file mode 100644 index 00000000..44d3c539 --- /dev/null +++ b/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.sym @@ -0,0 +1,33 @@ +MODULE solaris x86 3DC8191474338D8587339B5FB3E2C62A0 dump_syms_regtest.o +FILE 0 dump_syms_regtest.cc +FUNC 0 156 0 main +12 18 57 0 +1e 12 58 0 +36 24 59 0 +42 12 60 0 +57 21 61 0 +6c 21 63 0 +9c 48 64 0 +FUNC 0 16 0 int google_breakpad::i() +6 6 51 0 +10 10 52 0 +FUNC 0 37 0 google_breakpad::C::C() +25 37 36 0 +FUNC 0 3 0 google_breakpad::C::~C() +3 3 37 0 +FUNC 0 12 0 void google_breakpad::C::set_member(int) +3 3 39 0 +c 9 39 0 +FUNC 0 29 0 void google_breakpad::C::f() +3 3 42 0 +1d 26 42 0 +FUNC 0 16 0 int google_breakpad::C::g() +6 6 43 0 +10 10 43 0 +FUNC 0 16 0 char*google_breakpad::C::h(const google_breakpad::C&) +6 6 44 0 +10 10 44 0 +FUNC 0 15 0 google_breakpad::C::~C #Nvariant 1() +f 15 37 0 +FUNC 0 0 0 __SLIP.DELETER__A +FUNC 0 0 0 void operator delete(void*)