diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/processor/memory_region.h | 65 | ||||
| -rw-r--r-- | src/processor/minidump.cc | 2025 | ||||
| -rw-r--r-- | src/processor/minidump.h | 699 | ||||
| -rw-r--r-- | src/processor/minidump_dump.cc | 110 | ||||
| -rwxr-xr-x | src/processor/minidump_dump_test | 6 | ||||
| -rw-r--r-- | src/processor/minidump_format.h | 555 | ||||
| -rw-r--r-- | src/processor/range_map.h | 158 | ||||
| -rw-r--r-- | src/processor/range_map_unittest.cc | 334 | ||||
| -rw-r--r-- | src/processor/testdata/minidump1.dmp | bin | 0 -> 64111 bytes | |||
| -rw-r--r-- | src/processor/testdata/minidump1.out | 3734 |
10 files changed, 7686 insertions, 0 deletions
diff --git a/src/processor/memory_region.h b/src/processor/memory_region.h new file mode 100644 index 00000000..83d6dbf4 --- /dev/null +++ b/src/processor/memory_region.h @@ -0,0 +1,65 @@ +// Copyright (C) 2006 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// memory_region.h: Access to memory regions. +// +// A MemoryRegion provides virtual access to a range of memory. It is an +// abstraction allowing the actual source of memory to be independent of +// methods which need to access a virtual memory space. +// +// Author: Mark Mentovai + +#ifndef PROCESSOR_MEMORY_REGION_H__ +#define PROCESSOR_MEMORY_REGION_H__ + + +#include "google/airbag_types.h" + + +namespace google_airbag { + + +class MemoryRegion { + public: + virtual ~MemoryRegion() {} + + // The base address of this memory region. + virtual u_int64_t GetBase() = 0; + + // The size of this memory region. + virtual u_int32_t GetSize() = 0; + + // Access to data of various sizes within the memory region. address + // is a pointer to read, and it must lie within the memory region as + // defined by its base address and size. The location pointed to by + // value is set to the value at address. Byte-swapping is performed + // if necessary so that the value is appropriate for the running + // program. Returns true on success. Fails and returns false if address + // is out of the region's bounds (after considering the width of value), + // or for other types of errors. + virtual bool GetMemoryAtAddress(u_int64_t address, + u_int8_t* value) = 0; + virtual bool GetMemoryAtAddress(u_int64_t address, + u_int16_t* value) = 0; + virtual bool GetMemoryAtAddress(u_int64_t address, + u_int32_t* value) = 0; + virtual bool GetMemoryAtAddress(u_int64_t address, + u_int64_t* value) = 0; +}; + + +} // namespace google_airbag + + +#endif // PROCESSOR_MEMORY_REGION_H__ diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc new file mode 100644 index 00000000..46aa7c43 --- /dev/null +++ b/src/processor/minidump.cc @@ -0,0 +1,2025 @@ +// Copyright (C) 2006 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// minidump.cc: A minidump reader. +// +// See minidump.h for documentation. +// +// Author: Mark Mentovai + + +#include <stdio.h> +#include <time.h> +#include <unistd.h> +#ifdef _WIN32 +#include <io.h> +typedef SSIZE_T ssize_t; +#define read _read +#define lseek _lseek +#endif // _WIN32 + +#include <map> +#include <memory> +#include <vector> + +#include "processor/minidump.h" + + +namespace google_airbag { + + +using std::auto_ptr; +using std::vector; + + +// +// Swapping routines +// +// Inlining these doesn't increase code size significantly, and it saves +// a whole lot of unnecessary jumping back and forth. +// + + +// Swapping an 8-bit quantity is a no-op. This function is only provided +// to account for certain templatized operations that require swapping for +// wider types but handle u_int8_t too +// (MinidumpMemoryRegion::GetMemoryAtAddressInternal). +static inline void Swap(u_int8_t* value) { +} + + +// Optimization: don't need to AND the furthest right shift, because we're +// shifting an unsigned quantity. The standard requires zero-filling in this +// case. If the quantities were signed, a bitmask whould be needed for this +// right shift to avoid an arithmetic shift (which retains the sign bit). +// The furthest left shift never needs to be ANDed bitmask. + + +static inline void Swap(u_int16_t* value) { + *value = (*value >> 8) | + (*value << 8); +} + + +static inline void Swap(u_int32_t* value) { + *value = (*value >> 24) | + ((*value >> 8) & 0x0000ff00) | + ((*value << 8) & 0x00ff0000) | + (*value << 24); +} + + +static inline void Swap(u_int64_t* value) { + *value = (*value >> 56) | + ((*value >> 40) & 0x000000000000ff00LL) | + ((*value >> 24) & 0x0000000000ff0000LL) | + ((*value >> 8) & 0x00000000ff000000LL) | + ((*value << 8) & 0x000000ff00000000LL) | + ((*value << 24) & 0x0000ff0000000000LL) | + ((*value << 40) & 0x00ff000000000000LL) | + (*value << 56); +} + + +static inline void Swap(MDLocationDescriptor* location_descriptor) { + Swap(&location_descriptor->data_size); + Swap(&location_descriptor->rva); +} + + +static inline void Swap(MDMemoryDescriptor* memory_descriptor) { + Swap(&memory_descriptor->start_of_memory_range); + Swap(&memory_descriptor->memory); +} + + +static inline void Swap(MDGUID* guid) { + Swap(&guid->data1); + Swap(&guid->data2); + Swap(&guid->data3); + // Don't swap guid->data4[] because it contains 8-bit quantities. +} + + +// +// Character conversion routines +// + + +// Standard wide-character conversion routines depend on the system's own +// idea of what width a wide character should be: some use 16 bits, and +// some use 32 bits. For the purposes of a minidump, wide strings are +// always represented with 16-bit UTF-16 chracters. iconv isn't available +// everywhere, and its interface varies where it is available. iconv also +// deals purely with char* pointers, so in addition to considering the swap +// parameter, a converter that uses iconv would also need to take the host +// CPU's endianness into consideration. It doesn't seems worth the trouble +// of making it a dependency when we don't care about anything but UTF-16. +static string* UTF16ToUTF8(const vector<u_int16_t>& in, + bool swap) { + auto_ptr<string> out(new string()); + + // Set the string's initial capacity to the number of UTF-16 characters, + // because the UTF-8 representation will always be at least this long. + // If the UTF-8 representation is longer, the string will grow dynamically. + out->reserve(in.size()); + + for (vector<u_int16_t>::const_iterator iterator = in.begin(); + iterator != in.end(); + ++iterator) { + // Get a 16-bit value from the input + u_int16_t in_word = *iterator; + if (swap) + Swap(&in_word); + + // Convert the input value (in_word) into a Unicode code point (unichar). + u_int32_t unichar; + if (in_word >= 0xdc00 && in_word <= 0xdcff) { + // Low surrogate not following high surrogate, fail. + return NULL; + } else if (in_word >= 0xd800 && in_word <= 0xdbff) { + // High surrogate. + unichar = (in_word - 0xd7c0) << 10; + if (++iterator == in.end()) { + // End of input + return NULL; + } + in_word = *iterator; + if (in_word < 0xdc00 || in_word > 0xdcff) { + // Expected low surrogate, found something else + return NULL; + } + unichar |= in_word & 0x03ff; + } else { + // The ordinary case, a single non-surrogate Unicode character encoded + // as a single 16-bit value. + unichar = in_word; + } + + // Convert the Unicode code point (unichar) into its UTF-8 representation, + // appending it to the out string. + if (unichar < 0x80) { + (*out) += unichar; + } else if (unichar < 0x800) { + (*out) += 0xc0 | (unichar >> 6); + (*out) += 0x80 | (unichar & 0x3f); + } else if (unichar < 0x10000) { + (*out) += 0xe0 | (unichar >> 12); + (*out) += 0x80 | ((unichar >> 6) & 0x3f); + (*out) += 0x80 | (unichar & 0x3f); + } else if (unichar < 0x200000) { + (*out) += 0xf0 | (unichar >> 18); + (*out) += 0x80 | ((unichar >> 12) & 0x3f); + (*out) += 0x80 | ((unichar >> 6) & 0x3f); + (*out) += 0x80 | (unichar & 0x3f); + } else { + // Some (high) value that's not (presently) defined in UTF-8 + return NULL; + } + } + + return out.release(); +} + + +// +// MinidumpObject +// + + +MinidumpObject::MinidumpObject(Minidump* minidump) + : minidump_(minidump) + , valid_(false) { +} + + +// +// MinidumpStream +// + + +MinidumpStream::MinidumpStream(Minidump* minidump) + : MinidumpObject(minidump) { +} + + +// +// MinidumpContext +// + + +MinidumpContext::MinidumpContext(Minidump* minidump) + : MinidumpStream(minidump) + , context_() { +} + + +bool MinidumpContext::Read(u_int32_t expected_size) { + valid_ = false; + + if (expected_size != sizeof(context_)) + return false; + + if (!minidump_->ReadBytes(&context_, sizeof(context_))) + return false; + + if (minidump_->swap()) { + Swap(&context_.context_flags); + Swap(&context_.dr0); + Swap(&context_.dr1); + Swap(&context_.dr2); + Swap(&context_.dr3); + Swap(&context_.dr6); + Swap(&context_.dr7); + Swap(&context_.float_save.control_word); + Swap(&context_.float_save.status_word); + Swap(&context_.float_save.tag_word); + Swap(&context_.float_save.error_offset); + Swap(&context_.float_save.error_selector); + Swap(&context_.float_save.data_offset); + Swap(&context_.float_save.data_selector); + // context_.float_save.register_area[] contains 8-bit quantities and does + // not need to be swapped. + Swap(&context_.float_save.cr0_npx_state); + Swap(&context_.gs); + Swap(&context_.fs); + Swap(&context_.es); + Swap(&context_.ds); + Swap(&context_.edi); + Swap(&context_.esi); + Swap(&context_.ebx); + Swap(&context_.edx); + Swap(&context_.ecx); + Swap(&context_.eax); + Swap(&context_.ebp); + Swap(&context_.eip); + Swap(&context_.cs); + Swap(&context_.eflags); + Swap(&context_.esp); + Swap(&context_.ss); + // context_.extended_registers[] contains 8-bit quantities and does not + // need to be swapped. + } + + valid_ = true; + return true; +} + + +void MinidumpContext::Print() { + if (!valid_) + return; + + printf("MDRawContextX86\n"); + printf(" context_flags = 0x%x\n", context_.context_flags); + printf(" dr0 = 0x%x\n", context_.dr0); + printf(" dr1 = 0x%x\n", context_.dr1); + printf(" dr2 = 0x%x\n", context_.dr2); + printf(" dr3 = 0x%x\n", context_.dr3); + printf(" dr6 = 0x%x\n", context_.dr6); + printf(" dr7 = 0x%x\n", context_.dr7); + printf(" float_save.control_word = 0x%x\n", + context_.float_save.control_word); + printf(" float_save.status_word = 0x%x\n", + context_.float_save.status_word); + printf(" float_save.tag_word = 0x%x\n", + context_.float_save.tag_word); + printf(" float_save.error_offset = 0x%x\n", + context_.float_save.error_offset); + printf(" float_save.error_selector = 0x%x\n", + context_.float_save.error_selector); + printf(" float_save.data_offset = 0x%x\n", + context_.float_save.data_offset); + printf(" float_save.data_selector = 0x%x\n", + context_.float_save.data_selector); + printf(" float_save.register_area[%2d] = 0x", + MD_FLOATINGSAVEAREA_SIZEOF_REGISTERAREA_X86); + for (unsigned int register_index = 0; + register_index < MD_FLOATINGSAVEAREA_SIZEOF_REGISTERAREA_X86; + ++register_index) { + printf("%02x", context_.float_save.register_area[register_index]); + } + printf("\n"); + printf(" float_save.cr0_npx_state = 0x%x\n", + context_.float_save.cr0_npx_state); + printf(" gs = 0x%x\n", context_.gs); + printf(" fs = 0x%x\n", context_.fs); + printf(" es = 0x%x\n", context_.es); + printf(" ds = 0x%x\n", context_.ds); + printf(" edi = 0x%x\n", context_.edi); + printf(" esi = 0x%x\n", context_.esi); + printf(" ebx = 0x%x\n", context_.ebx); + printf(" edx = 0x%x\n", context_.edx); + printf(" ecx = 0x%x\n", context_.ecx); + printf(" eax = 0x%x\n", context_.eax); + printf(" ebp = 0x%x\n", context_.ebp); + printf(" eip = 0x%x\n", context_.eip); + printf(" cs = 0x%x\n", context_.cs); + printf(" eflags = 0x%x\n", context_.eflags); + printf(" esp = 0x%x\n", context_.esp); + printf(" ss = 0x%x\n", context_.ss); + printf(" extended_registers[%3d] = 0x", + MD_CONTEXT_SIZEOF_EXTENDED_REGISTERS_X86); + for (unsigned int register_index = 0; + register_index < MD_CONTEXT_SIZEOF_EXTENDED_REGISTERS_X86; + ++register_index) { + printf("%02x", context_.extended_registers[register_index]); + } + printf("\n\n"); +} + + +// +// MinidumpMemoryRegion +// + + +MinidumpMemoryRegion::MinidumpMemoryRegion(Minidump* minidump) + : MinidumpObject(minidump) + , descriptor_(NULL) + , memory_(NULL) { +} + + +MinidumpMemoryRegion::~MinidumpMemoryRegion() { + delete memory_; +} + + +void MinidumpMemoryRegion::SetDescriptor(MDMemoryDescriptor* descriptor) { + descriptor_ = descriptor; + valid_ = descriptor && + (descriptor_->start_of_memory_range + + descriptor_->memory.data_size) > + descriptor_->start_of_memory_range; +} + + +const u_int8_t* MinidumpMemoryRegion::GetMemory() { + if (!valid_) + return NULL; + + if (!memory_) { + if (!minidump_->SeekSet(descriptor_->memory.rva)) + return NULL; + + // TODO(mmentovai): verify rational size! + auto_ptr<vector<u_int8_t> > memory( + new vector<u_int8_t>(descriptor_->memory.data_size)); + + if (!minidump_->ReadBytes(&(*memory)[0], descriptor_->memory.data_size)) + return NULL; + + memory_ = memory.release(); + } + + return &(*memory_)[0]; +} + + +u_int64_t MinidumpMemoryRegion::GetBase() { + return valid_ ? descriptor_->start_of_memory_range : (u_int64_t)-1; +} + + +u_int32_t MinidumpMemoryRegion::GetSize() { + return valid_ ? descriptor_->memory.data_size : 0; +} + + +void MinidumpMemoryRegion::FreeMemory() { + delete memory_; + memory_ = NULL; +} + + +template<typename T> +bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(u_int64_t address, + T* value) { + if (!valid_ || !value) + return false; + + if (address < descriptor_->start_of_memory_range || + address + sizeof(T) > descriptor_->start_of_memory_range + + descriptor_->memory.data_size) { + return false; + } + + const u_int8_t* memory = GetMemory(); + if (!memory) + return false; + + // If the CPU requires memory accesses to be aligned, this can crash. + // x86 and ppc are able to cope, though. + *value = *reinterpret_cast<const T*>( + &memory[address - descriptor_->start_of_memory_range]); + + if (minidump_->swap()) + Swap(value); + + return true; +} + + +bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t address, + u_int8_t* value) { + return GetMemoryAtAddressInternal(address, value); +} + + +bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t address, + u_int16_t* value) { + return GetMemoryAtAddressInternal(address, value); +} + + +bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t address, + u_int32_t* value) { + return GetMemoryAtAddressInternal(address, value); +} + + +bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t address, + u_int64_t* value) { + return GetMemoryAtAddressInternal(address, value); +} + + +void MinidumpMemoryRegion::Print() { + if (!valid_) + return; + + const u_int8_t* memory = GetMemory(); + if (memory) { + printf("0x"); + for (unsigned int byte_index = 0; + byte_index < descriptor_->memory.data_size; + byte_index++) { + printf("%02x", memory[byte_index]); + } + printf("\n"); + } else { + printf("No memory\n"); + } +} + + +// +// MinidumpThread +// + + +MinidumpThread::MinidumpThread(Minidump* minidump) + : MinidumpObject(minidump) + , thread_() + , memory_(NULL) + , context_(NULL) { +} + + +MinidumpThread::~MinidumpThread() { + delete memory_; + delete context_; +} + + +bool MinidumpThread::Read() { + // Invalidate cached data. + delete memory_; + memory_ = NULL; + delete context_; + context_ = NULL; + + valid_ = false; + + if (!minidump_->ReadBytes(&thread_, sizeof(thread_))) + return false; + + if (minidump_->swap()) { + Swap(&thread_.thread_id); + Swap(&thread_.suspend_count); + Swap(&thread_.priority_class); + Swap(&thread_.priority); + Swap(&thread_.teb); + Swap(&thread_.stack); + Swap(&thread_.thread_context); + } + + // Check for base + size overflow or undersize. A separate size==0 + // check is needed in case base == 0. + u_int64_t high_address = thread_.stack.start_of_memory_range + + thread_.stack.memory.data_size - 1; + if (thread_.stack.memory.data_size == 0 || + high_address < thread_.stack.start_of_memory_range) + return false; + + memory_ = new MinidumpMemoryRegion(minidump_); + memory_->SetDescriptor(&thread_.stack); + + valid_ = true; + return true; +} + + +MinidumpMemoryRegion* MinidumpThread::GetMemory() { + return !valid_ ? NULL : memory_; +} + + +MinidumpContext* MinidumpThread::GetContext() { + if (!valid_) + return NULL; + + if (!context_) { + if (!minidump_->SeekSet(thread_.thread_context.rva)) + return NULL; + + auto_ptr<MinidumpContext> context(new MinidumpContext(minidump_)); + + if (!context->Read(thread_.thread_context.data_size)) + return NULL; + + context_ = context.release(); + } + + return context_; +} + + +u_int32_t MinidumpThread::GetThreadID() { + return valid_ ? thread_.thread_id : (u_int32_t)-1; +} + + +void MinidumpThread::Print() { + if (!valid_) + return; + + printf("MDRawThread\n"); + printf(" thread_id = 0x%x\n", thread_.thread_id); + printf(" suspend_count = %d\n", thread_.suspend_count); + printf(" priority_class = 0x%x\n", thread_.priority_class); + printf(" priority = 0x%x\n", thread_.priority); + printf(" teb = 0x%llx\n", thread_.teb); + printf(" stack.start_of_memory_range = 0x%llx\n", + thread_.stack.start_of_memory_range); + printf(" stack.memory.data_size = 0x%x\n", + thread_.stack.memory.data_size); + printf(" stack.memory.rva = 0x%x\n", thread_.stack.memory.rva); + printf(" thread_context.data_size = 0x%x\n", + thread_.thread_context.data_size); + printf(" thread_context.rva = 0x%x\n", + thread_.thread_context.rva); + + MinidumpContext* context = GetContext(); + if (context) { + printf("\n"); + context->Print(); + } else { + printf(" (no context)\n"); + printf("\n"); + } + + MinidumpMemoryRegion* memory = GetMemory(); + if (memory) { + printf("Stack\n"); + memory->Print(); + } else { + printf("No stack\n"); + } + printf("\n"); +} + + +// +// MinidumpThreadList +// + + +MinidumpThreadList::MinidumpThreadList(Minidump* minidump) + : MinidumpStream(minidump) + , id_to_thread_map_() + , threads_(NULL) + , thread_count_(0) { +} + + +MinidumpThreadList::~MinidumpThreadList() { + delete threads_; +} + + +bool MinidumpThreadList::Read(u_int32_t expected_size) { + // Invalidate cached data. + id_to_thread_map_.clear(); + delete threads_; + threads_ = NULL; + thread_count_ = 0; + + valid_ = false; + + u_int32_t thread_count; + if (expected_size < sizeof(thread_count)) + return false; + if (!minidump_->ReadBytes(&thread_count, sizeof(thread_count))) + return false; + + if (minidump_->swap()) + Swap(&thread_count); + + if (expected_size != sizeof(thread_count) + + thread_count * sizeof(MDRawThread)) { + return false; + } + + // TODO(mmentovai): verify rational size! + auto_ptr<MinidumpThreads> threads( + new MinidumpThreads(thread_count, MinidumpThread(minidump_))); + + for (unsigned int thread_index = 0; + thread_index < thread_count; + ++thread_index) { + MinidumpThread* thread = &(*threads)[thread_index]; + + // Assume that the file offset is correct after the last read. + if (!thread->Read()) + return false; + + u_int32_t thread_id = thread->GetThreadID(); + if (GetThreadByID(thread_id)) { + // Another thread with this ID is already in the list. Data error. + return false; + } + id_to_thread_map_[thread_id] = thread; + } + + threads_ = threads.release(); + thread_count_ = thread_count; + + valid_ = true; + return true; +} + + +MinidumpThread* MinidumpThreadList::GetThreadAtIndex(unsigned int index) + const { + if (!valid_ || index >= thread_count_) + return NULL; + + return &(*threads_)[index]; +} + + +MinidumpThread* MinidumpThreadList::GetThreadByID(u_int32_t thread_id) { + // Don't check valid_. Read calls this method before everything is + // validated. It is safe to not check valid_ here. + return id_to_thread_map_[thread_id]; +} + + +void MinidumpThreadList::Print() { + if (!valid_) + return; + + printf("MinidumpThreadList\n"); + printf(" thread_count = %d\n", thread_count_); + printf("\n"); + + for (unsigned int thread_index = 0; + thread_index < thread_count_; + ++thread_index) { + printf("thread[%d]\n", thread_index); + + (*threads_)[thread_index].Print(); + } +} + + +// +// MinidumpModule +// + + +MinidumpModule::MinidumpModule(Minidump* minidump) + : MinidumpObject(minidump) + , module_() + , name_(NULL) + , cv_record_(NULL) + , misc_record_(NULL) + , debug_filename_(NULL) { +} + + +MinidumpModule::~MinidumpModule() { + delete name_; + delete cv_record_; + delete misc_record_; + delete debug_filename_; +} + + +bool MinidumpModule::Read() { + // Invalidate cached data. + delete name_; + name_ = NULL; + delete cv_record_; + cv_record_ = NULL; + delete misc_record_; + misc_record_ = NULL; + delete debug_filename_; + debug_filename_ = NULL; + + valid_ = false; + + if (!minidump_->ReadBytes(&module_, MD_MODULE_SIZE)) + return false; + + if (minidump_->swap()) { + Swap(&module_.base_of_image); + Swap(&module_.size_of_image); + Swap(&module_.checksum); + Swap(&module_.time_date_stamp); + Swap(&module_.module_name_rva); + Swap(&module_.version_info.signature); + Swap(&module_.version_info.struct_version); + Swap(&module_.version_info.file_version_hi); + Swap(&module_.version_info.file_version_lo); + Swap(&module_.version_info.product_version_hi); + Swap(&module_.version_info.product_version_lo); + Swap(&module_.version_info.file_flags_mask); + Swap(&module_.version_info.file_flags); + Swap(&module_.version_info.file_os); + Swap(&module_.version_info.file_type); + Swap(&module_.version_info.file_subtype); + Swap(&module_.version_info.file_date_hi); + Swap(&module_.version_info.file_date_lo); + Swap(&module_.cv_record); + Swap(&module_.misc_record); + // Don't swap reserved fields because their contents are unknown (as + // are their proper widths). + } + + // Check for base + size overflow or undersize. A separate size==0 + // check is needed in case base == 0. + u_int64_t high_address = module_.base_of_image + module_.size_of_image - 1; + if (module_.size_of_image == 0 || high_address < module_.base_of_image) + return false; + + valid_ = true; + return true; +} + + +const string* MinidumpModule::GetName() { + if (!valid_) + return NULL; + + if (!name_) + name_ = minidump_->ReadString(module_.module_name_rva); + + return name_; +} + + +const u_int8_t* MinidumpModule::GetCVRecord() { + if (!valid_) + return NULL; + + if (!cv_record_) { + // Only check against the smallest possible structure size now - recheck + // if necessary later if the actual structure is larger. + if (sizeof(MDCVInfoPDB20) > module_.cv_record.data_size) + return NULL; + + if (!minidump_->SeekSet(module_.cv_record.rva)) + return NULL; + + // TODO(mmentovai): verify rational size! + + // Allocating something that will be accessed as MDCVInfoPDB70 or + // MDCVInfoPDB20 but is allocated as u_int8_t[] can cause alignment + // problems. x86 and ppc are able to cope, though. This allocation + // style is needed because the MDCVInfoPDB70 or MDCVInfoPDB20 are + // variable-sized due to their pdb_file_name fields; these structures + // are not sizeof(MDCVInfoPDB70) or sizeof(MDCVInfoPDB20) and treating + // them as such would result in incomplete structures or overruns. + auto_ptr<vector<u_int8_t> > cv_record( + new vector<u_int8_t>(module_.cv_record.data_size)); + + if (!minidump_->ReadBytes(&(*cv_record)[0], module_.cv_record.data_size)) + return NULL; + + MDCVInfoPDB70* cv_record_70 = + reinterpret_cast<MDCVInfoPDB70*>(&(*cv_record)[0]); + u_int32_t signature = cv_record_70->cv_signature; + if (minidump_->swap()) + Swap(&signature); + + if (signature == MD_CVINFOPDB70_SIGNATURE) { + // Now that the structure type is known, recheck the size. + if (sizeof(MDCVInfoPDB70) > module_.cv_record.data_size) + return NULL; + + if (minidump_->swap()) { + Swap(&cv_record_70->cv_signature); + Swap(&cv_record_70->signature); + Swap(&cv_record_70->age); + // Don't swap cv_record_70.pdb_file_name because it's an array of 8-bit + // quanities. (It's a path, is it UTF-8?) + } + } else if (signature == MD_CVINFOPDB20_SIGNATURE) { + if (minidump_->swap()) { + MDCVInfoPDB20* cv_record_20 = + reinterpret_cast<MDCVInfoPDB20*>(&(*cv_record)[0]); + Swap(&cv_record_20->cv_header.signature); + Swap(&cv_record_20->cv_header.offset); + Swap(&cv_record_20->signature); + Swap(&cv_record_20->age); + // Don't swap cv_record_20.pdb_file_name because it's an array of 8-bit + // quantities. (It's a path, is it UTF-8?) + } + } else { + // Some unknown structure type. We don't need to bail out here, but we + // do instead of returning it, because this method guarantees properly + // swapped data, and data in an unknown format can't possibly be swapped. + return NULL; + } + + // The last field of either structure is null-terminated 8-bit character + // data. Ensure that it's null-terminated. + if ((*cv_record)[module_.cv_record.data_size - 1] != '\0') + return NULL; + + // Store the vector type because that's how storage was allocated, but + // return it casted to u_int8_t*. + cv_record_ = cv_record.release(); + } + + return &(*cv_record_)[0]; +} + + +const MDImageDebugMisc* MinidumpModule::GetMiscRecord() { + if (!valid_) + return NULL; + + if (!misc_record_) { + if (sizeof(MDImageDebugMisc) > module_.misc_record.data_size) + return NULL; + + if (!minidump_->SeekSet(module_.misc_record.rva)) + return NULL; + + // TODO(mmentovai): verify rational size! + + // Allocating something that will be accessed as MDImageDebugMisc but + // is allocated as u_int8_t[] can cause alignment problems. x86 and + // ppc are able to cope, though. This allocation style is needed + // because the MDImageDebugMisc is variable-sized due to its data field; + // this structure is not sizeof(MDImageDebugMisc) and treating it as such + // would result in an incomplete structure or an overrun. + auto_ptr<vector<u_int8_t> > misc_record_mem( + new vector<u_int8_t>(module_.misc_record.data_size)); + MDImageDebugMisc* misc_record = + reinterpret_cast<MDImageDebugMisc*>(&(*misc_record_mem)[0]); + + if (!minidump_->ReadBytes(misc_record, module_.misc_record.data_size)) + return NULL; + + if (minidump_->swap()) { + Swap(&misc_record->data_type); + Swap(&misc_record->length); + // Don't swap misc_record.unicode because it's an 8-bit quantity. + // Don't swap the reserved fields for the same reason, and because + // they don't contain any valid data. + if (misc_record->unicode) { + // There is a potential alignment problem, but shouldn't be a problem + // in practice due to the layout of MDImageDebugMisc. + u_int16_t* data16 = reinterpret_cast<u_int16_t*>(&(misc_record->data)); + unsigned int dataBytes = module_.misc_record.data_size - + sizeof(MDImageDebugMisc); + unsigned int dataLength = dataBytes / 2; + for (unsigned int characterIndex = 0; + characterIndex < dataLength; + ++characterIndex) { + Swap(&data16[characterIndex]); + } + } + } + + if (module_.misc_record.data_size != misc_record->length) + return NULL; + + // Store the vector type because that's how storage was allocated, but + // return it casted to MDImageDebugMisc*. + misc_record_ = misc_record_mem.release(); + } + + return reinterpret_cast<MDImageDebugMisc*>(&(*misc_record_)[0]); +} + + +// This method will perform no allocation-size checking on its own; it relies +// on GetCVRecord() and GetMiscRecord() to have made the determination that +// the necessary structures aren't oversized. +const string* MinidumpModule::GetDebugFilename() { + if (!valid_) + return NULL; + + if (!debug_filename_) { + // Prefer the CodeView record if present. + const MDCVInfoPDB70* cv_record_70 = + reinterpret_cast<const MDCVInfoPDB70*>(GetCVRecord()); + if (cv_record_70) { + if (cv_record_70->cv_signature == MD_CVINFOPDB70_SIGNATURE) { + // GetCVRecord guarantees pdb_file_name is null-terminated. + debug_filename_ = new string( + reinterpret_cast<const char*>(cv_record_70->pdb_file_name)); + + return debug_filename_; + } else if (cv_record_70->cv_signature == MD_CVINFOPDB20_SIGNATURE) { + // It's actually a MDCVInfoPDB20 structure. + const MDCVInfoPDB20* cv_record_20 = + reinterpret_cast<const MDCVInfoPDB20*>(cv_record_70); + + // GetCVRecord guarantees pdb_file_name is null-terminated. + debug_filename_ = new string( + reinterpret_cast<const char*>(cv_record_20->pdb_file_name)); + + return debug_filename_; + } + + // If there's a CodeView record but it doesn't match either of those + // signatures, try the miscellaneous record - but it's suspicious because + // GetCVRecord shouldn't have returned a CodeView record that doesn't + // match either signature. + } + + // No usable CodeView record. Try the miscellaneous debug record. + const MDImageDebugMisc* misc_record = GetMiscRecord(); + if (!misc_record) + return NULL; + + if (!misc_record->unicode) { + // If it's not Unicode, just stuff it into the string. It's unclear + // if misc_record->data is 0-terminated, so use an explicit size. + debug_filename_ = new string( + reinterpret_cast<const char*>(misc_record->data), + module_.misc_record.data_size - sizeof(MDImageDebugMisc)); + + return debug_filename_; + } + + // There's a misc_record but it encodes the debug filename in UTF-16. + // (Actually, because miscellaneous records are so old, it's probably + // UCS-2.) Convert it to UTF-8 for congruity with the other strings that + // this method (and all other methods in the Minidump family) return. + + unsigned int bytes = + module_.misc_record.data_size - sizeof(MDImageDebugMisc); + if (bytes % 2 != 0) + return NULL; + unsigned int utf16_words = bytes / 2; + + // UTF16ToUTF8 expects a vector<u_int16_t>, so create a temporary one and + // copy the UTF-16 data into it. + vector<u_int16_t> string_utf16(utf16_words); + memcpy(&string_utf16[0], &misc_record->data, bytes); + + // GetMiscRecord already byte-swapped the data[] field if it contains + // UTF-16, so pass false as the swap argument. + debug_filename_ = UTF16ToUTF8(string_utf16, false); + } + + return debug_filename_; +} + + +void MinidumpModule::Print() { + if (!valid_) + return; + + printf("MDRawModule\n"); + printf(" base_of_image = 0x%llx\n", + module_.base_of_image); + printf(" size_of_image = 0x%x\n", + module_.size_of_image); + printf(" checksum = 0x%x\n", + module_.checksum); + printf(" time_date_stamp = 0x%x\n", + module_.time_date_stamp); + printf(" module_name_rva = 0x%x\n", + module_.module_name_rva); + printf(" version_info.signature = 0x%x\n", + module_.version_info.signature); + printf(" version_info.struct_version = 0x%x\n", + module_.version_info.struct_version); + printf(" version_info.file_version = 0x%x:0x%x\n", + module_.version_info.file_version_hi, + module_.version_info.file_version_lo); + printf(" version_info.product_version = 0x%x:0x%x\n", + module_.version_info.product_version_hi, + module_.version_info.product_version_lo); + printf(" version_info.file_flags_mask = 0x%x\n", + module_.version_info.file_flags_mask); + printf(" version_info.file_flags = 0x%x\n", + module_.version_info.file_flags); + printf(" version_info.file_os = 0x%x\n", + module_.version_info.file_os); + printf(" version_info.file_type = 0x%x\n", + module_.version_info.file_type); + printf(" version_info.file_subtype = 0x%x\n", + module_.version_info.file_subtype); + printf(" version_info.file_date = 0x%x:0x%x\n", + module_.version_info.file_date_hi, + module_.version_info.file_date_lo); + printf(" cv_record.data_size = %d\n", + module_.cv_record.data_size); + printf(" cv_record.rva = 0x%x\n", + module_.cv_record.rva); + printf(" misc_record.data_size = %d\n", + module_.misc_record.data_size); + printf(" misc_record.rva = 0x%x\n", + module_.misc_record.rva); + + const char* module_name = GetName()->c_str(); + if (module_name) + printf(" (module_name) = \"%s\"\n", module_name); + else + printf(" (module_name) = (null)\n"); + + const MDCVInfoPDB70* cv_record = + reinterpret_cast<const MDCVInfoPDB70*>(GetCVRecord()); + if (cv_record) { + if (cv_record->cv_signature == MD_CVINFOPDB70_SIGNATURE) { + printf(" (cv_record).cv_signature = 0x%x\n", + cv_record->cv_signature); + printf(" (cv_record).signature = %08x-%04x-%04x-%02x%02x-", + cv_record->signature.data1, + cv_record->signature.data2, + cv_record->signature.data3, + cv_record->signature.data4[0], + cv_record->signature.data4[1]); + for (unsigned int guidIndex = 2; + guidIndex < 8; + ++guidIndex) { + printf("%02x", cv_record->signature.data4[guidIndex]); + } + printf("\n"); + printf(" (cv_record).age = %d\n", + cv_record->age); + printf(" (cv_record).pdb_file_name = \"%s\"\n", + cv_record->pdb_file_name); + } else { + const MDCVInfoPDB20* cv_record_20 = + reinterpret_cast<const MDCVInfoPDB20*>(cv_record); + printf(" (cv_record).cv_header.signature = 0x%x\n", + cv_record_20->cv_header.signature); + printf(" (cv_record).cv_header.offset = 0x%x\n", + cv_record_20->cv_header.offset); + printf(" (cv_record).signature = 0x%x\n", + cv_record_20->signature); + printf(" (cv_record).age = %d\n", + cv_record_20->age); + printf(" (cv_record).pdb_file_name = \"%s\"\n", + cv_record_20->pdb_file_name); + } + } else { + printf(" (cv_record) = (null)\n"); + } + + const MDImageDebugMisc* misc_record = GetMiscRecord(); + if (misc_record) { + printf(" (misc_record).data_type = 0x%x\n", + misc_record->data_type); + printf(" (misc_record).length = 0x%x\n", + misc_record->length); + printf(" (misc_record).unicode = %d\n", + misc_record->unicode); + // Don't bother printing the UTF-16, we don't really even expect to ever + // see this misc_record anyway. + if (misc_record->unicode) + printf(" (misc_record).data = \"%s\"\n", + misc_record->data); + else + printf(" (misc_record).data = (UTF-16)\n"); + } else { + printf(" (misc_record) = (null)\n"); + } + + const string* debug_filename = GetDebugFilename(); + if (debug_filename) { + printf(" (debug_filename) = \"%s\"\n", + debug_filename->c_str()); + } else { + printf(" (debug_filename) = (null)\n"); + } + printf("\n"); +} + + +// +// MinidumpModuleList +// + + +MinidumpModuleList::MinidumpModuleList(Minidump* minidump) + : MinidumpStream(minidump) + , range_map_() + , modules_(NULL) + , module_count_(0) { +} + + +MinidumpModuleList::~MinidumpModuleList() { + delete modules_; +} + + +bool MinidumpModuleList::Read(u_int32_t expected_size) { + // Invalidate cached data. + range_map_.Clear(); + delete modules_; + modules_ = NULL; + module_count_ = 0; + + valid_ = false; + + u_int32_t module_count; + if (expected_size < sizeof(module_count)) + return false; + if (!minidump_->ReadBytes(&module_count, sizeof(module_count))) + return false; + + if (minidump_->swap()) + Swap(&module_count); + + if (expected_size != sizeof(module_count) + + module_count * MD_MODULE_SIZE) { + return false; + } + + // TODO(mmentovai): verify rational size! + auto_ptr<MinidumpModules> modules( + new MinidumpModules(module_count, MinidumpModule(minidump_))); + + for (unsigned int module_index = 0; + module_index < module_count; + ++module_index) { + MinidumpModule* module = &(*modules)[module_index]; + + // Assume that the file offset is correct after the last read. + if (!module->Read()) + return false; + + u_int64_t base_address = module->base_address(); + u_int64_t module_size = module->size(); + if (base_address == (u_int64_t)-1) + return false; + + if (!range_map_.StoreRange(base_address, module_size, module_index)) + return false; + } + + modules_ = modules.release(); + module_count_ = module_count; + + valid_ = true; + return true; +} + + +MinidumpModule* MinidumpModuleList::GetModuleAtIndex(unsigned int index) + const { + if (!valid_ || index >= module_count_) + return NULL; + + return &(*modules_)[index]; +} + + +MinidumpModule* MinidumpModuleList::GetModuleForAddress(u_int64_t address) { + if (!valid_) + return NULL; + + unsigned int module_index; + if (!range_map_.RetrieveRange(address, &module_index)) + return NULL; + + return GetModuleAtIndex(module_index); +} + + +void MinidumpModuleList::Print() { + if (!valid_) + return; + + printf("MinidumpModuleList\n"); + printf(" module_count = %d\n", module_count_); + printf("\n"); + + for (unsigned int module_index = 0; + module_index < module_count_; + ++module_index) { + printf("module[%d]\n", module_index); + + (*modules_)[module_index].Print(); + } +} + + +// +// MinidumpMemoryList +// + + +MinidumpMemoryList::MinidumpMemoryList(Minidump* minidump) + : MinidumpStream(minidump) + , range_map_() + , descriptors_(NULL) + , regions_(NULL) + , region_count_(0) { +} + + +MinidumpMemoryList::~MinidumpMemoryList() { + delete descriptors_; + delete regions_; +} + + +bool MinidumpMemoryList::Read(u_int32_t expected_size) { + // Invalidate cached data. + delete descriptors_; + descriptors_ = NULL; + delete regions_; + regions_ = NULL; + range_map_.Clear(); + region_count_ = 0; + + valid_ = false; + + u_int32_t region_count; + if (expected_size < sizeof(region_count)) + return false; + if (!minidump_->ReadBytes(®ion_count, sizeof(region_count))) + return false; + + if (minidump_->swap()) + Swap(®ion_count); + + if (expected_size != sizeof(region_count) + + region_count * sizeof(MDMemoryDescriptor)) { + return false; + } + + // TODO(mmentovai): verify rational size! + auto_ptr<MemoryDescriptors> descriptors(new MemoryDescriptors(region_count)); + + // Read the entire array in one fell swoop, instead of reading one entry + // at a time in the loop. + if (!minidump_->ReadBytes(&(*descriptors)[0], + sizeof(MDMemoryDescriptor) * region_count)) { + return false; + } + + auto_ptr<MemoryRegions> regions( + new MemoryRegions(region_count, MinidumpMemoryRegion(minidump_))); + + for (unsigned int region_index = 0; + region_index < region_count; + ++region_index) { + MDMemoryDescriptor* descriptor = &(*descriptors)[region_index]; + + if (minidump_->swap()) + Swap(&*descriptor); + + u_int64_t base_address = descriptor->start_of_memory_range; + u_int32_t region_size = descriptor->memory.data_size; + + // Check for base + size overflow or undersize. A separate size==0 + // check is needed in case base == 0. + u_int64_t high_address = base_address + region_size - 1; + if (region_size == 0 || high_address < base_address) + return false; + + if (!range_map_.StoreRange(base_address, region_size, region_index)) + return false; + + (*regions)[region_index].SetDescriptor(descriptor); + } + + region_count_ = region_count; + descriptors_ = descriptors.release(); + regions_ = regions.release(); + + valid_ = true; + return true; +} + + +MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionAtIndex( + unsigned int index) { + if (!valid_ || index >= region_count_) + return NULL; + + return &(*regions_)[index]; +} + + +MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionForAddress( + u_int64_t address) { + if (!valid_) + return NULL; + + unsigned int region_index; + if (!range_map_.RetrieveRange(address, ®ion_index)) + return NULL; + + return GetMemoryRegionAtIndex(region_index); +} + + +void MinidumpMemoryList::Print() { + if (!valid_) + return; + + printf("MinidumpMemoryList\n"); + printf(" region_count = %d\n", region_count_); + printf("\n"); + + for (unsigned int region_index = 0; + region_index < region_count_; + ++region_index) { + MDMemoryDescriptor* descriptor = &(*descriptors_)[region_index]; + printf("region[%d]\n", region_index); + printf("MDMemoryDescriptor\n"); + printf(" start_of_memory_range = 0x%llx\n", + descriptor->start_of_memory_range); + printf(" memory.data_size = 0x%x\n", descriptor->memory.data_size); + printf(" memory.rva = 0x%x\n", descriptor->memory.rva); + MinidumpMemoryRegion* region = GetMemoryRegionAtIndex(region_index); + if (region) { + printf("Memory\n"); + region->Print(); + } else { + printf("No memory\n"); + } + printf("\n"); + } +} + + +// +// MinidumpException +// + + +MinidumpException::MinidumpException(Minidump* minidump) + : MinidumpStream(minidump) + , exception_() + , context_(NULL) { +} + + +MinidumpException::~MinidumpException() { + delete context_; +} + + +bool MinidumpException::Read(u_int32_t expected_size) { + // Invalidate cached data. + delete context_; + context_ = NULL; + + valid_ = false; + + if (expected_size != sizeof(exception_)) + return false; + + if (!minidump_->ReadBytes(&exception_, sizeof(exception_))) + return false; + + if (minidump_->swap()) { + Swap(&exception_.thread_id); + // exception_.__align is for alignment only and does not need to be + // swapped. + Swap(&exception_.exception_record.exception_code); + Swap(&exception_.exception_record.exception_flags); + Swap(&exception_.exception_record.exception_record); + Swap(&exception_.exception_record.exception_address); + Swap(&exception_.exception_record.number_parameters); + // exception_.exception_record.__align is for alignment only and does not + // need to be swapped. + for (unsigned int parameter_index = 0; + parameter_index < MD_EXCEPTION_MAXIMUM_PARAMETERS; + ++parameter_index) { + Swap(&exception_.exception_record.exception_information[parameter_index]); + } + Swap(&exception_.thread_context); + } + + valid_ = true; + return true; +} + + +u_int32_t MinidumpException::GetThreadID() { + return valid_ ? exception_.thread_id : 0; +} + + +MinidumpContext* MinidumpException::GetContext() { + if (!valid_) + return NULL; + + if (!context_) { + if (!minidump_->SeekSet(exception_.thread_context.rva)) + return NULL; + + auto_ptr<MinidumpContext> context(new MinidumpContext(minidump_)); + + if (!context->Read(exception_.thread_context.data_size)) + return NULL; + + context_ = context.release(); + } + + return context_; +} + + +void MinidumpException::Print() { + if (!valid_) + return; + + printf("MDException\n"); + printf(" thread_id = 0x%x\n", + exception_.thread_id); + printf(" exception_record.exception_code = 0x%x\n", + exception_.exception_record.exception_code); + printf(" exception_record.exception_flags = 0x%x\n", + exception_.exception_record.exception_flags); + printf(" exception_record.exception_record = 0x%llx\n", + exception_.exception_record.exception_record); + printf(" exception_record.exception_address = 0x%llx\n", + exception_.exception_record.exception_address); + printf(" exception_record.number_parameters = %d\n", + exception_.exception_record.number_parameters); + for (unsigned int parameterIndex = 0; + parameterIndex < exception_.exception_record.number_parameters; + ++parameterIndex) { + printf(" exception_record.exception_information[%2d] = 0x%llx\n", + parameterIndex, + exception_.exception_record.exception_information[parameterIndex]); + } + printf(" thread_context.data_size = %d\n", + exception_.thread_context.data_size); + printf(" thread_context.rva = 0x%x\n", + exception_.thread_context.rva); + MinidumpContext* context = GetContext(); + if (context) { + printf("\n"); + context->Print(); + } else { + printf(" (no context)\n"); + printf("\n"); + } +} + + +// +// MinidumpSystemInfo +// + + +MinidumpSystemInfo::MinidumpSystemInfo(Minidump* minidump) + : MinidumpStream(minidump) + , system_info_() + , csd_version_(NULL) { +} + + +MinidumpSystemInfo::~MinidumpSystemInfo() { + delete csd_version_; +} + + +bool MinidumpSystemInfo::Read(u_int32_t expected_size) { + // Invalidate cached data. + delete csd_version_; + csd_version_ = NULL; + + valid_ = false; + + if (expected_size != sizeof(system_info_)) + return false; + + if (!minidump_->ReadBytes(&system_info_, sizeof(system_info_))) + return false; + + if (minidump_->swap()) { + Swap(&system_info_.processor_architecture); + Swap(&system_info_.processor_level); + Swap(&system_info_.processor_revision); + // number_of_processors and product_type are 8-bit quantities and need no + // swapping. + Swap(&system_info_.major_version); + Swap(&system_info_.minor_version); + Swap(&system_info_.build_number); + Swap(&system_info_.platform_id); + Swap(&system_info_.csd_version_rva); + Swap(&system_info_.suite_mask); + Swap(&system_info_.reserved2); + // TODO(mmentovai): This obviously only supports x86 for the time being. + for (unsigned int i = 0; i < 3; ++i) + Swap(&system_info_.cpu.x86_cpu_info.vendor_id[i]); + Swap(&system_info_.cpu.x86_cpu_info.version_information); + Swap(&system_info_.cpu.x86_cpu_info.feature_information); + Swap(&system_info_.cpu.x86_cpu_info.amd_extended_cpu_features); + } + + valid_ = true; + return true; +} + + +const string* MinidumpSystemInfo::GetCSDVersion() { + if (!valid_) + return NULL; + + if (!csd_version_) + csd_version_ = minidump_->ReadString(system_info_.csd_version_rva); + + return csd_version_; +} + + +void MinidumpSystemInfo::Print() { + if (!valid_) + return; + + printf("MDRawSystemInfo\n"); + printf(" processor_architecture = %d\n", + system_info_.processor_architecture); + printf(" processor_level = %d\n", + system_info_.processor_level); + printf(" number_of_processors = %d\n", + system_info_.number_of_processors); + printf(" product_type = %d\n", + system_info_.product_type); + printf(" major_version = %d\n", + system_info_.major_version); + printf(" minor_version = %d\n", + system_info_.minor_version); + printf(" build_number = %d\n", + system_info_.build_number); + printf(" platform_id = %d\n", + system_info_.platform_id); + printf(" csd_version_rva = 0x%x\n", + system_info_.csd_version_rva); + printf(" suite_mask = 0x%x\n", + system_info_.suite_mask); + printf(" reserved2 = 0x%x\n", + system_info_.reserved2); + for (unsigned int i = 0; i < 3; ++i) { + printf(" cpu.x86_cpu_info.vendor_id[%d] = 0x%x\n", + i, system_info_.cpu.x86_cpu_info.vendor_id[i]); + } + printf(" cpu.x86_cpu_info.version_information = 0x%x\n", + system_info_.cpu.x86_cpu_info.version_information); + printf(" cpu.x86_cpu_info.feature_information = 0x%x\n", + system_info_.cpu.x86_cpu_info.feature_information); + printf(" cpu.x86_cpu_info.amd_extended_cpu_features = 0x%x\n", + system_info_.cpu.x86_cpu_info.amd_extended_cpu_features); + const char* csd_version = GetCSDVersion()->c_str(); + if (csd_version) + printf(" (csd_version) = \"%s\"\n", + csd_version); + else + printf(" (csd_version) = (null)\n"); + printf("\n"); +} + + +// +// MinidumpMiscInfo +// + + +MinidumpMiscInfo::MinidumpMiscInfo(Minidump* minidump) + : MinidumpStream(minidump) + , misc_info_() { +} + + +bool MinidumpMiscInfo::Read(u_int32_t expected_size) { + valid_ = false; + + if (expected_size != MD_MISCINFO_SIZE && + expected_size != MD_MISCINFO2_SIZE) { + return false; + } + + if (!minidump_->ReadBytes(&misc_info_, expected_size)) + return false; + + if (minidump_->swap()) { + Swap(&misc_info_.size_of_info); + Swap(&misc_info_.flags1); + Swap(&misc_info_.process_id); + Swap(&misc_info_.process_create_time); + Swap(&misc_info_.process_user_time); + Swap(&misc_info_.process_kernel_time); + if (misc_info_.size_of_info > MD_MISCINFO_SIZE) { + Swap(&misc_info_.processor_max_mhz); + Swap(&misc_info_.processor_current_mhz); + Swap(&misc_info_.processor_mhz_limit); + Swap(&misc_info_.processor_max_idle_state); + Swap(&misc_info_.processor_current_idle_state); + } + } + + if (misc_info_.size_of_info != expected_size) + return false; + + valid_ = true; + return true; +} + + +void MinidumpMiscInfo::Print() { + if (!valid_) + return; + + printf("MDRawMiscInfo\n"); + printf(" size_of_info = %d\n", misc_info_.size_of_info); + printf(" flags1 = 0x%x\n", misc_info_.flags1); + printf(" process_id = 0x%x\n", misc_info_.process_id); + printf(" process_create_time = 0x%x\n", + misc_info_.process_create_time); + printf(" process_user_time = 0x%x\n", + misc_info_.process_user_time); + printf(" process_kernel_time = 0x%x\n", + misc_info_.process_kernel_time); + if (misc_info_.size_of_info > MD_MISCINFO_SIZE) { + printf(" processor_max_mhz = %d\n", + misc_info_.processor_max_mhz); + printf(" processor_current_mhz = %d\n", + misc_info_.processor_current_mhz); + printf(" processor_mhz_limit = %d\n", + misc_info_.processor_mhz_limit); + printf(" processor_max_idle_state = 0x%x\n", + misc_info_.processor_max_idle_state); + printf(" processor_current_idle_state = 0x%x\n", + misc_info_.processor_current_idle_state); + } +} + + +// +// Minidump +// + + +Minidump::Minidump(int fd) + : header_() + , directory_(NULL) + , stream_map_(NULL) + , fd_(fd) + , swap_(false) + , valid_(false) { +} + + +Minidump::~Minidump() { + delete directory_; + delete stream_map_; +} + + +bool Minidump::Read() { + // Invalidate cached data. + delete directory_; + directory_ = NULL; + delete stream_map_; + stream_map_ = NULL; + + valid_ = false; + + if (!ReadBytes(&header_, sizeof(MDRawHeader))) + return false; + + if (header_.signature != MD_HEADER_SIGNATURE) { + // The file may be byte-swapped. Under the present architecture, these + // classes don't know or need to know what CPU (or endianness) the + // minidump was produced on in order to parse it. Use the signature as + // a byte order marker. + u_int32_t signature_swapped = header_.signature; + Swap(&signature_swapped); + if (signature_swapped != MD_HEADER_SIGNATURE) { + // This isn't a minidump or a byte-swapped minidump. + return false; + } + swap_ = true; + } else { + // The file is not byte-swapped. Set swap_ false (it may have been true + // if the object is being reused?) + swap_ = false; + } + + if (swap_) { + Swap(&header_.signature); + Swap(&header_.version); + Swap(&header_.stream_count); + Swap(&header_.stream_directory_rva); + Swap(&header_.checksum); + Swap(&header_.time_date_stamp); + Swap(&header_.flags); + } + + // Version check. The high 16 bits of header_.version contain something + // else "implementation specific." + if ((header_.version & 0x0000ffff) != MD_HEADER_VERSION) { + return false; + } + + if (!SeekSet(header_.stream_directory_rva)) + return false; + + // TODO(mmentovai): verify rational size! + auto_ptr<MinidumpDirectoryEntries> directory( + new MinidumpDirectoryEntries(header_.stream_count)); + + // Read the entire array in one fell swoop, instead of reading one entry + // at a time in the loop. + if (!ReadBytes(&(*directory)[0], + sizeof(MDRawDirectory) * header_.stream_count)) + return false; + + auto_ptr<MinidumpStreamMap> stream_map(new MinidumpStreamMap()); + + for (unsigned int stream_index = 0; + stream_index < header_.stream_count; + ++stream_index) { + MDRawDirectory* directory_entry = &(*directory)[stream_index]; + + if (swap_) { + Swap(&directory_entry->stream_type); + Swap(&directory_entry->location); + } + + // Initialize the stream_map map, which speeds locating a stream by + // type. + unsigned int stream_type = directory_entry->stream_type; + switch(stream_type) { + case THREAD_LIST_STREAM: + case MODULE_LIST_STREAM: + case MEMORY_LIST_STREAM: + case EXCEPTION_STREAM: + case SYSTEM_INFO_STREAM: + case MISC_INFO_STREAM: { + if (stream_map->find(stream_type) != stream_map->end()) { + // Another stream with this type was already found. A minidump + // file should contain at most one of each of these stream types. + return false; + } + // Fall through to default + } + + default: { + // Overwrites for stream types other than those above, but it's + // expected to be the user's burden in that case. + (*stream_map)[stream_type].stream_index = stream_index; + } + } + } + + directory_ = directory.release(); + stream_map_ = stream_map.release(); + + valid_ = true; + return true; +} + + +MinidumpThreadList* Minidump::GetThreadList() { + MinidumpThreadList* thread_list; + return GetStream(&thread_list); +} + + +MinidumpModuleList* Minidump::GetModuleList() { + MinidumpModuleList* module_list; + return GetStream(&module_list); +} + + +MinidumpMemoryList* Minidump::GetMemoryList() { + MinidumpMemoryList* memory_list; + return GetStream(&memory_list); +} + + +MinidumpException* Minidump::GetException() { + MinidumpException* exception; + return GetStream(&exception); +} + + +MinidumpSystemInfo* Minidump::GetSystemInfo() { + MinidumpSystemInfo* system_info; + return GetStream(&system_info); +} + + +MinidumpMiscInfo* Minidump::GetMiscInfo() { + MinidumpMiscInfo* misc_info; + return GetStream(&misc_info); +} + + +void Minidump::Print() { + if (!valid_) + return; + + printf("MDRawHeader\n"); + printf(" signature = 0x%x\n", header_.signature); + printf(" version = 0x%x\n", header_.version); + printf(" stream_count = %d\n", header_.stream_count); + printf(" stream_directory_rva = 0x%x\n", header_.stream_directory_rva); + printf(" checksum = 0x%x\n", header_.checksum); + struct tm* timestruct = localtime((time_t*)&header_.time_date_stamp); + char timestr[20]; + strftime(timestr, 20, "%Y-%m-%d %H:%M:%S", timestruct); + printf(" time_date_stamp = 0x%x %s\n", header_.time_date_stamp, + timestr); + printf(" flags = 0x%llx\n", header_.flags); + printf("\n"); + + for (unsigned int stream_index = 0; + stream_index < header_.stream_count; + ++stream_index) { + MDRawDirectory* directory_entry = &(*directory_)[stream_index]; + + printf("mDirectory[%d]\n", stream_index); + printf("MDRawDirectory\n"); + printf(" stream_type = %d\n", directory_entry->stream_type); + printf(" location.data_size = %d\n", + directory_entry->location.data_size); + printf(" location.rva = 0x%x\n", directory_entry->location.rva); + printf("\n"); + } + + printf("Streams:\n"); + for (MinidumpStreamMap::const_iterator iterator = stream_map_->begin(); + iterator != stream_map_->end(); + ++iterator) { + u_int32_t stream_type = iterator->first; + MinidumpStreamInfo info = iterator->second; + printf(" stream type %2d at index %d\n", stream_type, info.stream_index); + } + printf("\n"); +} + + +const MDRawDirectory* Minidump::GetDirectoryEntryAtIndex(unsigned int index) + const { + if (!valid_ || index >= header_.stream_count) + return NULL; + + return &(*directory_)[index]; +} + + +bool Minidump::ReadBytes(void* bytes, size_t count) { + // Can't check valid_ because Read needs to call this method before + // validity can be determined. The only member that this method + // depends on is mFD, and an unset or invalid fd may generate an + // error but should not cause a crash. + ssize_t bytes_read = read(fd_, bytes, count); + if (static_cast<size_t>(bytes_read) != count) + return false; + return true; +} + + +bool Minidump::SeekSet(off_t offset) { + // Can't check valid_ because Read needs to call this method before + // validity can be determined. The only member that this method + // depends on is mFD, and an unset or invalid fd may generate an + // error but should not cause a crash. + off_t sought = lseek(fd_, offset, SEEK_SET); + if (sought != offset) + return false; + return true; +} + + +string* Minidump::ReadString(off_t offset) { + if (!valid_) + return NULL; + if (!SeekSet(offset)) + return NULL; + + u_int32_t bytes; + if (!ReadBytes(&bytes, sizeof(bytes))) + return NULL; + if (swap_) + Swap(&bytes); + + if (bytes % 2 != 0) + return NULL; + unsigned int utf16_words = bytes / 2; + + // TODO(mmentovai): verify rational size! + vector<u_int16_t> string_utf16(utf16_words); + + if (!ReadBytes(&string_utf16[0], bytes)) + return NULL; + + return UTF16ToUTF8(string_utf16, swap_); +} + + +bool Minidump::SeekToStreamType(u_int32_t stream_type, + u_int32_t* stream_length) { + if (!valid_ || !stream_length) + return false; + + MinidumpStreamMap::const_iterator iterator = stream_map_->find(stream_type); + if (iterator == stream_map_->end()) { + // This stream type didn't exist in the directory. + return false; + } + + MinidumpStreamInfo info = iterator->second; + if (info.stream_index >= header_.stream_count) + return false; + + MDRawDirectory* directory_entry = &(*directory_)[info.stream_index]; + if (!SeekSet(directory_entry->location.rva)) + return false; + + *stream_length = directory_entry->location.data_size; + + return true; +} + + +template<typename T> +T* Minidump::GetStream(T** stream) { + // stream is a garbage parameter that's present only to account for C++'s + // inability to overload a method based solely on its return type. + + if (!stream) + return NULL; + *stream = NULL; + + if (!valid_) + return NULL; + + u_int32_t stream_type = T::kStreamType; + MinidumpStreamMap::iterator iterator = stream_map_->find(stream_type); + if (iterator == stream_map_->end()) { + // This stream type didn't exist in the directory. + return NULL; + } + + // Get a pointer so that the stored stream field can be altered. + MinidumpStreamInfo* info = &iterator->second; + + if (info->stream) { + // This cast is safe because info.stream is only populated by this + // method, and there is a direct correlation between T and stream_type. + *stream = static_cast<T*>(info->stream); + return *stream; + } + + u_int32_t stream_length; + if (!SeekToStreamType(stream_type, &stream_length)) + return NULL; + + auto_ptr<T> new_stream(new T(this)); + + if (!new_stream->Read(stream_length)) + return NULL; + + *stream = new_stream.release(); + info->stream = *stream; + return *stream; +} + + +} // namespace google_airbag diff --git a/src/processor/minidump.h b/src/processor/minidump.h new file mode 100644 index 00000000..bbef1c99 --- /dev/null +++ b/src/processor/minidump.h @@ -0,0 +1,699 @@ +// Copyright (C) 2006 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// minidump.h: A minidump reader. +// +// The basic structure of this module tracks the structure of the minidump +// file itself. At the top level, a minidump file is represented by a +// Minidump object. Like most other classes in this module, Minidump +// provides a Read method that initializes the object with information from +// the file. Most of the classes in this file are wrappers around the +// "raw" structures found in the minidump file itself, and defined in +// minidump_format.h. For example, each thread is represented by a +// MinidumpThread object, whose parameters are specified in an MDRawThread +// structure. A properly byte-swapped MDRawThread can be obtained from a +// MinidumpThread easily by calling its thread() method. +// +// Most of the module lazily reads only the portion of the minidump file +// necessary to fulfill the user's request. Calling Minidump::Read +// only reads the minidump's directory. The thread list is not read until +// it is needed, and even once it's read, the memory regions for each +// thread's stack aren't read until they're needed. This strategy avoids +// unnecessary file input, and allocating memory for data in which the user +// has no interest. Note that although memory allocations for a typical +// minidump file are not particularly large, it is possible for legitimate +// minidumps to be sizable. A full-memory minidump, for example, contains +// a snapshot of the entire mapped memory space. Even a normal minidump, +// with stack memory only, can be large if, for example, the dump was +// generated in response to a crash that occurred due to an infinite- +// recursion bug that caused the stack's limits to be exceeded. Finally, +// some users of this library will unfortunately find themselves in the +// position of having to process potentially-hostile minidumps that might +// attempt to cause problems by forcing the minidump processor to over- +// allocate memory. +// +// Memory management in this module is based on a strict +// you-don't-own-anything policy. The only object owned by the user is +// the top-level Minidump object, the creation and destruction of which +// must be the user's own responsibility. All other objects obtained +// through interaction with this module are ultimately owned by the +// Minidump object, and will be freed upon the Minidump object's destruction. +// Because memory regions can potentially involve large allocations, a +// FreeMemory method is provided by MinidumpMemoryRegion, allowing the user +// to release data when it is no longer needed. Use of this method is +// optional but recommended. If freed data is later required, it will +// be read back in from the minidump file again. +// +// There is one exception to this memory management policy: +// Minidump::ReadString will return a string object to the user, and the user +// is responsible for its deletion. +// +// Author: Mark Mentovai + +#ifndef PROCESSOR_MINIDUMP_H__ +#define PROCESSOR_MINIDUMP_H__ + + +// TODO(mmentovai): is it ok to include non-<string> header in .h? +#include <map> +#include <string> +#include <vector> + +#include "processor/minidump_format.h" +#include "processor/memory_region.h" +#include "processor/range_map.h" + + +namespace google_airbag { + + +using std::map; +using std::string; +using std::vector; + + +class Minidump; + + +// MinidumpObject is the base of all Minidump* objects except for Minidump +// itself. +class MinidumpObject { + public: + virtual ~MinidumpObject() {} + + protected: + MinidumpObject(Minidump* minidump); + + // Refers to the Minidump object that is the ultimate parent of this + // Some MinidumpObjects are owned by other MinidumpObjects, but at the + // root of the ownership tree is always a Minidump. The Minidump object + // is kept here for access to its seeking and reading facilities, and + // for access to data about the minidump file itself, such as whether + // it should be byte-swapped. + Minidump* minidump_; + + // MinidumpObjects are not valid when created. When a subclass populates + // its own fields, it can set valid_ to true. Accessors and mutators may + // wish to consider or alter the valid_ state as they interact with + // objects. + bool valid_; +}; + + +// This class exists primarily to provide a virtual destructor in a base +// class common to all objects that might be stored in +// Minidump::mStreamObjects. Some object types (MinidumpContext) will +// never be stored in Minidump::mStreamObjects, but are represented as +// streams and adhere to the same interface, and may be derived from +// this class. +class MinidumpStream : public MinidumpObject { + public: + virtual ~MinidumpStream() {} + + protected: + MinidumpStream(Minidump* minidump); + + private: + // Populate (and validate) the MinidumpStream. minidump_ is expected + // to be positioned at the beginning of the stream, so that the next + // read from the minidump will be at the beginning of the stream. + // expected_size should be set to the stream's length as contained in + // the MDRawDirectory record or other identifying record. A class + // that implements MinidumpStream can compare expected_size to a + // known size as an integrity check. + virtual bool Read(u_int32_t expected_size) = 0; +}; + + +// MinidumpContext carries a CPU-specific MDRawContext structure, which +// contains CPU context such as register states. Each thread has its +// own context, and the exception record, if present, also has its own +// context. Note that if the exception record is present, the context it +// refers to is probably what the user wants to use for the exception +// thread, instead of that thread's own context. The exception thread's +// context (as opposed to the exception record's context) will contain +// context for the exception handler (which performs minidump generation), +// and not the context that caused the exception (which is probably what the +// user wants). +class MinidumpContext : public MinidumpStream { + public: + const MDRawContextX86* context() const { + return valid_ ? &context_ : NULL; } + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class MinidumpThread; + friend class MinidumpException; + + MinidumpContext(Minidump* minidump); + + bool Read(u_int32_t expected_size); + + // TODO(mmentovai): This is x86-only for now. When other CPUs are + // supported, this class can move to MinidumpContext_x86 and derive from + // a new abstract MinidumpContext. + MDRawContextX86 context_; +}; + + +// MinidumpMemoryRegion does not wrap any MDRaw structure, and only contains +// a reference to an MDMemoryDescriptor. This object is intended to wrap +// portions of a minidump file that contain memory dumps. In normal +// minidumps, each MinidumpThread owns a MinidumpMemoryRegion corresponding +// to the thread's stack memory. MinidumpMemoryList also gives access to +// memory regions in its list as MinidumpMemoryRegions. This class +// adheres to MemoryRegion so that it may be used as a data provider to +// the Stackwalker family of classes. +class MinidumpMemoryRegion : public MinidumpObject, + public MemoryRegion { + public: + ~MinidumpMemoryRegion(); + + // Returns a pointer to the base of the memory region. Returns the + // cached value if available, otherwise, reads the minidump file and + // caches the memory region. + const u_int8_t* GetMemory(); + + // The address of the base of the memory region. + u_int64_t GetBase(); + + // The size, in bytes, of the memory region. + u_int32_t GetSize(); + + // Frees the cached memory region, if cached. + void FreeMemory(); + + // Obtains the value of memory at the pointer specified by address. + bool GetMemoryAtAddress(u_int64_t address, u_int8_t* value); + bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value); + bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value); + bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class MinidumpThread; + friend class MinidumpMemoryList; + + MinidumpMemoryRegion(Minidump* minidump); + + // Identify the base address and size of the memory region, and the + // location it may be found in the minidump file. + void SetDescriptor(MDMemoryDescriptor* descriptor); + + // Implementation for GetMemoryAtAddress + template<typename T> bool GetMemoryAtAddressInternal(u_int64_t address, + T* value); + + // Base address and size of the memory region, and its position in the + // minidump file. + MDMemoryDescriptor* descriptor_; + + // Cached memory. + vector<u_int8_t>* memory_; +}; + + +// MinidumpThread contains information about a thread of execution, +// including a snapshot of the thread's stack and CPU context. For +// the thread that caused an exception, the context carried by +// MinidumpException is probably desired instead of the CPU context +// provided here. +class MinidumpThread : public MinidumpObject { + public: + ~MinidumpThread(); + + const MDRawThread* thread() const { return valid_ ? &thread_ : NULL; } + MinidumpMemoryRegion* GetMemory(); + MinidumpContext* GetContext(); + + // The thread ID is used to determine if a thread is the exception thread, + // so a special getter is provided to retrieve this data from the + // MDRawThread structure. + u_int32_t GetThreadID(); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + // This objects are managed by MinidumpThreadList. + friend class MinidumpThreadList; + + MinidumpThread(Minidump* minidump); + + // This works like MinidumpStream::Read, but is driven by + // MinidumpThreadList. No size checking is done, because + // MinidumpThreadList handles that directly. + bool Read(); + + MDRawThread thread_; + MinidumpMemoryRegion* memory_; + MinidumpContext* context_; +}; + + +// MinidumpThreadList contains all of the threads (as MinidumpThreads) in +// a process. +class MinidumpThreadList : public MinidumpStream { + public: + ~MinidumpThreadList(); + + unsigned int thread_count() const { return valid_ ? thread_count_ : 0; } + + // Sequential access to threads. + MinidumpThread* GetThreadAtIndex(unsigned int index) const; + + // Random access to threads. + MinidumpThread* GetThreadByID(u_int32_t thread_id); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class Minidump; + + typedef map<u_int32_t, MinidumpThread*> IDToThreadMap; + typedef vector<MinidumpThread> MinidumpThreads; + + static const u_int32_t kStreamType = THREAD_LIST_STREAM; + + MinidumpThreadList(Minidump* aMinidump); + + bool Read(u_int32_t aExpectedSize); + + // Access to threads using the thread ID as the key. + IDToThreadMap id_to_thread_map_; + + // The list of threads. + MinidumpThreads* threads_; + u_int32_t thread_count_; +}; + + +// MinidumpModule wraps MDRawModule, which contains information about loaded +// code modules. Access is provided to various data referenced indirectly +// by MDRawModule, such as the module's name and a specification for where +// to locate debugging information for the module. +class MinidumpModule : public MinidumpObject { + public: + ~MinidumpModule(); + + const MDRawModule* module() const { return valid_ ? &module_ : 0; } + u_int64_t base_address() const { + return valid_ ? module_.base_of_image : static_cast<u_int64_t>(-1); } + u_int32_t size() const { return valid_ ? module_.size_of_image : 0; } + + // The name of the file containing this module's code (exe, dll, so, + // dylib). + const string* GetName(); + + // The CodeView record, which contains information to locate the module's + // debugging information (pdb). This is returned as u_int8_t* because + // the data can be one of two types: MDCVInfoPDB20* or MDCVInfoPDB70*. + // Check the record's signature in the first four bytes to differentiate. + // Current toolchains generate modules which carry MDCVInfoPDB70. + const u_int8_t* GetCVRecord(); + + // The miscellaneous debug record, which is obsolete. Current toolchains + // do not generate this type of debugging information (dbg), and this + // field is not expected to be present. + const MDImageDebugMisc* GetMiscRecord(); + + // The filename of the file containing debugging information for this + // module. This data is supplied by the CodeView record, if present, or + // the miscellaneous debug record. As such, it will reference either a + // pdb or dbg file. + const string* GetDebugFilename(); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + // These objects are managed by MinidumpModuleList. + friend class MinidumpModuleList; + + MinidumpModule(Minidump* minidump); + + // This works like MinidumpStream::Read, but is driven by + // MinidumpModuleList. No size checking is done, because + // MinidumpModuleList handles that directly. + bool Read(); + + MDRawModule module_; + + // Cached module name. + const string* name_; + + // Cached CodeView record - this is MDCVInfoPDB20 or (likely) + // MDCVInfoPDB70. Stored as a u_int8_t because the structure contains + // a variable-sized string and its exact size cannot be known until it + // is processed. + vector<u_int8_t>* cv_record_; + + // Cached MDImageDebugMisc (usually not present), stored as u_int8_t + // because the structure contains a variable-sized string and its exact + // size cannot be known until it is processed. + vector<u_int8_t>* misc_record_; + + // Cached debug filename. + const string* debug_filename_; +}; + + +// MinidumpModuleList contains all of the loaded code modules for a process +// in the form of MinidumpModules. It maintains a map of these modules +// so that it may easily provide a code module corresponding to a specific +// address. +class MinidumpModuleList : public MinidumpStream { + public: + ~MinidumpModuleList(); + + unsigned int module_count() const { return valid_ ? module_count_ : 0; } + + // Sequential access to modules. + MinidumpModule* GetModuleAtIndex(unsigned int index) const; + + // Random access to modules. Returns the module whose code is present + // at the address identified by address. + MinidumpModule* GetModuleForAddress(u_int64_t address); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class Minidump; + + typedef vector<MinidumpModule> MinidumpModules; + + static const u_int32_t kStreamType = MODULE_LIST_STREAM; + + MinidumpModuleList(Minidump* minidump); + + bool Read(u_int32_t expected_size); + + // Access to modules using addresses as the key. + RangeMap<u_int64_t, unsigned int> range_map_; + + MinidumpModules* modules_; + u_int32_t module_count_; +}; + + +// MinidumpMemoryList corresponds to a minidump's MEMORY_LIST_STREAM stream, +// which references the snapshots of all of the memory regions contained +// within the minidump. For a normal minidump, this includes stack memory +// (also referenced by each MinidumpThread, in fact, the MDMemoryDescriptors +// here and in MDRawThread both point to exactly the same data in a +// minidump file, conserving space), as well as a 256-byte snapshot of memory +// surrounding the instruction pointer in the case of an exception. Other +// types of minidumps may contain significantly more memory regions. Full- +// memory minidumps contain all of a process' mapped memory. +class MinidumpMemoryList : public MinidumpStream { + public: + ~MinidumpMemoryList(); + + unsigned int region_count() const { return valid_ ? region_count_ : 0; } + + // Sequential access to memory regions. + MinidumpMemoryRegion* GetMemoryRegionAtIndex(unsigned int index); + + // Random access to memory regions. Returns the region encompassing + // the address identified by address. + MinidumpMemoryRegion* GetMemoryRegionForAddress(u_int64_t address); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class Minidump; + + typedef vector<MDMemoryDescriptor> MemoryDescriptors; + typedef vector<MinidumpMemoryRegion> MemoryRegions; + + static const u_int32_t kStreamType = MEMORY_LIST_STREAM; + + MinidumpMemoryList(Minidump* minidump); + + bool Read(u_int32_t expected_size); + + // Access to memory regions using addresses as the key. + RangeMap<u_int64_t, unsigned int> range_map_; + + // The list of descriptors. This is maintained separately from the list + // of regions, because MemoryRegion doesn't own its MemoryDescriptor, it + // maintains a pointer to it. descriptors_ provides the storage for this + // purpose. + MemoryDescriptors* descriptors_; + + // The list of regions. + MemoryRegions* regions_; + u_int32_t region_count_; +}; + + +// MinidumpException wraps MDRawExceptionStream, which contains information +// about the exception that caused the minidump to be generated, if the +// minidump was generated in an exception handler called as a result of +// an exception. It also provides access to a MinidumpContext object, +// which contains the CPU context for the exception thread at the time +// the exception occurred. +class MinidumpException : public MinidumpStream { + public: + ~MinidumpException(); + + const MDRawExceptionStream* exception() const { + return valid_ ? &exception_ : 0; } + + // The thread ID is used to determine if a thread is the exception thread, + // so a special getter is provided to retrieve this data from the + // MDRawExceptionStream structure. + u_int32_t GetThreadID(); + + MinidumpContext* GetContext(); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class Minidump; + + static const u_int32_t kStreamType = EXCEPTION_STREAM; + + MinidumpException(Minidump* minidump); + + bool Read(u_int32_t expected_size); + + MDRawExceptionStream exception_; + MinidumpContext* context_; +}; + + +// MinidumpSystemInfo wraps MDRawSystemInfo and provides information about +// the system on which the minidump was generated. See also MinidumpMiscInfo. +class MinidumpSystemInfo : public MinidumpStream { + public: + ~MinidumpSystemInfo(); + + const MDRawSystemInfo* system_info() const { + return valid_ ? &system_info_ : 0; } + + // I don't know what CSD stands for, but this field is documented as + // returning a textual representation of the OS service pack. + const string* GetCSDVersion(); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class Minidump; + + static const u_int32_t kStreamType = SYSTEM_INFO_STREAM; + + MinidumpSystemInfo(Minidump* minidump); + + bool Read(u_int32_t expected_size); + + MDRawSystemInfo system_info_; + + // Textual representation of the OS service pack, for minidumps produced + // by MiniDumpWriteDump on Windows. + const string* csd_version_; +}; + + +// MinidumpMiscInfo wraps MDRawMiscInfo and provides information about +// the process that generated the minidump, and optionally additional system +// information. See also MinidumpSystemInfo. +class MinidumpMiscInfo : public MinidumpStream { + public: + const MDRawMiscInfo* misc_info() const { + return valid_ ? &misc_info_ : 0; } + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class Minidump; + + static const u_int32_t kStreamType = MISC_INFO_STREAM; + + MinidumpMiscInfo(Minidump* minidump_); + + bool Read(u_int32_t expected_size_); + + MDRawMiscInfo misc_info_; +}; + + +// Minidump is the user's interface to a minidump file. It wraps MDRawHeader +// and provides access to the minidump's top-level stream directory. +class Minidump { + public: + // fd is a randomly seekable file descriptor that is open and is + // positioned at the beginning of the MDRawHeader structure (byte offset + // 0). + Minidump(int fd); + + ~Minidump(); + + const MDRawHeader* header() const { return valid_ ? &header_ : 0; } + + // Reads the minidump file's header and top-level stream directory. + // The minidump is expected to be positioned at the beginning of the + // header. Read() sets up the stream list and map, and validates the + // Minidump object. + bool Read(); + + // The next 6 methods are stubs that call GetStream. They exist to + // force code generation of the templatized API within the module, and + // to avoid exposing an ugly API (GetStream needs to accept a garbage + // parameter). + MinidumpThreadList* GetThreadList(); + MinidumpModuleList* GetModuleList(); + MinidumpMemoryList* GetMemoryList(); + MinidumpException* GetException(); + MinidumpSystemInfo* GetSystemInfo(); + MinidumpMiscInfo* GetMiscInfo(); + + // The next set of methods are provided for users who wish to access + // data in minidump files directly, while leveraging the rest of + // this class and related classes to handle the basic minidump + // structure and known stream types. + + unsigned int GetDirectoryEntryCount() const { + return valid_ ? header_.stream_count : 0; } + const MDRawDirectory* GetDirectoryEntryAtIndex(unsigned int index) const; + + // The next 2 methods are lower-level I/O routines. They use fd_. + + // Reads count bytes from the minidump at the current position into + // the storage area pointed to by bytes. bytes must be of sufficient + // size. After the read, the file position is advanced by count. + bool ReadBytes(void* bytes, size_t count); + + // Sets the position of the minidump file to offset. + bool SeekSet(off_t offset); + + // The next 2 methods are medium-level I/O routines. + + // ReadString returns a string which is owned by the caller! offset + // specifies the offset that a length-encoded string is stored at in the + // minidump file. + string* ReadString(off_t offset); + + // SeekToStreamType positions the file at the beginning of a stream + // identified by stream_type, and informs the caller of the stream's + // length by setting *stream_length. Because stream_map maps each stream + // type to only one stream in the file, this might mislead the user into + // thinking that the stream that this seeks to is the only stream with + // type stream_type. That can't happen for streams that these classes + // deal with directly, because they're only supposed to be present in the + // file singly, and that's verified when stream_map_ is built. Users who + // are looking for other stream types should be aware of this + // possibility, and consider using GetDirectoryEntryAtIndex (possibly + // with GetDirectoryEntryCount) if expecting multiple streams of the same + // type in a single minidump file. + bool SeekToStreamType(u_int32_t stream_type, u_int32_t* stream_length); + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + // These classes are friends to give them access to this class' file + // I/O utility routines. + friend class MinidumpContext; + friend class MinidumpMemoryRegion; + friend class MinidumpThread; + friend class MinidumpThreadList; + friend class MinidumpModule; + friend class MinidumpModuleList; + friend class MinidumpMemoryList; + friend class MinidumpException; + friend class MinidumpSystemInfo; + friend class MinidumpMiscInfo; + + // MinidumpStreamInfo is used in the MinidumpStreamMap. It lets + // the Minidump object locate interesting streams quickly, and + // provides a convenient place to stash MinidumpStream objects. + struct MinidumpStreamInfo { + MinidumpStreamInfo() + : stream_index(0) + , stream(NULL) {} + ~MinidumpStreamInfo() { delete stream; } + + // Index into the MinidumpDirectoryEntries vector + unsigned int stream_index; + + // Pointer to the stream if cached, or NULL if not yet populated + MinidumpStream* stream; + }; + + typedef vector<MDRawDirectory> MinidumpDirectoryEntries; + typedef map<u_int32_t, MinidumpStreamInfo> MinidumpStreamMap; + + bool swap() const { return valid_ ? swap_ : false; } + + template<typename T> T* GetStream(T** stream); + + MDRawHeader header_; + + // The list of streams. + MinidumpDirectoryEntries* directory_; + + // Access to streams using the stream type as the key. + MinidumpStreamMap* stream_map_; + + // The file descriptor for all file I/O. Used by ReadBytes and SeekSet. + int fd_; + + // swap_ is true if the minidump file should be byte-swapped. If the + // minidump was produced by a CPU that is other-endian than the CPU + // processing the minidump, this will be true. If the two CPUs are + // same-endian, this will be false. + bool swap_; + + // Validity of the Minidump structure, false immediately after + // construction or after a failed Read(); true following a successful + // Read(). + bool valid_; +}; + + +} // namespace google_airbag + + +#endif // PROCESSOR_MINIDUMP_H__ diff --git a/src/processor/minidump_dump.cc b/src/processor/minidump_dump.cc new file mode 100644 index 00000000..cf707b54 --- /dev/null +++ b/src/processor/minidump_dump.cc @@ -0,0 +1,110 @@ +// Copyright (C) 2006 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// minidump_dump.cc: Print the contents of a minidump file in somewhat +// readable text. +// +// Author: Mark Mentovai + +#include <errno.h> +#include <fcntl.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#ifndef _WIN32 +#include <unistd.h> +#define O_BINARY 0 +#else // !_WIN32 +#include <io.h> +#define open _open +#endif // !_WIN32 + +#include "processor/minidump.h" + + +using namespace google_airbag; + + +int main(int argc, char** argv) { + if (argc != 2) { + fprintf(stderr, "usage: %s <file>\n", argv[0]); + exit(1); + } + + int fd = open(argv[1], O_RDONLY | O_BINARY); + if (fd == -1) { + printf("open failed\n"); + exit(1); + } + + Minidump minidump(fd); + if (!minidump.Read()) { + printf("minidump.Read() failed\n"); + exit(1); + } + minidump.Print(); + + int error = 0; + + MinidumpThreadList* threadList = minidump.GetThreadList(); + if (!threadList) { + error |= 1 << 2; + printf("minidump.GetThreadList() failed\n"); + } else { + threadList->Print(); + } + + MinidumpModuleList* moduleList = minidump.GetModuleList(); + if (!moduleList) { + error |= 1 << 3; + printf("minidump.GetModuleList() failed\n"); + } else { + moduleList->Print(); + } + + MinidumpMemoryList* memoryList = minidump.GetMemoryList(); + if (!memoryList) { + error |= 1 << 4; + printf("minidump.GetMemoryList() failed\n"); + } else { + memoryList->Print(); + } + + MinidumpException* exception = minidump.GetException(); + if (!exception) { + error |= 1 << 5; + printf("minidump.GetException() failed\n"); + } else { + exception->Print(); + } + + MinidumpSystemInfo* systemInfo = minidump.GetSystemInfo(); + if (!systemInfo) { + error |= 1 << 6; + printf("minidump.GetSystemInfo() failed\n"); + } else { + systemInfo->Print(); + } + + MinidumpMiscInfo* miscInfo = minidump.GetMiscInfo(); + if (!miscInfo) { + error |= 1 << 7; + printf("minidump.GetMiscInfo() failed\n"); + } else { + miscInfo->Print(); + } + + // Use return instead of exit to allow destructors to run. + return(error); +} diff --git a/src/processor/minidump_dump_test b/src/processor/minidump_dump_test new file mode 100755 index 00000000..a35edfff --- /dev/null +++ b/src/processor/minidump_dump_test @@ -0,0 +1,6 @@ +#!/bin/sh +testdata_dir=$srcdir/src/processor/testdata +./src/processor/minidump_dump $testdata_dir/minidump1.dmp | \ + tr -s '\015' '\012' | \ + diff -u $testdata_dir/minidump1.out - +exit $? diff --git a/src/processor/minidump_format.h b/src/processor/minidump_format.h new file mode 100644 index 00000000..af24c6fb --- /dev/null +++ b/src/processor/minidump_format.h @@ -0,0 +1,555 @@ +/* Copyright (C) 2006 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. */ + +/* minidump_format.h: A cross-platform reimplementation of minidump-related + * portions of DbgHelp.h from the Windows Platform SDK. + * + * (This is C99 source, please don't corrupt it with C++.) + * + * This file contains the necessary definitions to read minidump files + * produced on win32/x86. These files may be read on any platform provided + * that the alignments of these structures on the processing system are + * identical to the alignments of these structures on the producing system. + * For this reason, precise-sized types are used. The structures defined by + * by this file have been laid out to minimize alignment problems by ensuring + * ensuring that all members are aligned on their natural boundaries. In + * In some cases, tail-padding may be significant when different ABIs specify + * different tail-padding behaviors. To avoid problems when reading or + * writing affected structures, MD_*_SIZE macros are provided where needed, + * containing the useful size of the structures without padding. + * + * These structures are also sufficient to populate minidump files. + * + * These definitions may be extended to support handling minidump files + * for other CPUs and other operating systems. + * + * Because precise data type sizes are crucial for this implementation to + * function properly and portably in terms of interoperability with minidumps + * produced by DbgHelp on Windows, a set of primitive types with known sizes + * are used as the basis of each structure defined by this file. DbgHelp + * on Windows is assumed to be the reference implementation; this file + * seeks to provide a cross-platform compatible implementation. To avoid + * collisions with the types and values defined and used by DbgHelp in the + * event that this implementation is used on Windows, each type and value + * defined here is given a new name, beginning with "MD". Names of the + * equivlaent types and values in the Windows Platform SDK are given in + * comments. + * + * Author: Mark Mentovai */ + + +#ifndef PROCESSOR_MINIDUMP_FORMAT_H__ +#define PROCESSOR_MINIDUMP_FORMAT_H__ + + +#include "google/airbag_types.h" + + +/* + * guiddef.h + */ + + +typedef struct { + u_int32_t data1; + u_int16_t data2; + u_int16_t data3; + u_int8_t data4[8]; +} MDGUID; /* GUID */ + + +/* + * WinNT.h + */ + + +#define MD_FLOATINGSAVEAREA_SIZEOF_REGISTERAREA_X86 80 + /* SIZE_OF_80387_REGISTERS */ + +typedef struct { + u_int32_t control_word; + u_int32_t status_word; + u_int32_t tag_word; + u_int32_t error_offset; + u_int32_t error_selector; + u_int32_t data_offset; + u_int32_t data_selector; + u_int8_t register_area[MD_FLOATINGSAVEAREA_SIZEOF_REGISTERAREA_X86]; + u_int32_t cr0_npx_state; +} MDFloatingSaveAreaX86; /* FLOATING_SAVE_AREA */ + + +#define MD_CONTEXT_SIZEOF_EXTENDED_REGISTERS_X86 512 + /* MAXIMUM_SUPPORTED_EXTENSION */ + +typedef struct { + /* The next field determines the layout of the structure, and what parts + * of it are populated */ + u_int32_t context_flags; + + /* The next 6 registers are included with MD_CONTEXT_X86_DEBUG_REGISTERS */ + u_int32_t dr0; + u_int32_t dr1; + u_int32_t dr2; + u_int32_t dr3; + u_int32_t dr6; + u_int32_t dr7; + + /* The next field is included with MD_CONTEXT_X86_FLOATING_POINT */ + MDFloatingSaveAreaX86 float_save; + + /* The next 4 registers are included with MD_CONTEXT_X86_SEGMENTS */ + u_int32_t gs; + u_int32_t fs; + u_int32_t es; + u_int32_t ds; + /* The next 6 registers are included with MD_CONTEXT_X86_INTEGER */ + u_int32_t edi; + u_int32_t esi; + u_int32_t ebx; + u_int32_t edx; + u_int32_t ecx; + u_int32_t eax; + + /* The next 6 registers are included with MD_CONTEXT_X86_CONTROL */ + u_int32_t ebp; + u_int32_t eip; + u_int32_t cs; /* WinNT.h says "must be sanitized" */ + u_int32_t eflags; /* WinNT.h says "must be sanitized" */ + u_int32_t esp; + u_int32_t ss; + + /* The next field is included with MD_CONTEXT_X86_EXTENDED_REGISTERS */ + u_int8_t extended_registers[ + MD_CONTEXT_SIZEOF_EXTENDED_REGISTERS_X86]; +} MDRawContextX86; /* CONTEXT */ + +/* For (MDRawContextX86).context_flags. These values indicate the type of + * context stored in the structure. */ +#define MD_CONTEXT_X86_X86 0x00010000 + /* CONTEXT_i386, CONTEXT_i486: identifies CPU */ +#define MD_CONTEXT_X86_CONTROL (MD_CONTEXT_X86_X86 | 0x00000001) + /* CONTEXT_CONTROL */ +#define MD_CONTEXT_X86_INTEGER (MD_CONTEXT_X86_X86 | 0x00000002) + /* CONTEXT_INTEGER */ +#define MD_CONTEXT_X86_SEGMENTS (MD_CONTEXT_X86_X86 | 0x00000004) + /* CONTEXT_SEGMENTS */ +#define MD_CONTEXT_X86_FLOATING_POINT (MD_CONTEXT_X86_X86 | 0x00000008) + /* CONTEXT_FLOATING_POINT */ +#define MD_CONTEXT_X86_DEBUG_REGISTERS (MD_CONTEXT_X86_X86 | 0x00000010) + /* CONTEXT_DEBUG_REGISTERS */ +#define MD_CONTEXT_X86_EXTENED_REGISTERS (MD_CONTEXT_X86_X86 | 0x00000020) + /* CONTEXT_EXTENDED_REGISTERS */ + +#define MD_CONTEXT_X86_FULL (MD_CONTEXT_X86_CONTROL | \ + MD_CONTEXT_X86_INTEGER | \ + MD_CONTEXT_X86_SEGMENTS) + /* CONTEXT_FULL */ + +#define MD_CONTEXT_X86_ALL (MD_CONTEXT_X86_FULL | \ + MD_CONTEXT_X86_FLOATING_POINT | \ + MD_CONTEXT_X86_DEBUG_REGISTERS | \ + MD_CONTEXT_X86_EXTENDED_REGISTERS) + /* CONTEXT_ALL */ + + +/* + * WinVer.h + */ + + +typedef struct { + u_int32_t signature; + u_int32_t struct_version; + u_int32_t file_version_hi; + u_int32_t file_version_lo; + u_int32_t product_version_hi; + u_int32_t product_version_lo; + u_int32_t file_flags_mask; /* Identifies valid bits in fileFlags */ + u_int32_t file_flags; + u_int32_t file_os; + u_int32_t file_type; + u_int32_t file_subtype; + u_int32_t file_date_hi; + u_int32_t file_date_lo; +} MDVSFixedFileInfo; /* VS_FIXEDFILEINFO */ + +/* For (MDVSFixedFileInfo).signature */ +#define MD_VSFIXEDFILEINFO_SIGNATURE 0xfeef04bd + /* VS_FFI_SIGNATURE */ + +/* For (MDVSFixedFileInfo).version */ +#define MD_VSFIXEDFILEINFO_VERSION 0x00010000 + /* VS_FFI_STRUCVERSION */ + +/* For (MDVSFixedFileInfo).file_flags_mask and + * (MDVSFixedFileInfo).file_flags */ +#define MD_VSFIXEDFILEINFO_FILE_FLAGS_DEBUG 0x00000001 + /* VS_FF_DEBUG */ +#define MD_VSFIXEDFILEINFO_FILE_FLAGS_PRERELEASE 0x00000002 + /* VS_FF_PRERELEASE */ +#define MD_VSFIXEDFILEINFO_FILE_FLAGS_PATCHED 0x00000004 + /* VS_FF_PATCHED */ +#define MD_VSFIXEDFILEINFO_FILE_FLAGS_PRIVATEBUILD 0x00000008 + /* VS_FF_PRIVATEBUILD */ +#define MD_VSFIXEDFILEINFO_FILE_FLAGS_INFOINFERRED 0x00000010 + /* VS_FF_INFOINFERRED */ +#define MD_VSFIXEDFILEINFO_FILE_FLAGS_SPECIALBUILD 0x00000020 + /* VS_FF_SPECIALBUILD */ + +/* For (MDVSFixedFileInfo).file_os: high 16 bits */ +#define MD_VSFIXEDFILEINFO_FILE_OS_UNKNOWN 0 /* VOS_UNKNOWN */ +#define MD_VSFIXEDFILEINFO_FILE_OS_DOS (1 << 16) /* VOS_DOS */ +#define MD_VSFIXEDFILEINFO_FILE_OS_OS216 (2 << 16) /* VOS_OS216 */ +#define MD_VSFIXEDFILEINFO_FILE_OS_OS232 (3 << 16) /* VOS_OS232 */ +#define MD_VSFIXEDFILEINFO_FILE_OS_NT (4 << 16) /* VOS_NT */ +#define MD_VSFIXEDFILEINFO_FILE_OS_WINCE (5 << 16) /* VOS_WINCE */ +/* Low 16 bits */ +#define MD_VSFIXEDFILEINFO_FILE_OS__BASE 0 /* VOS__BASE */ +#define MD_VSFIXEDFILEINFO_FILE_OS__WINDOWS16 1 /* VOS__WINDOWS16 */ +#define MD_VSFIXEDFILEINFO_FILE_OS__PM16 2 /* VOS__PM16 */ +#define MD_VSFIXEDFILEINFO_FILE_OS__PM32 3 /* VOS__PM32 */ +#define MD_VSFIXEDFILEINFO_FILE_OS__WINDOWS32 4 /* VOS__WINDOWS32 */ + +/* For (MDVSFixedFileInfo).file_type */ +#define MD_VSFIXEDFILEINFO_FILE_TYPE_UNKNOWN 0 /* VFT_UNKNOWN */ +#define MD_VSFIXEDFILEINFO_FILE_TYPE_APP 1 /* VFT_APP */ +#define MD_VSFIXEDFILEINFO_FILE_TYPE_DLL 2 /* VFT_DLL */ +#define MD_VSFIXEDFILEINFO_FILE_TYPE_DRV 3 /* VFT_DLL */ +#define MD_VSFIXEDFILEINFO_FILE_TYPE_FONT 4 /* VFT_FONT */ +#define MD_VSFIXEDFILEINFO_FILE_TYPE_VXD 5 /* VFT_VXD */ +#define MD_VSFIXEDFILEINFO_FILE_TYPE_STATIC_LIB 7 /* VFT_STATIC_LIB */ + +/* For (MDVSFixedFileInfo).file_subtype */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_UNKNOWN 0 + /* VFT2_UNKNOWN */ +/* with file_type = MD_VSFIXEDFILEINFO_FILETYPE_DRV */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_PRINTER 1 + /* VFT2_DRV_PRINTER */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_KEYBOARD 2 + /* VFT2_DRV_KEYBOARD */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_LANGUAGE 3 + /* VFT2_DRV_LANGUAGE */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_DISPLAY 4 + /* VFT2_DRV_DISPLAY */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_MOUSE 5 + /* VFT2_DRV_MOUSE */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_NETWORK 6 + /* VFT2_DRV_NETWORK */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_SYSTEM 7 + /* VFT2_DRV_SYSTEM */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_INSTALLABLE 8 + /* VFT2_DRV_INSTALLABLE */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_SOUND 9 + /* VFT2_DRV_SOUND */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_COMM 10 + /* VFT2_DRV_COMM */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_INPUTMETHOD 11 + /* VFT2_DRV_INPUTMETHOD */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_DRV_VERSIONED_PRINTER 12 + /* VFT2_DRV_VERSIONED_PRINTER */ +/* with file_type = MD_VSFIXEDFILEINFO_FILETYPE_FONT */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_FONT_RASTER 1 + /* VFT2_FONT_RASTER */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_FONT_VECTOR 2 + /* VFT2_FONT_VECTOR */ +#define MD_VSFIXEDFILEINFO_FILE_SUBTYPE_FONT_TRUETYPE 3 + /* VFT2_FONT_TRUETYPE */ + + +/* + * DbgHelp.h + */ + + +typedef u_int32_t MDRVA; /* RVA */ + + +typedef struct { + u_int32_t data_size; + MDRVA rva; +} MDLocationDescriptor; /* MINIDUMP_LOCATION_DESCRIPTOR */ + + +typedef struct { + u_int64_t start_of_memory_range; + MDLocationDescriptor memory; +} MDMemoryDescriptor; /* MINIDUMP_MEMORY_DESCRIPTOR */ + + +typedef struct { + u_int32_t signature; + u_int32_t version; + u_int32_t stream_count; + MDRVA stream_directory_rva; + u_int32_t checksum; + u_int32_t time_date_stamp; /* time_t */ + u_int64_t flags; +} MDRawHeader; /* MINIDUMP_HEADER */ + +/* For (MDRawHeader).signature and (MDRawHeader).version. Note that only the + * low 16 bits of (MDRawHeader).version are MD_HEADER_VERSION. Per the + * documentation, the high 16 bits are implementation-specific. */ +#define MD_HEADER_SIGNATURE 0x504d444d /* 'PMDM' */ + /* MINIDUMP_SIGNATURE */ +#define MD_HEADER_VERSION 0x0000a793 /* 42899 */ + /* MINIDUMP_VERSION */ + +/* For (MDRawHeader).flags */ +typedef enum { + MINIDUMP_NORMAL = 0x00000000, + MINIDUMP_WITH_DATA_SEGS = 0x00000001, + MINIDUMP_WITH_FULL_MEMORY = 0x00000002, + MINIDUMP_WITH_HANDLE_DATA = 0x00000004, + MINIDUMP_FILTER_MEMORY = 0x00000008, + MINIDUMP_SCAN_MEMORY = 0x00000010, + MINIDUMP_WITH_UNLOADED_MODULES = 0x00000020, + MINIDUMP_WITH_INDIRECTLY_REFERENCED_MEMORY = 0X00000040, + MINIDUMP_FILTER_MODULE_PATHS = 0x00000080, + MINIDUMP_WITH_PROCESS_THREAD_DATA = 0x00000100, + MINIDUMP_WITH_PRIVATE_READ_WRITE_MEMORY = 0x00000200, + MINIDUMP_WITHOUT_OPTIONAL_DATA = 0x00000400, + MINIDUMP_WITH_FULL_MEMORY_INFO = 0x00000800, + MINIDUMP_WITH_THREAD_INFO = 0x00001000, + MINIDUMP_WITH_CODE_SEGS = 0x00002000 +} MDType; /* MINIDUMP_TYPE */ + + +typedef struct { + u_int32_t stream_type; + MDLocationDescriptor location; +} MDRawDirectory; /* MINIDUMP_DIRECTORY */ + +/* For (MDRawDirectory).stream_type */ +typedef enum { + UNUSED_STREAM = 0, + RESERVED_STREAM_0 = 1, + RESERVED_STREAM_1 = 2, + THREAD_LIST_STREAM = 3, + MODULE_LIST_STREAM = 4, + MEMORY_LIST_STREAM = 5, + EXCEPTION_STREAM = 6, + SYSTEM_INFO_STREAM = 7, + THREAD_EX_LIST_STREAM = 8, + MEMORY_64_LIST_STREAM = 9, + COMMENT_STREAM_A = 10, + COMMENT_STREAM_W = 11, + HANDLE_DATA_STREAM = 12, + FUNCTION_TABLE_STREAM = 13, + UNLOADED_MODULE_LIST_STREAM = 14, + MISC_INFO_STREAM = 15, + LAST_RESERVED_STREAM = 0x0000FFFF +} MDStreamType; /* MINIDUMP_STREAM_TYPE */ + + +typedef struct { + u_int32_t thread_id; + u_int32_t suspend_count; + u_int32_t priority_class; + u_int32_t priority; + u_int64_t teb; /* Thread environment block */ + MDMemoryDescriptor stack; + MDLocationDescriptor thread_context; +} MDRawThread; /* MINIDUMP_THREAD */ + + +typedef struct { + u_int32_t number_of_threads; + MDRawThread threads[0]; +} MDRawThreadList; /* MINIDUMP_THREAD_LIST */ + + +typedef struct { + u_int64_t base_of_image; + u_int32_t size_of_image; + u_int32_t checksum; + u_int32_t time_date_stamp; + MDRVA module_name_rva; + MDVSFixedFileInfo version_info; + + /* The next field stores a CodeView record and is populated when a module's + * debug information resides in a PDB file. It identifies the PDB file. */ + MDLocationDescriptor cv_record; + + /* The next field is populated when a module's debug information resides + * in a DBG file. It identifies the DBG file. This field is effectively + * obsolete with modules built by recent toolchains. */ + MDLocationDescriptor misc_record; + + /* Alignment problem: reserved0 and reserved1 are defined by the platform + * SDK as 64-bit quantities. However, that results in a structure whose + * alignment is unpredictable on different CPUs and ABIs. If the ABI + * specifies full alignment of 64-bit quantities in structures (as ppc + * does), there will be padding between miscRecord and reserved0. If + * 64-bit quantities can be aligned on 32-bit boundaries (as on x86), + * this padding will not exist. (Note that the structure up to this point + * contains 1 64-bit member followed by 21 32-bit members.) + * As a workaround, reserved0 and reserved1 are instead defined here as + * four 32-bit quantities. This should be harmless, as there are + * currently no known uses for these fields. */ + u_int32_t reserved0[2]; + u_int32_t reserved1[2]; +} MDRawModule; /* MINIDUMP_MODULE */ + +/* The inclusion of a 64-bit type in MINIDUMP_MODULE forces the struct to + * be tail-padded out to a multiple of 64 bits under some ABIs (such as PPC). + * This doesn't occur on systems that don't tail-pad in this manner. Define + * this macro to be the usable size of the MDRawModule struct, and use it in + * place of sizeof(MDRawModule). */ +#define MD_MODULE_SIZE 108 + + +/* (MDRawModule).cv_record can reference MDCVInfoPDB20 or MDCVInfoPDB70. + * Ref.: http://www.debuginfo.com/articles/debuginfomatch.html + * MDCVInfoPDB70 is the expected structure type with recent toolchains. */ + +typedef struct { + u_int32_t signature; + u_int32_t offset; /* Offset to debug data (expect 0 in minidump) */ +} MDCVHeader; + +typedef struct { + MDCVHeader cv_header; + u_int32_t signature; /* time_t debug information created */ + u_int32_t age; /* revision of PDB file */ + u_int8_t pdb_file_name[0]; +} MDCVInfoPDB20; + +#define MD_CVINFOPDB20_SIGNATURE 0x3031424e /* cvHeader.signature = '01BN' */ + +typedef struct { + u_int32_t cv_signature; + MDGUID signature; /* GUID, identifies PDB file */ + u_int32_t age; /* Identifies incremental changes to PDB file */ + u_int8_t pdb_file_name[0]; /* 0-terminated 8-bit character data (UTF-8?) */ +} MDCVInfoPDB70; + +#define MD_CVINFOPDB70_SIGNATURE 0x53445352 /* cvSignature = 'SDSR' */ + +/* (MDRawModule).miscRecord can reference MDImageDebugMisc. The Windows + * structure is actually defined in WinNT.h. This structure is effectively + * obsolete with modules built by recent toolchains. */ + +typedef struct { + u_int32_t data_type; + u_int32_t length; + u_int8_t unicode; + u_int8_t reserved[3]; + u_int8_t data[0]; +} MDImageDebugMisc; /* IMAGE_DEBUG_MISC */ + + +typedef struct { + u_int32_t number_of_modules; + MDRawModule modules[0]; +} MDRawModuleList; /* MINIDUMP_MODULE_LIST */ + + +typedef struct { + u_int32_t number_of_memory_ranges; + MDMemoryDescriptor memory_ranges[0]; +} MDRawMemoryList; /* MINIDUMP_MEMORY_LIST */ + + +#define MD_EXCEPTION_MAXIMUM_PARAMETERS 15 + +typedef struct { + u_int32_t exception_code; + u_int32_t exception_flags; + u_int64_t exception_record; + u_int64_t exception_address; + u_int32_t number_parameters; + u_int32_t __align; + u_int64_t exception_information[MD_EXCEPTION_MAXIMUM_PARAMETERS]; +} MDException; /* MINIDUMP_EXCEPTION */ + + +typedef struct { + u_int32_t thread_id; + u_int32_t __align; + MDException exception_record; + MDLocationDescriptor thread_context; +} MDRawExceptionStream; /* MINIDUMP_EXCEPTION_STREAM */ + + +typedef union { + struct { + u_int32_t vendor_id[3]; /* cpuid 0: eax, ebx, ecx */ + u_int32_t version_information; /* cpuid 1: eax */ + u_int32_t feature_information; /* cpuid 1: edx */ + u_int32_t amd_extended_cpu_features; /* cpuid 0x80000001, ebx */ + } x86_cpu_info; + struct { + u_int64_t processor_features[2]; + } other_cpu_info; +} MDCPUInformation; /* CPU_INFORMATION */ + + +typedef struct { + /* The next 3 fields and numberOfProcessors are from the SYSTEM_INFO + * structure as returned by GetSystemInfo */ + u_int16_t processor_architecture; + u_int16_t processor_level; + u_int16_t processor_revision; + union { + u_int16_t reserved0; + struct { + u_int8_t number_of_processors; + u_int8_t product_type; + }; + }; + + /* The next 5 fields are from the OSVERSIONINFO structure as returned + * by GetVersionEx */ + u_int32_t major_version; + u_int32_t minor_version; + u_int32_t build_number; + u_int32_t platform_id; + MDRVA csd_version_rva; /* Name of the installed OS service pack */ + + union { + u_int32_t reserved1; + struct { + u_int16_t suite_mask; + u_int16_t reserved2; + }; + }; + MDCPUInformation cpu; +} MDRawSystemInfo; /* MINIDUMP_SYSTEM_INFO */ + + +typedef struct { + u_int32_t size_of_info; + u_int32_t flags1; + u_int32_t process_id; + u_int32_t process_create_time; + u_int32_t process_user_time; + u_int32_t process_kernel_time; + + /* The following fields are not present in MINIDUMP_MISC_INFO but are + * in MINIDUMP_MISC_INFO_2. When this struct is populated, these values + * may not be set. Use flags1 or sizeOfInfo to determine whether these + * values are present. */ + u_int32_t processor_max_mhz; + u_int32_t processor_current_mhz; + u_int32_t processor_mhz_limit; + u_int32_t processor_max_idle_state; + u_int32_t processor_current_idle_state; +} MDRawMiscInfo; /* MINIDUMP_MISC_INFO, MINIDUMP_MISC_INFO2 */ + +#define MD_MISCINFO_SIZE 24 +#define MD_MISCINFO2_SIZE 44 + + +#endif /* PROCESSOR_MINIDUMP_FORMAT_H__ */ diff --git a/src/processor/range_map.h b/src/processor/range_map.h new file mode 100644 index 00000000..a55efb13 --- /dev/null +++ b/src/processor/range_map.h @@ -0,0 +1,158 @@ +// Copyright (C) 2006 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// range_map.h: Range maps. +// +// A range map associates a range of addresses with a specific object. This +// is useful when certain objects of variable size are located within an +// address space. The range map makes it simple to determine which object is +// associated with a specific address, which may be any address within the +// range associated with an object. +// +// Author: Mark Mentovai + +#ifndef PROCESSOR_RANGE_MAP_H__ +#define PROCESSOR_RANGE_MAP_H__ + + +#include <map> + + +namespace google_airbag { + + +using std::map; + + +template<typename AddressType, typename EntryType> +class RangeMap { + public: + RangeMap() : map_() {} + + // Inserts a range into the map. Returns false for a parameter error, + // or if the location of the range would conflict with a range already + // stored in the map. + bool StoreRange(const AddressType& base, + const AddressType& size, + const EntryType& entry); + + // Locates the range encompassing the supplied address. If there is + // no such range, or if there is a parameter error, returns false. + bool RetrieveRange(const AddressType& address, EntryType* entry); + + // Empties the range map, restoring it to the state it was when it was + // initially created. + void Clear(); + + private: + class Range { + public: + Range(const AddressType& base, const EntryType& entry) + : base_(base), entry_(entry) {} + + AddressType base() const { return base_; } + EntryType entry() const { return entry_; } + + private: + // The base address of the range. The high address does not need to + // be stored, because RangeMap uses it as the key to the map. + const AddressType base_; + + // The entry, owned by the Range object. + const EntryType entry_; + }; + + typedef map<AddressType, Range> AddressToRangeMap; + + // Can't depend on implicit typenames in a template + typedef typename AddressToRangeMap::const_iterator const_iterator; + typedef typename AddressToRangeMap::value_type value_type; + + // Maps the high address of each range to a EntryType. + AddressToRangeMap map_; +}; + + +template<typename AddressType, typename EntryType> +bool RangeMap<AddressType, EntryType>::StoreRange(const AddressType& base, + const AddressType& size, + const EntryType& entry) { + AddressType high = base + size - 1; + + // Check for undersize or overflow. + if (size <= 0 || high < base) + return false; + + // Ensure that this range does not overlap with another one already in the + // map. + const_iterator iterator_base = map_.lower_bound(base); + const_iterator iterator_high = map_.lower_bound(high); + + if (iterator_base != iterator_high) { + // Some other range begins in the space used by this range. It may be + // contained within the space used by this range, or it may extend lower. + // Regardless, it is an error. + return false; + } + + if (iterator_high != map_.end()) { + if (iterator_high->second.base() <= high) { + // The range above this one overlaps with this one. It may fully + // contain this range, or it may begin within this range and extend + // higher. Regardless, it's an error. + return false; + } + } + + // Store the range in the map by its high address, so that lower_bound can + // be used to quickly locate a range by address. + map_.insert(value_type(high, Range(base, entry))); + return true; +} + + +template<typename AddressType, typename EntryType> +bool RangeMap<AddressType, EntryType>::RetrieveRange( + const AddressType& address, + EntryType* entry) { + if (!entry) + return false; + + const_iterator iterator = map_.lower_bound(address); + if (iterator == map_.end()) + return false; + + // The map is keyed by the high address of each range, so |address| is + // guaranteed to be lower than the range's high address. If |range| is + // not directly preceded by another range, it's possible for address to + // be below the range's low address, though. When that happens, address + // references something not within any range, so return false. + if (address < iterator->second.base()) + return false; + + *entry = iterator->second.entry(); + return true; +} + + +template<typename AddressType, typename EntryType> +void RangeMap<AddressType, EntryType>::Clear() { + map_.clear(); +} + + +} // namespace google_airbag + + +#endif // PROCESSOR_RANGE_MAP_H__ diff --git a/src/processor/range_map_unittest.cc b/src/processor/range_map_unittest.cc new file mode 100644 index 00000000..f81bcdf7 --- /dev/null +++ b/src/processor/range_map_unittest.cc @@ -0,0 +1,334 @@ +// Copyright (C) 2006 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// range_map_unittest.cc: Unit tests for RangeMap +// +// Author: Mark Mentovai + + +#include <stdio.h> + +#include <climits> +#include <memory> + +#include "processor/range_map.h" + + +using std::auto_ptr; +using google_airbag::RangeMap; + + +// A CountedObject holds an int. A global (not thread safe!) count of +// allocated CountedObjects is maintained to help test memory management. +class CountedObject { + public: + CountedObject(int id) : id_(id) { ++count_; } + CountedObject(const CountedObject& that) : id_(that.id_) { ++count_; } + ~CountedObject() { --count_; } + + static int count() { return count_; } + int id() const { return id_; } + + private: + static int count_; + int id_; +}; + +int CountedObject::count_; + + +typedef int AddressType; +typedef RangeMap<AddressType, CountedObject> TestMap; + + +// RangeTest contains data to use for store and retrieve tests. See +// RunTests for descriptions of the tests. +struct RangeTest { + // Base address to use for test + AddressType address; + + // Size of range to use for test + AddressType size; + + // Unique ID of range - unstorable ranges must have unique IDs too + int id; + + // Whether this range is expected to be stored successfully or not + bool expect_storable; +}; + + +// A RangeTestSet encompasses multiple RangeTests, which are run in +// sequence on the same RangeMap. +struct RangeTestSet { + // An array of RangeTests + const RangeTest* range_tests; + + // The number of tests in the set + unsigned int range_test_count; +}; + + +// StoreTest uses the data in a RangeTest and calls StoreRange on the +// test RangeMap. It returns true if the expected result occurred, and +// false if something else happened. +bool StoreTest(TestMap* range_map, const RangeTest* range_test) { + CountedObject object(range_test->id); + bool stored = range_map->StoreRange(range_test->address, + range_test->size, + object); + + if (stored != range_test->expect_storable) { + fprintf(stderr, "FAILED: " + "StoreRange id %d, expected %s, observed %s\n", + range_test->id, + range_test->expect_storable ? "storable" : "not storable", + stored ? "stored" : "not stored"); + return false; + } + + return true; +} + + +// RetrieveTest uses the data in RangeTest and calls RetrieveRange on the +// test RangeMap. If it retrieves the expected value (which can be no +// map entry at the specified range,) it returns true, otherwise, it returns +// false. RetrieveTest will check the values around the base address and +// the high address of a range to guard against off-by-one errors. +bool RetrieveTest(TestMap* range_map, const RangeTest* range_test) { + for (unsigned int side = 0; side <= 1; ++side) { + // When side == 0, check the low side (base address) of each range. + // When side == 1, check the high side (base + size) of each range. + + // Check one-less and one-greater than the target address in addition + // to the target address itself. + + // If the size of the range is only 1, don't check one greater than + // the base or one less than the high - for a successfully stored + // range, these tests would erroneously fail because the range is too + // small. + AddressType low_offset = -1; + AddressType high_offset = 1; + if (range_test->size == 1) { + if (!side) // when checking the low side, + high_offset = 0; // don't check one over the target + else // when checking the high side, + low_offset = 0; // don't check one under the target + } + + for (AddressType offset = low_offset; offset <= high_offset; ++offset) { + AddressType address = + offset + + (!side ? range_test->address : + range_test->address + range_test->size - 1); + + bool expected_result = false; // correct for tests not stored + if (range_test->expect_storable) { + if (offset == 0) // when checking target, + expected_result = true; // should always succeed + else if (offset == -1) // when checking one below target, + expected_result = side; // should fail low and succeed high + else // when checking one above target, + expected_result = !side; // should succeed low and fail high + } + + CountedObject object(-1); + bool retrieved = range_map->RetrieveRange(address, &object); + + bool observed_result = retrieved && object.id() == range_test->id; + + if (observed_result != expected_result) { + fprintf(stderr, "FAILED: " + "RetrieveRange id %d, side %d, offset %d, " + "expected %s, observed %s\n", + range_test->id, + side, + offset, + expected_result ? "true" : "false", + observed_result ? "true" : "false"); + return false; + } + } + } + + return true; +} + + +// RunTests runs a series of test sets. +bool RunTests() { + // These tests will be run sequentially. The first set of tests exercises + // most functions of RangeTest, and verifies all of the bounds-checking. + const RangeTest range_tests_0[] = { + { INT_MIN, 16, 1, true }, // lowest possible range + { -2, 5, 2, true }, // a range through zero + { INT_MAX - 9, 11, 3, false }, // tests anti-overflow + { INT_MAX - 9, 10, 4, true }, // highest possible range + { 5, 0, 5, false }, // tests anti-zero-size + { 5, 1, 6, true }, // smallest possible range + { -20, 15, 7, true }, // entirely negative + + { 10, 10, 10, true }, // causes the following tests to fail + { 9, 10, 11, false }, // one-less base, one-less high + { 9, 11, 12, false }, // one-less base, identical high + { 9, 12, 13, false }, // completely contains existing + { 10, 9, 14, false }, // identical base, one-less high + { 10, 10, 15, false }, // exactly identical to existing range + { 10, 11, 16, false }, // identical base, one-greater high + { 11, 8, 17, false }, // contained completely within + { 11, 9, 18, false }, // one-greater base, identical high + { 11, 10, 19, false }, // one-greater base, one-greater high + { 9, 2, 20, false }, // overlaps bottom by one + { 10, 1, 21, false }, // overlaps bottom by one, contained + { 19, 1, 22, false }, // overlaps top by one, contained + { 19, 2, 23, false }, // overlaps top by one + + { 9, 1, 24, true }, // directly below without overlap + { 20, 1, 25, true }, // directly above without overlap + + { 6, 3, 26, true }, // exactly between two ranges, gapless + { 7, 3, 27, false }, // tries to span two ranges + { 7, 5, 28, false }, // tries to span three ranges + { 4, 20, 29, false }, // tries to contain several ranges + + { 30, 50, 30, true }, + { 90, 25, 31, true }, + { 35, 65, 32, false }, // tries to span two noncontiguous + { 120, 10000, 33, true }, // > 8-bit + { 20000, 20000, 34, true }, // > 8-bit + { 0x10001, 0x10001, 35, true }, // > 16-bit + + { 27, -1, 36, false } // tests high < base + }; + + // Attempt to fill the entire space. The entire space must be filled with + // three stores because AddressType is signed for these tests, so RangeMap + // treats the size as signed and rejects sizes that appear to be negative. + // Even if these tests were run as unsigned, two stores would be needed + // to fill the space because the entire size of the space could only be + // described by using one more bit than would be present in AddressType. + const RangeTest range_tests_1[] = { + { INT_MIN, INT_MAX, 50, true }, // From INT_MIN to -2, inclusive + { -1, 2, 51, true }, // From -1 to 0, inclusive + { 1, INT_MAX, 52, true }, // From 1 to INT_MAX, inclusive + { INT_MIN, INT_MAX, 53, false }, // Can't fill the space twice + { -1, 2, 54, false }, + { 1, INT_MAX, 55, false }, + { -3, 6, 56, false }, // -3 to 2, inclusive - spans 3 ranges + }; + + // A light round of testing to verify that RetrieveRange does the right + // the right thing at the extremities of the range when nothing is stored + // there. Checks are forced without storing anything at the extremities + // by setting size = 0. + const RangeTest range_tests_2[] = { + { INT_MIN, 0, 100, false }, // makes RetrieveRange check low end + { -1, 3, 101, true }, + { INT_MAX, 0, 102, false }, // makes RetrieveRange check high end + }; + + // Similar to the previous test set, but with a couple of ranges closer + // to the extremities. + const RangeTest range_tests_3[] = { + { INT_MIN + 1, 1, 110, true }, + { INT_MAX - 1, 1, 111, true }, + { INT_MIN, 0, 112, false }, // makes RetrieveRange check low end + { INT_MAX, 0, 113, false } // makes RetrieveRange check high end + }; + + // The range map is cleared between sets of tests listed here. + const RangeTestSet range_test_sets[] = { + { range_tests_0, sizeof(range_tests_0) / sizeof(RangeTest) }, + { range_tests_1, sizeof(range_tests_1) / sizeof(RangeTest) }, + { range_tests_2, sizeof(range_tests_2) / sizeof(RangeTest) }, + { range_tests_3, sizeof(range_tests_3) / sizeof(RangeTest) }, + { range_tests_0, sizeof(range_tests_0) / sizeof(RangeTest) } // Run again + }; + + // Maintain the range map in a pointer so that deletion can be meaningfully + // tested. + auto_ptr<TestMap> range_map(new TestMap()); + + // Run all of the test sets in sequence. + unsigned int range_test_set_count = sizeof(range_test_sets) / + sizeof(RangeTestSet); + for (unsigned int range_test_set_index = 0; + range_test_set_index < range_test_set_count; + ++range_test_set_index) { + const RangeTest* range_tests = + range_test_sets[range_test_set_index].range_tests; + unsigned int range_test_count = + range_test_sets[range_test_set_index].range_test_count; + + // Run the StoreRange test, which validates StoreRange and initializes + // the RangeMap with data for the RetrieveRange test. + int stored_count = 0; // The number of ranges successfully stored + for (unsigned int range_test_index = 0; + range_test_index < range_test_count; + ++range_test_index) { + const RangeTest* range_test = &range_tests[range_test_index]; + if (!StoreTest(range_map.get(), range_test)) + return false; + + if (range_test->expect_storable) + ++stored_count; + } + + // There should be exactly one CountedObject for everything successfully + // stored in the RangeMap. + if (CountedObject::count() != stored_count) { + fprintf(stderr, "FAILED: " + "stored object counts don't match, expected %d, observed %d\n", + stored_count, + CountedObject::count()); + + return false; + } + + // Run the RetrieveRange test + for (unsigned int range_test_index = 0; + range_test_index < range_test_count; + ++range_test_index) { + const RangeTest* range_test = &range_tests[range_test_index]; + if (!RetrieveTest(range_map.get(), range_test)) + return false; + } + + // Clear the map between test sets. If this is the final test set, + // delete the map instead to test destruction. + if (range_test_set_index < range_test_set_count - 1) + range_map->Clear(); + else + range_map.reset(); + + // Test that all stored objects are freed when the RangeMap is cleared + // or deleted. + if (CountedObject::count() != 0) { + fprintf(stderr, "FAILED: " + "did not free all objects after %s, %d still allocated\n", + range_test_set_index < range_test_set_count - 1 ? "clear" + : "delete", + CountedObject::count()); + + return false; + } + } + + return true; +} + +int main(int argc, char** argv) { + return RunTests() ? 0 : 1; +} diff --git a/src/processor/testdata/minidump1.dmp b/src/processor/testdata/minidump1.dmp Binary files differnew file mode 100644 index 00000000..fd4e29fb --- /dev/null +++ b/src/processor/testdata/minidump1.dmp diff --git a/src/processor/testdata/minidump1.out b/src/processor/testdata/minidump1.out new file mode 100644 index 00000000..f6fae1f9 --- /dev/null +++ b/src/processor/testdata/minidump1.out @@ -0,0 +1,3734 @@ +MDRawHeader + signature = 0x504d444d + version = 0x5128a793 + stream_count = 8 + stream_directory_rva = 0x20 + checksum = 0x0 + time_date_stamp = 0x44172f15 2006-03-14 16:01:09 + flags = 0x0 +mDirectory[0] +MDRawDirectory + stream_type = 3 + location.data_size = 436 + location.rva = 0x178 +mDirectory[1] +MDRawDirectory + stream_type = 4 + location.data_size = 11992 + location.rva = 0x32c +mDirectory[2] +MDRawDirectory + stream_type = 5 + location.data_size = 164 + location.rva = 0x9343 +mDirectory[3] +MDRawDirectory + stream_type = 6 + location.data_size = 168 + location.rva = 0xd0 +mDirectory[4] +MDRawDirectory + stream_type = 7 + location.data_size = 56 + location.rva = 0x80 +mDirectory[5] +MDRawDirectory + stream_type = 15 + location.data_size = 24 + location.rva = 0xb8 +mDirectory[6] +MDRawDirectory + stream_type = 0 + location.data_size = 0 + location.rva = 0x0 +mDirectory[7] +MDRawDirectory + stream_type = 0 + location.data_size = 0 + location.rva = 0x0 +Streams: + stream type 0 at index 7 + stream type 3 at index 0 + stream type 4 at index 1 + stream type 5 at index 2 + stream type 6 at index 3 + stream type 7 at index 4 + stream type 15 at index 5 +MinidumpThreadList + thread_count = 9 +thread[0] +MDRawThread + thread_id = 0x124c + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffdf000 + stack.start_of_memory_range = 0x12d940 + stack.memory.data_size = 0x26c0 + stack.memory.rva = 0x94e7 + thread_context.data_size = 0x2cc + thread_context.rva = 0x5ef0 +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0100 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x23ae71f + float_save.error_selector = 0x11c001b + float_save.data_offset = 0x12bb30 + float_save.data_selector = 0xffff0023 + float_save.register_area[80] = 0xd3a68400d3a68400ffffd3a68400eab68400ffffffffed00f8ffff00ffffd4b7c600d4a78500ffff9cf2120060f2120052e900000000000000d002400000000000000080024000000000000000000000 + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x4ec7aa8 + esi = 0x4ec7a50 + ebx = 0x4ec7a78 + edx = 0x7c90eb94 + ecx = 0x7 + eax = 0x4b50000 + ebp = 0x12d954 + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x246 + esp = 0x12d944 + ss = 0x23 + extended_registers[512] = 0x7f02000100001c011fe73a021b00000030bb120023000000a01f0000ffff0000d3a68400d3a68400ffff000000000000d3a68400eab68400ffff000000000000ffffed00f8ffff00ffff000000000000d4b7c600d4a78500ffff0000000000009cf2120060f2120052e900000000000000000000000000d002400000000000000000000000000080024000000000000000000000000000000000000000000000d0f012003815917c9615917ceb06917c181100108800000000000000650063006900660069006500640020005b00770069006e0064006f00770073002000730079007300740065006d0020006500720072006f007200200032005d000000120000000000c805917c684e1600d8ef12005105917ca80714006d05917c00000000e878a403de0100003600000000f512000c000000f078a4030000000070059100f888100100000000a5ae2110e878a403000000000000000000000000e878a40360000000f078a40350000000d801ac0060000000fcf500000000ac00ecf3120098c00c013cf6120018ee907cf006917cffffffffeb06917cb5a621100000ac00000000005100000062696e00587cac0000f0fd7fabf3003014f8120068f61200d695201098f6120034c0201062696e003a9820101079a403cd0000002d000000510000007d290200f078a4030000000094282010b0eb2710a8f61200d4942010 +Stack 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 +thread[1] +MDRawThread + thread_id = 0x103c + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffde000 + stack.start_of_memory_range = 0x107fe2c + stack.memory.data_size = 0x1d4 + stack.memory.rva = 0xbba7 + thread_context.data_size = 0x2cc + thread_context.rva = 0x61bc +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0020 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x2f6e62 + float_save.error_selector = 0x41d001b + float_save.data_offset = 0x369d98 + float_save.data_selector = 0xffff0023 + float_save.register_area[80] = 0x02000000f87dac0000c002000000f87dac0000c03cf71200000000000cf87009917ca0f712000000acf7120000001500320778071500000015000000000000000050b0991e40002003f9d2e6c3dafe3f + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x0 + esi = 0xc4 + ebx = 0xac9078 + edx = 0xe0 + ecx = 0x8355c000 + eax = 0x7fffffff + ebp = 0x107fe94 + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x297 + esp = 0x107fe30 + ss = 0x23 + extended_registers[512] = 0x7f02200000001d04626e2f001b000000989d360023000000801f0000ffff000002000000f87dac0000c000000000000002000000f87dac0000c00000000000003cf71200000000000cf80000000000007009917ca0f712000000000000000000acf7120000001500320700000000000078071500000015000000000000000000000000000050b0991e40000000000000002003f9d2e6c3dafe3f000000000000d48fac00f87dac00000000000000000045040000fcf912007801ac0000000000eb06917c020000000000000000c0fd7f800000007801ac00010000009615917c0891ac0000000000f87dac0000c0fd7f488fac0000000000000000005090ac000800000050f8120000001500a08fac007801ac00780715005890ac00080000000000000002000000e08dac007801ac003807917c1091ac00400615007801ac00eb06917c7801ac007801ac00000000005890ac00780115007801ac004006ac007801ac000000000000001500000000007801ac007cf81200df030000a8cd15003807917cffffffff170400009615917c080000007801ac00f87dac0008000000780115000c04000060cd1500780115007801ac0088cd15005890ac00780115001700000088cd15000000000000000000b0cd1500a88fac00000000005090ac006801ac0000000000000000005090ac00b80000005890ac00a08fac007801ac00 +Stack +0x00000000c0e9907cdb25807cc40000000000000064fe07015436817c10f712007890ac00140000000100000000000000000000001000000000ba3cdcffffffff00c0fd7f00e0fd7f64fe07010000000044fe070100000000a4ff0701f399837c0826807c00000000a8fe07014225807cc400000060ea000000000000c8fe0701ff1e0330c400000060ea000060ea000000000000008eac0060ea0000e4fe070131980230cc8cac004c8bac0060ea0000000000004c8bac0000ff0701ff9f0230008eac00588cac00308bac0060ea0000008eac0040ff07011c742f00588cac0060ea00002cff07012df200300100000000020000308bac000000000000000000308bac00010000000000000000000000000000005cff0701d35d2e000c6639000c6639000000000000000000088dac006cff0701d9b70230088dac00008eac007cff070157fd0230008eac00008eac00b4ff070166322010008eac005436817c10f712007890ac0000000000f0a3ac0088ff070114015080dcff070134c020107877261000000000ecff07010bb5807cf0a3ac005436817c10f712007890ac0000e0fd7f00069c86c0ff0701703c9183fffffffff399837c18b5807c000000000000000000000000b03120107890ac0000000000 +thread[2] +MDRawThread + thread_id = 0x141c + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffdd000 + stack.start_of_memory_range = 0x374ff78 + stack.memory.data_size = 0x88 + stack.memory.rva = 0xbd7b + thread_context.data_size = 0x2cc + thread_context.rva = 0x6488 +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0000 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x0 + float_save.error_selector = 0x4910000 + float_save.data_offset = 0x0 + float_save.data_selector = 0xffff0000 + float_save.register_area[80] = 0x32005c0000000000d8f0e80017005cef12000000a1004c0200000802f0ec0000000040ef12000000780715007801150000000000000038ef120018ee48ef12003815917c96159cef120094ef12000000 + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x71a87558 + esi = 0x0 + ebx = 0xc0000000 + edx = 0x17f310 + ecx = 0x7ffdd000 + eax = 0x7ffdd000 + ebp = 0x374ffb4 + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x202 + esp = 0x374ff7c + ss = 0x23 + extended_registers[512] = 0x7f0200000000917c00000000000000000000000000000000801f000074c1977c32005c0000000000d8f0120060ef1200e80017005cef12000000000000000000a1004c0200000802f0ec1200000000000000000040ef12000000917c05000000780715007801150000000000f4ec12000000000038ef120018ee907cd202000048ef12003815917c9615917cf80817009cef120094ef12000000000000f2160028ed1200d4ed12006cef120078ed1200000015003207917c06000000a80715000000150030f1160050ed12000000000094ef120018ee907c3807917cffffffff3207917cab06917ceb06917c0000a57103001f000000000064ee12007801150064ee1200910e917c080615006d05917cf2081700da0017000000000000000000c8ed120070f916007801150018f0120078f916003b01000000f012004509917c0009170000000000f808170000c0fd7f110000000000000000c0fd7f0510907c00000000e800170078011500700700000e44917c7009917cc0e4977c8144917cf835887ca143917ce0001700f808170044ee1200460f917ce1000000f808170000001500e00017000000000018ef12007801150018ef1200910e917c080615006d05917c000000000000000000000000000000000000150070f9160078011500f8e5807c78f916006ce2807c00000000620764077801150000f0fd7f5105917c +Stack +0xe3d8a5711be3907c09d6a57178010000bcff7403b0ff7403a4ff740350d6a57104ef120018ee907c30f1160000000000000000000000a57168ef1700ecff74030bb5807cecd8a57104ef120018ee907c30f1160000d0fd7f00069c86c0ff740370b74085fffffffff399837c18b5807c000000000000000000000000afd5a57130f1160000000000 +thread[3] +MDRawThread + thread_id = 0x1338 + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffdb000 + stack.start_of_memory_range = 0x384ccac + stack.memory.data_size = 0x3354 + stack.memory.rva = 0xbe03 + thread_context.data_size = 0x2cc + thread_context.rva = 0x6754 +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0000 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x0 + float_save.error_selector = 0x0 + float_save.data_offset = 0x0 + float_save.data_selector = 0xffff0000 + float_save.register_area[80] = 0x02000000f87dac0000c002000000f87dac0000c000000000000000000000b8f11200c0ef12000000ccef12000000150032077807150000001500000090020000e8f1120018ee000000003815917c9615 + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0xffffffff + esi = 0x7fffffff + ebx = 0x16fb30 + edx = 0x11228d8 + ecx = 0x0 + eax = 0x11228d8 + ebp = 0x384ccec + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x293 + esp = 0x384ccb0 + ss = 0x23 + extended_registers[512] = 0x7f0200000000000000000000000000000000000000000000801f0000ffff000002000000f87dac0000c000000000000002000000f87dac0000c000000000000000000000000000000000000000000000b8f11200c0ef12000000000000000000ccef12000000150032070000000000007807150000001500000000000000000090020000e8f1120018ee000000000000000000003815917c9615000000000000ac2a1201f87dac000000000000000000030900001cf212007801ac0000000000eb06917c020000000000000000c0fd7f000000007801ac000100000000000000e02b120100000000000000007801ac00202a1201e82b120100000901282b1201080000007801ac007801ac00782a12017801ac007801ac00302b1201080000007801ac0000000000b8281201000000007801ac00802a1201400615007801ac00eb06917c282a1201780115000000000000000000780115000000000030fa160038f2120000000000efd8907c584da57180fb1600480100009d080000a8fb1600e0f0120047200100d5080000f80000007801ac00b4080000040000000800000078011500ca08000060fb160078011500f800000088fb1600302b12017801ac001700000088fb16000000000006000000b0fb1600c870120100000000282b12016801ac000000000000000000282b1201b8000000302b1201782a12017801ac00 +Stack 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 +thread[4] +MDRawThread + thread_id = 0x145c + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffda000 + stack.start_of_memory_range = 0x394fe30 + stack.memory.data_size = 0x1d0 + stack.memory.rva = 0xf157 + thread_context.data_size = 0x2cc + thread_context.rva = 0x6a20 +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0000 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x0 + float_save.error_selector = 0x0 + float_save.data_offset = 0x0 + float_save.data_selector = 0xffff0000 + float_save.register_area[80] = 0x02000000f87dac0000c002000000f87dac0000c063006c0068005f00630067006f008cf11200000098f11200000015003207780715000000150000003807917cb4f3120018ee000000003815917c9615 + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x0 + esi = 0x1a8 + ebx = 0x114da00 + edx = 0x114d788 + ecx = 0xac89d0 + eax = 0xac8920 + ebp = 0x394fe98 + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x297 + esp = 0x394fe34 + ss = 0x23 + extended_registers[512] = 0x7f0200000000000000000000000000000000000000000000801f0000eb06917c02000000f87dac0000c0fd7feb06917c02000000f87dac0000c0fd7f0c00000063006c0068005f00630061007400650067006f008cf11200000015003207917c98f11200000015003207917c0500000078071500000015000000000070f112003807917cb4f3120018ee907cbf010000000000003815917c9615917c000009015cd91401f87dac00000000000000000014010000e8f312007801ac0000000000eb06917c020000000000000000c0fd7f020000007801ac00010000006a09e66f90da140100000000040000000e000000d0d814010000000002000000d8d91401080000003cf212000000150028d914017801ac0078071500e0d91401080000007801ac006d006f0068d714017801ac003807917c98da1401400615007801ac00eb06917c7801ac007801ac0000000000e0d91401780115007801ac00000009017801ac00000000000000090174696f6e7801ac0005000000ae000000080217000200000000000000e60000006361744d616e00007801ac00480000000800000060d71401db00000000000000780115007801ac00e8011700e0d9140100000000170000005400013a000000000e0000001002170030d9140100000000d8d914016801ac000000000000000000d8d91401b8000000e0d9140128d914017801ac00 +Stack +0x00000000c0e9907cdb25807ca80100000000000068fe9403650072000b00000000da1401140000000100000000000000000000001000000030519bfcffffffff00c0fd7f00a0fd7f68fe94030000000048fe940300000000a4ff9403f399837c0826807c00000000acfe94034225807ca80100003d16000000000000ccfe9403ff1e0330a80100003d1600003d1600000a00000088d714013d160000e8fe940331980230448aac003c89ac003d160000000000006488ac0004ff9403ff9f023088d71401d089ac002089ac003d16000088d7140140ff9403f6e92e00d089ac003d1600002df200300100000037744600fa5d4600c0fa97033d1600002089ac0000000000000000002089ac00010000005cff9403d35d2e003888ac003888ac000000000000000000988813016cff9403d9b702309888130188d714017cff940357fd023088d7140188d71401b4ff94036632201088d71401650072000b00000000da140100000000d00a160188ff940314015080dcff940334c020107877261000000000ecff94030bb5807cd00a1601650072000b00000000da140100a0fd7f00069c86c0ff940328bf6f86fffffffff399837c18b5807c000000000000000000000000b031201000da140100000000 +thread[5] +MDRawThread + thread_id = 0xa6c + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffd8000 + stack.start_of_memory_range = 0x3f6fe18 + stack.memory.data_size = 0x1e8 + stack.memory.rva = 0xf327 + thread_context.data_size = 0x2cc + thread_context.rva = 0x6cec +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0000 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x0 + float_save.error_selector = 0x7ff0000 + float_save.data_offset = 0x0 + float_save.data_selector = 0xffff0000 + float_save.register_area[80] = 0x3807917cffffffff3207eb06917c38db12001f0018d81200000015003207a80715000000150040123207917c34da120018eeffffffff3207917cab0638db120060db1200ed10ab06917ceb06917cc42f + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x0 + esi = 0x152f88 + ebx = 0x0 + edx = 0x7c90eb94 + ecx = 0x152f88 + eax = 0x3f6ff54 + ebp = 0x3f6ff80 + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x246 + esp = 0x3f6fe1c + ss = 0x23 + extended_registers[512] = 0x7f0200000000ffff00000000000000000000000000000000801f0000d81117003807917cffffffff3207917cab06917ceb06917c38db12001f000000948ce77718d81200000015003207917c06000000a80715000000150040121700f0d712003207917c34da120018ee907c3807917cffffffff3207917cab06917ceb06917c38db120060db1200ed10907c3207917cab06917ceb06917cc42f150020db1200000000001000000080d81200000015003207917c0b000000980815000000150098d81200000015003207917c12000000e80915000000150058d4160070d812009615917cb4da120018ee907c3807917cffffffff3207917cab06917ceb06917cd01b170000000000e08d1600a0d81200e0da120018ee907c3807917cffffffff3207917cab06917ceb06917c882f150014db4e77ed10907c0800000000001500d002150008000000080815000000150050fc1600e8d81200201c17000500000018ee907c04000000ffffffff3207917cab06917c000000002cd9120000000000c805917cd0111700220000005105917cf80815006d05917c00000000d0021500d81117008800827cd612907c0000000018001a0078ff817c240026008800827c4000000078131700d00100005cd91200090000000000000000080000e0010000481217000c00000000000000d8121700300215000000000080131700d8121700 +Stack +0x85d3907c99e3907c0367e777d001000070fff60300000000b85c170054fff603000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005ca93f8524acb3b0d99a4f80e19a4f802ca93f85c0a73f85f4a73f8580fff6039966e7774cfff603a966e777ed10907cd01b170058d4160000a22f4dffffffff005d1eeeffffffff0000000038fef60358d41600ffffffff54fff60300000000b85c1700000000000000000088fff603226ce777a8fff6033b6ae777882f150000000000acd7120058d4160058d4160058d41600b4fff6030a6ce777e08d1600ecfff6030bb5807c58d4160000000000acd7120058d416000080fd7f00069c86c0fff603f0399383fffffffff399837c18b5807c000000000000000000000000f06be77758d4160000000000 +thread[6] +MDRawThread + thread_id = 0xf94 + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffd6000 + stack.start_of_memory_range = 0x41ffe24 + stack.memory.data_size = 0x1dc + stack.memory.rva = 0xf50f + thread_context.data_size = 0x2cc + thread_context.rva = 0x6fb8 +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0000 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x0 + float_save.error_selector = 0x120000 + float_save.data_offset = 0x0 + float_save.data_selector = 0xffff0000 + float_save.register_area[80] = 0x00000000305a1700961548fb120030dd2e00000000000000a8dd010000008cdb120048db120000000500000078071500000020db12000d00000064dd3807917cffffffff3207000096032cb6c20330dd + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x0 + esi = 0x1f0 + ebx = 0x3c2b760 + edx = 0x10 + ecx = 0x16d158 + eax = 0x102031b0 + ebp = 0x41ffe8c + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x246 + esp = 0x41ffe28 + ss = 0x23 + extended_registers[512] = 0x7f0200000000120000000000000000000000000000000000801f0000ffff000000000000305a1700961500000000000048fb120030dd2e00000000000000000000000000a8dd010000000000000000008cdb120048db120000000000000000000500000078071500000000000000000020db12000d00000064dd0000000000003807917cffffffff3207000000000000000096032cb6c20330dd000000000000000096037004ac0000000000d0dd1200360000006c00fd7f0b00000000009603eb06917c48fb12000000000000000000d0b5c2030d00000001000000b804ac00f0b7c20364005c002805ac001300000038b7c203000000007022917c9615917c08000000f8db1200000015009803ac000c000000f8b7c2030000150008000000d0db12009803ac0008000000080000005004ac005004ac00f0a9b703ab06917cc0bec203f4bdc20330dd2e000b000000a801ac0010000000000015000002ac000500000008000000eb06917c48fb120030dd2e00000000004400000018ee907c3807917cffffffff5b0000005004ac00eb06917cacbcc20330dd2e000000000060bec2030600000030dd2e000000000030dd2e002805ac000002ac007801ac0017000000b4de1200000000080002ac002e00000010bac2030000000038b7c2036401ac00000000000000000038b7c203b800000040b7c203000000005004ac00 +Stack +0x00000000c0e9907cdb25807cf001000000000000000000003431917cf4da120060b7c20314000000010000000000000000000000100000000060fd7fb8fe1f0400c0fd7f0060fd7f000000003431917c3cfe1f0460b7c203a4ff1f04f399837c0826807c00000000a0fe1f044225807cf0010000ffffffff00000000c0fe1f04ff1e0330f0010000fffffffffffffffffffffffff0b5c203ffffffffdcfe1f043198023064bcc2035cbbc203ffffffff000000005cbbc203f8fe1f04ff9f0230f0b5c203f0bbc20340bbc203fffffffff0b5c20324ff1f04016b0d03f0bbc203ffffffff40bbc203000000000000000040bbc20301000000000000000000000040ff1f0447580d0344ff1f04e6662e00a0bdc20344ff1f04e96a2e005cff1f04d35d2e0050bdc20350bdc203000000000000000090bdc2036cff1f04d9b7023090bdc203f0b5c2037cff1f0457fd0230f0b5c203f0b5c203b4ff1f0466322010f0b5c2033431917cf4da120060b7c2030000000040aec20388ff1f0414015080dcff1f0434c020107877261000000000ecff1f040bb5807c40aec2033431917cf4da120060b7c2030060fd7f00069c86c0ff1f04f0399383fffffffff399837c18b5807c000000000000000000000000b031201060b7c20300000000 +thread[7] +MDRawThread + thread_id = 0x2f8 + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffd9000 + stack.start_of_memory_range = 0x3e6fe50 + stack.memory.data_size = 0x1b0 + stack.memory.rva = 0xf6eb + thread_context.data_size = 0x2cc + thread_context.rva = 0x7284 +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0000 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x0 + float_save.error_selector = 0x120000 + float_save.data_offset = 0x0 + float_save.data_selector = 0xffff0000 + float_save.register_area[80] = 0x188d5504788c5504961584af1200f0c18f02000000000001145f12000c7c010000006c5d1200000005000000780715000000445d120000000000885f3807917cffffffff320700009603f47f5504f0c1 + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x0 + esi = 0x1b4 + ebx = 0x4558180 + edx = 0x2000 + ecx = 0x3e6fa1c + eax = 0x4563000 + ebp = 0x3e6feb8 + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x297 + esp = 0x3e6fe54 + ss = 0x23 + extended_registers[512] = 0x7f0200000000120000000000000000000000000000000000801f0000ffff0000188d5504788c5504961500000000000084af1200f0c18f02000000000000000000000001145f12000c7c000000000000010000006c5d1200000000000000000005000000780715000000000000000000445d120000000000885f0000000000003807917cffffffff320700000000000000009603f47f5504f0c1000000000000000096030c0000000c0000007801ac0084af1200000000000000000000009603c85d12007801ac0000000000f87e5504987f5504fc5d12000100000088a32610108255049615917ceb06917c0c00000000815504000000000c6012003815917c080000007801ac004e0100001803ac000c00000018825504cb00000006000000840000001803ac000800000008000000d003ac002804ac00d003ac0050601200608155049615917c0900000009000000d003ac001000000018bf26102804ac00407f5504400000000b00000000000000000000003207917c34000000b083550408000000387f550456000000d003ac0000000000387f550458000000407f55047801ac004b00000058000000000000000000ac00905c12002804ac00e05e120017000000f006917c00080000eb06917c2e000000b083550400000000588155046401ac00000000000000000058815504b80000006081550400000000d003ac00 +Stack +0x00000000c0e9907cdb25807cb40100000000000088fee6030000ac00f87e550480815504140000000100000000000000000000001000000000ba3cdcffffffff00c0fd7f0090fd7f88fee6030000000068fee60300000000a4ffe603f399837c0826807c00000000ccfee6034225807cb401000060ea000000000000ecfee603ff1e0330b401000060ea000060ea00000a000000b87f550460ea000008ffe60331980230a4a39b039ca29b0360ea000000000000f87e550424ffe603ff9f0230b87f550430a39b0380a29b0360ea0000b87f55045cffe6032851b40230a39b0360ea000020ed7204f00c000060ea0000db55460080a29b03000000000000000080a29b0301000000a8a19b036cffe603d9b70230a8a19b03b87f55047cffe60357fd0230b87f5504b87f5504b4ffe60366322010b87f55040000ac00f87e55048081550400000000b018560488ffe60314015080dcffe60334c020107877261000000000ecffe6030bb5807cb01856040000ac00f87e5504808155040090fd7f00069c86c0ffe603b8e3b683fffffffff399837c18b5807c000000000000000000000000b03120108081550400000000 +thread[8] +MDRawThread + thread_id = 0x12f8 + suspend_count = 0 + priority_class = 0x0 + priority = 0x0 + teb = 0x7ffd7000 + stack.start_of_memory_range = 0x406fe2c + stack.memory.data_size = 0x1d4 + stack.memory.rva = 0xf89b + thread_context.data_size = 0x2cc + thread_context.rva = 0x7550 +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff0000 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x0 + float_save.error_selector = 0x4900000 + float_save.data_offset = 0x0 + float_save.data_selector = 0xffff0000 + float_save.register_area[80] = 0x44fb84033815917c961518ee907c95020000502b00000000000000000000000000007cf9840300000500000078071500780154f98403e8093d0098fb3807917cffffffff3207000096037801ac009502 + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x0 + esi = 0x21c + ebx = 0x455fb58 + edx = 0x303b2 + ecx = 0x10 + eax = 0xfb + ebp = 0x406fe94 + eip = 0x7c90eb94 + cs = 0x1b + eflags = 0x297 + esp = 0x406fe30 + ss = 0x23 + extended_registers[512] = 0x7f0200000000900400000000000000000000000000000000801f0000ffff000044fb84033815917c961500000000000018ee907c95020000502b00000000000000000000000000000000000000000000000000007cf9840300000000000000000500000078071500780100000000000054f98403e8093d0098fb0000000000003807917cffffffff3207000000000000000096037801ac0095020000000000000000960300000000d8f9840300002004c0f9840368f955047801ac000000960338fb55043815917c00000000eb06917c70f955049502000001000000f0f75504e8fb55040000000002000000e0fa5504d8fa55040000000000000000d8f984030800000000000000b4f9840330fb55040c000000c871a771b844a571ffffffff7801ac007943ab71700100007801ac007801ac00f0fb550488fa84037801ac00a8f816007801ac008243ab717801ac00950200007801ac007801ac000000960338fb55047001000000002004010000007801ac0088fa84038300000000000000000400000cfb8403a500000000f95504700100007801ac000200000000000000080000009a0000007001000068f95504c8fa84039615917c38fb550418ee907c17000000502b1201000000000c0000002e000000e4fa84030000000030fb55046801ac00000000000000000030fb5504b800000038fb5504000000007801ac00 +Stack +0x00000000c0e9907cdb25807c1c0200000000000064fe0604000000000000000058fb5504140000000100000000000000000000001000000000ba3cdcffffffff00c0fd7f0070fd7f64fe06040000000044fe060400000000a4ff0604f399837c0826807c00000000a8fe06044225807c1c02000060ea000000000000c8fe0604ff1e03301c02000060ea000060ea0000ccfe060490f9550460ea0000e4fe060431980230043d1201fc3b120160ea0000000000000000000000ff0604ff9f023090f95504903c1201e03b120160ea000090f955043cff0604fbecb702903c120160ea0000503b120168ad2010e03b12010000000060ea00006f334600e03b12010000000000000000e03b1201010000005cff0604c5efb70258ff06040000000020800000201b6204503b1201481a62046cff0604d9b70230503b120190f955047cff060457fd023090f9550490f95504b4ff06046632201090f95504000000000000000058fb5504000000002823560488ff060414015080dcff060434c020107877261000000000ecff06040bb5807c28235604000000000000000058fb55040070fd7f00069c86c0ff06048881f184fffffffff399837c18b5807c000000000000000000000000b031201058fb550400000000 +MinidumpModuleList + module_count = 111 +module[0] +MDRawModule + base_of_image = 0x400000 + size_of_image = 0x1b000 + checksum = 0x0 + time_date_stamp = 0x44172bbf + module_name_rva = 0x3226 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x10006:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 72 + cv_record.rva = 0x781c + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\firefox.exe" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = ce283cf5-b088-4941-b668-af615ab364dc + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\browser\app\firefox.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\browser\app\firefox.pdb" +module[1] +MDRawModule + base_of_image = 0x7c900000 + size_of_image = 0xb0000 + checksum = 0xaf2f7 + time_date_stamp = 0x411096b4 + module_name_rva = 0x3284 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 34 + cv_record.rva = 0x7864 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\ntdll.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 36515fb5-d043-45e4-91f6-72fa2e2878c0 + (cv_record).age = 2 + (cv_record).pdb_file_name = "ntdll.pdb" + (misc_record) = (null) + (debug_filename) = "ntdll.pdb" +module[2] +MDRawModule + base_of_image = 0x7c800000 + size_of_image = 0xf4000 + checksum = 0xff848 + time_date_stamp = 0x411096b4 + module_name_rva = 0x32c4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x7886 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\kernel32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = fb334fb2-8fa3-4128-bde9-229285be4c2f + (cv_record).age = 2 + (cv_record).pdb_file_name = "kernel32.pdb" + (misc_record) = (null) + (debug_filename) = "kernel32.pdb" +module[3] +MDRawModule + base_of_image = 0x10000000 + size_of_image = 0x34000 + checksum = 0x0 + time_date_stamp = 0x44172a6a + module_name_rva = 0x330a + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 72 + cv_record.rva = 0x78ab + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\xul.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 1e9ed19a-1192-4b84-b659-91b62955c394 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\toolkit\library\xul.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\toolkit\library\xul.pdb" +module[4] +MDRawModule + base_of_image = 0x270000 + size_of_image = 0x133000 + checksum = 0x0 + time_date_stamp = 0x441720bc + module_name_rva = 0x3360 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 75 + cv_record.rva = 0x78f3 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\xpcom_core.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 584a7c15-1182-4dce-b5f1-6143772e544e + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\xpcom\build\xpcom_core.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\xpcom\build\xpcom_core.pdb" +module[5] +MDRawModule + base_of_image = 0x30000000 + size_of_image = 0x4c000 + checksum = 0x0 + time_date_stamp = 0x44171ff0 + module_name_rva = 0x33c4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x40007:0x0 + version_info.product_version = 0x40007:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x3 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 73 + cv_record.rva = 0x793e + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\nspr4.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = bdca0efb-2da1-42f1-a9e4-4ae53ecc8357 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nsprpub\pr\src\nspr4.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nsprpub\pr\src\nspr4.pdb" +module[6] +MDRawModule + base_of_image = 0x77dd0000 + size_of_image = 0x9b000 + checksum = 0xa0de4 + time_date_stamp = 0x411096a7 + module_name_rva = 0x341e + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x7987 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\advapi32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 455d6c5f-184d-45bb-b5c5-f30f82975114 + (cv_record).age = 2 + (cv_record).pdb_file_name = "advapi32.pdb" + (misc_record) = (null) + (debug_filename) = "advapi32.pdb" +module[7] +MDRawModule + base_of_image = 0x77e70000 + size_of_image = 0x91000 + checksum = 0x9c482 + time_date_stamp = 0x411096ae + module_name_rva = 0x3464 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x79ac + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\rpcrt4.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = bea45a72-1da1-41da-a3ba-86b3a2031153 + (cv_record).age = 2 + (cv_record).pdb_file_name = "rpcrt4.pdb" + (misc_record) = (null) + (debug_filename) = "rpcrt4.pdb" +module[8] +MDRawModule + base_of_image = 0x71ad0000 + size_of_image = 0x9000 + checksum = 0x12c31 + time_date_stamp = 0x411096ff + module_name_rva = 0x34a6 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x79cf + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\wsock32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = e7b6c17e-4360-4822-813d-3b65499b6c0f + (cv_record).age = 2 + (cv_record).pdb_file_name = "wsock32.pdb" + (misc_record) = (null) + (debug_filename) = "wsock32.pdb" +module[9] +MDRawModule + base_of_image = 0x71ab0000 + size_of_image = 0x17000 + checksum = 0x2030b + time_date_stamp = 0x411096f2 + module_name_rva = 0x34ea + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x79f3 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\ws2_32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 07ac0883-1007-408d-919e-0ccf1ea499bf + (cv_record).age = 2 + (cv_record).pdb_file_name = "ws2_32.pdb" + (misc_record) = (null) + (debug_filename) = "ws2_32.pdb" +module[10] +MDRawModule + base_of_image = 0x77c10000 + size_of_image = 0x58000 + checksum = 0x57cd3 + time_date_stamp = 0x41109752 + module_name_rva = 0x352c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x70000:0xa280884 + version_info.product_version = 0x60001:0x21be0884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x1 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x7a16 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\msvcrt.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = a678f3c3-0ded-426b-8390-32b996987e38 + (cv_record).age = 1 + (cv_record).pdb_file_name = "msvcrt.pdb" + (misc_record) = (null) + (debug_filename) = "msvcrt.pdb" +module[11] +MDRawModule + base_of_image = 0x71aa0000 + size_of_image = 0x8000 + checksum = 0xaff6 + time_date_stamp = 0x411096f3 + module_name_rva = 0x356e + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x7a39 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\ws2help.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 537ce830-efe9-4fe3-a92c-95153bdb7146 + (cv_record).age = 2 + (cv_record).pdb_file_name = "ws2help.pdb" + (misc_record) = (null) + (debug_filename) = "ws2help.pdb" +module[12] +MDRawModule + base_of_image = 0x76b40000 + size_of_image = 0x2d000 + checksum = 0x2ed0a + time_date_stamp = 0x411096d6 + module_name_rva = 0x35b2 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 34 + cv_record.rva = 0x7a5d + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\winmm.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 4fc9f179-9647-45ca-a3c7-8d6fadfc2832 + (cv_record).age = 2 + (cv_record).pdb_file_name = "winmm.pdb" + (misc_record) = (null) + (debug_filename) = "winmm.pdb" +module[13] +MDRawModule + base_of_image = 0x77d40000 + size_of_image = 0x90000 + checksum = 0x9505c + time_date_stamp = 0x42260159 + module_name_rva = 0x35f2 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280a3e + version_info.product_version = 0x50001:0xa280a3e + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x7a7f + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\user32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = ee2b714d-83a3-4c9d-8802-7621272f8326 + (cv_record).age = 2 + (cv_record).pdb_file_name = "user32.pdb" + (misc_record) = (null) + (debug_filename) = "user32.pdb" +module[14] +MDRawModule + base_of_image = 0x77f10000 + size_of_image = 0x47000 + checksum = 0x4d0d0 + time_date_stamp = 0x43b34feb + module_name_rva = 0x3634 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280b02 + version_info.product_version = 0x50001:0xa280b02 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 34 + cv_record.rva = 0x7aa2 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\gdi32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = c0ea66be-00a6-4bd7-aef7-9e443a91869c + (cv_record).age = 2 + (cv_record).pdb_file_name = "gdi32.pdb" + (misc_record) = (null) + (debug_filename) = "gdi32.pdb" +module[15] +MDRawModule + base_of_image = 0x10200000 + size_of_image = 0x87000 + checksum = 0x915f5 + time_date_stamp = 0x3e77de16 + module_name_rva = 0x3674 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x7000a:0xc050000 + version_info.product_version = 0x7000a:0xc050000 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x1 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x7ac4 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\msvcr71d.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = a286c371-23da-449e-bb63-b87354610d22 + (cv_record).age = 1 + (cv_record).pdb_file_name = "msvcr71d.pdb" + (misc_record) = (null) + (debug_filename) = "msvcr71d.pdb" +module[16] +MDRawModule + base_of_image = 0x3b0000 + size_of_image = 0xb000 + checksum = 0x0 + time_date_stamp = 0x44171ff4 + module_name_rva = 0x36ba + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x40007:0x0 + version_info.product_version = 0x40007:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x3 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 78 + cv_record.rva = 0x7ae9 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\plc4.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = d420f074-81bb-4eb3-8d6b-5e4c33e7db73 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nsprpub\lib\libc\src\plc4.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nsprpub\lib\libc\src\plc4.pdb" +module[17] +MDRawModule + base_of_image = 0x3c0000 + size_of_image = 0x9000 + checksum = 0x0 + time_date_stamp = 0x44171ff1 + module_name_rva = 0x3712 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x40007:0x0 + version_info.product_version = 0x40007:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x3 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 73 + cv_record.rva = 0x7b37 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\plds4.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 385f5c08-a70d-491f-b48f-e0d1f3c9a1c7 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nsprpub\lib\ds\plds4.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nsprpub\lib\ds\plds4.pdb" +module[18] +MDRawModule + base_of_image = 0x7c9c0000 + size_of_image = 0x815000 + checksum = 0x81cd3e + time_date_stamp = 0x433370f6 + module_name_rva = 0x376c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x60000:0xb540acb + version_info.product_version = 0x60000:0xb540acb + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x7b80 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\shell32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 48106cb6-8068-4680-899c-05c75658bb15 + (cv_record).age = 2 + (cv_record).pdb_file_name = "shell32.pdb" + (misc_record) = (null) + (debug_filename) = "shell32.pdb" +module[19] +MDRawModule + base_of_image = 0x77f60000 + size_of_image = 0x76000 + checksum = 0x7fcb5 + time_date_stamp = 0x43c2a517 + module_name_rva = 0x37b0 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x60000:0xb540b07 + version_info.product_version = 0x60000:0xb540b07 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x7ba4 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\shlwapi.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 2c2623fd-8435-4ae6-b89e-3457ef94bd2e + (cv_record).age = 2 + (cv_record).pdb_file_name = "shlwapi.pdb" + (misc_record) = (null) + (debug_filename) = "shlwapi.pdb" +module[20] +MDRawModule + base_of_image = 0x774e0000 + size_of_image = 0x13d000 + checksum = 0x13dc6b + time_date_stamp = 0x42e5be93 + module_name_rva = 0x37f4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280aa6 + version_info.product_version = 0x50001:0xa280aa6 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 34 + cv_record.rva = 0x7bc8 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\ole32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 683b65b2-46f4-4187-96d2-ee6d4c55eb11 + (cv_record).age = 2 + (cv_record).pdb_file_name = "ole32.pdb" + (misc_record) = (null) + (debug_filename) = "ole32.pdb" +module[21] +MDRawModule + base_of_image = 0x77c00000 + size_of_image = 0x8000 + checksum = 0x11d78 + time_date_stamp = 0x411096b7 + module_name_rva = 0x3834 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x7bea + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\version.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 180a90c4-0384-463e-82dd-c45b2c8ab76e + (cv_record).age = 2 + (cv_record).pdb_file_name = "version.pdb" + (misc_record) = (null) + (debug_filename) = "version.pdb" +module[22] +MDRawModule + base_of_image = 0x420000 + size_of_image = 0x126000 + checksum = 0x0 + time_date_stamp = 0x44172054 + module_name_rva = 0x3878 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x40000:0x0 + version_info.product_version = 0x40000:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x10004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 66 + cv_record.rva = 0x7c0e + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\js3250.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 6fb91d31-f9c7-4198-a3c9-096daf9aeb7d + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\js\src\js3250.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\js\src\js3250.pdb" +module[23] +MDRawModule + base_of_image = 0x773d0000 + size_of_image = 0x102000 + checksum = 0x1043f0 + time_date_stamp = 0x4110968c + module_name_rva = 0x38d4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x60000:0xb540884 + version_info.product_version = 0x60000:0xb540884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 83 + cv_record.rva = 0x7c50 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\WinSxS\x86_Microsoft.Windows.Common-Controls_6595b64144ccf1df_6.0.2600.2180_x-ww_a84f1ff9\comctl32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = c454919c-0316-4361-8f4c-ac675cbc6440 + (cv_record).age = 1 + (cv_record).pdb_file_name = "MicrosoftWindowsCommon-Controls-6.0.2600.2180-comctl32.pdb" + (misc_record) = (null) + (debug_filename) = "MicrosoftWindowsCommon-Controls-6.0.2600.2180-comctl32.pdb" +module[24] +MDRawModule + base_of_image = 0x74720000 + size_of_image = 0x4b000 + checksum = 0x49029 + time_date_stamp = 0x411096ea + module_name_rva = 0x39bc + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 34 + cv_record.rva = 0x7ca3 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\MSCTF.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 27ce4025-aee4-4b56-9b9e-d28f7b4e15e3 + (cv_record).age = 2 + (cv_record).pdb_file_name = "msctf.pdb" + (misc_record) = (null) + (debug_filename) = "msctf.pdb" +module[25] +MDRawModule + base_of_image = 0x63000000 + size_of_image = 0x14000 + checksum = 0x0 + time_date_stamp = 0x3ef8d1d1 + module_name_rva = 0x39fc + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x70002:0x3000a + version_info.product_version = 0x70002:0x3000a + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 0 + cv_record.rva = 0x0 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\SynTPFcs.dll" + (cv_record) = (null) + (misc_record) = (null) + (debug_filename) = (null) +module[26] +MDRawModule + base_of_image = 0xf50000 + size_of_image = 0x6000 + checksum = 0x0 + time_date_stamp = 0x42a71e65 + module_name_rva = 0x3a42 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x4000b:0x8a + version_info.product_version = 0x4000b:0x8a + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 0 + cv_record.rva = 0x0 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\Program Files\Utimaco\SafeGuard Easy\SgMsgBhk.dll" + (cv_record) = (null) + (misc_record) = (null) + (debug_filename) = (null) +module[27] +MDRawModule + base_of_image = 0x76fd0000 + size_of_image = 0x7f000 + checksum = 0x7b912 + time_date_stamp = 0x42e5be90 + module_name_rva = 0x3ab0 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x7d1000c:0x113e0134 + version_info.product_version = 0x30000:0x113e + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x20 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x7cc5 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\clbcatq.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 58d39469-4efa-45de-961f-5c692b3211bc + (cv_record).age = 2 + (cv_record).pdb_file_name = "clbcatq.pdb" + (misc_record) = (null) + (debug_filename) = "clbcatq.pdb" +module[28] +MDRawModule + base_of_image = 0x77050000 + size_of_image = 0xc5000 + checksum = 0xc916e + time_date_stamp = 0x411096b4 + module_name_rva = 0x3af4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x7d1000c:0x113e0102 + version_info.product_version = 0x30000:0x113e + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x20 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x7ce9 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\comres.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = d81244c4-1029-461f-aabc-731cfddf0ae0 + (cv_record).age = 8 + (cv_record).pdb_file_name = "COMRes.pdb" + (misc_record) = (null) + (debug_filename) = "COMRes.pdb" +module[29] +MDRawModule + base_of_image = 0x77120000 + size_of_image = 0x8c000 + checksum = 0x96957 + time_date_stamp = 0x411096f3 + module_name_rva = 0x3b36 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x7d0c + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\oleaut32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 149fb0c8-30bc-400d-ba99-728efb58a113 + (cv_record).age = 2 + (cv_record).pdb_file_name = "oleaut32.pdb" + (misc_record) = (null) + (debug_filename) = "oleaut32.pdb" +module[30] +MDRawModule + base_of_image = 0x11a0000 + size_of_image = 0xab000 + checksum = 0x0 + time_date_stamp = 0x441728d6 + module_name_rva = 0x3b7c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 83 + cv_record.rva = 0x7d31 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\accessibility.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = ba2e9f7e-baf4-4a93-b83d-fe608deaf5bf + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\accessible\build\accessibility.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\accessible\build\accessibility.pdb" +module[31] +MDRawModule + base_of_image = 0x1250000 + size_of_image = 0x28000 + checksum = 0x0 + time_date_stamp = 0x44172342 + module_name_rva = 0x3bfc + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 66 + cv_record.rva = 0x7d84 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\gkgfx.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 8cc0258b-8361-4115-b006-c6e06b2d1f94 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\gfx\src\gkgfx.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\gfx\src\gkgfx.pdb" +module[32] +MDRawModule + base_of_image = 0x10480000 + size_of_image = 0xbc000 + checksum = 0xc6ae8 + time_date_stamp = 0x3e77de37 + module_name_rva = 0x3c56 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x7000a:0xc050000 + version_info.product_version = 0x7000a:0xc050000 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x1 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x7dc6 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\msvcp71d.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = e4296eeb-3f9a-4d0b-a18d-6207eb11426b + (cv_record).age = 1 + (cv_record).pdb_file_name = "msvcp71d.pdb" + (misc_record) = (null) + (debug_filename) = "msvcp71d.pdb" +module[33] +MDRawModule + base_of_image = 0x1280000 + size_of_image = 0x35000 + checksum = 0x0 + time_date_stamp = 0x44172922 + module_name_rva = 0x3c9c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 83 + cv_record.rva = 0x7deb + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\appcomps.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = d106f767-3a2e-43ce-b03e-5bca76381590 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\xpfe\components\build\appcomps.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\xpfe\components\build\appcomps.pdb" +module[34] +MDRawModule + base_of_image = 0x18f0000 + size_of_image = 0x3c000 + checksum = 0x0 + time_date_stamp = 0x4417283e + module_name_rva = 0x3d12 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 79 + cv_record.rva = 0x7e3e + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\appshell.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 7a9f6f93-778e-434c-850c-7045e0e002ba + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\xpfe\appshell\src\appshell.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\xpfe\appshell\src\appshell.pdb" +module[35] +MDRawModule + base_of_image = 0x12c0000 + size_of_image = 0x11000 + checksum = 0x0 + time_date_stamp = 0x44172842 + module_name_rva = 0x3d88 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 73 + cv_record.rva = 0x7e8d + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\auth.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 48a2d3e3-4ecb-46ad-bbed-6d8ec74be5a1 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\extensions\auth\auth.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\extensions\auth\auth.pdb" +module[36] +MDRawModule + base_of_image = 0x1930000 + size_of_image = 0x18000 + checksum = 0x0 + time_date_stamp = 0x44172a51 + module_name_rva = 0x3df6 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 94 + cv_record.rva = 0x7ed6 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\autoconfig.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 892f887b-90bc-4a77-a94c-6a5e458beb08 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\extensions\pref\autoconfig\src\autoconfig.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\extensions\pref\autoconfig\src\autoconfig.pdb" +module[37] +MDRawModule + base_of_image = 0x1950000 + size_of_image = 0xc000 + checksum = 0x0 + time_date_stamp = 0x44172b8f + module_name_rva = 0x3e70 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 102 + cv_record.rva = 0x7f34 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\browserdirprovider.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 6e2d9bbd-9cd7-4163-b294-e952567e69ca + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\browser\components\dirprovider\browserdirprovider.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\browser\components\dirprovider\browserdirprovider.pdb" +module[38] +MDRawModule + base_of_image = 0x1960000 + size_of_image = 0xde000 + checksum = 0x0 + time_date_stamp = 0x44172bb6 + module_name_rva = 0x3efa + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 86 + cv_record.rva = 0x7f9a + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\brwsrcmp.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 14128c9f-69d5-4d8d-8d95-b54d7a7b4d85 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\browser\components\build\brwsrcmp.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\browser\components\build\brwsrcmp.pdb" +module[39] +MDRawModule + base_of_image = 0x1a40000 + size_of_image = 0x2f000 + checksum = 0x0 + time_date_stamp = 0x441720c7 + module_name_rva = 0x3f70 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 80 + cv_record.rva = 0x7ff0 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\xpcom_compat.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 4ef11cba-8daa-4975-b122-6e6c2f3fb51e + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\xpcom\obsolete\xpcom_compat.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\xpcom\obsolete\xpcom_compat.pdb" +module[40] +MDRawModule + base_of_image = 0x1a70000 + size_of_image = 0x2d000 + checksum = 0x0 + time_date_stamp = 0x44172307 + module_name_rva = 0x3fd8 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 66 + cv_record.rva = 0x8040 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\caps.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = a90d22b0-0f75-45d7-b20b-6e9673ceb799 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\caps\src\caps.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\caps\src\caps.pdb" +module[41] +MDRawModule + base_of_image = 0x1aa0000 + size_of_image = 0x2f000 + checksum = 0x0 + time_date_stamp = 0x44172912 + module_name_rva = 0x4046 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 70 + cv_record.rva = 0x8082 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\chrome.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = e35cbd83-d29a-45a5-a7ad-b5709d4abd3a + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\chrome\src\chrome.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\chrome\src\chrome.pdb" +module[42] +MDRawModule + base_of_image = 0x1ad0000 + size_of_image = 0x11000 + checksum = 0x0 + time_date_stamp = 0x4417293d + module_name_rva = 0x40b8 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 97 + cv_record.rva = 0x80c8 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\cmdlines.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 08e29112-a3fa-44ff-bd5c-d38db16e79af + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\toolkit\components\commandlines\src\cmdlines.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\toolkit\components\commandlines\src\cmdlines.pdb" +module[43] +MDRawModule + base_of_image = 0x1af0000 + size_of_image = 0x35000 + checksum = 0x0 + time_date_stamp = 0x44172832 + module_name_rva = 0x412e + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 81 + cv_record.rva = 0x8129 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\composer.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 6e5d68fc-fdc1-4559-a1e8-8e9b1deb4ea9 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\editor\composer\src\composer.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\editor\composer\src\composer.pdb" +module[44] +MDRawModule + base_of_image = 0x1b30000 + size_of_image = 0x1a000 + checksum = 0x0 + time_date_stamp = 0x44172b33 + module_name_rva = 0x41a4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 77 + cv_record.rva = 0x817a + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\cookie.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = b0e47f99-d675-42d8-b7cc-2d9ea0c837b0 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\extensions\cookie\cookie.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\extensions\cookie\cookie.pdb" +module[45] +MDRawModule + base_of_image = 0x1b50000 + size_of_image = 0xa8000 + checksum = 0x0 + time_date_stamp = 0x441727b9 + module_name_rva = 0x4216 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 76 + cv_record.rva = 0x81c7 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\docshell.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = d2aceac9-ca3b-44b5-9d96-fa5413f2f3d3 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\docshell\build\docshell.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\docshell\build\docshell.pdb" +module[46] +MDRawModule + base_of_image = 0x1c00000 + size_of_image = 0x132000 + checksum = 0x0 + time_date_stamp = 0x44172824 + module_name_rva = 0x428c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 82 + cv_record.rva = 0x8213 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\editor.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = ef8148d4-c16f-4bd5-be41-e41dd89a776b + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\editor\libeditor\build\editor.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\editor\libeditor\build\editor.pdb" +module[47] +MDRawModule + base_of_image = 0x1d40000 + size_of_image = 0x7b000 + checksum = 0x0 + time_date_stamp = 0x441727df + module_name_rva = 0x42fe + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 95 + cv_record.rva = 0x8265 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\embedcomponents.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 716f8df6-9152-4353-a9cc-364864025f18 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\embedding\components\build\embedcomponents.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\embedding\components\build\embedcomponents.pdb" +module[48] +MDRawModule + base_of_image = 0x73000000 + size_of_image = 0x26000 + checksum = 0x2a147 + time_date_stamp = 0x411096b6 + module_name_rva = 0x4382 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x3 + version_info.file_subtype = 0x1 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x82c4 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\winspool.drv" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 97a6ecc9-4ea7-450c-a7d3-75bd9dffca5e + (cv_record).age = 2 + (cv_record).pdb_file_name = "winspool.pdb" + (misc_record) = (null) + (debug_filename) = "winspool.pdb" +module[49] +MDRawModule + base_of_image = 0x763b0000 + size_of_image = 0x49000 + checksum = 0x4b1df + time_date_stamp = 0x411096b0 + module_name_rva = 0x43c8 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x60000:0xb540884 + version_info.product_version = 0x60000:0xb540884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x82e9 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\comdlg32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 4fcbead6-3d73-4599-8c1f-92d8dbb0dc27 + (cv_record).age = 2 + (cv_record).pdb_file_name = "comdlg32.pdb" + (misc_record) = (null) + (debug_filename) = "comdlg32.pdb" +module[50] +MDRawModule + base_of_image = 0x1dd0000 + size_of_image = 0x2f000 + checksum = 0x0 + time_date_stamp = 0x4417234e + module_name_rva = 0x440e + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 79 + cv_record.rva = 0x830e + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\gkgfxthebes.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = d73dd8a2-49bd-483a-8aad-ac22101cc29b + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\gfx\src\thebes\gkgfxthebes.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\gfx\src\thebes\gkgfxthebes.pdb" +module[51] +MDRawModule + base_of_image = 0x1e00000 + size_of_image = 0x68000 + checksum = 0x0 + time_date_stamp = 0x4417233a + module_name_rva = 0x448a + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 74 + cv_record.rva = 0x835d + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\thebes.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = b596a90c-d8d4-4c5c-84fe-0e64a981d63c + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\gfx\thebes\src\thebes.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\gfx\thebes\src\thebes.pdb" +module[52] +MDRawModule + base_of_image = 0x74d90000 + size_of_image = 0x6b000 + checksum = 0x656c9 + time_date_stamp = 0x411096ba + module_name_rva = 0x44e6 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x101a4:0xa280884 + version_info.product_version = 0x101a4:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 34 + cv_record.rva = 0x83a7 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\usp10.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 14c8d7f8-ab3c-48a4-b95a-73bac9a6b02c + (cv_record).age = 1 + (cv_record).pdb_file_name = "usp10.pdb" + (misc_record) = (null) + (debug_filename) = "usp10.pdb" +module[53] +MDRawModule + base_of_image = 0x1e80000 + size_of_image = 0x951000 + checksum = 0x0 + time_date_stamp = 0x4417271d + module_name_rva = 0x4526 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 74 + cv_record.rva = 0x83c9 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\gklayout.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 72800c10-fc1d-485c-865c-faf7e123534c + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\layout\build\gklayout.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\layout\build\gklayout.pdb" +module[54] +MDRawModule + base_of_image = 0x27e0000 + size_of_image = 0x85000 + checksum = 0x0 + time_date_stamp = 0x44172319 + module_name_rva = 0x459c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 83 + cv_record.rva = 0x8413 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\gkparser.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 55b1514d-a272-4ad7-a4ef-47a75d4f956d + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\parser\htmlparser\src\gkparser.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\parser\htmlparser\src\gkparser.pdb" +module[55] +MDRawModule + base_of_image = 0x2870000 + size_of_image = 0x72000 + checksum = 0x0 + time_date_stamp = 0x44172372 + module_name_rva = 0x4612 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 85 + cv_record.rva = 0x8466 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\gkplugin.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = cf6be981-d782-4329-99df-b1659f73ef36 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\modules\plugin\base\src\gkplugin.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\modules\plugin\base\src\gkplugin.pdb" +module[56] +MDRawModule + base_of_image = 0x28f0000 + size_of_image = 0x9f000 + checksum = 0x0 + time_date_stamp = 0x441723d6 + module_name_rva = 0x4688 + version_info.signature = 0x0 + version_info.struct_version = 0x0 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x0 + version_info.file_flags = 0x0 + version_info.file_os = 0x0 + version_info.file_type = 0x0 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 78 + cv_record.rva = 0x84bb + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\gkwidget.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 8e419b10-afd6-4da8-ba8d-70b75f0f9b65 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\widget\src\build\gkwidget.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\widget\src\build\gkwidget.pdb" +module[57] +MDRawModule + base_of_image = 0x2990000 + size_of_image = 0x63000 + checksum = 0x0 + time_date_stamp = 0x4417224a + module_name_rva = 0x46fe + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 68 + cv_record.rva = 0x8509 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\i18n.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 05a30357-0008-4eab-81eb-004caaebc3c7 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\intl\build\i18n.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\intl\build\i18n.pdb" +module[58] +MDRawModule + base_of_image = 0x2a00000 + size_of_image = 0x13000 + checksum = 0x0 + time_date_stamp = 0x44172357 + module_name_rva = 0x476c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 90 + cv_record.rva = 0x854d + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\imgicon.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 039e19b8-270a-4187-b4eb-4eccc0dc6292 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\modules\libpr0n\decoders\icon\imgicon.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\modules\libpr0n\decoders\icon\imgicon.pdb" +module[59] +MDRawModule + base_of_image = 0x2a20000 + size_of_image = 0x70000 + checksum = 0x0 + time_date_stamp = 0x44172360 + module_name_rva = 0x47e0 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 82 + cv_record.rva = 0x85a7 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\imglib2.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 1cc6948c-5364-405b-95fa-f6a8cc17e949 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\modules\libpr0n\build\imglib2.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\modules\libpr0n\build\imglib2.pdb" +module[60] +MDRawModule + base_of_image = 0x2a90000 + size_of_image = 0x1f000 + checksum = 0x0 + time_date_stamp = 0x44172012 + module_name_rva = 0x4854 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 74 + cv_record.rva = 0x85f9 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\mozz.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 072d6b76-ecd2-41cf-9623-2897a3866bf3 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\modules\zlib\src\mozz.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\modules\zlib\src\mozz.pdb" +module[61] +MDRawModule + base_of_image = 0x2ab0000 + size_of_image = 0xf000 + checksum = 0x0 + time_date_stamp = 0x4417224c + module_name_rva = 0x48ac + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 84 + cv_record.rva = 0x8643 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\intlcmpt.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 9bbbd5a9-bc77-41b5-9a71-3e73302c69b4 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\intl\compatibility\src\intlcmpt.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\intl\compatibility\src\intlcmpt.pdb" +module[62] +MDRawModule + base_of_image = 0x2ac0000 + size_of_image = 0x29000 + checksum = 0x0 + time_date_stamp = 0x441722d8 + module_name_rva = 0x4922 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 73 + cv_record.rva = 0x8697 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\jar50.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 15d6ee0d-b935-4be4-8984-3d6768449a64 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\modules\libjar\jar50.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\modules\libjar\jar50.pdb" +module[63] +MDRawModule + base_of_image = 0x2af0000 + size_of_image = 0x2e000 + checksum = 0x0 + time_date_stamp = 0x441729aa + module_name_rva = 0x4992 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 67 + cv_record.rva = 0x86e0 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\jsd3250.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 91f68816-8388-40a8-b90e-24ba5da2b786 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\js\jsd\jsd3250.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\js\jsd\jsd3250.pdb" +module[64] +MDRawModule + base_of_image = 0x2b20000 + size_of_image = 0xa000 + checksum = 0x0 + time_date_stamp = 0x4417291d + module_name_rva = 0x4a06 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 85 + cv_record.rva = 0x8723 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\mozfind.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = e91e5878-f2d4-4602-88da-47bef2986c78 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\xpfe\components\find\src\mozfind.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\xpfe\components\find\src\mozfind.pdb" +module[65] +MDRawModule + base_of_image = 0x2b30000 + size_of_image = 0x174000 + checksum = 0x0 + time_date_stamp = 0x441722be + module_name_rva = 0x4a7a + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 72 + cv_record.rva = 0x8778 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\necko.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 6a7583d2-b97e-4f29-9c40-59a1a2f3a021 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\netwerk\build\necko.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\netwerk\build\necko.pdb" +module[66] +MDRawModule + base_of_image = 0x2cb0000 + size_of_image = 0x21000 + checksum = 0x0 + time_date_stamp = 0x44172894 + module_name_rva = 0x4aea + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 72 + cv_record.rva = 0x87c0 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\oji.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 0cc03cae-31ba-4d6b-b16f-26ece3d85a09 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\modules\oji\src\oji.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\modules\oji\src\oji.pdb" +module[67] +MDRawModule + base_of_image = 0x2ce0000 + size_of_image = 0x28000 + checksum = 0x0 + time_date_stamp = 0x44172886 + module_name_rva = 0x4b56 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 79 + cv_record.rva = 0x8808 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\jsj3250.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 1c18ef87-64f1-44c7-a437-4efc3da223c9 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\js\src\liveconnect\jsj3250.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\js\src\liveconnect\jsj3250.pdb" +module[68] +MDRawModule + base_of_image = 0x2d10000 + size_of_image = 0xd000 + checksum = 0x0 + time_date_stamp = 0x44172b64 + module_name_rva = 0x4bb4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 81 + cv_record.rva = 0x8857 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\perms.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 3f95755e-5b8f-4755-a098-922125ab7724 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\extensions\permissions\perms.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\extensions\permissions\perms.pdb" +module[69] +MDRawModule + base_of_image = 0x2d20000 + size_of_image = 0x18000 + checksum = 0x0 + time_date_stamp = 0x44172a17 + module_name_rva = 0x4c24 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 86 + cv_record.rva = 0x88a8 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\pipboot.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 16d11d56-afd1-4bd3-abff-80413e12c52a + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\security\manager\boot\src\pipboot.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\security\manager\boot\src\pipboot.pdb" +module[70] +MDRawModule + base_of_image = 0x2d40000 + size_of_image = 0x9e000 + checksum = 0x0 + time_date_stamp = 0x44172a3f + module_name_rva = 0x4c98 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 84 + cv_record.rva = 0x88fe + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\pipnss.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = a81e4e81-8507-4ee6-89ad-94b7af5f1095 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\security\manager\ssl\src\pipnss.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\security\manager\ssl\src\pipnss.pdb" +module[71] +MDRawModule + base_of_image = 0x2de0000 + size_of_image = 0x3a000 + checksum = 0x0 + time_date_stamp = 0x441729f2 + module_name_rva = 0x4d0a + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x3000b:0x10000 + version_info.product_version = 0x3000b:0x10000 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x3 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 69 + cv_record.rva = 0x8952 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\smime3.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 7c369855-5aae-437d-8a9b-fef4c6f6f272 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nss\smime\smime3.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nss\smime\smime3.pdb" +module[72] +MDRawModule + base_of_image = 0x2e20000 + size_of_image = 0xc9000 + checksum = 0x0 + time_date_stamp = 0x441729e0 + module_name_rva = 0x4d66 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x3000b:0x10000 + version_info.product_version = 0x3000b:0x10000 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x3 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 65 + cv_record.rva = 0x8997 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\nss3.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 4bfc7d95-5db2-452a-a22b-de636b85b417 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nss\nss\nss3.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nss\nss\nss3.pdb" +module[73] +MDRawModule + base_of_image = 0x2ef0000 + size_of_image = 0x71000 + checksum = 0x0 + time_date_stamp = 0x441729c6 + module_name_rva = 0x4dbe + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x3000b:0x10000 + version_info.product_version = 0x3000b:0x10000 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x3 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 73 + cv_record.rva = 0x89d8 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\softokn3.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 2834c90f-1695-4d72-9a1d-d2bfe14b76f9 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nss\softokn\softokn3.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nss\softokn\softokn3.pdb" +module[74] +MDRawModule + base_of_image = 0x2f70000 + size_of_image = 0x4a000 + checksum = 0x0 + time_date_stamp = 0x441729e8 + module_name_rva = 0x4e1e + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x3000b:0x10000 + version_info.product_version = 0x3000b:0x10000 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x3 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 65 + cv_record.rva = 0x8a21 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\ssl3.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = bd1c8dec-e181-4c32-b774-45b4ac769699 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nss\ssl\ssl3.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nss\ssl\ssl3.pdb" +module[75] +MDRawModule + base_of_image = 0x2fc0000 + size_of_image = 0x14000 + checksum = 0x0 + time_date_stamp = 0x44172a4c + module_name_rva = 0x4e76 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 84 + cv_record.rva = 0x8a62 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\pippki.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = f151d2ee-5bb2-474e-aa89-d9a33a7d51a5 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\security\manager\pki\src\pippki.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\security\manager\pki\src\pippki.pdb" +module[76] +MDRawModule + base_of_image = 0x2fe0000 + size_of_image = 0x56000 + checksum = 0x0 + time_date_stamp = 0x441722eb + module_name_rva = 0x4ee8 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 66 + cv_record.rva = 0x8ab6 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\rdf.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = ffd69462-7676-439a-8bcf-a91691b53a0c + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\rdf\build\rdf.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\rdf\build\rdf.pdb" +module[77] +MDRawModule + base_of_image = 0x3040000 + size_of_image = 0x3c000 + checksum = 0x0 + time_date_stamp = 0x44172938 + module_name_rva = 0x4f54 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 91 + cv_record.rva = 0x8af8 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\satchel.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = a060def4-62a9-4f01-9ce7-5431f4f76bbc + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\toolkit\components\satchel\src\satchel.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\toolkit\components\satchel\src\satchel.pdb" +module[78] +MDRawModule + base_of_image = 0x3080000 + size_of_image = 0x46000 + checksum = 0x0 + time_date_stamp = 0x44172b88 + module_name_rva = 0x4fc8 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 87 + cv_record.rva = 0x8b53 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\srchsvc.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 2bc65c93-99d5-4f75-a2bd-8d34558b326d + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\xpfe\components\search\src\srchsvc.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\xpfe\components\search\src\srchsvc.pdb" +module[79] +MDRawModule + base_of_image = 0x30d0000 + size_of_image = 0x7a000 + checksum = 0x0 + time_date_stamp = 0x44172a69 + module_name_rva = 0x503c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 75 + cv_record.rva = 0x8baa + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\strgcmps.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 01cdab52-fbc2-4a10-9521-3fa689eda27d + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\storage\build\strgcmps.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\storage\build\strgcmps.pdb" +module[80] +MDRawModule + base_of_image = 0x3150000 + size_of_image = 0x15000 + checksum = 0x0 + time_date_stamp = 0x44172931 + module_name_rva = 0x50b2 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 96 + cv_record.rva = 0x8bf5 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\tkautoc.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = e07f7b03-7890-4b91-9e2c-bad76a2f0e97 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\toolkit\components\autocomplete\src\tkautoc.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\toolkit\components\autocomplete\src\tkautoc.pdb" +module[81] +MDRawModule + base_of_image = 0x3170000 + size_of_image = 0x3a000 + checksum = 0x0 + time_date_stamp = 0x44172941 + module_name_rva = 0x5126 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 86 + cv_record.rva = 0x8c55 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\tkitcmps.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 80fcaf2c-b79a-4f63-8789-7b37dd2723cd + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\toolkit\components\build\tkitcmps.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\toolkit\components\build\tkitcmps.pdb" +module[82] +MDRawModule + base_of_image = 0x31b0000 + size_of_image = 0xe000 + checksum = 0x0 + time_date_stamp = 0x44172828 + module_name_rva = 0x519c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 75 + cv_record.rva = 0x8cab + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\txmgr.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = d65a5b44-ee41-46d9-9a49-92dab2f3624f + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\editor\txmgr\src\txmgr.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\editor\txmgr\src\txmgr.pdb" +module[83] +MDRawModule + base_of_image = 0x31c0000 + size_of_image = 0x106000 + checksum = 0x0 + time_date_stamp = 0x44172231 + module_name_rva = 0x520c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 73 + cv_record.rva = 0x8cf6 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\uconv.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 99ac9d48-211b-477a-9415-1809725cb0a2 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\intl\uconv\src\uconv.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\intl\uconv\src\uconv.pdb" +module[84] +MDRawModule + base_of_image = 0x32d0000 + size_of_image = 0xf000 + checksum = 0x0 + time_date_stamp = 0x44172237 + module_name_rva = 0x527c + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 79 + cv_record.rva = 0x8d3f + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\ucvmath.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 66957e12-9a5c-4837-9f85-c9f6a9541006 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\intl\uconv\ucvmath\ucvmath.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\intl\uconv\ucvmath\ucvmath.pdb" +module[85] +MDRawModule + base_of_image = 0x32e0000 + size_of_image = 0x25000 + checksum = 0x0 + time_date_stamp = 0x4417287b + module_name_rva = 0x52f0 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 107 + cv_record.rva = 0x8d8e + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\universalchardet.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 8836d118-c383-434c-a312-887673b8c08e + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\extensions\universalchardet\src\xpcom\universalchardet.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\extensions\universalchardet\src\xpcom\universalchardet.pdb" +module[86] +MDRawModule + base_of_image = 0x3310000 + size_of_image = 0x3c000 + checksum = 0x0 + time_date_stamp = 0x441727eb + module_name_rva = 0x5376 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 85 + cv_record.rva = 0x8df9 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\webbrwsr.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 2ccf6083-dfd6-4b15-a9c5-9b86eda25dd3 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\embedding\browser\build\webbrwsr.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\embedding\browser\build\webbrwsr.pdb" +module[87] +MDRawModule + base_of_image = 0x3350000 + size_of_image = 0xf1000 + checksum = 0x0 + time_date_stamp = 0x44172870 + module_name_rva = 0x53ec + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 94 + cv_record.rva = 0x8e4e + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\websrvcs.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 819e3a3b-f285-4597-85cf-3123b523076a + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\extensions\webservices\build\src\websrvcs.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\extensions\webservices\build\src\websrvcs.pdb" +module[88] +MDRawModule + base_of_image = 0x3450000 + size_of_image = 0x33000 + checksum = 0x0 + time_date_stamp = 0x4417284b + module_name_rva = 0x5462 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 93 + cv_record.rva = 0x8eac + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\xmlextras.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 783e36d0-3d5e-40d7-b8d5-fede8eb80aac + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\extensions\xmlextras\build\src\xmlextras.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\extensions\xmlextras\build\src\xmlextras.pdb" +module[89] +MDRawModule + base_of_image = 0x3490000 + size_of_image = 0xd1000 + checksum = 0x0 + time_date_stamp = 0x441721cf + module_name_rva = 0x54da + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 81 + cv_record.rva = 0x8f09 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\xpc3250.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 409e253a-3ecc-4122-8663-8d98ff8bc066 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\js\src\xpconnect\src\xpc3250.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\js\src\xpconnect\src\xpc3250.pdb" +module[90] +MDRawModule + base_of_image = 0x3570000 + size_of_image = 0xe000 + checksum = 0x0 + time_date_stamp = 0x441720c9 + module_name_rva = 0x554e + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 92 + cv_record.rva = 0x8f5a + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\xpcom_compat_c.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 2ecedf87-ad8e-46c7-a809-5c59ac00087a + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\xpcom\obsolete\component\xpcom_compat_c.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\xpcom\obsolete\component\xpcom_compat_c.pdb" +module[91] +MDRawModule + base_of_image = 0x3580000 + size_of_image = 0x67000 + checksum = 0x0 + time_date_stamp = 0x44172999 + module_name_rva = 0x55d0 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 75 + cv_record.rva = 0x8fb6 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\xpinstal.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = bbfd3719-a789-48c8-b539-af0c32c3539c + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\xpinstall\src\xpinstal.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\xpinstall\src\xpinstal.pdb" +module[92] +MDRawModule + base_of_image = 0x35f0000 + size_of_image = 0x22000 + checksum = 0x0 + time_date_stamp = 0x441722fb + module_name_rva = 0x5646 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 81 + cv_record.rva = 0x9001 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\components\xppref32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 8dafa073-6c6c-46c8-b696-f12d084461c8 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\modules\libpref\src\xppref32.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\modules\libpref\src\xppref32.pdb" +module[93] +MDRawModule + base_of_image = 0x3620000 + size_of_image = 0x22000 + checksum = 0x0 + time_date_stamp = 0x44172b3e + module_name_rva = 0x56bc + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x0:0x0 + version_info.product_version = 0x0:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x9 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 93 + cv_record.rva = 0x9052 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\extensions\inspector@mozilla.org\components\inspector.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 67646af8-4653-4337-a45f-0beb845c92fc + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\extensions\inspector\build\src\inspector.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\extensions\inspector\build\src\inspector.pdb" +module[94] +MDRawModule + base_of_image = 0x71a50000 + size_of_image = 0x3f000 + checksum = 0x47a3c + time_date_stamp = 0x41109758 + module_name_rva = 0x5776 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x90af + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\mswsock.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = f6648803-69e2-43b7-8a86-03165451eab0 + (cv_record).age = 2 + (cv_record).pdb_file_name = "mswsock.pdb" + (misc_record) = (null) + (debug_filename) = "mswsock.pdb" +module[95] +MDRawModule + base_of_image = 0x662b0000 + size_of_image = 0x58000 + checksum = 0x57fcb + time_date_stamp = 0x411096a0 + module_name_rva = 0x57ba + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x90d3 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\hnetcfg.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = f662d314-f374-4997-84bc-0592b8db8bef + (cv_record).age = 1 + (cv_record).pdb_file_name = "HNetCfg.pdb" + (misc_record) = (null) + (debug_filename) = "HNetCfg.pdb" +module[96] +MDRawModule + base_of_image = 0x71a90000 + size_of_image = 0x8000 + checksum = 0x12290 + time_date_stamp = 0x411096fd + module_name_rva = 0x57fe + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x90f7 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\wshtcpip.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = de010d61-8735-45f4-9d43-d91367e871dc + (cv_record).age = 2 + (cv_record).pdb_file_name = "wshtcpip.pdb" + (misc_record) = (null) + (debug_filename) = "wshtcpip.pdb" +module[97] +MDRawModule + base_of_image = 0x746f0000 + size_of_image = 0x2a000 + checksum = 0x341bd + time_date_stamp = 0x41109729 + module_name_rva = 0x5844 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x911c + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\MSIMTF.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = cd2a06b7-a887-43cf-9cca-81dea9a98842 + (cv_record).age = 2 + (cv_record).pdb_file_name = "msimtf.pdb" + (misc_record) = (null) + (debug_filename) = "msimtf.pdb" +module[98] +MDRawModule + base_of_image = 0x20000000 + size_of_image = 0x2c5000 + checksum = 0x2d3044 + time_date_stamp = 0x411096b9 + module_name_rva = 0x5886 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 0 + cv_record.rva = 0x0 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\xpsp2res.dll" + (cv_record) = (null) + (misc_record) = (null) + (debug_filename) = (null) +module[99] +MDRawModule + base_of_image = 0x5ad70000 + size_of_image = 0x38000 + checksum = 0x3e638 + time_date_stamp = 0x411096bb + module_name_rva = 0x58cc + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x60000:0xb540884 + version_info.product_version = 0x60000:0xb540884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x913f + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\uxtheme.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = b982b8fe-390b-4359-ad3c-cecc16c0d59f + (cv_record).age = 2 + (cv_record).pdb_file_name = "uxtheme.pdb" + (misc_record) = (null) + (debug_filename) = "uxtheme.pdb" +module[100] +MDRawModule + base_of_image = 0x76390000 + size_of_image = 0x1d000 + checksum = 0x2a024 + time_date_stamp = 0x411096ae + module_name_rva = 0x5910 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 34 + cv_record.rva = 0x9163 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\imm32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 2c17a49c-251b-4c8e-b9e2-ad13d7d9ea16 + (cv_record).age = 2 + (cv_record).pdb_file_name = "imm32.pdb" + (misc_record) = (null) + (debug_filename) = "imm32.pdb" +module[101] +MDRawModule + base_of_image = 0x76380000 + size_of_image = 0x5000 + checksum = 0x5405 + time_date_stamp = 0x41109727 + module_name_rva = 0x5950 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x9185 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\msimg32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = e28d4258-d66b-428e-b5d7-4279eb57a08f + (cv_record).age = 2 + (cv_record).pdb_file_name = "msimg32.pdb" + (misc_record) = (null) + (debug_filename) = "msimg32.pdb" +module[102] +MDRawModule + base_of_image = 0x605d0000 + size_of_image = 0x9000 + checksum = 0x1447d + time_date_stamp = 0x4110972f + module_name_rva = 0x5994 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x91a9 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\mslbui.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 4e81fe42-1742-46f3-8bc5-8280403dd780 + (cv_record).age = 1 + (cv_record).pdb_file_name = "MSLBUI.pdb" + (misc_record) = (null) + (debug_filename) = "MSLBUI.pdb" +module[103] +MDRawModule + base_of_image = 0x76f20000 + size_of_image = 0x27000 + checksum = 0x31afa + time_date_stamp = 0x411096bd + module_name_rva = 0x59d6 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x91cc + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\dnsapi.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = a799adc3-1552-4318-b409-040f33c17aa2 + (cv_record).age = 2 + (cv_record).pdb_file_name = "dnsapi.pdb" + (misc_record) = (null) + (debug_filename) = "dnsapi.pdb" +module[104] +MDRawModule + base_of_image = 0x76fb0000 + size_of_image = 0x8000 + checksum = 0xad6f + time_date_stamp = 0x411096b3 + module_name_rva = 0x5a18 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 35 + cv_record.rva = 0x91ef + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\winrnr.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = a5953730-a350-4120-bceb-95b11d0d3b97 + (cv_record).age = 2 + (cv_record).pdb_file_name = "winrnr.pdb" + (misc_record) = (null) + (debug_filename) = "winrnr.pdb" +module[105] +MDRawModule + base_of_image = 0x76f60000 + size_of_image = 0x2c000 + checksum = 0x3811e + time_date_stamp = 0x411096bb + module_name_rva = 0x5a5a + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x9212 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\wldap32.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 025e111a-1921-44b0-a76e-5d156ba8a6a5 + (cv_record).age = 2 + (cv_record).pdb_file_name = "wldap32.pdb" + (misc_record) = (null) + (debug_filename) = "wldap32.pdb" +module[106] +MDRawModule + base_of_image = 0x76fc0000 + size_of_image = 0x6000 + checksum = 0xca69 + time_date_stamp = 0x411096a8 + module_name_rva = 0x5a9e + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 37 + cv_record.rva = 0x9236 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\rasadhlp.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 1fa989b2-899c-4e3e-94cb-74000514f592 + (cv_record).age = 2 + (cv_record).pdb_file_name = "rasadhlp.pdb" + (misc_record) = (null) + (debug_filename) = "rasadhlp.pdb" +module[107] +MDRawModule + base_of_image = 0x4a10000 + size_of_image = 0x4d000 + checksum = 0x0 + time_date_stamp = 0x441729c1 + module_name_rva = 0x5ae4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x3000b:0x10000 + version_info.product_version = 0x3000b:0x10000 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x3 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 90 + cv_record.rva = 0x925b + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\freebl3.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 8a694ad9-aad6-4304-8447-8ed7270c325a + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nss\freebl\WIN95_SINGLE_SHLIB\freebl3.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nss\freebl\WIN95_SINGLE_SHLIB\freebl3.pdb" +module[108] +MDRawModule + base_of_image = 0x4a60000 + size_of_image = 0x5f000 + checksum = 0x0 + time_date_stamp = 0x441729fe + module_name_rva = 0x5b42 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x1003c:0x0 + version_info.product_version = 0x1003c:0x0 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x1 + version_info.file_os = 0x4 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 72 + cv_record.rva = 0x92b5 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "c:\lizard\trunk\mozilla\dist\bin\nssckbi.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 0b60d8ee-9dcd-4ca8-b18a-66183619e989 + (cv_record).age = 1 + (cv_record).pdb_file_name = "c:\lizard\trunk\mozilla\nss\nssckbi\nssckbi.pdb" + (misc_record) = (null) + (debug_filename) = "c:\lizard\trunk\mozilla\nss\nssckbi\nssckbi.pdb" +module[109] +MDRawModule + base_of_image = 0x59a60000 + size_of_image = 0xa1000 + checksum = 0xa8824 + time_date_stamp = 0x4110969a + module_name_rva = 0x5ba0 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 36 + cv_record.rva = 0x92fd + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\dbghelp.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = 39559573-e21b-46f2-8e28-6923be9e6a76 + (cv_record).age = 1 + (cv_record).pdb_file_name = "dbghelp.pdb" + (misc_record) = (null) + (debug_filename) = "dbghelp.pdb" +module[110] +MDRawModule + base_of_image = 0x76bf0000 + size_of_image = 0xb000 + checksum = 0xa29b + time_date_stamp = 0x411096ca + module_name_rva = 0x5be4 + version_info.signature = 0xfeef04bd + version_info.struct_version = 0x10000 + version_info.file_version = 0x50001:0xa280884 + version_info.product_version = 0x50001:0xa280884 + version_info.file_flags_mask = 0x3f + version_info.file_flags = 0x0 + version_info.file_os = 0x40004 + version_info.file_type = 0x2 + version_info.file_subtype = 0x0 + version_info.file_date = 0x0:0x0 + cv_record.data_size = 34 + cv_record.rva = 0x9321 + misc_record.data_size = 0 + misc_record.rva = 0x0 + (module_name) = "C:\WINDOWS\system32\psapi.dll" + (cv_record).cv_signature = 0x53445352 + (cv_record).signature = a5c3a1f9-689f-43d8-ad22-8a0929388970 + (cv_record).age = 2 + (cv_record).pdb_file_name = "psapi.pdb" + (misc_record) = (null) + (debug_filename) = "psapi.pdb" +MinidumpMemoryList + region_count = 10 +region[0] +MDMemoryDescriptor + start_of_memory_range = 0x7c90eb14 + memory.data_size = 0x100 + memory.rva = 0x93e7 +Memory +0xff83c4ec890424c744240401000000895c2408c74424100000000054e877000000c208009090909090558bec83ec508944240c64a1180000008b80a4010000890424c744240400000000c744240800000000c74424100000000054e8380000008b04248be55dc3908da424000000008d490090909090908bd40f349090909090c38da424000000008d64240090909090908d542408cd2ec3558bec9c81ecd00200008985dcfdffff898dd8fdffff8b45088b4d0489480c8d852cfdffff8988b80000008998a40000008990a800000089b0a000000089b89c0000008d4d0c8988c40000008b4d008988b40000008b4dfc8988c00000008c88bc0000008c989800 +region[1] +MDMemoryDescriptor + start_of_memory_range = 0x12d940 + memory.data_size = 0x26c0 + memory.rva = 0x94e7 +Memory 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 +region[2] +MDMemoryDescriptor + start_of_memory_range = 0x107fe2c + memory.data_size = 0x1d4 + memory.rva = 0xbba7 +Memory +0x00000000c0e9907cdb25807cc40000000000000064fe07015436817c10f712007890ac00140000000100000000000000000000001000000000ba3cdcffffffff00c0fd7f00e0fd7f64fe07010000000044fe070100000000a4ff0701f399837c0826807c00000000a8fe07014225807cc400000060ea000000000000c8fe0701ff1e0330c400000060ea000060ea000000000000008eac0060ea0000e4fe070131980230cc8cac004c8bac0060ea0000000000004c8bac0000ff0701ff9f0230008eac00588cac00308bac0060ea0000008eac0040ff07011c742f00588cac0060ea00002cff07012df200300100000000020000308bac000000000000000000308bac00010000000000000000000000000000005cff0701d35d2e000c6639000c6639000000000000000000088dac006cff0701d9b70230088dac00008eac007cff070157fd0230008eac00008eac00b4ff070166322010008eac005436817c10f712007890ac0000000000f0a3ac0088ff070114015080dcff070134c020107877261000000000ecff07010bb5807cf0a3ac005436817c10f712007890ac0000e0fd7f00069c86c0ff0701703c9183fffffffff399837c18b5807c000000000000000000000000b03120107890ac0000000000 +region[3] +MDMemoryDescriptor + start_of_memory_range = 0x374ff78 + memory.data_size = 0x88 + memory.rva = 0xbd7b +Memory +0xe3d8a5711be3907c09d6a57178010000bcff7403b0ff7403a4ff740350d6a57104ef120018ee907c30f1160000000000000000000000a57168ef1700ecff74030bb5807cecd8a57104ef120018ee907c30f1160000d0fd7f00069c86c0ff740370b74085fffffffff399837c18b5807c000000000000000000000000afd5a57130f1160000000000 +region[4] +MDMemoryDescriptor + start_of_memory_range = 0x384ccac + memory.data_size = 0x3354 + memory.rva = 0xbe03 +Memory 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 +region[5] +MDMemoryDescriptor + start_of_memory_range = 0x394fe30 + memory.data_size = 0x1d0 + memory.rva = 0xf157 +Memory +0x00000000c0e9907cdb25807ca80100000000000068fe9403650072000b00000000da1401140000000100000000000000000000001000000030519bfcffffffff00c0fd7f00a0fd7f68fe94030000000048fe940300000000a4ff9403f399837c0826807c00000000acfe94034225807ca80100003d16000000000000ccfe9403ff1e0330a80100003d1600003d1600000a00000088d714013d160000e8fe940331980230448aac003c89ac003d160000000000006488ac0004ff9403ff9f023088d71401d089ac002089ac003d16000088d7140140ff9403f6e92e00d089ac003d1600002df200300100000037744600fa5d4600c0fa97033d1600002089ac0000000000000000002089ac00010000005cff9403d35d2e003888ac003888ac000000000000000000988813016cff9403d9b702309888130188d714017cff940357fd023088d7140188d71401b4ff94036632201088d71401650072000b00000000da140100000000d00a160188ff940314015080dcff940334c020107877261000000000ecff94030bb5807cd00a1601650072000b00000000da140100a0fd7f00069c86c0ff940328bf6f86fffffffff399837c18b5807c000000000000000000000000b031201000da140100000000 +region[6] +MDMemoryDescriptor + start_of_memory_range = 0x3f6fe18 + memory.data_size = 0x1e8 + memory.rva = 0xf327 +Memory +0x85d3907c99e3907c0367e777d001000070fff60300000000b85c170054fff603000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005ca93f8524acb3b0d99a4f80e19a4f802ca93f85c0a73f85f4a73f8580fff6039966e7774cfff603a966e777ed10907cd01b170058d4160000a22f4dffffffff005d1eeeffffffff0000000038fef60358d41600ffffffff54fff60300000000b85c1700000000000000000088fff603226ce777a8fff6033b6ae777882f150000000000acd7120058d4160058d4160058d41600b4fff6030a6ce777e08d1600ecfff6030bb5807c58d4160000000000acd7120058d416000080fd7f00069c86c0fff603f0399383fffffffff399837c18b5807c000000000000000000000000f06be77758d4160000000000 +region[7] +MDMemoryDescriptor + start_of_memory_range = 0x41ffe24 + memory.data_size = 0x1dc + memory.rva = 0xf50f +Memory +0x00000000c0e9907cdb25807cf001000000000000000000003431917cf4da120060b7c20314000000010000000000000000000000100000000060fd7fb8fe1f0400c0fd7f0060fd7f000000003431917c3cfe1f0460b7c203a4ff1f04f399837c0826807c00000000a0fe1f044225807cf0010000ffffffff00000000c0fe1f04ff1e0330f0010000fffffffffffffffffffffffff0b5c203ffffffffdcfe1f043198023064bcc2035cbbc203ffffffff000000005cbbc203f8fe1f04ff9f0230f0b5c203f0bbc20340bbc203fffffffff0b5c20324ff1f04016b0d03f0bbc203ffffffff40bbc203000000000000000040bbc20301000000000000000000000040ff1f0447580d0344ff1f04e6662e00a0bdc20344ff1f04e96a2e005cff1f04d35d2e0050bdc20350bdc203000000000000000090bdc2036cff1f04d9b7023090bdc203f0b5c2037cff1f0457fd0230f0b5c203f0b5c203b4ff1f0466322010f0b5c2033431917cf4da120060b7c2030000000040aec20388ff1f0414015080dcff1f0434c020107877261000000000ecff1f040bb5807c40aec2033431917cf4da120060b7c2030060fd7f00069c86c0ff1f04f0399383fffffffff399837c18b5807c000000000000000000000000b031201060b7c20300000000 +region[8] +MDMemoryDescriptor + start_of_memory_range = 0x3e6fe50 + memory.data_size = 0x1b0 + memory.rva = 0xf6eb +Memory +0x00000000c0e9907cdb25807cb40100000000000088fee6030000ac00f87e550480815504140000000100000000000000000000001000000000ba3cdcffffffff00c0fd7f0090fd7f88fee6030000000068fee60300000000a4ffe603f399837c0826807c00000000ccfee6034225807cb401000060ea000000000000ecfee603ff1e0330b401000060ea000060ea00000a000000b87f550460ea000008ffe60331980230a4a39b039ca29b0360ea000000000000f87e550424ffe603ff9f0230b87f550430a39b0380a29b0360ea0000b87f55045cffe6032851b40230a39b0360ea000020ed7204f00c000060ea0000db55460080a29b03000000000000000080a29b0301000000a8a19b036cffe603d9b70230a8a19b03b87f55047cffe60357fd0230b87f5504b87f5504b4ffe60366322010b87f55040000ac00f87e55048081550400000000b018560488ffe60314015080dcffe60334c020107877261000000000ecffe6030bb5807cb01856040000ac00f87e5504808155040090fd7f00069c86c0ffe603b8e3b683fffffffff399837c18b5807c000000000000000000000000b03120108081550400000000 +region[9] +MDMemoryDescriptor + start_of_memory_range = 0x406fe2c + memory.data_size = 0x1d4 + memory.rva = 0xf89b +Memory +0x00000000c0e9907cdb25807c1c0200000000000064fe0604000000000000000058fb5504140000000100000000000000000000001000000000ba3cdcffffffff00c0fd7f0070fd7f64fe06040000000044fe060400000000a4ff0604f399837c0826807c00000000a8fe06044225807c1c02000060ea000000000000c8fe0604ff1e03301c02000060ea000060ea0000ccfe060490f9550460ea0000e4fe060431980230043d1201fc3b120160ea0000000000000000000000ff0604ff9f023090f95504903c1201e03b120160ea000090f955043cff0604fbecb702903c120160ea0000503b120168ad2010e03b12010000000060ea00006f334600e03b12010000000000000000e03b1201010000005cff0604c5efb70258ff06040000000020800000201b6204503b1201481a62046cff0604d9b70230503b120190f955047cff060457fd023090f9550490f95504b4ff06046632201090f95504000000000000000058fb5504000000002823560488ff060414015080dcff060434c020107877261000000000ecff06040bb5807c28235604000000000000000058fb55040070fd7f00069c86c0ff06048881f184fffffffff399837c18b5807c000000000000000000000000b031201058fb550400000000 +MDException + thread_id = 0x124c + exception_record.exception_code = 0xc0000005 + exception_record.exception_flags = 0x0 + exception_record.exception_record = 0x0 + exception_record.exception_address = 0x20a1515 + exception_record.number_parameters = 2 + exception_record.exception_information[ 0] = 0x0 + exception_record.exception_information[ 1] = 0xffffffffdddddde1 + thread_context.data_size = 716 + thread_context.rva = 0x5c24 +MDRawContextX86 + context_flags = 0x1003f + dr0 = 0x0 + dr1 = 0x0 + dr2 = 0x0 + dr3 = 0x0 + dr6 = 0x0 + dr7 = 0x0 + float_save.control_word = 0xffff027f + float_save.status_word = 0xffff4020 + float_save.tag_word = 0xffffffff + float_save.error_offset = 0x1f57ee1 + float_save.error_selector = 0x2e9001b + float_save.data_offset = 0x47a1a2c + float_save.data_selector = 0xffff0023 + float_save.register_area[80] = 0x8080800080808000ffffc8d0d400ffffff00ffff8080800080808000ffffc8d0d400ffffff00ffffaeb5b921b3babe1bffffb300ba00be000000ffff0000000000000080ff3f0000000000000080ff3f + float_save.cr0_npx_state = 0x0 + gs = 0x0 + fs = 0x3b + es = 0x23 + ds = 0x23 + edi = 0x2 + esi = 0xac7df8 + ebx = 0x7ffdc000 + edx = 0xdddddddd + ecx = 0x488857c + eax = 0x12ed2c + ebp = 0x12ecb8 + eip = 0x20a1515 + cs = 0x1b + eflags = 0x10202 + esp = 0x12eb9c + ss = 0x23 + extended_registers[512] = 0x7f0220400000e902e17ef5011b0000002c1a7a0423000000a01f0000ffff00008080800080808000ffff000000000000c8d0d400ffffff00ffff0000000000008080800080808000ffff000000000000c8d0d400ffffff00ffff000000000000aeb5b921b3babe1bffff000000000000b300ba00be000000ffff0000000000000000000000000080ff3f0000000000000000000000000080ff3f000000000000fe030000000000000000000000000000ff01000000000000000000000000000035000000000000003304000000000000000000fcffe788c10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e03f0000000000000000e878a403de0100003600000000f512000c000000f078a4030000000070059100f888100100000000a5ae2110e878a403000000000000000000000000e878a40360000000f078a40350000000d801ac0060000000fcf500000000ac00ecf3120098c00c013cf6120018ee907cf006917cffffffffeb06917cb5a621100000ac00000000005100000062696e00587cac0000f0fd7fabf3003014f8120068f61200d695201098f6120034c0201062696e003a9820101079a403cd0000002d000000510000007d290200f078a4030000000094282010b0eb2710a8f61200d4942010 +MDRawSystemInfo + processor_architecture = 0 + processor_level = 6 + number_of_processors = 1 + product_type = 1 + major_version = 5 + minor_version = 1 + build_number = 2600 + platform_id = 2 + csd_version_rva = 0x3204 + suite_mask = 0x100 + reserved2 = 0x0 + cpu.x86_cpu_info.vendor_id[0] = 0x756e6547 + cpu.x86_cpu_info.vendor_id[1] = 0x49656e69 + cpu.x86_cpu_info.vendor_id[2] = 0x6c65746e + cpu.x86_cpu_info.version_information = 0x6d8 + cpu.x86_cpu_info.feature_information = 0xafe9fbff + cpu.x86_cpu_info.amd_extended_cpu_features = 0xffffffff + (csd_version) = "Service Pack 2" +MDRawMiscInfo + size_of_info = 24 + flags1 = 0x3 + process_id = 0xdd8 + process_create_time = 0x44172e6e + process_user_time = 0x0 + process_kernel_time = 0x4 |