reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-29 14:40:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
0f2988565a
wine/debugger/msc.c
Eric Pouech a88cae1a0b Allow loading of modules debug information after first invocation of 
debugger.
1999-10-23 18:55:02 +00:00

2509 lines
65 KiB
C
Raw Blame History

/*
* File msc.c - read VC++ debug information from COFF and eventually
* from PDB files.
*
* Copyright (C) 1996, Eric Youngdale.
*
* Note - this handles reading debug information for 32 bit applications
* that run under Windows-NT for example. I doubt that this would work well
* for 16 bit applications, but I don't think it really matters since the
* file format is different, and we should never get in here in such cases.
*
* TODO:
* Get 16 bit CV stuff working.
* Add symbol size to internal symbol table.
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#include <fcntl.h>
#include <sys/stat.h>
#include <limits.h>
#include <string.h>
#include <unistd.h>
#ifndef PATH_MAX
#define PATH_MAX _MAX_PATH
#endif
#include "debugger.h"
#include "neexe.h"
#include "peexe.h"
#include "file.h"
/*
*dbg_filename must be at least MAX_PATHNAME_LEN bytes in size
*/
static void LocateDebugInfoFile(char *filename, char *dbg_filename)
{
char *str1 = DBG_alloc(MAX_PATHNAME_LEN*10);
char *str2 = DBG_alloc(MAX_PATHNAME_LEN);
char *file;
char *name_part;
DOS_FULL_NAME fullname;
file = strrchr(filename, '\\');
if( file == NULL ) file = filename; else file++;
if (GetEnvironmentVariableA("_NT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN))
if (SearchPathA(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))
goto ok;
if (GetEnvironmentVariableA("_NT_ALT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN))
if (SearchPathA(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))
goto ok;
if (SearchPathA(NULL, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))
goto ok;
else
{
quit:
memcpy(dbg_filename, filename, MAX_PATHNAME_LEN);
DBG_free(str1);
DBG_free(str2);
return;
}
ok:
if (DOSFS_GetFullName(str2, TRUE, &fullname))
memcpy(dbg_filename, fullname.long_name, MAX_PATHNAME_LEN);
else
goto quit;
DBG_free(str1);
DBG_free(str2);
return;
}
/*
* This is an index we use to keep track of the debug information
* when we have multiple sources. We use the same database to also
* allow us to do an 'info shared' type of deal, and we use the index
* to eliminate duplicates.
*/
static int DEBUG_next_index = 0;
union any_size
{
char * c;
short * s;
int * i;
unsigned int * ui;
};
/*
* This is a convenience structure used to map portions of the
* line number table.
*/
struct startend
{
unsigned int start;
unsigned int end;
};
/*
* This is how we reference the various record types.
*/
union codeview_symbol
{
struct
{
short int len;
short int id;
} generic;
struct
{
short int len;
short int id;
unsigned int offset;
unsigned short seg;
unsigned short symtype;
unsigned char namelen;
unsigned char name[1];
} data;
struct
{
short int len;
short int id;
unsigned int pparent;
unsigned int pend;
unsigned int next;
unsigned int offset;
unsigned short segment;
unsigned short thunk_len;
unsigned char thtype;
unsigned char namelen;
unsigned char name[1];
} thunk;
struct
{
short int len;
short int id;
unsigned int pparent;
unsigned int pend;
unsigned int next;
unsigned int proc_len;
unsigned int debug_start;
unsigned int debug_end;
unsigned int offset;
unsigned short segment;
unsigned short proctype;
unsigned char flags;
unsigned char namelen;
unsigned char name[1];
} proc;
struct
{
short int len; /* Total length of this entry */
short int id; /* Always S_BPREL32 */
unsigned int offset; /* Stack offset relative to BP */
unsigned short symtype;
unsigned char namelen;
unsigned char name[1];
} stack;
};
union codeview_type
{
struct
{
short int len;
short int id;
} generic;
struct
{
short int len;
short int id;
short int attribute;
short int datatype;
unsigned char variant[1];
} pointer;
struct
{
short int len;
short int id;
unsigned char nbits;
unsigned char bitoff;
unsigned short type;
} bitfield;
struct
{
short int len;
short int id;
short int elemtype;
short int idxtype;
unsigned char arrlen;
unsigned char namelen;
unsigned char name[1];
} array;
struct
{
short int len;
short int id;
short int n_element;
short int fieldlist;
short int property;
short int derived;
short int vshape;
unsigned short structlen;
unsigned char namelen;
unsigned char name[1];
} structure;
struct
{
short int len;
short int id;
short int count;
short int field;
short int property;
unsigned short un_len;
unsigned char namelen;
unsigned char name[1];
} t_union;
struct
{
short int len;
short int id;
short int count;
short int type;
short int field;
short int property;
unsigned char namelen;
unsigned char name[1];
} enumeration;
struct
{
short int id;
short int attribute;
unsigned short int value;
unsigned char namelen;
unsigned char name[1];
} enumerate;
struct
{
short int id;
short int type;
short int attribute;
unsigned short int offset;
unsigned char namelen;
unsigned char name[1];
} member;
struct
{
short int len;
short int id;
short int count;
short int type;
short int field;
short int property;
unsigned char namelen;
unsigned char name[1];
} fieldlist;
};
#define S_BPREL 0x200
#define S_LDATA 0x201
#define S_GDATA 0x202
#define S_PUB 0x203
#define S_LPROC 0x204
#define S_GPROC 0x205
#define S_THUNK 0x206
#define S_BLOCK 0x207
#define S_WITH 0x208
#define S_LABEL 0x209
#define S_PROCREF 0x400
#define S_DATAREF 0x401
#define S_ALIGN 0x402
#define S_UNKNOWN 0x403
/*
* This covers the basic datatypes that VC++ seems to be using these days.
* 32 bit mode only. There are additional numbers for the pointers in 16
* bit mode. There are many other types listed in the documents, but these
* are apparently not used by the compiler, or represent pointer types
* that are not used.
*/
#define T_NOTYPE 0x0000 /* Notype */
#define T_ABS 0x0001 /* Abs */
#define T_VOID 0x0003 /* Void */
#define T_CHAR 0x0010 /* signed char */
#define T_SHORT 0x0011 /* short */
#define T_LONG 0x0012 /* long */
#define T_QUAD 0x0013 /* long long */
#define T_UCHAR 0x0020 /* unsigned char */
#define T_USHORT 0x0021 /* unsigned short */
#define T_ULONG 0x0022 /* unsigned long */
#define T_UQUAD 0x0023 /* unsigned long long */
#define T_REAL32 0x0040 /* float */
#define T_REAL64 0x0041 /* double */
#define T_RCHAR 0x0070 /* real char */
#define T_WCHAR 0x0071 /* wide char */
#define T_INT4 0x0074 /* int */
#define T_UINT4 0x0075 /* unsigned int */
#define T_32PVOID 0x0403 /* 32 bit near pointer to void */
#define T_32PCHAR 0x0410 /* 16:32 near pointer to signed char */
#define T_32PSHORT 0x0411 /* 16:32 near pointer to short */
#define T_32PLONG 0x0412 /* 16:32 near pointer to int */
#define T_32PQUAD 0x0413 /* 16:32 near pointer to long long */
#define T_32PUCHAR 0x0420 /* 16:32 near pointer to unsigned char */
#define T_32PUSHORT 0x0421 /* 16:32 near pointer to unsigned short */
#define T_32PULONG 0x0422 /* 16:32 near pointer to unsigned int */
#define T_32PUQUAD 0x0423 /* 16:32 near pointer to long long */
#define T_32PREAL32 0x0440 /* 16:32 near pointer to float */
#define T_32PREAL64 0x0441 /* 16:32 near pointer to float */
#define T_32PRCHAR 0x0470 /* 16:32 near pointer to real char */
#define T_32PWCHAR 0x0471 /* 16:32 near pointer to real char */
#define T_32PINT4 0x0474 /* 16:32 near pointer to int */
#define T_32PUINT4 0x0475 /* 16:32 near pointer to unsigned int */
#define LF_MODIFIER 0x1
#define LF_POINTER 0x2
#define LF_ARRAY 0x3
#define LF_CLASS 0x4
#define LF_STRUCTURE 0x5
#define LF_UNION 0x6
#define LF_ENUMERATION 0x7
#define LF_PROCEDURE 0x8
#define LF_MFUNCTION 0x9
#define LF_VTSHAPE 0xa
#define LF_BARRAY 0xd
#define LF_DIMARRAY 0x11
#define LF_VFTPATH 0x12
#define LF_SKIP 0x200
#define LF_ARGLIST 0x201
#define LF_FIELDLIST 0x204
#define LF_DERIVED 0x205
#define LF_BITFIELD 0x206
#define LF_BCLASS 0x400
#define LF_VBCLASS 0x401
#define LF_IVBCLASS 0x402
#define LF_ENUMERATE 0x403
#define LF_FRIENDFCN 0x404
#define LF_INDEX 0x405
#define LF_MEMBER 0x406
#define LF_STMEMBER 0x407
#define LF_METHOD 0x408
#define LF_NESTEDTYPE 0x409
#define LF_VFUNCTAB 0x40a
#define LF_FRIENDCLS 0x40b
#define LF_ONEMETHOD 0x40c
#define LF_FUNCOFF 0x40d
#define MAX_BUILTIN_TYPES 0x480
static struct datatype * cv_basic_types[MAX_BUILTIN_TYPES];
static int num_cv_defined_types = 0;
static struct datatype **cv_defined_types = NULL;
/*
* For the type CODEVIEW debug directory entries, the debug directory
* points to a structure like this. The cv_name field is the name
* of an external .PDB file.
*/
struct CodeViewDebug
{
char cv_nbtype[8];
unsigned int cv_timestamp;
char cv_unknown[4];
char cv_name[1];
};
struct MiscDebug {
unsigned int DataType;
unsigned int Length;
char Unicode;
char Reserved[3];
char Data[1];
};
/*
* This is the header that the COFF variety of debug header points to.
*/
struct CoffDebug {
unsigned int N_Sym;
unsigned int SymbolOffset;
unsigned int N_Linenum;
unsigned int LinenumberOffset;
unsigned int Unused[4];
};
struct CoffLinenum {
unsigned int VirtualAddr;
unsigned short int Linenum;
};
struct CoffFiles {
unsigned int startaddr;
unsigned int endaddr;
char * filename;
int linetab_offset;
int linecnt;
struct name_hash **entries;
int neps;
int neps_alloc;
};
struct CoffSymbol {
union {
char ShortName[8];
struct {
unsigned int NotLong;
unsigned int StrTaboff;
} Name;
} N;
unsigned int Value;
short SectionNumber;
short Type;
char StorageClass;
unsigned char NumberOfAuxSymbols;
};
struct CoffAuxSection{
unsigned int Length;
unsigned short NumberOfRelocations;
unsigned short NumberOfLinenumbers;
unsigned int CheckSum;
short Number;
char Selection;
} Section;
/*
* These two structures are used in the directory within a .DBG file
* to locate the individual important bits that we might want to see.
*/
struct CV4_DirHead {
short unsigned int dhsize;
short unsigned int desize;
unsigned int ndir;
unsigned int next_offset;
unsigned int flags;
};
struct CV4_DirEnt {
short unsigned int subsect_number;
short unsigned int module_number;
unsigned int offset;
unsigned int size;
};
/*
* These are the values of interest that the subsect_number field takes.
*/
#define sstAlignSym 0x125
#define sstSrcModule 0x127
struct codeview_linetab_hdr
{
unsigned int nline;
unsigned int segno;
unsigned int start;
unsigned int end;
char * sourcefile;
unsigned short * linetab;
unsigned int * offtab;
};
struct codeview_pdb_hdr
{
char ident[44];
unsigned int blocksize; /* Extent size */
unsigned short loc_freelist; /* freelist. */
unsigned short alloc_filesize; /* # extents allocated. */
unsigned int toc_len;
unsigned int unknown;
unsigned short toc_ext[1]; /* array of extent #'s for toc. */
};
/*
* This is our own structure that we use to keep track of the contents
* of a PDB file.
*/
struct file_list
{
int record_len;
int nextents;
short int * extent_list;
unsigned int linetab_offset;
unsigned int linetab_len;
};
/*
* These are the structures that represent how the file table is set up
* within the PDB file.
*/
struct filetab_hdr
{
unsigned short tab1_file;
unsigned short tab2_file;
unsigned short gsym_file;
unsigned short padding;
unsigned int ftab_len;
unsigned int fofftab_len;
unsigned int hash_len;
unsigned int strtab_len;
};
struct file_ent
{
unsigned int reserved1;
unsigned short datasect_segment;
unsigned short reserved2;
unsigned int datasect_offset;
unsigned int datasect_size;
unsigned int datasect_flags;
unsigned short reserved3;
unsigned short index;
unsigned short num6a;
unsigned short file_number;
unsigned int linetab_offset;
unsigned int linetab_len;
unsigned int num9;
unsigned int num10;
unsigned int num11;
unsigned char filename[1];
};
/*
********************************************************************
*/
struct deferred_debug_info
{
struct deferred_debug_info * next;
char * load_addr;
char * module_name;
char * dbg_info;
int dbg_size;
HMODULE module;
PIMAGE_DEBUG_DIRECTORY dbgdir;
PIMAGE_SECTION_HEADER sectp;
int nsect;
short int dbg_index;
char status;
};
#define DF_STATUS_NEW 0
#define DF_STATUS_LOADED 1
#define DF_STATUS_ERROR 2
struct deferred_debug_info * dbglist = NULL;
/*
* A simple macro that tells us whether a given COFF symbol is a
* function or not.
*/
#define N_TMASK 0x0030
#define IMAGE_SYM_DTYPE_FUNCTION 2
#define N_BTSHFT 4
#define ISFCN(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_FUNCTION << N_BTSHFT))
/*
* This is what we are looking for in the COFF symbols.
*/
#define IMAGE_SYM_CLASS_EXTERNAL 0x2
#define IMAGE_SYM_CLASS_STATIC 0x3
#define IMAGE_SYM_CLASS_FILE 0x67
static
struct datatype * DEBUG_GetCVType(int typeno)
{
struct datatype * dt = NULL;
/*
* Convert Codeview type numbers into something we can grok internally.
* Numbers < 0x1000 are all fixed builtin types. Numbers from 0x1000 and
* up are all user defined (structs, etc).
*/
if( typeno < 0x1000 )
{
if( typeno < MAX_BUILTIN_TYPES )
{
dt = cv_basic_types[typeno];
}
}
else
{
if( typeno - 0x1000 < num_cv_defined_types )
{
dt = cv_defined_types[typeno - 0x1000];
}
}
return dt;
}
static int
DEBUG_ParseTypeTable(char * table, int len)
{
int arr_max;
int curr_type;
enum debug_type fieldtype;
int elem_size;
union any_size ptr;
union any_size ptr2;
struct datatype * subtype;
char symname[256];
union codeview_type * type;
union codeview_type * type2;
struct datatype * typeptr;
curr_type = 0x1000;
ptr.c = (table + 16);
while( ptr.c - table < len )
{
type = (union codeview_type *) ptr.c;
if( curr_type - 0x1000 >= num_cv_defined_types )
{
num_cv_defined_types += 0x100;
cv_defined_types = (struct datatype **) DBG_realloc(cv_defined_types,
num_cv_defined_types * sizeof(struct datatype *));
memset(cv_defined_types + num_cv_defined_types - 0x100,
0,
0x100 * sizeof(struct datatype *));
if( cv_defined_types == NULL )
{
return FALSE;
}
}
switch(type->generic.id)
{
case LF_POINTER:
cv_defined_types[curr_type - 0x1000] =
DEBUG_FindOrMakePointerType(DEBUG_GetCVType(type->pointer.datatype));
break;
case LF_ARRAY:
if( type->array.arrlen >= 0x8000 )
{
/*
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
break;
}
if( type->array.namelen != 0 )
{
memset(symname, 0, sizeof(symname));
memcpy(symname, type->array.name, type->array.namelen);
typeptr = DEBUG_NewDataType(DT_ARRAY, symname);
}
else
{
typeptr = DEBUG_NewDataType(DT_ARRAY, NULL);
}
cv_defined_types[curr_type - 0x1000] = typeptr;
subtype = DEBUG_GetCVType(type->array.elemtype);
if( (subtype == NULL)
|| (elem_size = DEBUG_GetObjectSize(subtype)) == 0 )
{
arr_max = 0;
}
else
{
arr_max = type->array.arrlen / DEBUG_GetObjectSize(subtype);
}
DEBUG_SetArrayParams(typeptr, 0, arr_max, subtype);
break;
case LF_FIELDLIST:
/*
* This is where the basic list of fields is defined for
* structures and classes.
*
* First, we need to look ahead and see whether we are building
* a fieldlist for an enum or a struct.
*/
ptr2.i = ptr.i + 1;
type2 = (union codeview_type *) ptr2.c;
if( type2->member.id == LF_MEMBER )
{
typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
fieldtype = DT_STRUCT;
}
else if( type2->member.id == LF_ENUMERATE )
{
typeptr = DEBUG_NewDataType(DT_ENUM, NULL);
fieldtype = DT_ENUM;
}
else
{
break;
}
cv_defined_types[curr_type - 0x1000] = typeptr;
while( ptr2.c < (ptr.c + ((type->generic.len + 3) & ~3)) )
{
type2 = (union codeview_type *) ptr2.c;
if( type2->member.id == LF_MEMBER && fieldtype == DT_STRUCT )
{
memset(symname, 0, sizeof(symname));
memcpy(symname, type2->member.name, type2->member.namelen);
subtype = DEBUG_GetCVType(type2->member.type);
elem_size = 0;
if( subtype != NULL )
{
elem_size = DEBUG_GetObjectSize(subtype);
}
if( type2->member.offset >= 0x8000 )
{
/*
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
}
else
{
DEBUG_AddStructElement(typeptr, symname, subtype,
type2->member.offset << 3,
elem_size << 3);
}
}
else if( type2->member.id == LF_ENUMERATE && fieldtype == DT_ENUM )
{
memset(symname, 0, sizeof(symname));
memcpy(symname, type2->enumerate.name, type2->enumerate.namelen);
if( type2->enumerate.value >= 0x8000 )
{
/*
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
}
else
{
DEBUG_AddStructElement(typeptr, symname, NULL,
type2->enumerate.value, 0);
}
}
else
{
/*
* Something else I have never seen before. Either wrong type of
* object in the fieldlist, or some other problem which I wouldn't
* really know how to handle until it came up.
*/
fprintf(stderr, "Unexpected entry in fieldlist\n");
break;
}
ptr2.c += ((type2->member.namelen + 9 + 3) & ~3);
}
break;
case LF_STRUCTURE:
case LF_CLASS:
if( type->structure.structlen >= 0x8000 )
{
/*
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
break;
}
memset(symname, 0, sizeof(symname));
memcpy(symname, type->structure.name, type->structure.namelen);
if( strcmp(symname, "__unnamed") == 0 )
{
typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
}
else
{
typeptr = DEBUG_NewDataType(DT_STRUCT, symname);
}
cv_defined_types[curr_type - 0x1000] = typeptr;
/*
* Now copy the relevant bits from the fieldlist that we specified.
*/
subtype = DEBUG_GetCVType(type->structure.fieldlist);
if( subtype != NULL )
{
DEBUG_SetStructSize(typeptr, type->structure.structlen);
DEBUG_CopyFieldlist(typeptr, subtype);
}
break;
case LF_UNION:
if( type->t_union.un_len >= 0x8000 )
{
/*
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
break;
}
memset(symname, 0, sizeof(symname));
memcpy(symname, type->t_union.name, type->t_union.namelen);
if( strcmp(symname, "__unnamed") == 0 )
{
typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
}
else
{
typeptr = DEBUG_NewDataType(DT_STRUCT, symname);
}
cv_defined_types[curr_type - 0x1000] = typeptr;
/*
* Now copy the relevant bits from the fieldlist that we specified.
*/
subtype = DEBUG_GetCVType(type->t_union.field);
if( subtype != NULL )
{
DEBUG_SetStructSize(typeptr, type->t_union.un_len);
DEBUG_CopyFieldlist(typeptr, subtype);
}
break;
case LF_BITFIELD:
typeptr = DEBUG_NewDataType(DT_BITFIELD, NULL);
cv_defined_types[curr_type - 0x1000] = typeptr;
DEBUG_SetBitfieldParams(typeptr, type->bitfield.bitoff,
type->bitfield.nbits,
DEBUG_GetCVType(type->bitfield.type));
break;
case LF_ENUMERATION:
memset(symname, 0, sizeof(symname));
memcpy(symname, type->enumeration.name, type->enumeration.namelen);
typeptr = DEBUG_NewDataType(DT_ENUM, symname);
cv_defined_types[curr_type - 0x1000] = typeptr;
/*
* Now copy the relevant bits from the fieldlist that we specified.
*/
subtype = DEBUG_GetCVType(type->enumeration.field);
if( subtype != NULL )
{
DEBUG_CopyFieldlist(typeptr, subtype);
}
break;
case LF_DIMARRAY:
default:
break;
}
curr_type++;
ptr.c += (type->generic.len + 3) & ~3;
}
return TRUE;
}
void
DEBUG_InitCVDataTypes()
{
/*
* These are the common builtin types that are used by VC++.
*/
cv_basic_types[T_NOTYPE] = NULL;
cv_basic_types[T_ABS] = NULL;
cv_basic_types[T_VOID] = DEBUG_NewDataType(DT_BASIC, "void");
cv_basic_types[T_CHAR] = DEBUG_NewDataType(DT_BASIC, "char");
cv_basic_types[T_SHORT] = DEBUG_NewDataType(DT_BASIC, "short int");
cv_basic_types[T_LONG] = DEBUG_NewDataType(DT_BASIC, "long int");
cv_basic_types[T_QUAD] = DEBUG_NewDataType(DT_BASIC, "long long int");
cv_basic_types[T_UCHAR] = DEBUG_NewDataType(DT_BASIC, "unsigned char");
cv_basic_types[T_USHORT] = DEBUG_NewDataType(DT_BASIC, "short unsigned int");
cv_basic_types[T_ULONG] = DEBUG_NewDataType(DT_BASIC, "long unsigned int");
cv_basic_types[T_UQUAD] = DEBUG_NewDataType(DT_BASIC, "long long unsigned int");
cv_basic_types[T_REAL32] = DEBUG_NewDataType(DT_BASIC, "float");
cv_basic_types[T_REAL64] = DEBUG_NewDataType(DT_BASIC, "double");
cv_basic_types[T_RCHAR] = DEBUG_NewDataType(DT_BASIC, "char");
cv_basic_types[T_WCHAR] = DEBUG_NewDataType(DT_BASIC, "short");
cv_basic_types[T_INT4] = DEBUG_NewDataType(DT_BASIC, "int");
cv_basic_types[T_UINT4] = DEBUG_NewDataType(DT_BASIC, "unsigned int");
cv_basic_types[T_32PVOID] = DEBUG_FindOrMakePointerType(cv_basic_types[T_VOID]);
cv_basic_types[T_32PCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_CHAR]);
cv_basic_types[T_32PSHORT] = DEBUG_FindOrMakePointerType(cv_basic_types[T_SHORT]);
cv_basic_types[T_32PLONG] = DEBUG_FindOrMakePointerType(cv_basic_types[T_LONG]);
cv_basic_types[T_32PQUAD] = DEBUG_FindOrMakePointerType(cv_basic_types[T_QUAD]);
cv_basic_types[T_32PUCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UCHAR]);
cv_basic_types[T_32PUSHORT] = DEBUG_FindOrMakePointerType(cv_basic_types[T_USHORT]);
cv_basic_types[T_32PULONG] = DEBUG_FindOrMakePointerType(cv_basic_types[T_ULONG]);
cv_basic_types[T_32PUQUAD] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UQUAD]);
cv_basic_types[T_32PREAL32] = DEBUG_FindOrMakePointerType(cv_basic_types[T_REAL32]);
cv_basic_types[T_32PREAL64] = DEBUG_FindOrMakePointerType(cv_basic_types[T_REAL64]);
cv_basic_types[T_32PRCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_RCHAR]);
cv_basic_types[T_32PWCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_WCHAR]);
cv_basic_types[T_32PINT4] = DEBUG_FindOrMakePointerType(cv_basic_types[T_INT4]);
cv_basic_types[T_32PUINT4] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UINT4]);
}
/*
* In this function, we keep track of deferred debugging information
* that we may need later if we were to need to use the internal debugger.
* We don't fully process it here for performance reasons.
*/
int
DEBUG_RegisterDebugInfo( HMODULE hModule, const char *module_name)
{
int has_codeview = FALSE;
int rtn = FALSE;
int orig_size;
PIMAGE_DEBUG_DIRECTORY dbgptr;
u_long v_addr, size;
PIMAGE_NT_HEADERS nth = PE_HEADER(hModule);
size = nth->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size;
if (size) {
v_addr = nth->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;
dbgptr = (PIMAGE_DEBUG_DIRECTORY) (hModule + v_addr);
orig_size = size;
for(; size >= sizeof(*dbgptr); size -= sizeof(*dbgptr), dbgptr++ )
{
switch(dbgptr->Type)
{
case IMAGE_DEBUG_TYPE_CODEVIEW:
case IMAGE_DEBUG_TYPE_MISC:
has_codeview = TRUE;
break;
}
}
size = orig_size;
dbgptr = (PIMAGE_DEBUG_DIRECTORY) (hModule + v_addr);
for(; size >= sizeof(*dbgptr); size -= sizeof(*dbgptr), dbgptr++ )
{
switch(dbgptr->Type)
{
case IMAGE_DEBUG_TYPE_COFF:
/*
* If we have both codeview and COFF debug info, ignore the
* coff debug info as it would just confuse us, and it is
* less complete.
*
* FIXME - this is broken - if we cannot find the PDB file, then
* we end up with no debugging info at all. In this case, we
* should use the COFF info as a backup.
*/
if( has_codeview )
{
break;
}
case IMAGE_DEBUG_TYPE_CODEVIEW:
case IMAGE_DEBUG_TYPE_MISC:
/*
* This is usually an indirection to a .DBG file.
* This is similar to (but a slightly older format) from the
* PDB file.
*
* First check to see if the image was 'stripped'. If so, it
* means that this entry points to a .DBG file. Otherwise,
* it just points to itself, and we can ignore this.
*/
if( (dbgptr->Type != IMAGE_DEBUG_TYPE_MISC) ||
(PE_HEADER(hModule)->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) != 0 )
{
char fn[PATH_MAX];
int fd = -1;
DOS_FULL_NAME full_name;
struct deferred_debug_info* deefer = (struct deferred_debug_info *) DBG_alloc(sizeof(*deefer));
deefer->module = hModule;
deefer->load_addr = (char *)hModule;
/*
* Read the important bits. What we do after this depends
* upon the type, but this is always enough so we are able
* to proceed if we know what we need to do next.
*/
/* basically, the PE loader maps all sections (data, resources...), but doesn't map
* the DataDirectory array's content. One its entry contains the *beloved*
* debug information. (Note the DataDirectory is mapped, not its content)
*/
if (GetModuleFileNameA(hModule, fn, sizeof(fn)) > 0 &&
DOSFS_GetFullName(fn, TRUE, &full_name) &&
(fd = open(full_name.long_name, O_RDONLY)) > 0)
{
deefer->dbg_info = mmap(NULL, dbgptr->SizeOfData,
PROT_READ, MAP_PRIVATE, fd, dbgptr->PointerToRawData);
close(fd);
if( deefer->dbg_info == (char *) 0xffffffff )
{
DBG_free(deefer);
break;
}
}
else
{
DBG_free(deefer);
fprintf(stderr, " (not mapped: fn=%s, lfn=%s, fd=%d)", fn, full_name.long_name, fd);
break;
}
deefer->dbg_size = dbgptr->SizeOfData;
deefer->dbgdir = dbgptr;
deefer->next = dbglist;
deefer->status = DF_STATUS_NEW;
deefer->dbg_index = DEBUG_next_index;
deefer->module_name = DBG_strdup(module_name);
deefer->sectp = PE_SECTIONS(hModule);
deefer->nsect = PE_HEADER(hModule)->FileHeader.NumberOfSections;
dbglist = deefer;
}
break;
#if 0
default:
#endif
}
}
DEBUG_next_index++;
}
/* look for .stabs/.stabstr sections */
{
PIMAGE_SECTION_HEADER pe_seg = PE_SECTIONS(hModule);
int i,stabsize=0,stabstrsize=0;
unsigned int stabs=0,stabstr=0;
for (i=0;i<nth->FileHeader.NumberOfSections;i++) {
if (!strcasecmp(pe_seg[i].Name,".stab")) {
stabs = pe_seg[i].VirtualAddress;
stabsize = pe_seg[i].SizeOfRawData;
}
if (!strncasecmp(pe_seg[i].Name,".stabstr",8)) {
stabstr = pe_seg[i].VirtualAddress;
stabstrsize = pe_seg[i].SizeOfRawData;
}
}
if (stabstrsize && stabsize) {
#ifdef _WE_SUPPORT_THE_STAB_TYPES_USED_BY_MINGW_TOO
/* Won't work currently, since MINGW32 uses some special typedefs
* which we do not handle yet. Support for them is a bit difficult.
*/
DEBUG_ParseStabs(hModule,0,stabs,stabsize,stabstr,stabstrsize);
#endif
fprintf(stderr,"(stabs not loaded)");
}
}
return (rtn);
}
/*
* ELF modules are also entered into the list - this is so that we
* can make 'info shared' types of displays possible.
*/
int
DEBUG_RegisterELFDebugInfo(int load_addr, u_long size, char * name)
{
struct deferred_debug_info * deefer;
deefer = (struct deferred_debug_info *) DBG_alloc(sizeof(*deefer));
deefer->module = 0;
/*
* Read the important bits. What we do after this depends
* upon the type, but this is always enough so we are able
* to proceed if we know what we need to do next.
*/
deefer->dbg_size = size;
deefer->dbg_info = (char *) NULL;
deefer->load_addr = (char *) load_addr;
deefer->dbgdir = NULL;
deefer->next = dbglist;
deefer->status = DF_STATUS_LOADED;
deefer->dbg_index = DEBUG_next_index;
deefer->module_name = DBG_strdup(name);
dbglist = deefer;
DEBUG_next_index++;
return (TRUE);
}
/*
* Process COFF debugging information embedded in a Win32 application.
*
*/
static
int
DEBUG_ProcessCoff(struct deferred_debug_info * deefer)
{
struct CoffAuxSection * aux;
struct CoffDebug * coff;
struct CoffFiles * coff_files = NULL;
struct CoffLinenum * coff_linetab;
char * coff_strtab;
struct CoffSymbol * coff_sym;
struct CoffSymbol * coff_symbol;
struct CoffFiles * curr_file = NULL;
int i;
int j;
int k;
struct CoffLinenum * linepnt;
int linetab_indx;
char namebuff[9];
char * nampnt;
int naux;
DBG_ADDR new_addr;
int nfiles = 0;
int nfiles_alloc = 0;
struct CoffFiles orig_file;
int rtn = FALSE;
char * this_file = NULL;
coff = (struct CoffDebug *) deefer->dbg_info;
coff_symbol = (struct CoffSymbol *) ((unsigned int) coff + coff->SymbolOffset);
coff_linetab = (struct CoffLinenum *) ((unsigned int) coff + coff->LinenumberOffset);
coff_strtab = (char *) ((unsigned int) coff_symbol + 18*coff->N_Sym);
linetab_indx = 0;
for(i=0; i < coff->N_Sym; i++ )
{
/*
* We do this because some compilers (i.e. gcc) incorrectly
* pad the structure up to a 4 byte boundary. The structure
* is really only 18 bytes long, so we have to manually make sure
* we get it right.
*
* FIXME - there must be a way to have autoconf figure out the
* correct compiler option for this. If it is always gcc, that
* makes life simpler, but I don't want to force this.
*/
coff_sym = (struct CoffSymbol *) ((unsigned int) coff_symbol + 18*i);
naux = coff_sym->NumberOfAuxSymbols;
if( coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE )
{
if( nfiles + 1 >= nfiles_alloc )
{
nfiles_alloc += 10;
coff_files = (struct CoffFiles *) DBG_realloc(coff_files,
nfiles_alloc * sizeof(struct CoffFiles));
}
curr_file = coff_files + nfiles;
nfiles++;
curr_file->startaddr = 0xffffffff;
curr_file->endaddr = 0;
curr_file->filename = ((char *) coff_sym) + 18;
curr_file->linetab_offset = -1;
curr_file->linecnt = 0;
curr_file->entries = NULL;
curr_file->neps = curr_file->neps_alloc = 0;
#if 0
fprintf(stderr,"New file %s\n", curr_file->filename);
#endif
i += naux;
continue;
}
/*
* This guy marks the size and location of the text section
* for the current file. We need to keep track of this so
* we can figure out what file the different global functions
* go with.
*/
if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
&& (naux != 0)
&& (coff_sym->Type == 0)
&& (coff_sym->SectionNumber == 1) )
{
aux = (struct CoffAuxSection *) ((unsigned int) coff_sym + 18);
if( curr_file->linetab_offset != -1 )
{
#if 0
fprintf(stderr, "Duplicating sect from %s: %x %x %x %d %d\n",
curr_file->filename,
aux->Length,
aux->NumberOfRelocations,
aux->NumberOfLinenumbers,
aux->Number,
aux->Selection);
fprintf(stderr, "More sect %d %x %d %d %d\n",
coff_sym->SectionNumber,
coff_sym->Value,
coff_sym->Type,
coff_sym->StorageClass,
coff_sym->NumberOfAuxSymbols);
#endif
/*
* Save this so we can copy bits from it.
*/
orig_file = *curr_file;
/*
* Duplicate the file entry. We have no way to describe
* multiple text sections in our current way of handling things.
*/
if( nfiles + 1 >= nfiles_alloc )
{
nfiles_alloc += 10;
coff_files = (struct CoffFiles *) DBG_realloc(coff_files,
nfiles_alloc * sizeof(struct CoffFiles));
}
curr_file = coff_files + nfiles;
nfiles++;
curr_file->startaddr = 0xffffffff;
curr_file->endaddr = 0;
curr_file->filename = orig_file.filename;
curr_file->linetab_offset = -1;
curr_file->linecnt = 0;
curr_file->entries = NULL;
curr_file->neps = curr_file->neps_alloc = 0;
}
#if 0
else
{
fprintf(stderr, "New text sect from %s: %x %x %x %d %d\n",
curr_file->filename,
aux->Length,
aux->NumberOfRelocations,
aux->NumberOfLinenumbers,
aux->Number,
aux->Selection);
}
#endif
if( curr_file->startaddr > coff_sym->Value )
{
curr_file->startaddr = coff_sym->Value;
}
if( curr_file->startaddr > coff_sym->Value )
{
curr_file->startaddr = coff_sym->Value;
}
if( curr_file->endaddr < coff_sym->Value + aux->Length )
{
curr_file->endaddr = coff_sym->Value + aux->Length;
}
curr_file->linetab_offset = linetab_indx;
curr_file->linecnt = aux->NumberOfLinenumbers;
linetab_indx += aux->NumberOfLinenumbers;
i += naux;
continue;
}
if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
&& (naux == 0)
&& (coff_sym->SectionNumber == 1) )
{
/*
* This is a normal static function when naux == 0.
* Just register it. The current file is the correct
* one in this instance.
*/
if( coff_sym->N.Name.NotLong )
{
memcpy(namebuff, coff_sym->N.ShortName, 8);
namebuff[8] = '\0';
nampnt = &namebuff[0];
}
else
{
nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
}
if( nampnt[0] == '_' )
{
nampnt++;
}
new_addr.seg = 0;
new_addr.off = (int) (deefer->load_addr + coff_sym->Value);
if( curr_file->neps + 1 >= curr_file->neps_alloc )
{
curr_file->neps_alloc += 10;
curr_file->entries = (struct name_hash **)
DBG_realloc(curr_file->entries,
curr_file->neps_alloc * sizeof(struct name_hash *));
}
#if 0
fprintf(stderr,"\tAdding static symbol %s\n", nampnt);
#endif
curr_file->entries[curr_file->neps++] =
DEBUG_AddSymbol( nampnt, &new_addr, this_file, SYM_WIN32 );
i += naux;
continue;
}
if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
&& ISFCN(coff_sym->Type)
&& (coff_sym->SectionNumber > 0) )
{
if( coff_sym->N.Name.NotLong )
{
memcpy(namebuff, coff_sym->N.ShortName, 8);
namebuff[8] = '\0';
nampnt = &namebuff[0];
}
else
{
nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
}
if( nampnt[0] == '_' )
{
nampnt++;
}
new_addr.seg = 0;
new_addr.off = (int) (deefer->load_addr + coff_sym->Value);
#if 0
fprintf(stderr, "%d: %x %s\n", i, new_addr.off, nampnt);
fprintf(stderr,"\tAdding global symbol %s\n", nampnt);
#endif
/*
* Now we need to figure out which file this guy belongs to.
*/
this_file = NULL;
for(j=0; j < nfiles; j++)
{
if( coff_files[j].startaddr <= coff_sym->Value
&& coff_files[j].endaddr > coff_sym->Value )
{
this_file = coff_files[j].filename;
break;
}
}
if( coff_files[j].neps + 1 >= coff_files[j].neps_alloc )
{
coff_files[j].neps_alloc += 10;
coff_files[j].entries = (struct name_hash **)
DBG_realloc(coff_files[j].entries,
coff_files[j].neps_alloc * sizeof(struct name_hash *));
}
coff_files[j].entries[coff_files[j].neps++] =
DEBUG_AddSymbol( nampnt, &new_addr, this_file, SYM_WIN32 );
i += naux;
continue;
}
if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
&& (coff_sym->SectionNumber > 0) )
{
/*
* Similar to above, but for the case of data symbols.
* These aren't treated as entrypoints.
*/
if( coff_sym->N.Name.NotLong )
{
memcpy(namebuff, coff_sym->N.ShortName, 8);
namebuff[8] = '\0';
nampnt = &namebuff[0];
}
else
{
nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
}
if( nampnt[0] == '_' )
{
nampnt++;
}
new_addr.seg = 0;
new_addr.off = (int) (deefer->load_addr + coff_sym->Value);
#if 0
fprintf(stderr, "%d: %x %s\n", i, new_addr.off, nampnt);
fprintf(stderr,"\tAdding global data symbol %s\n", nampnt);
#endif
/*
* Now we need to figure out which file this guy belongs to.
*/
DEBUG_AddSymbol( nampnt, &new_addr, NULL, SYM_WIN32 );
i += naux;
continue;
}
if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
&& (naux == 0) )
{
/*
* Ignore these. They don't have anything to do with
* reality.
*/
i += naux;
continue;
}
#if 0
fprintf(stderr,"Skipping unknown entry %d %d %d\n", coff_sym->StorageClass,
coff_sym->SectionNumber, naux);
#endif
/*
* For now, skip past the aux entries.
*/
i += naux;
}
/*
* OK, we now should have a list of files, and we should have a list
* of entrypoints. We need to sort the entrypoints so that we are
* able to tie the line numbers with the given functions within the
* file.
*/
if( coff_files != NULL )
{
for(j=0; j < nfiles; j++)
{
if( coff_files[j].entries != NULL )
{
qsort(coff_files[j].entries, coff_files[j].neps,
sizeof(struct name_hash *), DEBUG_cmp_sym);
}
}
/*
* Now pick apart the line number tables, and attach the entries
* to the given functions.
*/
for(j=0; j < nfiles; j++)
{
i = 0;
if( coff_files[j].neps != 0 )
for(k=0; k < coff_files[j].linecnt; k++)
{
/*
* Another monstrosity caused by the fact that we are using
* a 6 byte structure, and gcc wants to pad structures to 4 byte
* boundaries. Otherwise we could just index into an array.
*/
linepnt = (struct CoffLinenum *)
((unsigned int) coff_linetab +
6*(coff_files[j].linetab_offset + k));
/*
* If we have spilled onto the next entrypoint, then
* bump the counter..
*/
while(TRUE)
{
if (i+1 >= coff_files[j].neps) break;
DEBUG_GetSymbolAddr(coff_files[j].entries[i+1], &new_addr);
if( (((unsigned int)deefer->load_addr +
linepnt->VirtualAddr) >= new_addr.off) )
{
i++;
} else break;
}
/*
* Add the line number. This is always relative to the
* start of the function, so we need to subtract that offset
* first.
*/
DEBUG_GetSymbolAddr(coff_files[j].entries[i], &new_addr);
DEBUG_AddLineNumber(coff_files[j].entries[i],
linepnt->Linenum,
(unsigned int) deefer->load_addr
+ linepnt->VirtualAddr
- new_addr.off);
}
}
}
rtn = TRUE;
if( coff_files != NULL )
{
for(j=0; j < nfiles; j++)
{
if( coff_files[j].entries != NULL )
{
DBG_free(coff_files[j].entries);
}
}
DBG_free(coff_files);
}
return (rtn);
}
/*
* Process a codeview line number table. Digestify the thing so that
* we can easily reference the thing when we process the rest of
* the information.
*/
static struct codeview_linetab_hdr *
DEBUG_SnarfLinetab(char * linetab,
int size)
{
int file_segcount;
char filename[PATH_MAX];
unsigned int * filetab;
char * fn;
int i;
int k;
struct codeview_linetab_hdr * lt_hdr;
unsigned int * lt_ptr;
int nfile;
int nseg;
union any_size pnt;
union any_size pnt2;
struct startend * start;
int this_seg;
/*
* Now get the important bits.
*/
pnt.c = linetab;
nfile = *pnt.s++;
nseg = *pnt.s++;
filetab = (unsigned int *) pnt.c;
/*
* Now count up the number of segments in the file.
*/
nseg = 0;
for(i=0; i<nfile; i++)
{
pnt2.c = linetab + filetab[i];
nseg += *pnt2.s;
}
/*
* Next allocate the header we will be returning.
* There is one header for each segment, so that we can reach in
* and pull bits as required.
*/
lt_hdr = (struct codeview_linetab_hdr *)
DBG_alloc((nseg + 1) * sizeof(*lt_hdr));
if( lt_hdr == NULL )
{
goto leave;
}
memset(lt_hdr, 0, sizeof(*lt_hdr) * (nseg+1));
/*
* Now fill the header we will be returning, one for each segment.
* Note that this will basically just contain pointers into the existing
* line table, and we do not actually copy any additional information
* or allocate any additional memory.
*/
this_seg = 0;
for(i=0; i<nfile; i++)
{
/*
* Get the pointer into the segment information.
*/
pnt2.c = linetab + filetab[i];
file_segcount = *pnt2.s;
pnt2.ui++;
lt_ptr = (unsigned int *) pnt2.c;
start = (struct startend *) (lt_ptr + file_segcount);
/*
* Now snarf the filename for all of the segments for this file.
*/
fn = (unsigned char *) (start + file_segcount);
memset(filename, 0, sizeof(filename));
memcpy(filename, fn + 1, *fn);
fn = DBG_strdup(filename);
for(k = 0; k < file_segcount; k++, this_seg++)
{
pnt2.c = linetab + lt_ptr[k];
lt_hdr[this_seg].start = start[k].start;
lt_hdr[this_seg].end = start[k].end;
lt_hdr[this_seg].sourcefile = fn;
lt_hdr[this_seg].segno = *pnt2.s++;
lt_hdr[this_seg].nline = *pnt2.s++;
lt_hdr[this_seg].offtab = pnt2.ui;
lt_hdr[this_seg].linetab = (unsigned short *)
(pnt2.ui + lt_hdr[this_seg].nline);
}
}
leave:
return lt_hdr;
}
static int
DEBUG_SnarfCodeView( struct deferred_debug_info * deefer,
char * cv_data,
int size,
struct codeview_linetab_hdr * linetab)
{
struct name_hash * curr_func = NULL;
struct wine_locals * curr_sym = NULL;
int i;
int j;
int len;
DBG_ADDR new_addr;
int nsect;
union any_size ptr;
IMAGE_SECTION_HEADER * sectp;
union codeview_symbol * sym;
char symname[PATH_MAX];
struct name_hash * thunk_sym = NULL;
ptr.c = cv_data;
nsect = deefer->nsect;
sectp = deefer->sectp;
/*
* Skip over the first word. Don't really know what it means, but
* it is useless.
*/
ptr.ui++;
/*
* Loop over the different types of records and whenever we
* find something we are interested in, record it and move on.
*/
while( ptr.c - cv_data < size )
{
sym = (union codeview_symbol *) ptr.c;
if( sym->generic.len - sizeof(int) == (ptr.c - cv_data) )
{
/*
* This happens when we have indirect symbols that VC++ 4.2
* sometimes uses when there isn't a line number table.
* We ignore it - we will process and enter all of the
* symbols in the global symbol table anyways, so there
* isn't much point in keeping track of all of this crap.
*/
break;
}
memset(symname, 0, sizeof(symname));
switch(sym->generic.id)
{
case S_GDATA:
case S_LDATA:
case S_PUB:
/*
* First, a couple of sanity checks.
*/
if( sym->data.namelen == 0 )
{
break;
}
if( sym->data.seg == 0 || sym->data.seg > nsect )
{
break;
}
/*
* Global and local data symbols. We don't associate these
* with any given source file.
*/
memcpy(symname, sym->data.name, sym->data.namelen);
new_addr.seg = 0;
new_addr.type = DEBUG_GetCVType(sym->data.symtype);
new_addr.off = (unsigned int) deefer->load_addr +
sectp[sym->data.seg - 1].VirtualAddress +
sym->data.offset;
DEBUG_AddSymbol( symname, &new_addr, NULL, SYM_WIN32 | SYM_DATA );
break;
case S_THUNK:
/*
* Sort of like a global function, but it just points
* to a thunk, which is a stupid name for what amounts to
* a PLT slot in the normal jargon that everyone else uses.
*/
memcpy(symname, sym->thunk.name, sym->thunk.namelen);
new_addr.seg = 0;
new_addr.type = NULL;
new_addr.off = (unsigned int) deefer->load_addr +
sectp[sym->thunk.segment - 1].VirtualAddress +
sym->thunk.offset;
thunk_sym = DEBUG_AddSymbol( symname, &new_addr, NULL,
SYM_WIN32 | SYM_FUNC);
DEBUG_SetSymbolSize(thunk_sym, sym->thunk.thunk_len);
break;
case S_GPROC:
case S_LPROC:
/*
* Global and static functions.
*/
memcpy(symname, sym->proc.name, sym->proc.namelen);
new_addr.seg = 0;
new_addr.type = DEBUG_GetCVType(sym->proc.proctype);
new_addr.off = (unsigned int) deefer->load_addr +
sectp[sym->proc.segment - 1].VirtualAddress +
sym->proc.offset;
/*
* See if we can find a segment that this goes with. If so,
* it means that we also may have line number information
* for this function.
*/
for(i=0; linetab[i].linetab != NULL; i++)
{
if( ((unsigned int) deefer->load_addr
+ sectp[linetab[i].segno - 1].VirtualAddress
+ linetab[i].start <= new_addr.off)
&& ((unsigned int) deefer->load_addr
+ sectp[linetab[i].segno - 1].VirtualAddress
+ linetab[i].end > new_addr.off) )
{
break;
}
}
DEBUG_Normalize(curr_func);
if( linetab[i].linetab == NULL )
{
curr_func = DEBUG_AddSymbol( symname, &new_addr, NULL,
SYM_WIN32 | SYM_FUNC);
}
else
{
/*
* First, create the entry. Then dig through the linetab
* and add whatever line numbers are appropriate for this
* function.
*/
curr_func = DEBUG_AddSymbol( symname, &new_addr,
linetab[i].sourcefile,
SYM_WIN32 | SYM_FUNC);
for(j=0; j < linetab[i].nline; j++)
{
if( linetab[i].offtab[j] >= sym->proc.offset
&& linetab[i].offtab[j] < sym->proc.offset
+ sym->proc.proc_len )
{
DEBUG_AddLineNumber(curr_func, linetab[i].linetab[j],
linetab[i].offtab[j] - sym->proc.offset);
}
}
}
/*
* Add information about where we should set breakpoints
* in this function.
*/
DEBUG_SetSymbolBPOff(curr_func, sym->proc.debug_start);
DEBUG_SetSymbolSize(curr_func, sym->proc.proc_len);
break;
case S_BPREL:
/*
* Function parameters and stack variables.
*/
memcpy(symname, sym->stack.name, sym->stack.namelen);
curr_sym = DEBUG_AddLocal(curr_func,
0,
sym->stack.offset,
0,
0,
symname);
DEBUG_SetLocalSymbolType(curr_sym, DEBUG_GetCVType(sym->stack.symtype));
break;
default:
break;
}
/*
* Adjust pointer to point to next entry, rounding up to a word
* boundary. MS preserving alignment? Stranger things have
* happened.
*/
if( sym->generic.id == S_PROCREF
|| sym->generic.id == S_DATAREF
|| sym->generic.id == S_UNKNOWN )
{
len = (sym->generic.len + 3) & ~3;
len += ptr.c[16] + 1;
ptr.c += (len + 3) & ~3;
}
else
{
ptr.c += (sym->generic.len + 3) & ~3;
}
}
if( linetab != NULL )
{
DBG_free(linetab);
}
return TRUE;
}
/*
* Process PDB file which contains debug information.
*
* These are really weird beasts. They are intended to be incrementally
* updated by the incremental linker, and this means that you need to
* be able to remove and add information. Thus the PDB file is sort of
* like a block structured device, with a freelist and lists of extent numbers
* that are used to get the relevant pieces. In all cases seen so far, the
* blocksize is always 0x400 bytes. The header has a field which apparently
* holds the blocksize, so if it ever changes we are safe.
*
* In general, every time we need to extract something from the pdb file,
* it is easier to copy it into another buffer so we have the information
* in one contiguous block rather than attempt to try and keep track of when
* we need to grab another extent from the pdb file.
*
* The thing that is a real pain about some MS stuff is that they choose
* data structures which are not representable in C. Thus we have to
* hack around and diddle pointers.
*/
/* static */
int
DEBUG_ProcessPDBFile(struct deferred_debug_info * deefer, char * full_filename)
{
char * addr = (char *) 0xffffffff;
unsigned int blocksize;
unsigned int bufflen = 0;
char * buffer = NULL;
unsigned short * extent_table;
int fd = -1;
struct file_ent * fent;
char filename[MAX_PATHNAME_LEN];
struct file_list * filelist = NULL;
unsigned int gsym_record = 0;
char * gsymtab = NULL;
struct filetab_hdr * hd;
int i;
int j;
unsigned int last_extent;
struct codeview_linetab_hdr * linetab;
unsigned int nblocks;
unsigned int npair;
unsigned int offset;
struct codeview_pdb_hdr * pdbhdr;
unsigned int * pnt;
struct stat statbuf;
int status;
unsigned short * table;
char * toc;
unsigned int toc_blocks;
LocateDebugInfoFile(full_filename, filename);
status = stat(filename, &statbuf);
if( status == -1 )
{
fprintf(stderr, "-Unable to open .PDB file %s\n", filename);
goto leave;
}
/*
* Now open the file, so that we can mmap() it.
*/
fd = open(filename, O_RDONLY);
if( fd == -1 )
{
fprintf(stderr, "-Unable to open .DBG file %s\n", filename);
goto leave;
}
/*
* Now mmap() the file.
*/
addr = mmap(0, statbuf.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
if( addr == (char *) 0xffffffff )
{
fprintf(stderr, "-Unable to mmap .DBG file %s\n", filename);
goto leave;
}
/*
* Now that we have the formalities over and done with, we need
* to find the table of contents for the PDB file.
*/
pdbhdr = (struct codeview_pdb_hdr *) addr;
blocksize = pdbhdr->blocksize;
last_extent = (statbuf.st_size + blocksize - 1) / blocksize;
/*
* The TOC itself isn't always contiguous, so we need to extract a few
* extents from the file to form the TOC.
*/
toc_blocks = (pdbhdr->toc_len + blocksize - 1) / blocksize;
toc = (char *) DBG_alloc(toc_blocks * blocksize);
table = pdbhdr->toc_ext;
for(i=0; i < toc_blocks; i++)
{
memcpy(toc + blocksize*i, addr + table[i]*blocksize, blocksize);
}
/*
* Next build our own table which will have the size and extent block
* list for each record in the PDB file.
*
* The TOC starts out with the number of files. Then it is followed by
* (npair * 2*sizeof(int)) bytes of information, which are pairs of ints.
* The first one is the size of the record (in bytes), and the second one
* is something else which I haven't figured out yet.
*/
pnt = (unsigned int *) toc;
npair = *pnt++;
extent_table = (unsigned short *) ((unsigned int) toc +
npair * 2 * sizeof(int) + sizeof(int));
/*
* Sanity check.
*/
if( sizeof(int) + 2*sizeof(int)*npair > pdbhdr->toc_len )
{
goto leave;
}
filelist = (struct file_list *) DBG_alloc(npair * sizeof(*filelist));
if( filelist == NULL )
{
goto leave;
}
memset(filelist, 0, npair * sizeof(*filelist));
nblocks = 0;
for(i=0; i < npair; i++)
{
filelist[i].record_len = pnt[i*2];
filelist[i].nextents = (filelist[i].record_len + blocksize - 1)
/ blocksize;
filelist[i].extent_list = extent_table + nblocks;
nblocks += filelist[i].nextents;
/*
* These get filled in later when we parse one of the records.
*/
filelist[i].linetab_offset = 0;
filelist[i].linetab_len = 0;
}
/*
* OK, now walk through the various records and pick out the bits we
* really want to see. Some of the records are extra special, and
* we need to handle these a little bit differently.
*/
for(i=0; i < npair; i++)
{
if( filelist[i].record_len == 0xffffffff )
{
continue;
}
/*
* Make sure our buffer is large enough to hold the record.
*/
if( bufflen < filelist[i].nextents * blocksize )
{
bufflen = filelist[i].nextents * blocksize;
buffer = (char *) DBG_realloc(buffer, bufflen);
}
/*
* Do this just for completeness. It makes debugging easier
* if we have a clean indication of where the record ends.
*/
memset(buffer, 0, filelist[i].nextents * blocksize);
/*
* Next, build the record using the extent list.
*/
for(j=0; j < filelist[i].nextents; j++)
{
memcpy(buffer + j * blocksize,
addr + filelist[i].extent_list[j] * blocksize,
blocksize);
}
pnt = (unsigned int *) buffer;
/*
* OK, now figure out what to do with it.
*/
/*
* Always ignore the first entry. It seems to contain a backup copy
* of the TOC (the last time the file was modified??)
*/
if( i == 0 )
{
continue;
}
/*
* The second entry as a id block. It contains a magic number
* to identify the compiler, plus it also contains the timestamp
* which must match the timestamp in the executable.
*/
if( i == 1 )
{
if( ((*pnt != 19950623) && (*pnt != 19950814))
|| (filelist[i].record_len != 0x24)
|| (pnt[1] != ((struct CodeViewDebug *)(deefer->dbg_info))->cv_timestamp) )
{
goto leave;
}
}
/*
* The third entry contains pointers to the global symbol table,
* plus it also contains additional information about each record
* in the PDB file.
*/
if( i == 3 )
{
hd = (struct filetab_hdr *) buffer;
gsym_record = hd->gsym_file;
gsymtab = (char *) DBG_alloc(filelist[gsym_record].nextents
* blocksize);
memset(gsymtab, 0, filelist[gsym_record].nextents * blocksize);
for(j=0; j < filelist[gsym_record].nextents; j++)
{
memcpy(gsymtab + j * blocksize,
addr + filelist[gsym_record].extent_list[j] * blocksize,
blocksize);
}
/*
* This record also contains information about where in the
* remaining records we will be able to find the start of the
* line number table. We could locate that bit using heuristics,
* but since we have the info handy, we might as well use it.
*/
offset = sizeof(*hd);
while(1==1)
{
fent = (struct file_ent *) (buffer + offset);
if( offset > hd->ftab_len )
{
break;
}
if( fent->file_number == 0 || fent->file_number >= npair )
{
break;
}
filelist[fent->file_number].linetab_offset =
fent->linetab_offset;
filelist[fent->file_number].linetab_len =
fent->linetab_len;
/*
* Figure out the offset of the next entry.
* There is a fixed part of the record and a variable
* length filename which we must also skip past.
*/
offset += ((unsigned int) &fent->filename - (unsigned int) fent)
+ strlen(fent->filename) + 1;
offset += strlen(buffer+offset) + 1;
offset = (offset + 3) & ~3;
}
}
/*
* Two different magic numbers used as dates.
* These indicate the 'type' table.
*/
if( *pnt == 19950410
|| *pnt == 19951122 )
{
DEBUG_ParseTypeTable(buffer, filelist[i].record_len);
continue;
}
/*
* This is something we really want to look at, since it contains
* real debug info. Anything that doesn't match this can be
* ignored for now.
*/
if( *pnt == 1 )
{
/*
* First, snag the line table, if we have one. This always
* occurs at the end of the record, so we take the linetab
* offset as the end of the normal part of the record.
*/
linetab = NULL;
if( filelist[i].linetab_len != 0 )
{
linetab = DEBUG_SnarfLinetab(buffer + filelist[i].linetab_offset,
filelist[i].linetab_len);
DEBUG_SnarfCodeView(deefer, buffer,
filelist[i].linetab_offset,
linetab);
}
else
{
DEBUG_SnarfCodeView(deefer, buffer,
filelist[i].record_len,
linetab);
}
continue;
}
}
/*
* Finally, process the global symbol table itself. There isn't
* a line number component to this, so we just toss everything
* into the mix and it all should work out.
*/
if( gsym_record != 0 )
{
DEBUG_SnarfCodeView(deefer, gsymtab - sizeof(int),
filelist[gsym_record].record_len,
NULL);
}
leave:
if( gsymtab != NULL )
{
DBG_free(gsymtab);
gsymtab = NULL;
}
if( buffer != NULL )
{
DBG_free(buffer);
}
if( filelist != NULL )
{
DBG_free(filelist);
}
if( addr != (char *) 0xffffffff )
{
munmap(addr, statbuf.st_size);
}
if( fd != -1 )
{
close(fd);
}
return TRUE;
}
/*
* Process DBG file which contains debug information.
*/
/* static */
int
DEBUG_ProcessDBGFile(struct deferred_debug_info * deefer, char * filename)
{
char * addr = (char *) 0xffffffff;
char * codeview;
struct CV4_DirHead * codeview_dir;
struct CV4_DirEnt * codeview_dent;
PIMAGE_DEBUG_DIRECTORY dbghdr;
struct deferred_debug_info deefer2;
int fd = -1;
int i;
int j;
struct codeview_linetab_hdr * linetab;
int nsect;
PIMAGE_SEPARATE_DEBUG_HEADER pdbg = NULL;
IMAGE_SECTION_HEADER * sectp;
struct stat statbuf;
int status;
char dbg_file[MAX_PATHNAME_LEN];
LocateDebugInfoFile(filename, dbg_file);
status = stat(dbg_file, &statbuf);
if( status == -1 )
{
fprintf(stderr, "-Unable to open .DBG file %s\n", dbg_file);
goto leave;
}
/*
* Now open the file, so that we can mmap() it.
*/
fd = open(dbg_file, O_RDONLY);
if( fd == -1 )
{
fprintf(stderr, "Unable to open .DBG file %s\n", dbg_file);
goto leave;
}
/*
* Now mmap() the file.
*/
addr = mmap(0, statbuf.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
if( addr == (char *) 0xffffffff )
{
fprintf(stderr, "Unable to mmap .DBG file %s\n", dbg_file);
goto leave;
}
pdbg = (PIMAGE_SEPARATE_DEBUG_HEADER) addr;
if( pdbg->TimeDateStamp != deefer->dbgdir->TimeDateStamp )
{
fprintf(stderr, "Warning - %s has incorrect internal timestamp\n",
dbg_file);
/* goto leave; */
/*
Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
files but nonetheless this check fails. Anyway, WINDBG (debugger for
Windows by Microsoft) loads debug symbols which have incorrect timestamps.
*/
}
fprintf(stderr, "Processing symbols from %s...\n", dbg_file);
dbghdr = (PIMAGE_DEBUG_DIRECTORY) ( addr + sizeof(*pdbg)
+ pdbg->NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
+ pdbg->ExportedNamesSize);
sectp = (PIMAGE_SECTION_HEADER) ((char *) pdbg + sizeof(*pdbg));
nsect = pdbg->NumberOfSections;
for( i=0; i < pdbg->DebugDirectorySize / sizeof(*pdbg); i++, dbghdr++ )
{
switch(dbghdr->Type)
{
case IMAGE_DEBUG_TYPE_COFF:
/*
* Dummy up a deferred debug header to handle the
* COFF stuff embedded within the DBG file.
*/
memset((char *) &deefer2, 0, sizeof(deefer2));
deefer2.dbg_info = (addr + dbghdr->PointerToRawData);
deefer2.dbg_size = dbghdr->SizeOfData;
deefer2.load_addr = deefer->load_addr;
DEBUG_ProcessCoff(&deefer2);
break;
case IMAGE_DEBUG_TYPE_CODEVIEW:
/*
* This is the older format by which codeview stuff is
* stored, known as the 'NB09' format. Newer executables
* and dlls created by VC++ use PDB files instead, which
* have lots of internal similarities, but the overall
* format and structure is quite different.
*/
codeview = (addr + dbghdr->PointerToRawData);
/*
* The first thing in the codeview section should be
* an 'NB09' identifier. As a sanity check, make sure
* it is there.
*/
if( *((unsigned int*) codeview) != 0x3930424e )
{
break;
}
/*
* Next we need to find the directory. This is easy too.
*/
codeview_dir = (struct CV4_DirHead *)
(codeview + ((unsigned int*) codeview)[1]);
/*
* Some more sanity checks. Make sure that everything
* is as we expect it.
*/
if( codeview_dir->next_offset != 0
|| codeview_dir->dhsize != sizeof(*codeview_dir)
|| codeview_dir->desize != sizeof(*codeview_dent) )
{
break;
}
codeview_dent = (struct CV4_DirEnt *) (codeview_dir + 1);
for(j=0; j < codeview_dir->ndir; j++, codeview_dent++)
{
if( codeview_dent->subsect_number == sstAlignSym )
{
/*
* Check the previous entry. If it is a
* sstSrcModule, it contains the line number
* info for this file.
*/
linetab = NULL;
if( codeview_dent[1].module_number == codeview_dent[0].module_number
&& codeview_dent[1].subsect_number == sstSrcModule )
{
linetab = DEBUG_SnarfLinetab(
codeview + codeview_dent[1].offset,
codeview_dent[1].size);
}
if( codeview_dent[-1].module_number == codeview_dent[0].module_number
&& codeview_dent[-1].subsect_number == sstSrcModule )
{
linetab = DEBUG_SnarfLinetab(
codeview + codeview_dent[-1].offset,
codeview_dent[-1].size);
}
/*
* Now process the CV stuff.
*/
DEBUG_SnarfCodeView(deefer,
codeview + codeview_dent->offset,
codeview_dent->size,
linetab);
}
}
break;
default:
break;
}
}
leave:
if( addr != (char *) 0xffffffff )
{
munmap(addr, statbuf.st_size);
}
if( fd != -1 )
{
close(fd);
}
return TRUE;
}
int
DEBUG_ProcessDeferredDebug()
{
struct deferred_debug_info * deefer;
struct CodeViewDebug * cvd;
struct MiscDebug * misc;
char * filename;
int last_proc = -1;
int need_print =0;
int sts;
for(deefer = dbglist; deefer; deefer = deefer->next)
{
if( deefer->status != DF_STATUS_NEW )
{
continue;
}
if( last_proc != deefer->dbg_index )
{
if (!need_print)
{
fprintf(stderr, "DeferredDebug for:");
need_print=1;
}
fprintf(stderr, " %s",deefer->module_name);
last_proc = deefer->dbg_index;
}
switch(deefer->dbgdir->Type)
{
case IMAGE_DEBUG_TYPE_COFF:
/*
* Standard COFF debug information that VC++ adds when you
* use /debugtype:both with the linker.
*/
#if 0
fprintf(stderr, "Processing COFF symbols...\n");
#endif
sts = DEBUG_ProcessCoff(deefer);
break;
case IMAGE_DEBUG_TYPE_CODEVIEW:
/*
* This is a pointer to a PDB file of some sort.
*/
cvd = (struct CodeViewDebug *) deefer->dbg_info;
if( strcmp(cvd->cv_nbtype, "NB10") != 0 )
{
/*
* Whatever this is, we don't know how to deal with
* it yet.
*/
sts = FALSE;
break;
}
sts = DEBUG_ProcessPDBFile(deefer, cvd->cv_name);
#if 0
fprintf(stderr, "Processing PDB file %s\n", cvd->cv_name);
#endif
break;
case IMAGE_DEBUG_TYPE_MISC:
/*
* A pointer to a .DBG file of some sort. These files
* can contain either CV4 or COFF information. Open
* the file, and try to do the right thing with it.
*/
misc = (struct MiscDebug *) deefer->dbg_info;
filename = strrchr((char *) &misc->Data, '.');
/*
* Ignore the file if it doesn't have a .DBG extension.
*/
if( (filename == NULL)
|| ( (strcmp(filename, ".dbg") != 0)
&& (strcmp(filename, ".DBG") != 0)) )
{
sts = FALSE;
break;
}
filename = (char *) &misc->Data;
/*
* Do the dirty deed...
*/
sts = DEBUG_ProcessDBGFile(deefer, filename);
break;
default:
/*
* We should never get here...
*/
sts = FALSE;
break;
}
deefer->status = (sts) ? DF_STATUS_LOADED : DF_STATUS_ERROR;
}
if(need_print)
fprintf(stderr, "\n");
return TRUE;
}
/***********************************************************************
* DEBUG_InfoShare
*
* Display shared libarary information.
*/
void DEBUG_InfoShare(void)
{
struct deferred_debug_info * deefer;
fprintf(stderr,"Address\t\tModule\tName\n");
for(deefer = dbglist; deefer; deefer = deefer->next)
{
fprintf(stderr,"0x%8.8x\t(%s)\t%s\n", (unsigned int) deefer->load_addr,
deefer->module ? "Win32" : "ELF", deefer->module_name);
}
}
Reference in New Issue View Git Blame Copy Permalink