int sperateCMD(char* in){
int i=0;
int len = strlen(in);
/* flag to determine if we should skip the space in
a string */
int findQuote = 0;
/* Stack to valid the quotes pair */
Stack stk;
Stack_Init(&stk);
for(; i<len; i++){
if(in[i] == ' ' && !findQuote)
in[i]='\0';
if( in[i] == '\'' || in[i] == '\"' ){
if( stk.size > 0 && Stack_Top(&stk) == in[i])
Stack_Pop(&stk);
else
Stack_Push(&stk,in[i]);
findQuote++;
if(stk.size == 0)
findQuote = 0;
in[i] = '\0';
}
}
return len;
}
/// <summary>
/// Evaluate_next_operator for the next operator.
/// </summary>
/// <param name="operands">The operands.</param>
/// <param name="operators">The operators.</param>
bool evaluate_next_operator(struct Stack* operands, struct Stack* operators) {
char op = Stack_Top(operators);
Stack_Pop(operators);
if (op == '_') { // deal with unary '-' differently
int val = -Stack_Top(operands);
Stack_Pop(operands);
Stack_Push(operands, val);
return;
}
int opr2 = Stack_Top(operands);
Stack_Pop(operands);
int opr1 = Stack_Top(operands);
Stack_Pop(operands);
switch (op) {
case '*':
Stack_Push(operands, opr1 * opr2);
break;
case '/':
if (opr2 == 0) {
syslog(LOG_ERR, "Cannot divide by 0");
return DIVIDED_BY_0;
}
Stack_Push(operands, opr1 / opr2);
break;
case '+':
Stack_Push(operands, opr1 + opr2);
break;
case '-':
Stack_Push(operands, opr1 - opr2);
break;
}
return false;
}
/*
* see "Beyond Induction Variables" paper for details on this
* implementation of tarjan's algo
*/
static void
Find_Components(PSS_TarLoop tloop)
{
PSS_TarNode tnode;
tloop->number = 0;
#if 0 /* this does not work cause stacks are lame */
/* sanity check */
if (Stack_Top(tloop->node_stack) != NULL)
P_punt("Find_Components: stack not empty before tarjan calculations");
#endif
/* all the ops are allocated to NOTYET to start */
/* process all the ops */
for (tnode = tloop->first; tnode; tnode = tnode->next)
{
if (tnode->status == NOTYET)
{
Visit_Node(tloop, tnode);
} /* only process if not yet processed */
} /* for all the ops in the loop */
}
static void decode_location(Dwarf_Locdesc *locationList, Dwarf_Signed listLength, long *offset, long *init_val, int *frameRel){
/*Location Decoding Code from http://ns.dyninst.org/coverage/dyninstAPI/src/parseDwarf.C.gcov.html*/
Stack *opStack = (Stack*)malloc(sizeof(Stack));
Stack_Init(opStack);
assert( listLength > 0 );
if( listLength > 1 ) { fprintf( stderr, "Warning: more than one location, ignoring all but first.\n" ); }
/* Initialize the stack. */
if( init_val != NULL ) { Stack_Push(opStack, * init_val); }
/* Variable can only become frame-relative by using the frame pointer operand. */
if( frameRel != NULL ) { * frameRel = false; }
/* Ignore all but the first location, for now. */
Dwarf_Locdesc location = locationList[0];
Dwarf_Loc * locations = location.ld_s;
unsigned int i;
for( i = 0; i < location.ld_cents; i++ ) {
/* Handle the literals w/o 32 case statements. */
if( DW_OP_lit0 <= locations[i].lr_atom && locations[i].lr_atom <= DW_OP_lit31 ) {
//fprintf( stderr, "Pushing named constant: %d\n", locations[i].lr_atom - DW_OP_lit0 );
Stack_Push(opStack, locations[i].lr_atom - DW_OP_lit0 );
continue;
}
if( (DW_OP_breg0 <= locations[i].lr_atom && locations[i].lr_atom <= DW_OP_breg31) || locations[i].lr_atom == DW_OP_bregx ) {
/* Offsets from the specified register. Since we're not
doing this at runtime, we can't do anything useful here. */
fprintf( stderr, "Warning: location decode requires run-time information, giving up.\n" );
*offset = -1;
return;
}
if( (DW_OP_reg0 <= locations[i].lr_atom && locations[i].lr_atom <= DW_OP_reg31) || locations[i].lr_atom == DW_OP_regx ) {
/* The variable resides in the particular register. We can't do anything
useful with this information yet. */
fprintf( stderr, "Warning: location decode indicates register, giving up.\n" );
*offset = -1;
return;
}
switch( locations[i].lr_atom ) {
case DW_OP_addr:
case DW_OP_const1u:
case DW_OP_const2u:
case DW_OP_const4u:
case DW_OP_const8u:
case DW_OP_constu:
// fprintf( stderr, "Pushing constant %lu\n", (unsigned long)locations[i].lr_number );
Stack_Push(opStack, (Dwarf_Unsigned)locations[i].lr_number );
break;
case DW_OP_const1s:
case DW_OP_const2s:
case DW_OP_const4s:
case DW_OP_const8s:
case DW_OP_consts:
// fprintf( stderr, "Pushing constant %ld\n", (signed long)(locations[i].lr_number) );
Stack_Push(opStack, (Dwarf_Signed)(locations[i].lr_number) );
break;
case DW_OP_fbreg:
/* We're only interested in offsets, so don't add the FP. */
// fprintf( stderr, "Pushing FP offset %ld\n", (signed long)(locations[i].lr_number) );
Stack_Push(opStack, (Dwarf_Signed)(locations[i].lr_number) );
if( frameRel != NULL ) { * frameRel = true; }
break;
case DW_OP_dup:
Stack_Push(opStack, Stack_Top(opStack) );
break;
case DW_OP_drop:
Stack_Pop(opStack);
break;
case DW_OP_over: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second ); Stack_Push(opStack, first ); Stack_Push(opStack, second );
} break;
case DW_OP_pick: {
/* Duplicate the entry at index locations[i].lr_number. */
Stack temp;
Stack_Init(&temp);
unsigned int i;
for( i = 0; i < locations[i].lr_number; i++ ) {
Stack_Push(&temp, Stack_Top(opStack) ); Stack_Pop(opStack);
}
long int dup = Stack_Top(opStack);
for( i = 0; i < locations[i].lr_number; i++ ) {
Stack_Push(opStack, Stack_Top(&temp) ); Stack_Pop(&temp);
}
Stack_Push(opStack, dup );
} break;
case DW_OP_swap: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first ); Stack_Push(opStack, second );
} break;
case DW_OP_rot: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
long int third = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first ); Stack_Push(opStack, third ); Stack_Push(opStack, second );
} break;
case DW_OP_deref:
case DW_OP_deref_size:
case DW_OP_xderef:
case DW_OP_xderef_size:
// fprintf( stderr, "Warning: location decode requires run-time information, giving up.\n" );
* offset = -1;
return;
case DW_OP_abs: {
long int top = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, abs( top ) );
} break;
case DW_OP_and: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second & first );
} break;
case DW_OP_div: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second / first );
} break;
case DW_OP_minus: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second - first );
} break;
case DW_OP_mod: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second % first );
} break;
case DW_OP_mul: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second * first );
} break;
case DW_OP_neg: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first * (-1) );
} break;
case DW_OP_not: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, ~ first );
} break;
case DW_OP_or: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second | first );
} break;
case DW_OP_plus: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second + first );
} break;
case DW_OP_plus_uconst: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first + locations[i].lr_number );
} break;
case DW_OP_shl: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second << first );
} break;
case DW_OP_shr: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, (long int)((unsigned long)second >> (unsigned long)first) );
} break;
case DW_OP_shra: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second >> first );
} break;
case DW_OP_xor: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, second ^ first );
} break;
case DW_OP_le: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first <= second ? 1 : 0 );
} break;
case DW_OP_ge: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first >= second ? 1 : 0 );
} break;
case DW_OP_eq: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first == second ? 1 : 0 );
} break;
case DW_OP_lt: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first < second ? 1 : 0 );
} break;
case DW_OP_gt: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first > second ? 1 : 0 );
} break;
case DW_OP_ne: {
long int first = Stack_Top(opStack); Stack_Pop(opStack);
long int second = Stack_Top(opStack); Stack_Pop(opStack);
Stack_Push(opStack, first != second ? 1 : 0 );
} break;
case DW_OP_bra:
if( Stack_Top(opStack) == 0 ) { break; }
Stack_Pop(opStack);
break;/*Right?*/
case DW_OP_skip: {
int bytes = (int)(Dwarf_Signed)locations[i].lr_number;
unsigned int target = locations[i].lr_offset + bytes;
int j = i;
if( bytes < 0 ) {
for( j = i - 1; j >= 0; j-- ) {
if( locations[j].lr_offset == target ) { break; }
} /* end search backward */
} else {
for( j = i + 1; j < location.ld_cents; j ++ ) {
if( locations[j].lr_offset == target ) { break; }
} /* end search forward */
} /* end if positive offset */
/* Because i will be incremented the next time around the loop. */
i = j - 1;
} break;
case DW_OP_piece:
/* For multi-part variables, which we don't handle. */
break;
case DW_OP_nop:
break;
default:
fprintf( stderr, "Unrecognized location opcode 0x%x, returning offset -1.\n", locations[i].lr_atom );
*offset = -1;
return;
} /* end operand switch */
} /* end iteration over Dwarf_Loc entries. */
/* The top of the stack is the computed location. */
//fprintf( stderr, "Location decoded: %ld\n", Stack_Top(opStack) );
*offset = Stack_Top(opStack);
}
/// <summary>
/// Evaluate_exps evaluates the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>The evaluated result</returns>
struct Result evaluate_expr(char* exp) {
static const char* ods = "0123456789(";
static const char* ops = "+-*/_"; // '_' is unary '-'
struct Stack operands;
struct Stack operators;
Stack_Init(&operators);
Stack_Init(&operands);
removeSpaces(exp);
findUnaryOperators(exp);
//syslog(LOG_INFO, "parsing: %s", exp);
int i;
i = 0;
while (exp[i] != '\0') {
char c = exp[i++];
if (strchr(ods, c) != NULL) { // if char == operand
if (c == '(') {
Stack_Push(&operators, c);
} else {
int iStart = i - 1;
int iEnd = iStart;
do {
c = exp[i++];
} while (c != '\n' && isdigit(c));
iEnd = --i;
char num[MAX_DIGITS] = "";
strncat(num, exp + iStart, iEnd - iStart);
Stack_Push(&operands, atoi(num));
}
} else if (strchr(ops, c) != NULL) { // if char == operator
int currentPres = getPrecendence(c);
while (Stack_Size(&operators) > 0 &&
Stack_Size(&operands) > 0 &&
currentPres < getPrecendence((char)Stack_Top(&operators))) {
if (evaluate_next_operator(&operands, &operators) == DIVIDED_BY_0) {
return inf;
}
}
Stack_Push(&operators, c);
} else if (c == ')') {
while (Stack_Top(&operators) != '(') {
if (evaluate_next_operator(&operands, &operators) == DIVIDED_BY_0) {
return inf;
}
}
Stack_Pop(&operators);
}
}
while (Stack_Size(&operators) > 0) {
if (evaluate_next_operator(&operands, &operators) == DIVIDED_BY_0) {
return inf;
}
}
int resultInt = Stack_Top(&operands);
syslog(LOG_INFO, "Result: %d", resultInt);
struct Result result = {resultInt, false};
return result;
}
/*
* see "Beyond Induction Variables" paper for details on this
* implementation of tarjan's algo
*/
static void
Visit_Node (PSS_TarLoop tloop, PSS_TarNode tnode)
{
int low, this;
Expr def_var_expr, operand_expr;
List operand_list;
tnode->status = ONSTACK;
tnode->lowlink = low = this = tloop->number++;
Push_Top(tloop->node_stack, tnode);
/* o visit all operand descendents
* o visit all ssa flows
* - in our implementation, these all happen together
* because the ssa links off of phi functions are just
* treated like operands to a phi function */
operand_list = PSS_GetSubExprByOpcode_List (tnode->expr->operands, OP_var);
List_start(operand_list);
while ((operand_expr = List_next(operand_list)))
{
Expr op_def_expr;
PSS_TarNode op_def_node;
/* we can't have parameters or undef's on the SCC */
if (operand_expr->value.var.ssa &&
!UNINITIALIZED_TYPE (operand_expr->value.var.ssa->type))
{
op_def_expr = operand_expr->value.var.ssa->var->parentexpr;
if ((op_def_node = Find_TarNode_Expr(tloop, op_def_expr)))
{
low = MIN(low, Visit_Descendent(tloop, op_def_node));
}
}
}
tnode->lowlink = low;
/* check if classification not possible at this time */
if (this != low) return;
def_var_expr = tnode->expr->operands;
/* sanity check */
if (tnode->expr->opcode != OP_assign || def_var_expr->opcode != OP_var)
P_punt("Visit_Node: Illegal TarNode Expression");
/* SCC's always finish off with the same element
* on the top of the stack, unless the node we are
* taking a look at is a mu node */
if (Stack_Top(tloop->node_stack) == tnode &&
!MU_TYPE (def_var_expr->value.var.ssa->type))
{
Classify_Trivial(tloop, tnode);
Pop(tloop->node_stack);
tnode->status = DONE;
} /* trivial */
else /* SCC */
{
PSS_TarNode stacktop;
PSS_TarSCC scc;
scc = New_TarSCC(tloop);
do
{
stacktop = Pop(tloop->node_stack);
stacktop->status = DONE;
Add_Node_To_Scc(stacktop, scc);
/* === ADD STACKTOP TO COMPONENT === */
} while(stacktop != tnode);
/* in the algo presented in the paper, one would classify
* the sequences here. however, because different types
* of induction variables depend on knowledge abou previous
* types (for example, a polynomial induction var is made
* up of linear induction vars), it is necessary to identify
* all the SCC's (and vars) that are of certain types before
* identifying other types. as such, we will classify all
* the induction vars at one time at the end.
*/
#if 0
Classify_Sequence(scc);
#endif
} /* SCC */
}
