PTREE FoldUnary( PTREE expr )
/***************************/
{
PTREE op1;
TYPE result_type;
bool dont_care;
op1 = expr->u.subtree[0];
if( notFoldable( op1 ) ) {
switch( expr->cgop ) {
case CO_EXCLAMATION:
if( nonZeroExpr( op1 ) ) {
expr = makeTrueFalse( expr, op1, 0 );
}
break;
}
return( expr );
}
result_type = expr->type;
if( op1->op == PT_FLOATING_CONSTANT ) {
switch( expr->cgop ) {
case CO_EXCLAMATION:
op1->u.int64_constant.u._32[ I64HI32 ] = 0;
op1->u.int64_constant.u._32[ I64LO32 ]
= ( BFSign( op1->u.floating_constant ) == 0 );
op1->op = PT_INT_CONSTANT;
op1 = NodeSetBooleanType( op1 );
break;
case CO_UMINUS:
BFNegate( op1->u.floating_constant );
break;
case CO_UPLUS:
break;
default:
return( expr );
}
op1 = PTreeCopySrcLocation( op1, expr );
PTreeFree( expr );
return( castConstant( op1, result_type, &dont_care ) );
}
switch( expr->cgop ) {
case CO_TILDE:
op1->u.int64_constant.u._32[0] = ~ op1->u.int64_constant.u._32[0];
op1->u.int64_constant.u._32[1] = ~ op1->u.int64_constant.u._32[1];
break;
case CO_EXCLAMATION:
op1 = makeBooleanConst( op1, ! nonZeroExpr( op1 ) );
break;
case CO_UMINUS:
U64Neg( &op1->u.int64_constant, &op1->u.int64_constant );
break;
case CO_UPLUS:
break;
default:
return( expr );
}
op1 = PTreeCopySrcLocation( op1, expr );
PTreeFree( expr );
return( castConstant( op1, result_type, &dont_care ) );
}
void OverlapIndexDeleteIntoClause2(OverlapIndex_p tindex,
OverlapIndex_p naindex,
Clause_p clause)
{
PStack_p trans;
Term_p term;
PTree_p terms = NULL,
natoms= NULL,
cell;
ClauseCollectIntoTerms2(clause, &terms, &natoms);
trans = PTreeTraverseInit(terms);
while((cell = PTreeTraverseNext(trans)))
{
term = cell->key;
OverlapIndexDeleteClauseOcc(tindex, clause, term);
}
PTreeTraverseExit(trans);
PTreeFree(terms);
trans = PTreeTraverseInit(natoms);
while((cell = PTreeTraverseNext(trans)))
{
term = cell->key;
OverlapIndexDeleteClauseOcc(naindex, clause, term);
}
PTreeTraverseExit(trans);
PTreeFree(natoms);
}
void GCAdminFree(GCAdmin_p junk)
{
assert(junk);
PTreeFree(junk->clause_sets);
PTreeFree(junk->formula_sets);
GCAdminCellFree(junk);
}
void DPLLFormulaFree(DPLLFormula_p junk)
{
int i;
for(i=0; i<junk->atom_no; i++)
{
PTreeFree(junk->atoms[i].pos_active);
PTreeFree(junk->atoms[i].neg_active);
}
FREE(junk->atoms);
while(!PStackEmpty(junk->clauses))
{
DPLLClauseFree(PStackPopP(junk->clauses));
}
PStackFree(junk->clauses);
PropSigFree(junk->sig);
DPLLFormulaCellFree(junk);
}
PTREE AnalyseReturnClassVal // RETURN CLASS VALUE
( PTREE expr ) // - expression for return
{
TYPE retn_type; // - return type
TYPE retn_class; // - class for return
PTREE tgt; // - target expression
CNV_DIAG* diag; // - diagnosis
retn_type = expr->u.subtree[0]->type;
retn_class = StructType( retn_type );
DbgVerify( retn_class != NULL, "AnalyseReturnClassVal -- not class" );
if( ClassCorrupted( retn_class ) ) {
PTreeErrorNode( expr );
} else if( TypeAbstract( retn_class ) ) {
PTreeErrorExprType( expr, ERR_CONVERT_TO_ABSTRACT_TYPE, retn_class );
ScopeNotePureFunctions( retn_class );
} else {
diag = DefargBeingCompiled() ? &diagDefarg : &diagReturn;
tgt = NodeFetchReference( getReturnSym() );
expr = removeReturnNode( expr );
expr = CopyClassRetnVal( expr, tgt, retn_type, diag );
if( expr->op != PT_ERROR ) {
if( NodeIsBinaryOp( expr, CO_DTOR ) ) {
PTREE node = expr->u.subtree[0];
if( SymFunctionReturn() == node->u.symcg.symbol ) {
PTreeFree( node );
node = expr;
expr = expr->u.subtree[1];
PTreeFree( node );
}
}
}
#if 0
// this is just so we can do some checking
expr = CastImplicit( expr
, retn_type
, CNV_EXPR
, DefargBeingCompiled()
? &diagDefarg : &diagReturn );
}
#endif
}
void FIndexFree(FIndex_p junk)
{
long i;
PTree_p tmp;
for(i = 0; i<junk->index->size; i++)
{
tmp = PDArrayElementP(junk->index, i);
PTreeFree(tmp);
}
PDArrayFree(junk->index);
FIndexCellFree(junk);
}
ACTerm_p ACTermNormalize(Sig_p sig, Term_p term)
{
ACTerm_p handle = ACTermAlloc(term->f_code);
if(!TermIsVar(term) && (term->arity != 0))
{
int i;
if(SigQueryFuncProp(sig, term->f_code, FPIsAC))
{
PTree_p args = NULL, cell;
PStack_p stack;
ac_collect_args(&args, sig, term->f_code, term);
i=0;
stack = PTreeTraverseInit(args);
while((cell = PTreeTraverseNext(stack)))
{
PDArrayAssignP(handle->args,i++, cell->key);
}
PTreeTraverseExit(stack);
PTreeFree(args);
}
else if(SigQueryFuncProp(sig, term->f_code, FPCommutative))
{
ACTerm_p t1, t2, tmp;
t1 = ACTermNormalize(sig,term->args[0]);
t2 = ACTermNormalize(sig,term->args[1]);
if(ACTermCompare(t1, t2) > 0)
{
tmp = t1;
t1 = t2;
t2 = tmp;
}
PDArrayAssignP(handle->args,0,t1);
PDArrayAssignP(handle->args,1,t2);
}
else
{
for(i=0; i<term->arity; i++)
{
PDArrayAssignP(handle->args,i,
ACTermNormalize(sig,term->args[i]));
}
}
}
return handle;
}
static PTREE castFloatingConstant( PTREE expr, TYPE type, bool *happened )
{
target_long value;
PTREE new_expr;
type_id id;
id = TypedefModifierRemove( type )->id;
switch( id ) {
case TYP_POINTER:
case TYP_MEMBER_POINTER:
id = TYP_ULONG;
// drops thru
case TYP_SCHAR:
case TYP_SSHORT:
case TYP_SINT:
case TYP_SLONG:
case TYP_UCHAR:
case TYP_USHORT:
case TYP_UINT:
case TYP_ULONG:
case TYP_WCHAR:
value = BFGetLong( &(expr->u.floating_constant) );
new_expr = PTreeIntConstant( (target_ulong) value, id );
new_expr = CastIntConstant( new_expr, type, happened );
break;
case TYP_FLOAT: {
float_handle flt_val;
flt_val = BFCopy( expr->u.floating_constant );
new_expr = PTreeFloatingConstant( flt_val, id );
}
break;
case TYP_LONG_DOUBLE:
case TYP_DOUBLE:
{ float_handle flt_val;
flt_val = BFCopy( expr->u.floating_constant );
new_expr = PTreeFloatingConstant( flt_val, id );
} break;
case TYP_SLONG64:
case TYP_ULONG64:
{ signed_64 val = BFCnvF64( expr->u.floating_constant );
new_expr = PTreeInt64Constant( val, id );
} break;
default:
return( expr );
}
*happened = true;
new_expr = PTreeCopySrcLocation( new_expr, expr );
PTreeFree( expr );
return( new_expr );
}
static void clause_print_dfg(FILE* out, Clause_p clause)
{
Eqn_p handle;
PTree_p variables = NULL, cell;
PStack_p stack;
Term_p var;
long var_no;
fprintf(out, "clause(");
var_no = ClauseCollectVariables(clause, &variables);
if(var_no)
{
fprintf(out, "forall([");
stack=PTreeTraverseInit(variables);
cell = PTreeTraverseNext(stack);
if(cell)
{
assert(clause->literals);
var = cell->key;
TBPrintTerm(out, clause->literals->bank, var, true);
while((cell=PTreeTraverseNext(stack)))
{
fputc(',', out);
var = cell->key;
TBPrintTerm(out, clause->literals->bank, var, true);
}
}
PTreeTraverseExit(stack);
PTreeFree(variables);
fprintf(out, "],");
}
fprintf(out, "or(");
handle=clause->literals;
if(handle)
{
eqn_print_dfg(out, handle);
handle=handle->next;
while(handle)
{
fputs(",", out);
eqn_print_dfg(out, handle);
handle=handle->next;
}
}
else
{
fputs("not(equal(spass_hack,spass_hack))",out);
}
fprintf(out, ")%c, c%ld ).", (var_no?')':' '), clause->ident);
}
void OverlapIndexDeleteFromClause(OverlapIndex_p index, Clause_p clause)
{
PStack_p trans;
Term_p term;
PTree_p collector = NULL, cell;
ClauseCollectFromTerms(clause, &collector);
trans = PTreeTraverseInit(collector);
while((cell = PTreeTraverseNext(trans)))
{
term = cell->key;
OverlapIndexDeleteClauseOcc(index, clause, term);
}
PTreeTraverseExit(trans);
PTreeFree(collector);
}
static PTREE insertCDtor( // INSERT CDTOR NODE INTO CALL LIST
PTREE seq, // - argument sequence
PTREE arg ) // - argument
{
PTREE* r_val; // - reference[ arg value ]
PTREE val; // - arg value
if( arg != NULL ) {
r_val = PTreeRefRight( arg );
val = *r_val;
if( val->op == PT_INT_CONSTANT ) {
PTREE new_val = NodeIcUnsigned( IC_CDARG_VAL
, val->u.uint_constant );
new_val->type = val->type;
*r_val = new_val;
PTreeFree( val );
}
}
return insertArg( seq, arg );
}
static PTREE addPtIc( // DECORATE TREE WITH PT_IC NODE
PTREE tree, // - tree
PTREE node ) // - IC node
{
PTREE *a_expr; // - expression for side-effect
if( tree == NULL ) {
CgFrontCodePtr( node->u.ic.opcode, node->u.ic.value.pvalue );
CgFrontCode( IC_EXPR_TRASH );
PTreeFree( node );
tree = NULL;
} else {
PTREE dup = tree;
if( NodeIsUnaryOp( tree, CO_EXPR_DONE ) ) {
a_expr = &dup->u.subtree[0];
} else {
a_expr = &dup;
}
*a_expr = NodeAddSideEffect( node, *a_expr );
tree = dup;
}
return tree;
}
PTREE CastIntConstant( PTREE expr, TYPE type, bool *happened )
{
PTREE new_expr;
target_ulong ul_val;
float_handle dbl_val;
type_id id;
bool signed_type;
signed_type = SignedIntType( expr->type );
id = TypedefModifierRemove( type )->id;
ul_val = expr->u.uint_constant;
if( NULL == Integral64Type( expr->type ) ) {
switch( id ) {
case TYP_SCHAR:
ul_val = (target_schar) ul_val;
/* fall through */
case TYP_SSHORT:
ul_val = (target_short) ul_val;
/* fall through */
case TYP_SINT:
ul_val = (target_int) ul_val;
/* fall through */
case TYP_SLONG:
ul_val = (target_long) ul_val;
new_expr = PTreeIntConstant( ul_val, id );
break;
case TYP_UCHAR:
ul_val = (target_uchar) ul_val;
/* fall through */
case TYP_USHORT:
ul_val = (target_ushort) ul_val;
/* fall through */
case TYP_UINT:
ul_val = (target_uint) ul_val;
/* fall through */
case TYP_ULONG:
ul_val = (target_ulong) ul_val;
new_expr = PTreeIntConstant( ul_val, id );
break;
case TYP_ULONG64:
case TYP_SLONG64:
if( PT_FLOATING_CONSTANT == expr->op ) {
new_expr = PTreeInt64Constant
( BFCnvF64( expr->u.floating_constant )
, id );
} else {
new_expr = PTreeInt64Constant( expr->u.int64_constant, id );
}
break;
case TYP_POINTER:
case TYP_MEMBER_POINTER:
ul_val = (target_ulong) ul_val;
new_expr = PTreeIntConstant( ul_val, TYP_ULONG );
new_expr->type = type;
break;
case TYP_FLOAT:
#if 0
// these are now identical, with canonical floating point
if( signed_type ) {
flt_val = BFCnvIF( expr->u.int_constant );
} else {
flt_val = BFCnvUF( expr->u.uint_constant );
}
new_expr = PTreeFloatingConstant( flt_val, id );
break;
#endif
case TYP_LONG_DOUBLE:
case TYP_DOUBLE:
if( signed_type ) {
dbl_val = BFCnvIF( expr->u.int_constant );
} else {
dbl_val = BFCnvUF( expr->u.uint_constant );
}
new_expr = PTreeFloatingConstant( dbl_val, id );
break;
case TYP_WCHAR:
ul_val = (target_wchar) ul_val;
new_expr = PTreeIntConstant( ul_val, id );
break;
default:
return( expr );
}
} else {
ul_val = expr->u.int_constant;
switch( id ) {
case TYP_SCHAR:
ul_val = (target_schar) ul_val;
/* fall through */
case TYP_SSHORT:
ul_val = (target_short) ul_val;
/* fall through */
case TYP_SINT:
ul_val = (target_int) ul_val;
/* fall through */
case TYP_SLONG:
ul_val = (target_long) ul_val;
new_expr = PTreeIntConstant( ul_val, id );
break;
case TYP_SLONG64:
case TYP_ULONG64:
new_expr = PTreeInt64Constant( expr->u.int64_constant, id );
break;
case TYP_UCHAR:
ul_val = (target_uchar) ul_val;
/* fall through */
case TYP_USHORT:
ul_val = (target_ushort) ul_val;
/* fall through */
case TYP_UINT:
ul_val = (target_uint) ul_val;
/* fall through */
case TYP_ULONG:
ul_val = (target_ulong) ul_val;
new_expr = PTreeIntConstant( ul_val, id );
break;
case TYP_POINTER:
case TYP_MEMBER_POINTER:
ul_val = (target_ulong) ul_val;
new_expr = PTreeIntConstant( ul_val, TYP_ULONG );
new_expr->type = type;
break;
case TYP_FLOAT:
#if 0
// these are now identical, with canonical floating point
if( signed_type ) {
flt_val = BFCnvI64F( expr->u.int64_constant );
} else {
flt_val = BFCnvU64F( expr->u.uint64_constant );
}
new_expr = PTreeFloatingConstant( flt_val, id );
break;
#endif
case TYP_LONG_DOUBLE:
case TYP_DOUBLE:
if( signed_type ) {
dbl_val = BFCnvI64F( expr->u.int64_constant );
} else {
dbl_val = BFCnvU64F( expr->u.int64_constant );
}
new_expr = PTreeFloatingConstant( dbl_val, id );
break;
case TYP_WCHAR:
ul_val = (target_wchar) ul_val;
new_expr = PTreeIntConstant( ul_val, id );
break;
default:
return( expr );
}
}
*happened = true;
new_expr->flags = expr->flags;
new_expr = PTreeCopySrcLocation( new_expr, expr );
PTreeFree( expr );
return( new_expr );
}
PTREE FoldBinary( PTREE expr )
/****************************/
{
PTREE orig1;
PTREE orig2;
PTREE op1;
PTREE op2;
PTREE op_t;
PTREE op_f;
PTREE op_test;
TYPE type;
unsigned typ1;
unsigned typ2;
bool cast_happened;
bool has_decoration_left;
bool has_decoration_right;
bool has_decoration;
type = expr->type;
orig1 = expr->u.subtree[0];
orig2 = expr->u.subtree[1];
type = expr->type;
op1 = overCondDecor( orig1 );
has_decoration_left = op1 != orig1;
op2 = overCondDecor( orig2 );
has_decoration_right = op2 != orig2;
has_decoration = has_decoration_left | has_decoration_left;
if( notFoldable( op1 ) ) {
if( notFoldable( op2 ) ) {
return( expr );
}
switch( expr->cgop ) {
case CO_EQ:
DbgVerify( ! has_decoration, "FoldBinary -- bad ==" );
if( zeroConstant( op2 ) ) {
if( zeroConstant( op1 ) ) {
expr = makeTrueFalse( expr, op1, 1 );
} else if( nonZeroExpr( op1 ) ) {
expr = makeTrueFalse( expr, op1, 0 );
}
}
break;
case CO_NE:
DbgVerify( ! has_decoration, "FoldBinary -- bad !=" );
if( zeroConstant( op2 ) ) {
if( zeroConstant( op1 ) ) {
expr = makeTrueFalse( expr, op1, 0 );
} else if( nonZeroExpr( op1 ) ) {
expr = makeTrueFalse( expr, op1, 1 );
}
}
break;
case CO_PLUS_EQUAL :
case CO_MINUS_EQUAL :
case CO_AND_EQUAL :
case CO_OR_EQUAL :
case CO_XOR_EQUAL :
case CO_EQUAL:
/* have to be careful with pointer scaling of numbers */
DbgVerify( ! has_decoration, "FoldBinary -- bad equals" );
if( ArithType( type ) != NULL ) {
expr->u.subtree[1] = castConstant( op2, type, &cast_happened );
}
break;
case CO_CONVERT:
DbgVerify( ! has_decoration, "FoldBinary -- bad convert" );
op_test = castConstant( op2, type, &cast_happened );
if( cast_happened ) {
/* op2 was freed */
op_test = PTreeCopySrcLocation( op_test, expr );
NodeFreeDupedExpr( op1 );
PTreeFree( expr );
return( op_test );
}
break;
case CO_COMMA :
//
// X, c -- can be optimized when X is PT_IC( IC_COND_TRUE )
// and comma node has PTF_COND_END set
//
if( (expr->flags & PTF_COND_END)
&& op1->op == PT_IC
&& op1->u.ic.opcode == IC_COND_TRUE ) {
expr = pruneExpr( expr, &expr->u.subtree[1], op2 );
}
break;
}
return( expr );
}
if( notFoldable( op2 ) ) {
switch( expr->cgop ) {
case CO_EQ:
DbgVerify( ! has_decoration, "FoldBinary -- bad ==" );
if( zeroConstant( op1 ) ) {
if( zeroConstant( op2 ) ) {
expr = makeTrueFalse( expr, op2, 1 );
} else if( nonZeroExpr( op2 ) ) {
expr = makeTrueFalse( expr, op2, 0 );
}
}
break;
case CO_NE:
DbgVerify( ! has_decoration, "FoldBinary -- bad !=" );
if( zeroConstant( op1 ) ) {
if( zeroConstant( op2 ) ) {
expr = makeTrueFalse( expr, op2, 0 );
} else if( nonZeroExpr( op2 ) ) {
expr = makeTrueFalse( expr, op2, 1 );
}
}
break;
case CO_AND_AND:
// DbgVerify( has_decoration, "FoldBinary -- bad &&" );
if( ! zeroConstant( op1 ) ) {
/* 1 && X => X (X is already boolean) */
expr = pruneExpr( expr, &expr->u.subtree[1], op2 );
} else {
/* 0 && X => 0 */
return pruneExpr( expr, &expr->u.subtree[0], op1 );
}
break;
case CO_OR_OR:
// DbgVerify( has_decoration, "FoldBinary -- bad ||" );
if( zeroConstant( op1 ) ) {
/* 0 || X => X (X is already boolean) */
return pruneExpr( expr, &expr->u.subtree[1], op2 );
} else {
/* 1 || X => 1 */
return pruneExpr( expr, &expr->u.subtree[0], op1 );
}
break;
case CO_COMMA:
/* c , X => X */
// DbgVerify( ! has_decoration, "FoldBinary -- bad comma" );
expr->u.subtree[1] = NULL;
op2 = PTreeCopySrcLocation( op2, expr );
NodeFreeDupedExpr( expr );
return( op2 );
case CO_QUESTION:
DbgVerify( ! has_decoration, "FoldBinary -- bad ?" );
op_t = op2->u.subtree[0];
op_f = op2->u.subtree[1];
has_decoration = isCondDecor( op_t );
DbgVerify( has_decoration == isCondDecor( op_f )
, "FoldBinary -- bad ?:" );
if( has_decoration ) {
op_t = op_t->u.subtree[1];
op_f = op_f->u.subtree[1];
}
if( ! zeroConstant( op1 ) ) {
/* 1 ? T : F => T */
if( has_decoration ) {
op2->u.subtree[0]->u.subtree[1] = NULL;
} else {
op2->u.subtree[0] = NULL;
}
op2 = op_t;
} else {
/* 0 ? T : F => F */
if( has_decoration ) {
op2->u.subtree[1]->u.subtree[1] = NULL;
} else {
op2->u.subtree[1] = NULL;
}
op2 = op_f;
}
op2 = PTreeCopySrcLocation( op2, expr );
NodeFreeDupedExpr( expr );
return( op2 );
}
} else {
typ1 = op1->op;
typ2 = op2->op;
if( ! isIntFloatOp( typ1 ) || ! isIntFloatOp( typ2 ) ) {
// (void)0 can make it here
return expr;
}
if( typ1 != typ2 ) {
if( PT_FLOATING_CONSTANT == typ1 ) {
if( NULL == Integral64Type( op2->type ) ) {
if( SignedIntType( op2->type ) ) {
op2->u.floating_constant
= BFCnvIF( op2->u.int_constant );
} else {
op2->u.floating_constant
= BFCnvUF( op2->u.uint_constant );
}
} else {
if( SignedIntType( op2->type ) ) {
op2->u.floating_constant
= BFCnvI64F( op2->u.int64_constant );
} else {
op2->u.floating_constant
= BFCnvU64F( op2->u.int64_constant );
}
}
typ2 = PT_FLOATING_CONSTANT;
op2->op = typ2;
} else {
if( NULL == Integral64Type( op1->type ) ) {
if( SignedIntType( op1->type ) ) {
op1->u.floating_constant
= BFCnvIF( op1->u.int_constant );
} else {
op1->u.floating_constant
= BFCnvUF( op1->u.uint_constant );
}
} else {
if( SignedIntType( op1->type ) ) {
op1->u.floating_constant
= BFCnvI64F( op1->u.int64_constant );
} else {
op1->u.floating_constant
= BFCnvU64F( op1->u.int64_constant );
}
}
typ1 = PT_FLOATING_CONSTANT;
op1->op = typ2;
}
}
if( PT_FLOATING_CONSTANT == typ1 ) {
op1 = foldFloating( expr->cgop, op1, op2->u.floating_constant );
} else if( SignedIntType( op1->type ) ) {
if( NULL == Integral64Type( op1->type )
&& NULL == Integral64Type( op2->type ) ) {
op1 = foldInt( expr->cgop, op1, op2->u.int_constant );
} else {
op1 = foldInt64( expr->cgop, op1, op2->u.int64_constant );
}
} else {
if( NULL == Integral64Type( op1->type )
&& NULL == Integral64Type( op2->type ) ) {
op1 = foldUInt( expr->cgop, op1, op2->u.uint_constant );
} else {
op1 = foldUInt64( expr->cgop, op1, op2->u.int64_constant );
}
}
if( op1 != NULL ) {
/* binary op was folded! */
if( has_decoration ) {
orig1->u.subtree[1] = NULL;
orig2->u.subtree[1] = NULL;
} else {
expr->u.subtree[0] = NULL;
}
op1 = castConstant( op1, type, &cast_happened );
op1 = PTreeCopySrcLocation( op1, expr );
NodeFreeDupedExpr( expr );
return op1;
}
}
return( expr );
}
