void prepareTestCase6(procType proc_type, BPatch_thread *thread, forkWhen when)
{
const int TN = 6;
if(proc_type == Parent_p && when == PostFork) {
BPatch_image *parImage = thread->getImage();
BPatch_variableExpr *var7_6p =
parImage->findVariable("globalVariable7_6");
if(doError(TN, (var7_6p==NULL),
" Unable to locate variable globalVariable7_6\n")) return;
BPatch_arithExpr a_expr7_6p(BPatch_plus, *var7_6p, BPatch_constExpr(5));
BPatch_arithExpr b_expr7_6p(BPatch_assign, *var7_6p, a_expr7_6p);
thread->oneTimeCode(b_expr7_6p);
} else if(proc_type == Child_p && when == PostFork) {
BPatch_image *childImage = thread->getImage();
BPatch_variableExpr *var7_6c =
childImage->findVariable("globalVariable7_6");
if(doError(TN, (var7_6c==NULL),
" Unable to locate variable globalVariable7_6\n")) return;
BPatch_arithExpr a_expr7_6c(BPatch_plus, *var7_6c, BPatch_constExpr(9));
BPatch_arithExpr b_expr7_6c(BPatch_assign, *var7_6c, a_expr7_6c);
thread->oneTimeCode(b_expr7_6c);
}
}
/*
* Given a string variable name and an expected value, lookup the varaible
* in the process, and verify that the value matches.
*
*/
bool verifyProcMemory(BPatch_thread *appThread, const char *name,
int expectedVal, procType proc_type)
{
BPatch_image *appImage = appThread->getImage();
if (!appImage) {
dprintf("unable to locate image for %d\n", appThread->getPid());
return false;
}
BPatch_variableExpr *var = appImage->findVariable(name);
if (!var) {
dprintf("unable to located variable %s in child\n", name);
return false;
}
int actualVal;
var->readValue(&actualVal);
if (expectedVal != actualVal) {
fprintf(stderr,"*** for %s (%s), expected val = %d, but actual was %d\n",
name, procName[proc_type], expectedVal, actualVal);
return false;
} else {
dprintf("verified %s (%s) was = %d\n", name, procName[proc_type],
actualVal);
return true;
}
}
void prepareTestCase1(procType proc_type, BPatch_thread *thread, forkWhen when)
{
static BPatchSnippetHandle *parSnippetHandle1;
if(proc_type == Parent_p && when == PreFork) {
BPatch_image *parImage = thread->getImage();
BPatch_Vector<BPatch_function *> found_funcs;
const char *inFunction = "func7_1";
if ((NULL == parImage->findFunction(inFunction, found_funcs, 1)) || !found_funcs.size()) {
fprintf(stderr, " Unable to find function %s\n",
inFunction);
exit(1);
}
if (1 < found_funcs.size()) {
fprintf(stderr, "%s[%d]: WARNING : found %d functions named %s. Using the first.\n",
__FILE__, __LINE__, found_funcs.size(), inFunction);
}
BPatch_Vector<BPatch_point *> *point7_1p = found_funcs[0]->findPoint(BPatch_entry);
if(doError(1, !point7_1p || ((*point7_1p).size() == 0),
" Unable to find entry point to \"func7_1\".\n")) return;
BPatch_variableExpr *var7_1p =
parImage->findVariable("globalVariable7_1");
if(doError(1, (var7_1p==NULL),
" Unable to locate variable globalVariable7_1\n")) return;
BPatch_arithExpr expr7_1p(BPatch_assign, *var7_1p,BPatch_constExpr(321));
parSnippetHandle1 =
thread->insertSnippet(expr7_1p, *point7_1p, BPatch_callBefore);
if(doError(1, (parSnippetHandle1 == NULL),
" Unable to insert snippet into parent for test 1\n")) return;
} else if(proc_type == Parent_p && when == PostFork) {
thread->deleteSnippet(parSnippetHandle1);
}
}
void prepareTestCase4(procType proc_type, BPatch_thread *thread, forkWhen when)
{
const int TN = 4;
static BPatchSnippetHandle *parSnippetHandle4;
if(proc_type == Child_p && when == PostFork) {
BPatch_image *childImage = thread->getImage();
BPatch_Vector<BPatch_function *> found_funcs;
const char *inFunction = "func7_4";
if ((NULL == childImage->findFunction(inFunction, found_funcs, 1)) || !found_funcs.size()) {
fprintf(stderr, " Unable to find function %s\n",
inFunction);
exit(1);
}
if (1 < found_funcs.size()) {
fprintf(stderr, "%s[%d]: WARNING : found %d functions named %s. Using the first.\n",
__FILE__, __LINE__, found_funcs.size(), inFunction);
}
BPatch_Vector<BPatch_point *> *points7_4c = found_funcs[0]->findPoint(BPatch_entry);
if(doError(TN, !points7_4c || ((*points7_4c).size() == 0),
" Unable to find entry point to \"func7_4\".\n")) return;
BPatch_point *point7_4c = (*points7_4c)[0];
BPatch_variableExpr *var7_4c =
childImage->findVariable("globalVariable7_4");
if(doError(TN, (var7_4c==NULL),
" Unable to locate variable globalVariable7_4\n")) return;
BPatch_arithExpr a_expr7_4c(BPatch_plus, *var7_4c,BPatch_constExpr(211));
BPatch_arithExpr b_expr7_4c(BPatch_assign, *var7_4c, a_expr7_4c);
parSnippetHandle4 =
thread->insertSnippet(b_expr7_4c, *point7_4c, BPatch_callBefore);
}
}
void prepareTestCase3(procType proc_type, BPatch_thread *thread, forkWhen when)
{
static BPatchSnippetHandle *parSnippetHandle3;
if(proc_type == Parent_p && when == PreFork) {
BPatch_image *parImage = thread->getImage();
BPatch_Vector<BPatch_function *> found_funcs;
const char *inFunction = "func7_3";
if ((NULL == parImage->findFunction(inFunction, found_funcs, 1)) || !found_funcs.size()) {
fprintf(stderr, " Unable to find function %s\n",
inFunction);
exit(1);
}
if (1 < found_funcs.size()) {
fprintf(stderr, "%s[%d]: WARNING : found %d functions named %s. Using the first.\n",
__FILE__, __LINE__, found_funcs.size(), inFunction);
}
BPatch_Vector<BPatch_point *> *points7_3p = found_funcs[0]->findPoint(BPatch_entry);
if(doError(3, !points7_3p || ((*points7_3p).size() == 0),
" Unable to find entry point to \"func7_3\".\n")) return;
BPatch_point *point7_3p = (*points7_3p)[0];
BPatch_variableExpr *var7_3p =
parImage->findVariable("globalVariable7_3");
if(doError(3, (var7_3p==NULL),
" Unable to locate variable globalVariable7_3\n")) return;
BPatch_arithExpr expr7_3p(BPatch_assign, *var7_3p,BPatch_constExpr(642));
parSnippetHandle3 =
thread->insertSnippet(expr7_3p, *point7_3p, BPatch_callBefore);
} else if(proc_type == Parent_p && when == PostFork) {
bool result = thread->deleteSnippet(parSnippetHandle3);
if(result == false) {
fprintf(stderr, " error, couldn't delete snippet\n");
passedTest[3] = false;
return;
}
} else if(proc_type == Child_p && when == PostFork) {
BPatch_image *childImage = thread->getImage();
BPatch_Vector<BPatch_function *> found_funcs;
const char *inFunction = "func7_3";
if ((NULL == childImage->findFunction(inFunction, found_funcs, 1)) || !found_funcs.size()) {
fprintf(stderr, " Unable to find function %s\n",
inFunction);
exit(1);
}
if (1 < found_funcs.size()) {
fprintf(stderr, "%s[%d]: WARNING : found %d functions named %s. Using the first.\n",
__FILE__, __LINE__, found_funcs.size(), inFunction);
}
BPatch_Vector<BPatch_point *> *points7_3c = found_funcs[0]->findPoint(BPatch_entry);
if(doError(3, !points7_3c || ((*points7_3c).size() == 0),
" Unable to find entry point to \"func7_3\".\n")) return;
BPatch_point *point7_3c = (*points7_3c)[0];
BPatch_Vector<BPatchSnippetHandle *> childSnippets =
point7_3c->getCurrentSnippets();
if(doError(3, (childSnippets.size()==0),
" No snippets were found at func7_3\n")) return;
for(unsigned i=0; i<childSnippets.size(); i++) {
bool result = thread->deleteSnippet(childSnippets[i]);
if(result == false) {
fprintf(stderr, " error, couldn't delete snippet\n");
passedTest[3] = false;
return;
}
}
}
}
// parseStabTypes: parses type and variable info, does some init
// does NOT parse file-line info anymore, this is done later, upon request.
void BPatch_module::parseStabTypes()
{
stab_entry *stabptr;
const char *next_stabstr;
unsigned i;
char *modName;
pdstring temp;
image * imgPtr=NULL;
char *ptr, *ptr2, *ptr3;
bool parseActive = false;
pdstring* currentFunctionName = NULL;
Address currentFunctionBase = 0;
BPatch_variableExpr *commonBlockVar = NULL;
char *commonBlockName;
BPatch_typeCommon *commonBlock = NULL;
int mostRecentLinenum = 0;
#if defined(TIMED_PARSE)
struct timeval starttime;
gettimeofday(&starttime, NULL);
unsigned int pss_count = 0;
double pss_dur = 0;
unsigned int src_count = 0;
double src_dur = 0;
unsigned int fun_count = 0;
double fun_dur = 0;
struct timeval t1, t2;
#endif
imgPtr = mod->obj()->parse_img();
imgPtr->analyzeIfNeeded();
const Object &objPtr = imgPtr->getObject();
//Using the Object to get the pointers to the .stab and .stabstr
// XXX - Elf32 specific needs to be in seperate file -- jkh 3/18/99
stabptr = objPtr.get_stab_info();
next_stabstr = stabptr->getStringBase();
for (i=0; i<stabptr->count(); i++) {
switch(stabptr->type(i)){
case N_UNDF: /* start of object file */
/* value contains offset of the next string table for next module */
// assert(stabptr->nameIdx(i) == 1);
stabptr->setStringBase(next_stabstr);
next_stabstr = stabptr->getStringBase() + stabptr->val(i);
//N_UNDF is the start of object file. It is time to
//clean source file name at this moment.
/*
if(currentSourceFile){
delete currentSourceFile;
currentSourceFile = NULL;
delete absoluteDirectory;
absoluteDirectory = NULL;
delete currentFunctionName;
currentFunctionName = NULL;
currentFileInfo = NULL;
currentFuncInfo = NULL;
}
*/
break;
case N_ENDM: /* end of object file */
break;
case N_SO: /* compilation source or file name */
/* bperr("Resetting CURRENT FUNCTION NAME FOR NEXT OBJECT FILE\n");*/
#ifdef TIMED_PARSE
src_count++;
gettimeofday(&t1, NULL);
#endif
current_func_name = ""; // reset for next object file
current_mangled_func_name = ""; // reset for next object file
current_func = NULL;
modName = const_cast<char*>(stabptr->name(i));
// cerr << "checkpoint B" << endl;
ptr = strrchr(modName, '/');
// cerr << "checkpoint C" << endl;
if (ptr) {
ptr++;
modName = ptr;
}
if (!strcmp(modName, mod->fileName().c_str())) {
parseActive = true;
moduleTypes->clearNumberedTypes();
BPatch_language lang;
// language should be set in the constructor, this is probably redundant
switch (stabptr->desc(i)) {
case N_SO_FORTRAN:
lang = BPatch_fortran;
break;
case N_SO_F90:
lang = BPatch_fortran90;
break;
case N_SO_AS:
lang = BPatch_assembly;
break;
case N_SO_ANSI_C:
case N_SO_C:
lang = BPatch_c;
break;
case N_SO_CC:
lang = BPatch_cPlusPlus;
break;
default:
lang = BPatch_unknownLanguage;
break;
}
if (BPatch_f90_demangled_stabstr != getLanguage())
setLanguage(lang);
} else {
parseActive = false;
}
#ifdef TIMED_PARSE
gettimeofday(&t2, NULL);
src_dur += (t2.tv_sec - t1.tv_sec)*1000.0 + (t2.tv_usec - t1.tv_usec)/1000.0;
//src_dur += (t2.tv_sec/1000 + t2.tv_usec*1000) - (t1.tv_sec/1000 + t1.tv_usec*1000) ;
#endif
break;
case N_SLINE:
mostRecentLinenum = stabptr->desc(i);
break;
default:
break;
}
if(parseActive || mod->obj()->isSharedLib()) {
BPatch_Vector<BPatch_function *> bpfv;
switch(stabptr->type(i)){
case N_FUN:
#ifdef TIMED_PARSE
fun_count++;
gettimeofday(&t1, NULL);
#endif
//all we have to do with function stabs at this point is to assure that we have
//properly set the var currentFunctionName for the later case of (parseActive)
current_func = NULL;
int currentEntry = i;
int funlen = strlen(stabptr->name(currentEntry));
ptr = new char[funlen+1];
strcpy(ptr, stabptr->name(currentEntry));
while(strlen(ptr) != 0 && ptr[strlen(ptr)-1] == '\\'){
ptr[strlen(ptr)-1] = '\0';
currentEntry++;
strcat(ptr,stabptr->name(currentEntry));
}
char* colonPtr = NULL;
if(currentFunctionName) delete currentFunctionName;
if(!ptr || !(colonPtr = strchr(ptr,':')))
currentFunctionName = NULL;
else {
char* tmp = new char[colonPtr-ptr+1];
strncpy(tmp,ptr,colonPtr-ptr);
tmp[colonPtr-ptr] = '\0';
currentFunctionName = new pdstring(tmp);
currentFunctionBase = 0;
Symbol info;
// Shouldn't this be a function name lookup?
if (!proc->llproc->getSymbolInfo(*currentFunctionName,
info))
{
pdstring fortranName = *currentFunctionName + pdstring("_");
if (proc->llproc->getSymbolInfo(fortranName,info))
{
delete currentFunctionName;
currentFunctionName = new pdstring(fortranName);
}
}
currentFunctionBase = info.addr();
delete[] tmp;
// if(currentSourceFile && (currentFunctionBase > 0)){
// lineInformation->insertSourceFileName(
// *currentFunctionName,
// *currentSourceFile,
// ¤tFileInfo,¤tFuncInfo);
//}
}
// used to be a symbol lookup here to find currentFunctionBase, do we need it?
delete[] ptr;
#ifdef TIMED_PARSE
gettimeofday(&t2, NULL);
fun_dur += (t2.tv_sec - t1.tv_sec)*1000.0 + (t2.tv_usec - t1.tv_usec)/1000.0;
//fun_dur += (t2.tv_sec/1000 + t2.tv_usec*1000) - (t1.tv_sec/1000 + t1.tv_usec*1000);
#endif
break;
}
if (!parseActive) continue;
switch(stabptr->type(i)){
case N_BCOMM: {
// begin Fortran named common block
commonBlockName = const_cast<char*>(stabptr->name(i));
// find the variable for the common block
BPatch_image *progam = (BPatch_image *) getObjParent();
commonBlockVar = progam->findVariable(commonBlockName);
if (!commonBlockVar) {
bperr("unable to find variable %s\n", commonBlockName);
} else {
commonBlock = dynamic_cast<BPatch_typeCommon *>(const_cast<BPatch_type *> (commonBlockVar->getType()));
if (commonBlock == NULL) {
// its still the null type, create a new one for it
commonBlock = new BPatch_typeCommon(commonBlockName);
commonBlockVar->setType(commonBlock);
moduleTypes->addGlobalVariable(commonBlockName, commonBlock);
}
// reset field list
commonBlock->beginCommonBlock();
}
break;
}
case N_ECOMM: {
// copy this set of fields
assert(currentFunctionName);
if (NULL == findFunction(currentFunctionName->c_str(), bpfv) || !bpfv.size()) {
bperr("unable to locate current function %s\n", currentFunctionName->c_str());
} else {
if (bpfv.size() > 1) {
// warn if we find more than one function with this name
bperr("%s[%d]: WARNING: found %d funcs matching name %s, using the first\n",
__FILE__, __LINE__, bpfv.size(), currentFunctionName->c_str());
}
BPatch_function *func = bpfv[0];
commonBlock->endCommonBlock(func, commonBlockVar->getBaseAddr());
}
// update size if needed
if (commonBlockVar)
commonBlockVar->setSize(commonBlock->getSize());
commonBlockVar = NULL;
commonBlock = NULL;
break;
}
// case C_BINCL: -- what is the elf version of this jkh 8/21/01
// case C_EINCL: -- what is the elf version of this jkh 8/21/01
case 32: // Global symbols -- N_GYSM
case 38: // Global Static -- N_STSYM
case N_FUN:
case 128: // typedefs and variables -- N_LSYM
case 160: // parameter variable -- N_PSYM
case 0xc6: // position-independant local typedefs -- N_ISYM
case 0xc8: // position-independant external typedefs -- N_ESYM
#ifdef TIMED_PARSE
pss_count++;
gettimeofday(&t1, NULL);
#endif
if (stabptr->type(i) == N_FUN) current_func = NULL;
ptr = const_cast<char *>(stabptr->name(i));
while (ptr[strlen(ptr)-1] == '\\') {
//ptr[strlen(ptr)-1] = '\0';
ptr2 = const_cast<char *>(stabptr->name(i+1));
ptr3 = (char *) malloc(strlen(ptr) + strlen(ptr2));
strcpy(ptr3, ptr);
ptr3[strlen(ptr)-1] = '\0';
strcat(ptr3, ptr2);
ptr = ptr3;
i++;
// XXX - memory leak on multiple cont. lines
}
// bperr("stab #%d = %s\n", i, ptr);
// may be nothing to parse - XXX jdd 5/13/99
if (nativeCompiler)
temp = parseStabString(this, mostRecentLinenum, (char *)ptr, stabptr->val(i), commonBlock);
else
temp = parseStabString(this, stabptr->desc(i), (char *)ptr, stabptr->val(i), commonBlock);
if (temp.length()) {
//Error parsing the stabstr, return should be \0
bperr( "Stab string parsing ERROR!! More to parse: %s\n",
temp.c_str());
bperr( " symbol: %s\n", ptr);
}
#ifdef TIMED_PARSE
gettimeofday(&t2, NULL);
pss_dur += (t2.tv_sec - t1.tv_sec)*1000.0 + (t2.tv_usec - t1.tv_usec)/1000.0;
// pss_dur += (t2.tv_sec/1000 + t2.tv_usec*1000) - (t1.tv_sec/1000 + t1.tv_usec*1000);
#endif
break;
default:
break;
}
}
}
#if defined(TIMED_PARSE)
struct timeval endtime;
gettimeofday(&endtime, NULL);
unsigned long lstarttime = starttime.tv_sec * 1000 * 1000 + starttime.tv_usec;
unsigned long lendtime = endtime.tv_sec * 1000 * 1000 + endtime.tv_usec;
unsigned long difftime = lendtime - lstarttime;
double dursecs = difftime/(1000 );
cout << __FILE__ << ":" << __LINE__ <<": parseTypes("<< mod->fileName()
<<") took "<<dursecs <<" msecs" << endl;
cout << "Breakdown:" << endl;
cout << " Functions: " << fun_count << " took " << fun_dur << "msec" << endl;
cout << " Sources: " << src_count << " took " << src_dur << "msec" << endl;
cout << " parseStabString: " << pss_count << " took " << pss_dur << "msec" << endl;
cout << " Total: " << pss_dur + fun_dur + src_dur
<< " msec" << endl;
#endif
}
// Gets the stab and stabstring section and parses it for types
// and variables
void BPatch_module::parseTypes()
{
int i, j;
int nlines;
int nstabs;
char* lines;
SYMENT *syms;
SYMENT *tsym;
char *stringPool;
char tempName[9];
char *stabstr=NULL;
union auxent *aux;
image * imgPtr=NULL;
pdstring funcName;
Address staticBlockBaseAddr = 0;
unsigned long linesfdptr;
BPatch_typeCommon *commonBlock = NULL;
BPatch_variableExpr *commonBlockVar = NULL;
pdstring currentSourceFile;
bool inCommonBlock = false;
#if defined(TIMED_PARSE)
struct timeval starttime;
gettimeofday(&starttime, NULL);
#endif
imgPtr = mod->obj()->parse_img();
const Object &objPtr = imgPtr->getObject();
//Using the Object to get the pointers to the .stab and .stabstr
objPtr.get_stab_info(stabstr, nstabs, syms, stringPool);
objPtr.get_line_info(nlines,lines,linesfdptr);
bool parseActive = true;
//fprintf(stderr, "%s[%d]: parseTypes for module %s: nstabs = %d\n", FILE__, __LINE__,mod->fileName().c_str(),nstabs);
//int num_active = 0;
for (i=0; i < nstabs; i++) {
/* do the pointer addition by hand since sizeof(struct syment)
* seems to be 20 not 18 as it should be */
SYMENT *sym = (SYMENT *) (((unsigned) syms) + i * SYMESZ);
// SYMENT *sym = (SYMENT *) (((unsigned) syms) + i * sizeof(struct syment));
if (sym->n_sclass == C_FILE) {
char *moduleName;
if (!sym->n_zeroes) {
moduleName = &stringPool[sym->n_offset];
} else {
memset(tempName, 0, 9);
strncpy(tempName, sym->n_name, 8);
moduleName = tempName;
}
/* look in aux records */
for (j=1; j <= sym->n_numaux; j++) {
aux = (union auxent *) ((char *) sym + j * SYMESZ);
if (aux->x_file._x.x_ftype == XFT_FN) {
if (!aux->x_file._x.x_zeroes) {
moduleName = &stringPool[aux->x_file._x.x_offset];
} else {
// x_fname is 14 bytes
memset(moduleName, 0, 15);
strncpy(moduleName, aux->x_file.x_fname, 14);
}
}
}
currentSourceFile = pdstring(moduleName);
currentSourceFile = mod->processDirectories(currentSourceFile);
if (strrchr(moduleName, '/')) {
moduleName = strrchr(moduleName, '/');
moduleName++;
}
if (!strcmp(moduleName, mod->fileName().c_str())) {
parseActive = true;
// Clear out old types
moduleTypes->clearNumberedTypes();
} else {
parseActive = false;
}
}
if (!parseActive) continue;
//num_active++;
char *nmPtr;
if (!sym->n_zeroes && ((sym->n_sclass & DBXMASK) ||
(sym->n_sclass == C_BINCL) ||
(sym->n_sclass == C_EINCL))) {
if (sym->n_offset < 3) {
if (sym->n_offset == 2 && stabstr[0]) {
nmPtr = &stabstr[0];
} else {
nmPtr = &stabstr[sym->n_offset];
}
} else if (!stabstr[sym->n_offset-3]) {
nmPtr = &stabstr[sym->n_offset];
} else {
/* has off by two error */
nmPtr = &stabstr[sym->n_offset-2];
}
#ifdef notdef
bperr("using nmPtr = %s\n", nmPtr);
bperr("got n_offset = (%d) %s\n", sym->n_offset, &stabstr[sym->n_offset]);
if (sym->n_offset>=2)
bperr("got n_offset-2 = %s\n", &stabstr[sym->n_offset-2]);
if (sym->n_offset>=3)
bperr("got n_offset-3 = %x\n", stabstr[sym->n_offset-3]);
if (sym->n_offset>=4)
bperr("got n_offset-4 = %x\n", stabstr[sym->n_offset-4]);
#endif
} else {
// names 8 or less chars on inline, not in stabstr
memset(tempName, 0, 9);
strncpy(tempName, sym->n_name, 8);
nmPtr = tempName;
}
if ((sym->n_sclass == C_BINCL) ||
(sym->n_sclass == C_EINCL) ||
(sym->n_sclass == C_FUN)) {
funcName = nmPtr;
/* The call to parseLineInformation(), below, used to modify the symbols passed to it. */
if (funcName.find(":") < funcName.length())
funcName = funcName.substr(0,funcName.find(":"));
// I'm not sure why we bother with this here, since we fetch line numbers in symtab.C anyway.
// mod->parseLineInformation(proc->llproc, currentSourceFile,
// funcName, sym,
// linesfdptr, lines, nlines);
}
if (sym->n_sclass & DBXMASK) {
if (sym->n_sclass == C_BCOMM) {
char *commonBlockName;
inCommonBlock = true;
commonBlockName = nmPtr;
// find the variable for the common block
BPatch_image *progam = (BPatch_image *) getObjParent();
commonBlockVar = progam->findVariable(commonBlockName);
if (!commonBlockVar) {
bperr("unable to find variable %s\n", commonBlockName);
} else {
commonBlock =
dynamic_cast<BPatch_typeCommon *>(const_cast<BPatch_type *> (commonBlockVar->getType()));
if (commonBlock == NULL) {
// its still the null type, create a new one for it
commonBlock = new BPatch_typeCommon(commonBlockName);
commonBlockVar->setType(commonBlock);
moduleTypes->addGlobalVariable(commonBlockName, commonBlock);
}
// reset field list
commonBlock->beginCommonBlock();
}
} else if (sym->n_sclass == C_ECOMM) {
inCommonBlock = false;
if (commonBlock == NULL)
continue;
// copy this set of fields
BPatch_Vector<BPatch_function *> bpmv;
if (NULL == findFunction(funcName.c_str(), bpmv) || !bpmv.size()) {
bperr("unable to locate current function %s\n", funcName.c_str());
} else {
BPatch_function *func = bpmv[0];
commonBlock->endCommonBlock(func, commonBlockVar->getBaseAddr());
}
// update size if needed
if (commonBlockVar)
commonBlockVar->setSize(commonBlock->getSize());
commonBlockVar = NULL;
commonBlock = NULL;
} else if (sym->n_sclass == C_BSTAT) {
// begin static block
// find the variable for the common block
tsym = (SYMENT *) (((unsigned) syms) + sym->n_value * SYMESZ);
// We can't lookup the value by name, because the name might have been
// redefined later on (our lookup would then pick the last one)
// Since this whole function is AIX only, we're ok to get this info
staticBlockBaseAddr = tsym->n_value;
/*
char *staticName, tempName[9];
if (!tsym->n_zeroes) {
staticName = &stringPool[tsym->n_offset];
} else {
memset(tempName, 0, 9);
strncpy(tempName, tsym->n_name, 8);
staticName = tempName;
}
BPatch_image *progam = (BPatch_image *) getObjParent();
BPatch_variableExpr *staticBlockVar = progam->findVariable(staticName);
if (!staticBlockVar) {
bperr("unable to find static block %s\n", staticName);
staticBlockBaseAddr = 0;
} else {
staticBlockBaseAddr = (Address) staticBlockVar->getBaseAddr();
}
*/
} else if (sym->n_sclass == C_ESTAT) {
staticBlockBaseAddr = 0;
}
// There's a possibility that we were parsing a common block that
// was never instantiated (meaning there's type info, but no
// variable info
if (inCommonBlock && commonBlock == NULL)
continue;
if (staticBlockBaseAddr && (sym->n_sclass == C_STSYM)) {
parseStabString(this, 0, nmPtr,
sym->n_value+staticBlockBaseAddr, commonBlock);
} else {
parseStabString(this, 0, nmPtr, sym->n_value, commonBlock);
}
}
}
#if defined(TIMED_PARSE)
struct timeval endtime;
gettimeofday(&endtime, NULL);
unsigned long lstarttime = starttime.tv_sec * 1000 * 1000 + starttime.tv_usec;
unsigned long lendtime = endtime.tv_sec * 1000 * 1000 + endtime.tv_usec;
unsigned long difftime = lendtime - lstarttime;
double dursecs = difftime/(1000 );
cout << __FILE__ << ":" << __LINE__ <<": parseTypes("<< mod->fileName()
<<") took "<<dursecs <<" msecs" << endl;
#endif
// fprintf(stderr, "%s[%d]: parseTypes for %s, num_active = %d\n", FILE__, __LINE__, mod->fileName().c_str(), num_active);
}
static void prepareTestCase5(procType proc_type, BPatch_thread *thread, forkWhen when)
{
static BPatchSnippetHandle *parSnippetHandle5;
logerror("prepareTestCase5, %d, %p, %d\n",
proc_type, thread, when);
if(proc_type == Parent_p && when == PreFork) {
BPatch_image *parImage = thread->getProcess()->getImage();
BPatch_Vector<BPatch_function *> found_funcs;
const char *inFunction = "test_fork_9_func1";
if ((NULL == parImage->findFunction(inFunction, found_funcs, 1)) || !found_funcs.size()) {
logerror(" Unable to find function %s\n",
inFunction);
exit(1);
}
if (1 < found_funcs.size()) {
logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n",
__FILE__, __LINE__, found_funcs.size(), inFunction);
}
BPatch_Vector<BPatch_point *> *points7_5p = found_funcs[0]->findPoint(BPatch_entry);
if(doError(&passedTest, !points7_5p || ((*points7_5p).size() == 0),
" Unable to find entry point to \"test_fork_9_func1\".\n")) return;
BPatch_point *point7_5p = (*points7_5p)[0];
BPatch_variableExpr *var7_5p =
parImage->findVariable("test_fork_9_global1");
if(doError(&passedTest, (var7_5p==NULL),
" Unable to locate variable test_fork_9_global1\n")) return;
BPatch_arithExpr expr7_5p(BPatch_plus, *var7_5p, BPatch_constExpr(9));
BPatch_arithExpr b_expr7_5p(BPatch_assign, *var7_5p, expr7_5p);
parSnippetHandle5 =
thread->getProcess()->insertSnippet(b_expr7_5p, *point7_5p, BPatch_callBefore);
} else if(proc_type == Parent_p && when == PostFork) {
BPatch_image *parImage = thread->getProcess()->getImage();
BPatch_Vector<BPatch_function *> found_funcs;
const char *inFunction = "test_fork_9_func1";
if ((NULL == parImage->findFunction(inFunction, found_funcs, 1)) || !found_funcs.size()) {
logerror(" Unable to find function %s\n",
inFunction);
exit(1);
}
if (1 < found_funcs.size()) {
logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n",
__FILE__, __LINE__, found_funcs.size(), inFunction);
}
BPatch_Vector<BPatch_point *> *points7_5p = found_funcs[0]->findPoint(BPatch_entry);
if(doError(&passedTest, !points7_5p || ((*points7_5p).size() == 0),
" Unable to find entry point to \"test_fork_9_func1\".\n")) return;
BPatch_point *point7_5p = (*points7_5p)[0];
BPatch_variableExpr *var7_5p =
parImage->findVariable("test_fork_9_global1");
if(doError(&passedTest, (var7_5p==NULL),
" Unable to locate variable test_fork_9_global1\n")) return;
BPatch_arithExpr a_expr7_5p(BPatch_plus, *var7_5p, BPatch_constExpr(11));
BPatch_arithExpr b_expr7_5p(BPatch_assign, *var7_5p, a_expr7_5p);
parSnippetHandle5 =
thread->getProcess()->insertSnippet(b_expr7_5p, *point7_5p, BPatch_callBefore,
BPatch_lastSnippet);
BPatch_arithExpr c_expr7_5p(BPatch_plus, *var7_5p, BPatch_constExpr(13));
BPatch_arithExpr d_expr7_5p(BPatch_assign, *var7_5p, c_expr7_5p);
parSnippetHandle5 =
thread->getProcess()->insertSnippet(d_expr7_5p, *point7_5p, BPatch_callBefore);
} else if(proc_type == Child_p && when == PostFork) {
BPatch_image *childImage = thread->getProcess()->getImage();
BPatch_Vector<BPatch_function *> found_funcs;
const char *inFunction = "test_fork_9_func1";
if ((NULL == childImage->findFunction(inFunction, found_funcs, 1)) || !found_funcs.size()) {
logerror(" Unable to find function %s\n",
inFunction);
exit(1);
}
if (1 < found_funcs.size()) {
logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n",
__FILE__, __LINE__, found_funcs.size(), inFunction);
}
BPatch_Vector<BPatch_point *> *points7_5c = found_funcs[0]->findPoint(BPatch_entry);
if(doError(&passedTest, !points7_5c || ((*points7_5c).size() == 0),
" Unable to find entry point to \"test_fork_9_func1\".\n")) return;
BPatch_point *point7_5c = (*points7_5c)[0];
BPatch_variableExpr *var7_5c =
childImage->findVariable("test_fork_9_global1");
if(doError(&passedTest, (var7_5c==NULL),
" Unable to locate variable test_fork_9_global1\n")) return;
BPatch_arithExpr a_expr7_5c(BPatch_plus, *var7_5c, BPatch_constExpr(5));
BPatch_arithExpr b_expr7_5c(BPatch_assign, *var7_5c, a_expr7_5c);
parSnippetHandle5 =
thread->getProcess()->insertSnippet(b_expr7_5c, *point7_5c, BPatch_callBefore,
BPatch_lastSnippet);
BPatch_arithExpr c_expr7_5c(BPatch_plus, *var7_5c, BPatch_constExpr(3));
BPatch_arithExpr d_expr7_5c(BPatch_assign, *var7_5c, c_expr7_5c);
parSnippetHandle5 =
thread->getProcess()->insertSnippet(d_expr7_5c, *point7_5c, BPatch_callBefore);
}
}
