myexceptiondump.h

SQLBig5BugTool 宽字符操作问题

	
	if(iBufSpaceLeft>=0) // if we added anything, we have a trailing semicolon
	{
		szSymbolSearchPath[iSymbolSearchPatBufSize-iBufSpaceLeft]='\0';
	}

	TRACEOUT("szSearchPath:%s",szSymbolSearchPath);

	//2、初始化，加载符号，设置参数
	SymInitialize(hProcess, szSymbolSearchPath, TRUE);
	
	SymSetOptions( (SymGetOptions()| SYMOPT_LOAD_LINES) &~SYMOPT_UNDNAME);
	
	const int MAXNAMELEN=1024 ;// max name length for found symbols
	const int IMGSYMLEN = sizeof (IMAGEHLP_SYMBOL);
	
	char undName[MAXNAMELEN]={0,}; // undecorated name
	char undFullName[MAXNAMELEN]={0,}; // undecorated name with all shenanigans
	
	IMAGEHLP_MODULE Module={0,};
	IMAGEHLP_LINE Line={0,};

	Line.SizeOfStruct = sizeof Line;
	
	Module.SizeOfStruct = sizeof Module;
	
	DWORD dwOffsetFromSymbol= 0; // tells us how far from the symbol we were
	
	STACKFRAME sfStackFrame={0,}; // in/out sfStackFrame
	
	sfStackFrame.AddrPC.Offset = pExceptionInfo->ContextRecord->Eip;
	sfStackFrame.AddrPC.Mode = AddrModeFlat;
	sfStackFrame.AddrFrame.Offset = pExceptionInfo->ContextRecord->Ebp;
	sfStackFrame.AddrFrame.Mode = AddrModeFlat;
	
	// normally, call ImageNtHeader() and use machine info from PE header
	DWORD dwImageType = IMAGE_FILE_MACHINE_I386;
	
	// Get path to executable:
	::GetModuleFileName(NULL, szTemp, sizeof(szTemp)-1);
	strncat(szTemp,".ExceptionDump.txt",sizeof(szTemp)-strlen(szTemp));

	WRITE_EXCEPTION_LOG(  "-- Begin stack trace --" );
	
	WRITE_EXCEPTION_LOG(" Id PC");
	
	DWORD dwLastError=0;

	IMAGEHLP_SYMBOL *pSym = (IMAGEHLP_SYMBOL *) malloc(IMGSYMLEN + MAXNAMELEN);
	
	if(NULL==pSym)
	{
		WRITE_EXCEPTION_LOG("!!!!!!!!!!!NULL==pSym!!!!!!!!!!!!!");
	}
	else
	{
		ZeroMemory(pSym,IMGSYMLEN + MAXNAMELEN);

		pSym->SizeOfStruct = IMGSYMLEN;
		pSym->MaxNameLength = MAXNAMELEN;

		//3、开始遍历调用栈

		int iFrameIndex = 0;
		while (true)
		{
			// if this returns ERROR_INVALID_ADDRESS (487) or ERROR_NOACCESS (998), you can
			// assume that either you are done, or that the stack is so hosed that the next
			// deeper frame could not be found.
			
			if (!StackWalk(
				dwImageType,
				hProcess,
				hThread,
				&sfStackFrame,
				pExceptionInfo->ContextRecord,
				0,
				SymFunctionTableAccess,
				SymGetModuleBase,
				0 ) )
			{
				break;
			}

			GET_LOGICAL_ADDRESS_PARMS glap={0,};
			GetLogicalAddress((void*)sfStackFrame.AddrPC.Offset,glap);

			GET_LOGICAL_ADDRESS_PARMS glapReturn={0,};
			GetLogicalAddress((void*)sfStackFrame.AddrReturn.Offset,glapReturn);

			WRITE_EXCEPTION_LOG(
				"%3d %08lx(%02d:%08lx)",
				iFrameIndex,
				sfStackFrame.AddrPC.Offset,
				glap.dwSectionId,
				glap.dwOffsetInSection
				);


			if ( sfStackFrame.AddrPC.Offset == 0 )
			{
				WRITE_EXCEPTION_LOG("(-nosymbols- PC == 0)" );
			}
			else
			{
				// we seem to have a valid PC
				
				// show procedure info (SymGetSymFromAddr())
				if ( ! SymGetSymFromAddr( hProcess, sfStackFrame.AddrPC.Offset, &dwOffsetFromSymbol, pSym ) )
				{
					dwLastError = GetLastError();

					if ( ERROR_INVALID_ADDRESS == dwLastError )
					{
//						WRITE_EXCEPTION_LOG("SymGetSymFromAddr(): invalid address:%08lx",sfStackFrame.AddrPC.Offset);
					}
					else
					{
						if ( 126 == dwLastError  )
						{
							TRACEOUT("Sym to Addr error: ErrorCode = %lu", dwLastError );
						}
						else
						{
							WRITE_EXCEPTION_LOG("Sym to Addr error: ErrorCode = %lu", dwLastError);
						}
					}
				}
				else
				{
					// UnDecorateSymbolName()
					UnDecorateSymbolName( pSym->Name, undName, MAXNAMELEN, UNDNAME_NAME_ONLY );
					UnDecorateSymbolName( pSym->Name, undFullName, MAXNAMELEN, UNDNAME_COMPLETE );

					WRITE_EXCEPTION_LOG(undName );

					if ( dwOffsetFromSymbol != 0 )
					{
						APPEND_EXCEPTION_LOG(" %+ld bytes", (long) dwOffsetFromSymbol );
					}
					
					//WRITE_EXCEPTION_LOG("    Sig:  %s", pSym->Name );
					
					//WRITE_EXCEPTION_LOG("    Decl: %s", undFullName );
				}
				
				// show line number info, NT5.0-method (SymGetLineFromAddr())
				if ( SymGetLineFromAddr != 0 )
				{ // yes, we have SymGetLineFromAddr()
					if ( ! SymGetLineFromAddr( hProcess, sfStackFrame.AddrPC.Offset, &dwOffsetFromSymbol, &Line ) )
					{
						dwLastError = GetLastError();
						if ( ERROR_INVALID_ADDRESS == dwLastError  )
						{
//							WRITE_EXCEPTION_LOG("SymGetSymFromAddr(): invalid address:%08lx",sfStackFrame.AddrPC.Offset);
						}
						else
						{
							if ( 126 == dwLastError  )
							{
								TRACEOUT("addr to line error: ErrorCode = %lu",dwLastError );
							}
							else
							{
								WRITE_EXCEPTION_LOG("addr to line error: ErrorCode = %lu", dwLastError );
							}
						}
					}
					else
					{
						WRITE_EXCEPTION_LOG("    Line: %s(%lu) %+ld bytes",
							Line.FileName, Line.LineNumber, dwOffsetFromSymbol );
					}
				}

				// show module info (SymGetModuleInfo())
				if ( ! SymGetModuleInfo( hProcess, sfStackFrame.AddrPC.Offset, &Module ) )
				{
					dwLastError = GetLastError();

					if ( 126 == dwLastError  )
					{
						TRACEOUT("Get Module Info error: gle = %lu", dwLastError );
					}
					else
					{
						WRITE_EXCEPTION_LOG("Get Module Info error: gle = %lu", dwLastError );
					}
					
					GET_LOGICAL_ADDRESS_PARMS glap={0,};
					GetLogicalAddress((void*)sfStackFrame.AddrPC.Offset,glap);
					
					char *pchModName=strrchr(glap.szModuleFilePath,'\\');
					if(pchModName)
					{
						++pchModName;
					}
					else
					{
						pchModName=glap.szModuleFilePath;
					}
					
					WRITE_EXCEPTION_LOG("    Mod:  %s[%s], base: 0x%08lxh",
						pchModName,
						glap.szModuleFilePath,
						glap.dwAllocationBase
						);
				}
				else
				{ // got module info OK
					
					
					WRITE_EXCEPTION_LOG("    Mod:  %s[%s], base: 0x%08lxh",
						Module.ModuleName, Module.ImageName, Module.BaseOfImage );

					switch ( Module.SymType )
					{
					case SymNone:
						WRITE_EXCEPTION_LOG("    Sym:  type: %s, file: %s","-nosymbols-", Module.LoadedImageName );
						break;
					case SymCoff:
						WRITE_EXCEPTION_LOG("    Sym:  type: %s, file: %s","COFF", Module.LoadedImageName );
						break;
					case SymCv:
						WRITE_EXCEPTION_LOG("    Sym:  type: %s, file: %s","CV", Module.LoadedImageName );
						break;
					case SymPdb:
						WRITE_EXCEPTION_LOG("    Sym:  type: %s, file: %s","PDB", Module.LoadedImageName );
						break;
					case SymExport:
						WRITE_EXCEPTION_LOG("    Sym:  type: %s, file: %s","-exported-", Module.LoadedImageName );
						break;
					case SymDeferred:
						WRITE_EXCEPTION_LOG("    Sym:  type: %s, file: %s","-deferred-", Module.LoadedImageName );
						break;
					case SymSym:
						WRITE_EXCEPTION_LOG("    Sym:  type: %s, file: %s","SYM", Module.LoadedImageName );
						break;
					default:
						WRITE_EXCEPTION_LOG("    Sym:  type: unknown(%ld) , file: %s ",(long) Module.SymType, Module.LoadedImageName );
						break;
					}
				}	
			}
			
			// no return address means no deeper sfStackFrame
			if ( sfStackFrame.AddrReturn.Offset == 0 ) 
			{
				break;
			}			

			iFrameIndex++;
		}

		free(pSym);

		pSym=NULL;
	}
	
	WRITE_EXCEPTION_LOG("-- End stack trace --");

	SymCleanup(hProcess);
}

// Initializes the symbol files
bool InitSymInfo( PCSTR lpszInitialSymbolPath )
{
	CHAR     lpszSymbolPath[3072]={0,};
	DWORD    symOptions = SymGetOptions();
	
	symOptions |= SYMOPT_LOAD_LINES; 
	symOptions &= ~SYMOPT_UNDNAME;
	SymSetOptions( symOptions );
	
	// Get the search path for the symbol files
	InitSymbolPath( lpszSymbolPath, sizeof(lpszSymbolPath),lpszInitialSymbolPath );
	
	return SymInitialize( GetCurrentProcess(), lpszSymbolPath, true)?true:false;
}

#endif