790 lines
24 KiB
C++
790 lines
24 KiB
C++
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <vector>
|
||
|
|
#include <map>
|
||
|
|
#include <string>
|
||
|
|
|
||
|
|
#include "../GraphCall/graph_calls.h"
|
||
|
|
#include "../Utils/errors.h"
|
||
|
|
#include "../Utils/utils.h"
|
||
|
|
#include "sage++user.h"
|
||
|
|
#include "definesValues.h"
|
||
|
|
#include "set.h"
|
||
|
|
#include "definitionSet.h"
|
||
|
|
|
||
|
|
|
||
|
|
using std::map;
|
||
|
|
using std::string;
|
||
|
|
using std::vector;
|
||
|
|
using std::wstring;
|
||
|
|
|
||
|
|
#ifdef __SPF
|
||
|
|
extern "C" void addToCollection(const int line, const char *file, void *pointer, int type);
|
||
|
|
extern "C" void removeFromCollection(void *pointer);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
//
|
||
|
|
// Global table to store the use and def
|
||
|
|
//
|
||
|
|
|
||
|
|
// Not used anymore, replaced by attributes;
|
||
|
|
// SgExpression *Used[MAXNODE];
|
||
|
|
// SgExpression *Defined[MAXNODE];
|
||
|
|
|
||
|
|
//
|
||
|
|
// declaration for the data flow framework
|
||
|
|
//
|
||
|
|
|
||
|
|
extern Set *genSet[MAXNODE];
|
||
|
|
extern Set *killSet[MAXNODE];
|
||
|
|
extern Set *inSet[MAXNODE];
|
||
|
|
extern Set *outSet[MAXNODE];
|
||
|
|
|
||
|
|
extern void iterativeForwardFlowAnalysis(SgFile *file,
|
||
|
|
SgStatement *func,
|
||
|
|
Set *(*giveGenSet)(SgStatement *func, SgStatement *stmt),
|
||
|
|
Set *(*giveKillSet)(SgStatement *func, SgStatement *stmt),
|
||
|
|
int(*feq)(void *e1, void *e2),
|
||
|
|
void *(*fcomb)(void *e1, void *e2),
|
||
|
|
void(*fp)(void *e1));
|
||
|
|
|
||
|
|
extern void generalIterativeFlowAnalysis(SgFile *file,
|
||
|
|
SgStatement *func,
|
||
|
|
Set *(*transfertSet)(SgStatement *func, SgStatement *stmt, Set *setin),
|
||
|
|
int(*feq)(void *e1, void *e2),
|
||
|
|
void* (*fcomb)(void *e1, void *e2),
|
||
|
|
void(*fp)(void *e1));
|
||
|
|
|
||
|
|
/////////////////////////////////////////////////////////////////////
|
||
|
|
// from the intrinsic.C file
|
||
|
|
/////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
extern int isSymbolIntrinsic(SgSymbol *symb);
|
||
|
|
|
||
|
|
/////////////////////////////////////////////////////////////////////
|
||
|
|
// computes the definition for each file;
|
||
|
|
/////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
static inline bool isVarRef(SgExpression *ex)
|
||
|
|
{
|
||
|
|
const int var = ex->variant();
|
||
|
|
return (var == ARRAY_REF || var == VAR_REF || var == ARRAY_OP);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void fillDef(SgExpression *ex, vector<SgExpression*> &useL, vector<SgExpression*> &defL,
|
||
|
|
const map<string, FuncInfo*> &funcs, vector<Messages> &messagesForFile, const int currLine);
|
||
|
|
|
||
|
|
static void fillUse(SgExpression *ex, vector<SgExpression*> &useL, vector<SgExpression*> &defL,
|
||
|
|
const map<string, FuncInfo*> &funcs, vector<Messages> &messagesForFile, const int currLine)
|
||
|
|
{
|
||
|
|
if (ex)
|
||
|
|
{
|
||
|
|
if (isVarRef(ex))
|
||
|
|
{
|
||
|
|
useL.push_back(ex);
|
||
|
|
fillUse(ex->lhs(), useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
fillUse(ex->rhs(), useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
}
|
||
|
|
else if (ex->variant() == FUNC_CALL)
|
||
|
|
fillDef(ex, useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
fillUse(ex->lhs(), useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
fillUse(ex->rhs(), useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void fillDef(SgExpression *ex, vector<SgExpression*> &useL, vector<SgExpression*> &defL,
|
||
|
|
const map<string, FuncInfo*> &funcs, vector<Messages> &messagesForFile, const int currLine)
|
||
|
|
{
|
||
|
|
if (ex)
|
||
|
|
{
|
||
|
|
if (ex->variant() == FUNC_CALL)
|
||
|
|
{
|
||
|
|
bool isIntrinsic = isSymbolIntrinsic(ex->symbol());
|
||
|
|
SgFunctionCallExp *call = (SgFunctionCallExp*)ex;
|
||
|
|
|
||
|
|
FuncInfo *currInfo = NULL;
|
||
|
|
auto it = funcs.find(call->funName()->identifier());
|
||
|
|
if (funcs.end() != it)
|
||
|
|
{
|
||
|
|
currInfo = it->second;
|
||
|
|
if (currInfo->funcParams.countOfPars != call->numberOfArgs())
|
||
|
|
{
|
||
|
|
wstring bufE, bufR;
|
||
|
|
__spf_printToLongBuf(bufE, L"Count of formal and actual parameters are not equal for function call '%s'", to_wstring(currInfo->funcName).c_str());
|
||
|
|
__spf_printToLongBuf(bufR, R82, to_wstring(currInfo->funcName).c_str());
|
||
|
|
|
||
|
|
messagesForFile.push_back(Messages(ERROR, currLine, bufR, bufE, 1046));
|
||
|
|
throw -991;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int z = 0; z < call->numberOfArgs(); ++z)
|
||
|
|
{
|
||
|
|
SgExpression *arg = call->arg(z);
|
||
|
|
if (isVarRef(arg))
|
||
|
|
{
|
||
|
|
if (currInfo)
|
||
|
|
{
|
||
|
|
if (currInfo->funcParams.isArgOut(z))
|
||
|
|
defL.push_back(arg);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!isIntrinsic)
|
||
|
|
defL.push_back(arg);
|
||
|
|
}
|
||
|
|
useL.push_back(arg);
|
||
|
|
}
|
||
|
|
|
||
|
|
fillUse(arg->lhs(), useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
fillUse(arg->rhs(), useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
fillUse(ex->lhs(), useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
fillUse(ex->rhs(), useL, defL, funcs, messagesForFile, currLine);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SgExpression* makeList(const std::vector<SgExpression*> &vec)
|
||
|
|
{
|
||
|
|
if (vec.size() == 0)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
SgExpression *list = new SgExpression(EXPR_LIST);
|
||
|
|
SgExpression *r_list = list;
|
||
|
|
for (int i = 0; i < vec.size(); ++i)
|
||
|
|
{
|
||
|
|
list->setLhs(vec[i]);
|
||
|
|
if (i != vec.size() - 1)
|
||
|
|
{
|
||
|
|
list->setRhs(new SgExpression(EXPR_LIST));
|
||
|
|
list = list->rhs();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return r_list;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void defUseVar(SgStatement *stmt, SgStatement *func, SgExpression **def, SgExpression **use,
|
||
|
|
const map<string, FuncInfo*> &allFuncs, vector<Messages> &messagesForFile)
|
||
|
|
{
|
||
|
|
SgExpression *expr1, *expr2;
|
||
|
|
SgExpression *temp, *pt, *pt1;
|
||
|
|
SgArrayRefExp *aref;
|
||
|
|
SgExprListExp *exprli;
|
||
|
|
SgFunctionCallExp *fc;
|
||
|
|
SgInputOutputStmt *iostmt;
|
||
|
|
SgCallStmt *callStat;
|
||
|
|
if (!stmt || !func)
|
||
|
|
return;
|
||
|
|
|
||
|
|
*def = NULL;
|
||
|
|
*use = NULL;
|
||
|
|
|
||
|
|
switch (stmt->variant())
|
||
|
|
{
|
||
|
|
case ASSIGN_STAT:
|
||
|
|
expr1 = stmt->expr(0);
|
||
|
|
expr2 = stmt->expr(1);
|
||
|
|
// need to be recursively applied later;
|
||
|
|
if (expr1)
|
||
|
|
*def = expr1->symbRefs();
|
||
|
|
else
|
||
|
|
*def = NULL;
|
||
|
|
if (expr2)
|
||
|
|
*use = expr2->symbRefs();
|
||
|
|
else
|
||
|
|
*use = NULL;
|
||
|
|
for (temp = *def; temp; temp = temp->rhs())
|
||
|
|
{
|
||
|
|
if (aref = isSgArrayRefExp(temp->lhs()))
|
||
|
|
{
|
||
|
|
pt = aref->subscripts();
|
||
|
|
if (pt)
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
// we add it to the end of use;
|
||
|
|
if (*use)
|
||
|
|
{
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
*use = pt1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (temp = *use; temp; temp = temp->rhs())
|
||
|
|
{
|
||
|
|
if (aref = isSgArrayRefExp(temp->lhs()))
|
||
|
|
{
|
||
|
|
pt = aref->subscripts();
|
||
|
|
if (pt)
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
// we add it to the end of use;
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (fc = isSgFunctionCallExp(temp->lhs()))
|
||
|
|
{
|
||
|
|
FuncInfo *currInfo = NULL;
|
||
|
|
auto it = allFuncs.find(fc->funName()->identifier());
|
||
|
|
if (allFuncs.end() != it)
|
||
|
|
{
|
||
|
|
currInfo = it->second;
|
||
|
|
if (currInfo->funcParams.countOfPars != fc->numberOfArgs())
|
||
|
|
{
|
||
|
|
wstring bufE, bufR;
|
||
|
|
__spf_printToLongBuf(bufE, L"Count of formal and actual parameters are not equal for function call '%s'", to_wstring(currInfo->funcName).c_str());
|
||
|
|
__spf_printToLongBuf(bufR, R83, to_wstring(currInfo->funcName).c_str());
|
||
|
|
|
||
|
|
messagesForFile.push_back(Messages(ERROR, stmt->lineNumber(), bufR, bufE, 1046));
|
||
|
|
throw -991;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pt = fc->args();
|
||
|
|
if (pt)
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
// we add it to the end of use;
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
|
||
|
|
//new algo
|
||
|
|
if (currInfo)
|
||
|
|
{
|
||
|
|
vector<SgExpression*> defL;
|
||
|
|
vector<SgExpression*> useL;
|
||
|
|
fillDef(fc, useL, defL, allFuncs, messagesForFile, stmt->lineNumber());
|
||
|
|
if (defL.size())
|
||
|
|
{
|
||
|
|
SgExpression *list = makeList(defL);
|
||
|
|
if (exprli = isSgExprListExp(*def))
|
||
|
|
exprli->linkToEnd(*list);
|
||
|
|
else
|
||
|
|
*def = list;
|
||
|
|
}
|
||
|
|
} //old algo
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// if not an intrinsic, needs to be added to the def list;
|
||
|
|
if (!isSymbolIntrinsic(fc->funName()))
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*def)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
*def = pt1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case FOR_NODE:
|
||
|
|
{
|
||
|
|
SgExprListExp *el;
|
||
|
|
SgVarRefExp *vr;
|
||
|
|
if (stmt->symbol())
|
||
|
|
{
|
||
|
|
vr = new SgVarRefExp(*(stmt->symbol()));
|
||
|
|
*def = new SgExprListExp(*vr);
|
||
|
|
*use = new SgExprListExp(*vr);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*use = NULL;
|
||
|
|
*def = NULL;
|
||
|
|
}
|
||
|
|
// Borne inf and sup are also sunject to use;
|
||
|
|
expr1 = stmt->expr(0);
|
||
|
|
expr2 = stmt->expr(1);
|
||
|
|
// need to be recursively applied later;
|
||
|
|
if (expr1)
|
||
|
|
{
|
||
|
|
pt1 = expr1->symbRefs();
|
||
|
|
if (*use)
|
||
|
|
{
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
*use = pt1;
|
||
|
|
}
|
||
|
|
if (expr2)
|
||
|
|
{
|
||
|
|
pt1 = expr2->symbRefs();
|
||
|
|
if (*use)
|
||
|
|
{
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
*use = pt1;
|
||
|
|
}
|
||
|
|
for (temp = *use; temp; temp = temp->rhs())
|
||
|
|
{
|
||
|
|
if (aref = isSgArrayRefExp(temp->lhs()))
|
||
|
|
{
|
||
|
|
pt = aref->subscripts();
|
||
|
|
if (pt)
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
// we add it to the end of use;
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (fc = isSgFunctionCallExp(temp->lhs()))
|
||
|
|
{
|
||
|
|
pt = fc->args();
|
||
|
|
if (pt)
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
// we add it to the end of use;
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
// if not an intrinsic, needs to be added to the def list;
|
||
|
|
if (!isSymbolIntrinsic(fc->funName()))
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*def)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
*def = pt1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case LOGIF_NODE:
|
||
|
|
case CONT_STAT:
|
||
|
|
case CONTROL_END: // here we should check if loop...
|
||
|
|
case IF_NODE:
|
||
|
|
case WHILE_NODE:
|
||
|
|
case DO_WHILE_NODE:
|
||
|
|
expr2 = stmt->expr(0);
|
||
|
|
// need to be recursively applied later;
|
||
|
|
if (expr2)
|
||
|
|
*use = expr2->symbRefs();
|
||
|
|
else
|
||
|
|
*use = NULL;
|
||
|
|
*def = NULL;
|
||
|
|
for (temp = *use; temp; temp = temp->rhs())
|
||
|
|
{
|
||
|
|
if (aref = isSgArrayRefExp(temp->lhs()))
|
||
|
|
{
|
||
|
|
pt = aref->subscripts();
|
||
|
|
if (pt)
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
// we add it to the end of use;
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (fc = isSgFunctionCallExp(temp->lhs()))
|
||
|
|
{
|
||
|
|
pt = fc->args();
|
||
|
|
if (pt)
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
// we add it to the end of use;
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*use)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
// if not an intrinsic, needs to be added to the def list;
|
||
|
|
if (!isSymbolIntrinsic(fc->funName()))
|
||
|
|
{
|
||
|
|
pt1 = pt->symbRefs();
|
||
|
|
if (pt1 && (exprli = isSgExprListExp(*def)))
|
||
|
|
{
|
||
|
|
exprli->linkToEnd(*pt1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
*def = pt1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case READ_STAT:
|
||
|
|
iostmt = isSgInputOutputStmt(stmt);
|
||
|
|
if (iostmt)
|
||
|
|
{
|
||
|
|
if (iostmt->itemList())
|
||
|
|
*def = iostmt->itemList()->symbRefs();
|
||
|
|
else
|
||
|
|
*def = NULL;
|
||
|
|
*use = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
Message("internal error : IO statements not found\n", 0);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WRITE_STAT:
|
||
|
|
case PRINT_STAT:
|
||
|
|
iostmt = isSgInputOutputStmt(stmt);
|
||
|
|
if (iostmt)
|
||
|
|
{
|
||
|
|
if (iostmt->itemList())
|
||
|
|
*use = iostmt->itemList()->symbRefs();
|
||
|
|
else
|
||
|
|
*use = NULL;
|
||
|
|
*def = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
Message("internal error : IO statements not found\n", 0);
|
||
|
|
break;
|
||
|
|
case PROC_STAT:
|
||
|
|
callStat = (SgCallStmt*)stmt;
|
||
|
|
|
||
|
|
pt = callStat->expr(0);
|
||
|
|
if (pt)
|
||
|
|
{
|
||
|
|
/**use = pt->symbRefs();
|
||
|
|
// if not an intrinsic, needs to be added to the def list;
|
||
|
|
if (!isSymbolIntrinsic(callStat->name()))
|
||
|
|
*def = pt->symbRefs();
|
||
|
|
printf("old use:\n");
|
||
|
|
recExpressionPrint(*use);
|
||
|
|
printf("old def:\n");
|
||
|
|
recExpressionPrint(*def);*/
|
||
|
|
|
||
|
|
vector<SgExpression*> defL;
|
||
|
|
vector<SgExpression*> useL;
|
||
|
|
|
||
|
|
FuncInfo *currInfo = NULL;
|
||
|
|
auto it = allFuncs.find(callStat->name()->identifier());
|
||
|
|
if (allFuncs.end() != it)
|
||
|
|
{
|
||
|
|
currInfo = it->second;
|
||
|
|
if (currInfo->funcParams.countOfPars != callStat->numberOfArgs())
|
||
|
|
{
|
||
|
|
wstring bufE, bufR;
|
||
|
|
__spf_printToLongBuf(bufE, L"Count of formal and actual parameters are not equal for function call '%s'", to_wstring(currInfo->funcName).c_str());
|
||
|
|
__spf_printToLongBuf(bufR, R84, to_wstring(currInfo->funcName).c_str());
|
||
|
|
|
||
|
|
messagesForFile.push_back(Messages(ERROR, stmt->lineNumber(), bufR, bufE, 1046));
|
||
|
|
throw -991;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int z = 0; z < callStat->numberOfArgs(); ++z)
|
||
|
|
{
|
||
|
|
SgExpression *arg = callStat->arg(z);
|
||
|
|
if (isVarRef(arg))
|
||
|
|
{
|
||
|
|
if (currInfo)
|
||
|
|
{
|
||
|
|
if (currInfo->funcParams.isArgOut(z))
|
||
|
|
defL.push_back(arg);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
defL.push_back(arg);
|
||
|
|
useL.push_back(arg);
|
||
|
|
}
|
||
|
|
|
||
|
|
fillUse(arg->lhs(), useL, defL, allFuncs, messagesForFile, callStat->lineNumber());
|
||
|
|
fillUse(arg->rhs(), useL, defL, allFuncs, messagesForFile, callStat->lineNumber());
|
||
|
|
}
|
||
|
|
|
||
|
|
*use = makeList(useL);
|
||
|
|
*def = makeList(defL);
|
||
|
|
|
||
|
|
/*printf("new use:\n");
|
||
|
|
recExpressionPrint(*use);
|
||
|
|
printf("new def:\n");
|
||
|
|
recExpressionPrint(*def);
|
||
|
|
printf("");*/
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*def = NULL;
|
||
|
|
*use = NULL;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case GOTO_NODE:
|
||
|
|
case STOP_STAT:
|
||
|
|
case RETURN_STAT:
|
||
|
|
case RETURN_NODE:
|
||
|
|
case ELSEIF_NODE:
|
||
|
|
case ARITHIF_NODE:
|
||
|
|
case WHERE_NODE:
|
||
|
|
case WHERE_BLOCK_STMT:
|
||
|
|
case SWITCH_NODE:
|
||
|
|
case CASE_NODE:
|
||
|
|
case BREAK_NODE:
|
||
|
|
case EXIT_STMT:
|
||
|
|
case ASSGOTO_NODE:
|
||
|
|
case COMGOTO_NODE:
|
||
|
|
default:
|
||
|
|
*def = NULL;
|
||
|
|
*use = NULL;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void initDefUseTable(SgStatement *func, const map<string, FuncInfo*> &allFuncs, vector<Messages> &messagesForFile)
|
||
|
|
{
|
||
|
|
SgStatement *last, *first, *lastfunc, *temp;
|
||
|
|
SgExpression *def, *use, *pt;
|
||
|
|
int i;
|
||
|
|
int nbatt, typeat, j;
|
||
|
|
|
||
|
|
if (!func)
|
||
|
|
return;
|
||
|
|
|
||
|
|
lastfunc = func->lastNodeOfStmt();
|
||
|
|
|
||
|
|
|
||
|
|
for (temp = func; temp; temp = temp->lexNext())
|
||
|
|
{
|
||
|
|
if (isSgExecutableStatement(temp))
|
||
|
|
{
|
||
|
|
nbatt = temp->numberOfAttributes();
|
||
|
|
for (j = 0; j < nbatt; j++)
|
||
|
|
{
|
||
|
|
typeat = temp->attributeType(j);
|
||
|
|
if ((typeat == USEDLIST_ATTRIBUTE) ||
|
||
|
|
(typeat == DEFINEDLIST_ATTRIBUTE))
|
||
|
|
{
|
||
|
|
temp->deleteAttribute(j);
|
||
|
|
j--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (temp == lastfunc)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (temp = func; temp; temp = temp->lexNext())
|
||
|
|
{
|
||
|
|
if (isSgExecutableStatement(temp))
|
||
|
|
{
|
||
|
|
defUseVar(temp, func, &def, &use, allFuncs, messagesForFile);
|
||
|
|
temp->addAttribute(USEDLIST_ATTRIBUTE, (void*)use, 0);
|
||
|
|
temp->addAttribute(DEFINEDLIST_ATTRIBUTE, (void*)def, 0);
|
||
|
|
}
|
||
|
|
if (temp == lastfunc)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Example of functions for flow analysis
|
||
|
|
//
|
||
|
|
int symbRefEqual(void *e1, void *e2)
|
||
|
|
{
|
||
|
|
SgExpression *ex1, *ex2;
|
||
|
|
SgSymbol *s1, *s2;
|
||
|
|
PT_ELSET el1, el2;
|
||
|
|
if (!e1 && !e2)
|
||
|
|
return 1;
|
||
|
|
if (!e1 || !e2)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
el1 = (PT_ELSET)e1;
|
||
|
|
el2 = (PT_ELSET)e2;
|
||
|
|
|
||
|
|
ex1 = el1->expr;
|
||
|
|
ex2 = el2->expr;
|
||
|
|
|
||
|
|
if ((s1 = ex1->symbol()) && (s2 = ex2->symbol()))
|
||
|
|
{
|
||
|
|
if (s1 == s2)
|
||
|
|
{
|
||
|
|
if (el1->stmt == el2->stmt)
|
||
|
|
return 1;
|
||
|
|
else
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void myPrint(void *e1)
|
||
|
|
{
|
||
|
|
SgExpression *ex1;
|
||
|
|
PT_ELSET el1;
|
||
|
|
if (!e1)
|
||
|
|
return;
|
||
|
|
el1 = (PT_ELSET)e1;
|
||
|
|
ex1 = el1->expr;
|
||
|
|
if (el1->stmt)
|
||
|
|
printf("(id = %d, line = %d, ", el1->stmt->id(), el1->stmt->lineNumber());
|
||
|
|
else
|
||
|
|
printf("(id = -, line = -, ");
|
||
|
|
if (ex1->symbol())
|
||
|
|
printf("%s", ex1->symbol()->identifier());
|
||
|
|
else
|
||
|
|
ex1->unparsestdout();
|
||
|
|
printf(")");
|
||
|
|
printf(",");
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Example of function to compute gen and kill sets for Reaching Definition.
|
||
|
|
// NOARRAYREF indicate if we want array ref in
|
||
|
|
|
||
|
|
Set *makeGenSet(SgStatement *func, SgStatement *stmt)
|
||
|
|
{
|
||
|
|
SgExpression *def, *use, *pt;
|
||
|
|
PT_ELSET el;
|
||
|
|
Set *defset, *pts;
|
||
|
|
|
||
|
|
if (!func || !stmt)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
def = (SgExpression *)stmt->attributeValue(0, DEFINEDLIST_ATTRIBUTE);
|
||
|
|
// Defined[stmt->id()];
|
||
|
|
defset = new Set(symbRefEqual, NULL, myPrint);
|
||
|
|
#ifdef __SPF
|
||
|
|
addToCollection(__LINE__, __FILE__, defset, 1);
|
||
|
|
#endif
|
||
|
|
if (def)
|
||
|
|
{
|
||
|
|
for (pt = def; pt; pt = pt->rhs())
|
||
|
|
{
|
||
|
|
if (!isSgTypeExp(pt->lhs()))
|
||
|
|
{
|
||
|
|
if (!NOARRAYREF || !isSgArrayRefExp(pt->lhs()))
|
||
|
|
{
|
||
|
|
el = new struct elset;
|
||
|
|
#ifdef __SPF
|
||
|
|
addToCollection(__LINE__, __FILE__, el, 1);
|
||
|
|
#endif
|
||
|
|
el->stmt = stmt;
|
||
|
|
el->expr = pt->lhs();
|
||
|
|
defset->addElement((void *)el);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pts = defset;
|
||
|
|
// printf("Printing defset:\n");
|
||
|
|
// defset->printSet();
|
||
|
|
defset = defset->compact();
|
||
|
|
if (pts)
|
||
|
|
{
|
||
|
|
#ifdef __SPF
|
||
|
|
removeFromCollection(pts);
|
||
|
|
#endif
|
||
|
|
delete pts;
|
||
|
|
}
|
||
|
|
// defset->printSet();
|
||
|
|
return defset;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
Set *makeKillSet(SgStatement *func, SgStatement *stmt)
|
||
|
|
{
|
||
|
|
|
||
|
|
SgExpression *def, *use, *pt, *defstmt, *expr1, *pt1;
|
||
|
|
PT_ELSET el;
|
||
|
|
Set *killset, *pts;
|
||
|
|
SgStatement *last, *first, *lastfunc, *temp;
|
||
|
|
int trouve;
|
||
|
|
if (!func || !stmt)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
killset = new Set(symbRefEqual, NULL, myPrint);
|
||
|
|
#ifdef __SPF
|
||
|
|
addToCollection(__LINE__, __FILE__, killset, 1);
|
||
|
|
#endif
|
||
|
|
last = func->lastNodeOfStmt();
|
||
|
|
defstmt = (SgExpression *)stmt->attributeValue(0, DEFINEDLIST_ATTRIBUTE);
|
||
|
|
//Defined[stmt->id()];
|
||
|
|
if (defstmt)
|
||
|
|
{
|
||
|
|
for (pt1 = defstmt; pt1; pt1 = pt1->rhs())
|
||
|
|
{
|
||
|
|
expr1 = pt1->lhs();
|
||
|
|
if (!isSgArrayRefExp(expr1) && !isSgTypeExp(expr1))
|
||
|
|
{ // cannot kill an array ref;
|
||
|
|
for (temp = func; temp; temp = temp->lexNext())
|
||
|
|
{
|
||
|
|
if (temp != stmt)
|
||
|
|
{
|
||
|
|
if (def = (SgExpression *)temp->attributeValue(0, DEFINEDLIST_ATTRIBUTE))
|
||
|
|
//Defined[temp->id()])
|
||
|
|
{
|
||
|
|
for (pt = def; pt; pt = pt->rhs())
|
||
|
|
{
|
||
|
|
if (pt->lhs())
|
||
|
|
{
|
||
|
|
if (pt->lhs()->symbol() == expr1->symbol())
|
||
|
|
{
|
||
|
|
el = new struct elset;
|
||
|
|
#ifdef __SPF
|
||
|
|
addToCollection(__LINE__, __FILE__, el, 1);
|
||
|
|
#endif
|
||
|
|
el->stmt = temp;
|
||
|
|
el->expr = pt->lhs();
|
||
|
|
killset->addElement((void *)el);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (temp == last)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
pts = killset;
|
||
|
|
// printf("Printing killset:\n");
|
||
|
|
// killset->printSet();
|
||
|
|
killset = killset->compact();
|
||
|
|
// killset->printSet();
|
||
|
|
if (pts)
|
||
|
|
{
|
||
|
|
#ifdef __SPF
|
||
|
|
removeFromCollection(pts);
|
||
|
|
#endif
|
||
|
|
delete pts;
|
||
|
|
}
|
||
|
|
return killset;
|
||
|
|
}
|