/*
-** LCLint - annotation-assisted static program checker
-** Copyright (C) 1994-2001 University of Virginia,
+** Splint - annotation-assisted static program checker
+** Copyright (C) 1994-2003 University of Virginia,
** Massachusetts Institute of Technology
**
** This program is free software; you can redistribute it and/or modify it
** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
** MA 02111-1307, USA.
**
-** For information on lclint: lclint-request@cs.virginia.edu
-** To report a bug: lclint-bug@cs.virginia.edu
-** For more information: http://lclint.cs.virginia.edu
+** For information on splint: info@splint.org
+** To report a bug: splint-bug@splint.org
+** For more information: http://www.splint.org
*/
/*
** storeRef.c
**
*/
-# include "lclintMacros.nf"
+# include "splintMacros.nf"
# include "basic.h"
# include "exprChecks.h"
# include "transferChecks.h"
static bool sRef_isAllocatedStorage (sRef p_s) /*@*/ ;
static void sRef_setNullErrorLoc (sRef p_s, fileloc) /*@*/ ;
-
-static void
- sRef_aliasSetComplete (void (p_predf) (sRef, fileloc), sRef p_s, fileloc p_loc)
- /*@modifies p_s@*/ ;
+static void sRef_setNullStateN (sRef p_s, nstate p_n) /*@modifies p_s@*/ ;
static int sRef_depth (sRef p_s) /*@*/ ;
sRef_innerAliasSetCompleteParam (void (p_predf) (sRef, sRef), sRef p_s, sRef p_t)
/*@modifies p_s@*/ ;
-static void
- sRef_aliasSetCompleteParam (void (p_predf) (sRef, alkind, fileloc), sRef p_s,
- alkind p_kind, fileloc p_loc)
- /*@modifies p_s@*/ ;
-
static speckind speckind_fromInt (int p_i);
static bool sRef_equivalent (sRef p_s1, sRef p_s2);
static bool sRef_isDeepUnionField (sRef p_s);
static void sRef_addDeriv (/*@notnull@*/ sRef p_s, /*@notnull@*/ /*@exposed@*/ sRef p_t);
-static /*@dependent@*/ sRef sRef_makeResultType (ctype p_ct) /*@*/ ;
static bool sRef_checkModify (sRef p_s, sRefSet p_sl) /*@*/ ;
+/*
+** If s is definitely null, it has no memory state.
+*/
+
+static void sRef_resetAliasKind (/*@notnull@*/ sRef s) /*@modifies s->aliaskind@*/
+{
+ if (s->nullstate == NS_DEFNULL)
+ {
+ /* s->aliaskind = AK_ERROR; */
+ }
+}
+
+# ifdef DEBUGSPLINT
+extern void sRef_checkCompletelyReasonable (sRef s) /*@*/
+{
+ DPRINTF (("Check sRef: [%p] %s / %s", s, sRef_unparse (s),
+ sRefSet_unparse (sRef_derivedFields (s))));
+
+ if (sRef_isReasonable (s))
+ {
+ sRefSet_elements (s->deriv, el)
+ {
+ llassert (el != s);
+ sRef_checkCompletelyReasonable (el);
+ } end_sRefSet_elements ;
+ }
+}
+# endif
+
+/*@falsewhennull@*/ bool sRef_isReasonable (sRef s) /*@*/
+{
+ if (sRef_isValid (s))
+ {
+# ifdef DEBUGSPLINT
+ if (!bool_isReasonable (s->safe)
+ || !bool_isReasonable (s->modified)
+ || !bool_isReasonable (s->immut))
+ {
+ llcontbug (message ("Unreasonable sRef [%p]", s));
+ return FALSE;
+ }
+
+ if (!sstate_isValid (s->defstate))
+ {
+ llcontbug (message ("Unreasonable sRef [%p]", s));
+ return FALSE;
+ }
+
+ if (!nstate_isValid (s->nullstate))
+ {
+ llcontbug (message ("Unreasonable sRef [%p]", s));
+ return FALSE;
+ }
+
+ if (!alkind_isValid (s->aliaskind)
+ || !alkind_isValid (s->oaliaskind))
+ {
+ llcontbug (message ("Unreasonable sRef [%p]", s));
+ return FALSE;
+ }
+
+ if (!exkind_isValid (s->expkind)
+ || !exkind_isValid (s->oexpkind))
+ {
+ llcontbug (message ("Unreasonable sRef [%p]", s));
+ return FALSE;
+ }
+# endif
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static /*@nullwhentrue@*/ bool sRef_isUnreasonable (sRef s) /*@*/
+{
+ return (!sRef_isReasonable (s));
+}
+
static void sRef_checkMutable (/*@unused@*/ sRef s)
{
- /*@i235@*/
- if (sRef_isValid (s) && s->immut)
+ if (sRef_isReasonable (s) && s->immut)
{
llcontbug (message ("Modification to sRef marked immutable: %q",
sRef_unparseFull (s)));
static /*@null@*/ sinfo sinfo_copy (/*@notnull@*/ sRef p_s) /*@*/ ;
static void sRef_setPartsFromUentry (sRef p_s, uentry p_ue)
/*@modifies p_s@*/ ;
-static bool checkDeadState (/*@notnull@*/ sRef p_el, bool p_tbranch, fileloc p_loc);
+static bool checkDeadState (/*@notnull@*/ sRef p_el, /*@null@*/ sRef p_e2,
+ bool p_tbranch, fileloc p_loc);
static /*@dependent@*/ sRef sRef_constructPointerAux (/*@notnull@*/ /*@exposed@*/ sRef p_t) /*@*/ ;
static void
static /*@only@*/ cstring sRef_unparseNoArgs (sRef p_s);
static /*@exposed@*/ sRef sRef_findDerivedPointer (sRef p_s);
+static /*@exposed@*/ sRef sRef_findDerivedArrayFetch (/*@notnull@*/ sRef, bool, int, bool) ;
static /*@exposed@*/ sRef sRef_findDerivedField (/*@notnull@*/ sRef p_rec, cstring p_f);
static /*@exposed@*/ sRef
sRef_getDeriv (/*@notnull@*/ /*@returned@*/ sRef p_set, sRef p_guide);
{
llassert (FALSE);
- if (!sRef_isValid (s)) return;
+ if (!sRef_isReasonable (s)) return;
if (sRefSet_containsSameObject (checkedsofar, s))
{
case SK_PARAM:
llassert (s->info->paramno >= -1);
- llassert (s->info->paramno <= 50); /*@i32 bogus...*/
+ llassert (s->info->paramno <= 999); /* sanity check */
break;
case SK_ARRAYFETCH:
s->safe = TRUE;
s->modified = FALSE;
s->immut = FALSE;
+ s->val = multiVal_undefined;
s->type = ctype_unknown;
s->defstate = SS_UNKNOWN;
/* start modifications */
s->bufinfo.bufstate = BB_NOTNULLTERMINATED;
+ s->bufinfo.size = -1;
+ s->bufinfo.len = -1;
/* end modifications */
s->aliaskind = AK_UNKNOWN;
fieldname = sRef_getField (s);
base = sRef_getBase (s);
- while (sRef_isValid (base))
+ while (sRef_isReasonable (base))
{
if (sRef_isField (base))
{
{
if (!context_inProtectVars ()
&& !protectDerivs
- && sRef_isValid (s)
- && sRef_isValid (t)
+ && sRef_isReasonable (s)
+ && sRef_isReasonable (t)
&& !sRef_isConst (s))
{
int sd = sRef_depth (s);
return;
}
+ /* This sometimes fails: (evans 2001-07-12)
+ if (sRef_isArrayFetch (t))
+ {
+ DPRINTF (("Derived fetch: %s / %s / %s",
+ sRef_unparseFull (s), sRef_unparseFull (t),
+ sRef_unparseFull (t->info->arrayfetch->arr)));
+ llassert (t->info->arrayfetch->arr == s);
+ }
+ */
+
if (sRef_isFileOrGlobalScope (s))
{
if (context_inFunctionLike ()
}
else
{
+ DPRINTF (("Add deriv: [%p] %s / [%p] %s",
+ s, sRef_unparse (s),
+ t, sRef_unparse (t)));
+
s->deriv = sRefSet_insert (s->deriv, t);
}
}
bool
sRef_deepPred (bool (predf) (sRef), sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if ((*predf)(s)) return TRUE;
void sRef_setStateFromType (sRef s, ctype ct)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (ctype_isUser (ct))
{
static void sRef_setTypeState (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef_setStateFromType (s, s->type);
}
}
-static bool
- sRef_hasAliasInfoLoc (sRef s)
+bool sRef_hasAliasInfoLoc (sRef s)
{
- return (sRef_isValid (s) && (s->aliasinfo != NULL)
+ return (sRef_isReasonable (s) && (s->aliasinfo != NULL)
&& (fileloc_isDefined (s->aliasinfo->loc)));
}
-static /*@falsenull@*/ bool
-sRef_hasStateInfoLoc (sRef s)
+/*@falsewhennull@*/ bool sRef_hasStateInfoLoc (sRef s)
{
- return (sRef_isValid (s) && (s->definfo != NULL)
+ return (sRef_isReasonable (s) && (s->definfo != NULL)
&& (fileloc_isDefined (s->definfo->loc)));
}
-static /*@falsenull@*/ bool
-sRef_hasExpInfoLoc (sRef s)
+/*@falsewhennull@*/ bool sRef_hasExpInfoLoc (sRef s)
{
- return (sRef_isValid (s)
+ return (sRef_isReasonable (s)
&& (s->expinfo != NULL) && (fileloc_isDefined (s->expinfo->loc)));
}
+# if 0
static /*@observer@*/ /*@unused@*/ stateInfo sRef_getInfo (sRef s, cstring key)
{
stateValue sv;
- if (!sRef_isValid (s)) {
+ if (!sRef_isReasonable (s)) {
return stateInfo_undefined;
}
return stateInfo_undefined;
}
-
+# endif
static bool
sRef_hasNullInfoLoc (sRef s)
{
- return (sRef_isValid (s) && s->nullinfo != NULL
+ return (sRef_isReasonable (s) && s->nullinfo != NULL
&& (fileloc_isDefined (s->nullinfo->loc)));
}
bool
sRef_hasAliasInfoRef (sRef s)
{
- return (sRef_isValid (s) && (s->aliasinfo != NULL)
- && (sRef_isValid (s->aliasinfo->ref)));
+ return (sRef_isReasonable (s) && (s->aliasinfo != NULL)
+ && (sRef_isReasonable (s->aliasinfo->ref)));
}
static /*@observer@*/ fileloc
sRef_getAliasInfoLoc (/*@exposed@*/ sRef s)
{
- llassert (sRef_isValid (s) && s->aliasinfo != NULL
+ llassert (sRef_isReasonable (s) && s->aliasinfo != NULL
&& (fileloc_isDefined (s->aliasinfo->loc)));
return (s->aliasinfo->loc);
}
static /*@observer@*/ fileloc
sRef_getStateInfoLoc (/*@exposed@*/ sRef s)
{
- llassert (sRef_isValid (s) && s->definfo != NULL
+ llassert (sRef_isReasonable (s) && s->definfo != NULL
&& (fileloc_isDefined (s->definfo->loc)));
return (s->definfo->loc);
}
static /*@observer@*/ fileloc
sRef_getExpInfoLoc (/*@exposed@*/ sRef s)
{
- llassert (sRef_isValid (s) && s->expinfo != NULL
+ llassert (sRef_isReasonable (s) && s->expinfo != NULL
&& (fileloc_isDefined (s->expinfo->loc)));
return (s->expinfo->loc);
}
static /*@observer@*/ fileloc
sRef_getNullInfoLoc (/*@exposed@*/ sRef s)
{
- llassert (sRef_isValid (s) && s->nullinfo != NULL
+ llassert (sRef_isReasonable (s) && s->nullinfo != NULL
&& (fileloc_isDefined (s->nullinfo->loc)));
return (s->nullinfo->loc);
}
/*@observer@*/ sRef
sRef_getAliasInfoRef (/*@temp@*/ sRef s)
{
- llassert (sRef_isValid (s) && s->aliasinfo != NULL);
+ llassert (sRef_isReasonable (s) && s->aliasinfo != NULL);
return (s->aliasinfo->ref);
}
}
static bool oldInFunction = FALSE;
+static int nestedScope = 0;
void sRef_setGlobalScopeSafe ()
{
- oldInFunction = inFunction;
- DPRINTF (("leave function"));
+ if (nestedScope == 0)
+ {
+ oldInFunction = inFunction;
+ }
+
+ nestedScope++;
+ DPRINTF (("leave function safe"));
inFunction = FALSE;
}
void sRef_clearGlobalScopeSafe ()
{
- inFunction = oldInFunction;
- DPRINTF (("clear function: %s", bool_unparse (inFunction)));
+ nestedScope--;
+ llassert (nestedScope >= 0);
+
+ if (nestedScope == 0)
+ {
+ inFunction = oldInFunction;
+ }
+
+ DPRINTF (("clear function: %s", bool_unparse (inFunction)));
}
void sRef_enterFunctionScope ()
{
+ /* evans 2001-09-09 - cleanup if we are in a macro! */
+ if (context_inMacro ())
+ {
+ if (inFunction) {
+ sRef_exitFunctionScope ();
+ }
+ }
+
llassert (!inFunction);
llassert (sRefTable_isEmpty (allRefs));
inFunction = TRUE;
}
void sRef_exitFunctionScope ()
-{
-
+{
if (inFunction)
{
DPRINTF (("Exit function scope."));
sRefTable_clear (allRefs);
+ DPRINTF (("Exit function scope done."));
inFunction = FALSE;
}
else
s = sRef_getConjA (s);
} while (sRef_isConj (s));
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
return s; /* don't need to ref */
}
else
bool res = FALSE;
sRef base = sRef_getRootBase (s);
- if (sRef_isValid (base))
+ if (sRef_isReasonable (base))
{
res = sRef_isParam (base) || sRef_isFileOrGlobalScope (base) || sRef_isExternal (base);
}
sRef base = sRef_getRootBase (s);
uentry res = uentry_undefined;
- if (sRef_isValid (base))
+ if (sRef_isReasonable (base))
{
switch (base->kind)
{
case SK_PARAM:
- res = usymtab_getRefQuiet (paramsScope, base->info->paramno);
+ res = usymtab_getRefQuiet (paramsScope, usymId_fromInt (base->info->paramno));
break;
case SK_CVAR:
sRef ret;
sRef res;
- if (!sRef_isValid (s)) return sRef_undefined;
+ if (!sRef_isReasonable (s)) return sRef_undefined;
switch (s->kind)
{
uentry
sRef_getUentry (sRef s)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
switch (s->kind)
{
case SK_PARAM:
- return (usymtab_getRefQuiet (paramsScope, s->info->paramno));
+ return (usymtab_getRefQuiet (paramsScope, usymId_fromInt (s->info->paramno)));
case SK_CVAR:
return (usymtab_getRefQuiet (s->info->cvar->lexlevel, s->info->cvar->index));
case SK_CONJ:
return sRef_getUentry (s->info->conj->b);
}
}
+ case SK_FIELD: /* evans 2002-07-17: added case for SK_FIELD */
case SK_UNKNOWN:
case SK_SPECIAL:
return uentry_undefined;
int
sRef_getParam (sRef s)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
llassert (s->kind == SK_PARAM);
return s->info->paramno;
bool
sRef_isModified (sRef s)
{
- return (!sRef_isValid (s) || s->modified);
+ return (!sRef_isReasonable (s) || s->modified);
}
void sRef_setModified (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
s->modified = TRUE;
{
sRef base = sRef_getBase (s);
-
llassert (s->kind == SK_FIELD);
-
if (sRef_isPointer (base))
{
base = sRef_getBase (base);
bool
sRef_canModify (sRef s, sRefSet sl)
{
-
if (context_getFlag (FLG_MUSTMOD))
{
return (sRef_doModify (s, sl));
static bool sRef_checkModify (sRef s, sRefSet sl)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
switch (s->kind)
{
static
bool sRef_doModifyVal (sRef s, sRefSet sl)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
switch (s->kind)
static
bool sRef_doModify (sRef s, sRefSet sl)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
switch (s->kind)
{
{
llassert (sRef_similar (s1, s2));
- if (!sRef_isValid (s1)) return s1;
- if (!sRef_isValid (s2)) return s1;
+ if (!sRef_isReasonable (s1)) return s1;
+ if (!sRef_isReasonable (s2)) return s1;
sRef_combineDefState (s1, s2);
sRef_combineNullState (s1, s2);
bool
sRef_realSame (sRef s1, sRef s2)
{
- if (s1 == s2) return TRUE;
- if (sRef_isInvalid (s1) || sRef_isInvalid (s2)) return FALSE;
+ if (s1 == s2) return TRUE;
+
+ if (sRef_isUnreasonable (s1)
+ || sRef_isUnreasonable (s2))
+ {
+ return FALSE;
+ }
switch (s1->kind)
{
s is an sRef of a formal paramenter in a function call constraint
we trys to return a constraint expression derived from the actual parementer of a function call.
*/
+
/*@only@*/ constraintExpr sRef_fixConstraintParam (/*@observer@*/ sRef s, /*@observer@*/ /*@temp@*/ exprNodeList args)
{
constraintExpr ce;
{
case SK_RESULT:
{
- // s = sRef_saveCopy(s);
ce = constraintExpr_makeTermsRef (s);
return ce;
}
{
sRef temp;
temp = (sRef_makePointer (sRef_fixBaseParam (s->info->ref, args)));
- //temp = sRef_saveCopy(temp);
ce = constraintExpr_makeTermsRef (temp);
return ce;
}
return ce;
}
case SK_PARAM:
- llassert(exprNodeList_size (args) > s->info->paramno);
- {
- exprNode e = exprNodeList_nth (args, s->info->paramno);
-
- llassert( !(exprNode_isError (e)) );
- ce = constraintExpr_makeExprNode (e);
- return ce;
- }
+ {
+ exprNode e;
+ llassert (exprNodeList_size (args) > s->info->paramno);
+ e = exprNodeList_nth (args, s->info->paramno);
+
+ llassert (!(exprNode_isError (e)));
+ ce = constraintExpr_makeExprNode (e);
+ return ce;
+ }
default:
{
sRef temp;
- llcontbug ((message("Trying to do fixConstraintParam on nonparam, nonglobal: %q for function with arguments %q", sRef_unparse (s), exprNodeList_unparse(args) ) ));
+ llcontbug (message ("Trying to do fixConstraintParam on nonparam, nonglobal: %q for function with arguments %q",
+ sRef_unparse (s), exprNodeList_unparse(args)));
temp = sRef_saveCopy(s);
ce = constraintExpr_makeTermsRef (temp);
return ce;
}
}
-
-
-
}
/*@exposed@*/ sRef
(sRef_fixBaseParam (s->info->arrayfetch->arr, args)));
}
case SK_FIELD:
- return (sRef_makeField (sRef_fixBaseParam (s->info->field->rec, args),
- s->info->field->field));
-
+ {
+ sRef res;
+ DPRINTF (("Fix field: %s", sRef_unparseFull (s)));
+ res = sRef_makeField (sRef_fixBaseParam (s->info->field->rec, args),
+ s->info->field->field);
+ DPRINTF (("Returns: %s", sRef_unparseFull (res)));
+ return res;
+ }
case SK_PTR:
return (sRef_makePointer (sRef_fixBaseParam (s->info->ref, args)));
reader_checkChar (c, '@');
nullstate = nstate_fromInt (reader_getInt (c));
- ret = sRef_makeGlobal (uid, ctype_unknown);
+ ret = sRef_makeGlobal (uid, ctype_unknown, stateInfo_currentLoc ());
sRef_setNullStateN (ret, nullstate);
ret->defstate = defstate;
return ret;
BADEXIT;
}
-/*@exposed@*/ sRef
-sRef_undump (char **c)
+static /*@exposed@*/ sRef sRef_undumpBody (char **c)
{
char p = **c;
switch (p)
{
case 'g':
- return (sRef_makeGlobal (usymId_fromInt (reader_getInt (c)), ctype_unknown));
+ return (sRef_makeGlobal (usymId_fromInt (reader_getInt (c)),
+ ctype_unknown, stateInfo_currentLoc ()));
case 'p':
- return (sRef_makeParam (reader_getInt (c), ctype_unknown));
+ return (sRef_makeParam (reader_getInt (c), ctype_unknown,
+ stateInfo_makeLoc (g_currentloc, SA_DECLARED)));
case 'r':
- return (sRef_makeResultType (ctype_undump (c)));
+ return (sRef_makeResult (ctype_undump (c)));
case 'a':
{
if ((**c >= '0' && **c <= '9') || **c == '-')
BADEXIT;
}
-/*@only@*/ cstring
-sRef_dump (sRef s)
+/*@exposed@*/ sRef sRef_undump (char **c)
+{
+ sRef res = sRef_undumpBody (c);
+
+ if (reader_optCheckChar (c, '='))
+ {
+ multiVal mv = multiVal_undump (c);
+ sRef_setValue (res, mv);
+ reader_checkChar (c, '=');
+ }
+
+ return res;
+}
+
+static /*@only@*/ cstring sRef_dumpBody (sRef s)
{
if (sRef_isInvalid (s))
{
BADEXIT;
}
+/*@only@*/ cstring sRef_dump (sRef s)
+{
+ cstring res = sRef_dumpBody (s);
+
+ if (sRef_hasValue (s))
+ {
+ res = message ("%q=%q=", res, multiVal_dump (sRef_getValue (s)));
+ }
+
+ return res;
+}
+
cstring sRef_dumpGlobal (sRef s)
{
+ llassert (!sRef_hasValue (s));
+
if (sRef_isInvalid (s))
{
return (cstring_makeLiteral ("-"));
return uentry_getName (ue);
}
- return (message ("<bad param: %q / args %q",
- sRef_unparseDebug (s),
- uentryList_unparse (args)));
+ return (message ("parameter %d", s->info->paramno + 1));
}
case SK_ARRAYFETCH:
if (s->info->arrayfetch->indknown)
case SK_TYPE:
return (message ("<type %s>", ctype_unparse (s->type)));
case SK_CONST:
- return (message ("<const %s>", ctype_unparse (s->type)));
+ if (sRef_hasValue (s))
+ {
+ return (message ("<const %s=%q>", ctype_unparse (s->type), multiVal_unparse (sRef_getValue (s))));
+ }
+ else
+ {
+ return (message ("<const %s>", ctype_unparse (s->type)));
+ }
case SK_RESULT:
return (message ("<result %s>", ctype_unparse (s->type)));
case SK_SPECIAL:
s->kind = SK_UNCONSTRAINED;
s->info = (sinfo) dmalloc (sizeof (*s->info));
- s->info->fname = fname;
+ s->info->fname = cstring_copy (fname); /* evans 2002-07-12: this was exposed, causing memory errors */
return (s);
}
bool sRef_isUnconstrained (sRef s)
{
- return (sRef_isValid(s) && s->kind == SK_UNCONSTRAINED);
+ return (sRef_isReasonable(s) && s->kind == SK_UNCONSTRAINED);
}
static /*@dependent@*/ /*@notnull@*/ sRef
- sRef_makeCvarAux (int level, usymId index, ctype ct)
+ sRef_makeCvarAux (int level, usymId index, ctype ct, /*@only@*/ stateInfo stinfo)
{
sRef s = sRef_newRef ();
DPRINTF (("Made cvar: [%p] %s", s, sRef_unparseDebug (s)));
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stinfo);
return s;
}
-/*@dependent@*/ sRef sRef_makeCvar (int level, usymId index, ctype ct)
+/*@dependent@*/ sRef sRef_makeCvar (int level, usymId index, ctype ct, /*@only@*/ stateInfo stinfo)
{
- return (sRef_makeCvarAux (level, index, ct));
+ return (sRef_makeCvarAux (level, index, ct, stinfo));
}
int sRef_lexLevel (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef conj;
conj = sRef_fixConj (s);
s = sRef_getRootBase (conj);
- if (sRef_isValid (s) && s->kind == SK_CVAR)
+ if (sRef_isReasonable (s) && s->kind == SK_CVAR)
{
return (s->info->cvar->lexlevel);
}
}
sRef
-sRef_makeGlobal (usymId l, ctype ct)
+sRef_makeGlobal (usymId l, ctype ct, /*@only@*/ stateInfo stinfo)
{
- return (sRef_makeCvar (globScope, l, ct));
+ return (sRef_makeCvar (globScope, l, ct, stinfo));
}
void
sRef_setParamNo (sRef s, int l)
{
- llassert (sRef_isValid (s) && s->kind == SK_PARAM);
+ llassert (sRef_isReasonable (s) && s->kind == SK_PARAM);
s->info->paramno = l;
llassert (l >= -1);
}
/*@dependent@*/ sRef
-sRef_makeParam (int l, ctype ct)
+sRef_makeParam (int l, ctype ct, stateInfo stinfo)
{
sRef s = sRef_new ();
/* (probably defined, unless its an out parameter) */
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stinfo);
return s;
}
{
bool res;
- llassert (sRef_isValid (arr));
+ llassert (sRef_isReasonable (arr));
arr = sRef_fixConj (arr);
llassert (arr->kind == SK_ARRAYFETCH);
{
int result;
- llassert (sRef_isValid (arr));
+ llassert (sRef_isReasonable (arr));
arr = sRef_fixConj (arr);
llassert (arr->kind == SK_ARRAYFETCH);
s->kind = SK_ADR;
s->type = ctype_makePointer (t->type);
s->info = (sinfo) dmalloc (sizeof (*s->info));
- s->info->ref = t; /* sRef_copy (t); */ /*@i32@*/
+ s->info->ref = t;
if (t->defstate == SS_UNDEFINED)
/* no! it is allocated even still: && !ctype_isPointer (t->type)) */
}
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s,
+ stateInfo_makeLoc (g_currentloc, SA_CREATED));
return s;
}
}
{
cstring res;
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
s = sRef_fixConj (s);
- llassertprint (sRef_isValid (s) && (s->kind == SK_FIELD),
+ llassertprint (sRef_isReasonable (s) && (s->kind == SK_FIELD),
("s = %s", sRef_unparseDebug (s)));
res = s->info->field->field;
("Warning: reference base limit exceeded for %q. "
"This either means there is a variable with at least "
"%d indirections from this reference, or "
- "there is a bug in LCLint.",
+ "there is a bug in Splint.",
sRef_unparse (s),
MAXBASEDEPTH),
g_currentloc);
sRef
sRef_makeObject (ctype o)
{
- sRef s = sRef_newRef (); /*@i423 same line is bad...@*/
+ sRef s = sRef_newRef ();
s->kind = SK_OBJECT;
s->info = (sinfo) dmalloc (sizeof (*s->info));
s->info->object = o;
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
return s;
}
{
sRef s = sRef_newRef ();
- llassert (sRef_isValid (t));
+ llassert (sRef_isReasonable (t));
s->kind = SK_EXTERNAL;
s->info = (sinfo) dmalloc (sizeof (*s->info));
s->type = t->type;
- s->info->ref = t; /* sRef_copy (t); */ /*@i32 was exposed@*/
+ s->info->ref = t;
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_DECLARED));
return s;
}
/*@dependent@*/ sRef sRef_makeDerived (/*@exposed@*/ sRef t)
{
- if (sRef_isValid (t))
+ if (sRef_isReasonable (t))
{
sRef s = sRef_newRef ();
s->kind = SK_DERIVED;
s->info = (sinfo) dmalloc (sizeof (*s->info));
- s->info->ref = t; /* sRef_copy (t); */ /*@i32@*/
+ s->info->ref = t;
s->type = t->type;
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
return s;
}
else
void
sRef_mergeStateQuiet (sRef res, sRef other)
{
- llassert (sRef_isValid (res));
- llassert (sRef_isValid (other));
+ llassert (sRef_isReasonable (res));
+ llassert (sRef_isReasonable (other));
res->modified = res->modified || other->modified;
res->safe = res->safe && other->safe;
{
bool changed = FALSE;
- llassert (sRef_isValid (res));
- llassert (sRef_isValid (other));
+ llassert (sRef_isReasonable (res));
+ llassert (sRef_isReasonable (other));
sRef_checkMutable (res);
if (res->kind != other->kind)
if (other->defstate != SS_UNKNOWN)
{
res->defstate = other->defstate;
+ res->definfo = stateInfo_update (res->definfo, other->definfo);
}
}
}
else
{
- if (sRef_getNullState (other) != NS_UNKNOWN && sRef_getNullState (other) != sRef_getNullState (res))
+ if (sRef_getNullState (other) != NS_UNKNOWN
+ && sRef_getNullState (other) != sRef_getNullState (res))
{
changed = TRUE;
sRef_updateNullState (res, other);
void
sRef_mergeState (sRef res, sRef other, clause cl, fileloc loc)
{
- if (sRef_isValid (res) && sRef_isValid (other))
+ if (sRef_isReasonable (res) && sRef_isReasonable (other))
{
sRef_mergeStateAux (res, other, cl, FALSE, loc, TRUE);
}
void
sRef_mergeOptState (sRef res, sRef other, clause cl, fileloc loc)
{
- if (sRef_isValid (res) && sRef_isValid (other))
+ if (sRef_isReasonable (res) && sRef_isReasonable (other))
{
sRef_mergeStateAux (res, other, cl, TRUE, loc, TRUE);
}
bool doDerivs)
/*@modifies res@*/
{
- llassertfatal (sRef_isValid (res));
- llassertfatal (sRef_isValid (other));
+ llassertfatal (sRef_isReasonable (res));
+ llassertfatal (sRef_isReasonable (other));
+ DPRINTF (("Merge aux: %s / %s",
+ sRef_unparseFull (res),
+ sRef_unparseFull (other)));
+
sRef_checkMutable (res);
sRef_checkMutable (other);
res->defstate = SS_DEAD;
}
+ res->definfo = stateInfo_update (res->definfo, other->definfo);
sRef_clearDerived (other);
sRef_clearDerived (res);
}
{
sRef nother = sRef_buildPointer (sRef_getBase (other));
- if (sRef_isValid (nother))
+ if (sRef_isReasonable (nother))
{
sRef_copyState (nother, other);
sRef_mergeStateAux (res, nother, cl, opt, loc, doDerivs);
** Merge value table states
*/
+# if 0
+ /*
+ ** This doesn't do anything. And its broken too...
+ */
+
valueTable_elements (res->state, key, sv)
{
stateValue os = valueTable_lookup (other->state, key);
DPRINTF (("Val: %d / %s", val, msg));
*/
} end_valueTable_elements ;
+# endif
+
+ DPRINTF (("Merge aux: %s / %s",
+ sRef_unparseFull (res),
+ sRef_unparseFull (other)));
}
static sRefSet
{
sRefSet_allElements (other, el)
{
- if (sRef_isValid (el))
+ if (sRef_isReasonable (el))
{
sRef e2 = sRefSet_lookupMember (other, el);
- if (sRef_isValid (e2))
+ if (sRef_isReasonable (e2))
{
sRef_mergeStateAux (el, e2, cl, opt, loc, FALSE);
}
sRefSet_allElements (res, el)
{
- if (sRef_isValid (el))
+ if (sRef_isReasonable (el))
{
sRef e2 = sRefSet_lookupMember (other, el);
- if (sRef_isValid (e2))
+ if (sRef_isReasonable (e2))
{
if (el->defstate == SS_ALLOCATED &&
e2->defstate == SS_PDEFINED)
el->defstate == SS_PDEFINED)
{
el->defstate = SS_ALLOCATED;
+ el->definfo = stateInfo_update (el->definfo, e2->definfo);
sRef_clearDerived (el);
}
else if ((el->defstate == SS_DEAD || sRef_isKept (el)) &&
(e2->defstate == SS_DEFINED && !sRef_isKept (e2)))
{
-
- if (checkDeadState (el, TRUE, loc))
+ DPRINTF (("Checking dead: %s / %s", sRef_unparseFull (el),
+ sRef_unparseFull (e2)));
+
+ if (checkDeadState (el, e2, TRUE, loc))
{
if (sRef_isThroughArrayFetch (el))
{
else if ((e2->defstate == SS_DEAD || sRef_isKept (e2)) &&
(el->defstate == SS_DEFINED && !sRef_isKept (el)))
{
-
- if (checkDeadState (e2, FALSE, loc))
+ DPRINTF (("Checking dead: %s / %s", sRef_unparseFull (el),
+ sRef_unparseFull (e2)));
+
+ if (checkDeadState (e2, el, FALSE, loc))
{
if (sRef_isThroughArrayFetch (el))
{
{
DPRINTF (("set pdefined: %s", sRef_unparseFull (el)));
el->defstate = SS_PDEFINED;
+ el->definfo = stateInfo_update (el->definfo, e2->definfo);
}
else if (e2->defstate == SS_DEFINED &&
el->defstate == SS_PDEFINED)
{
DPRINTF (("set pdefined: %s", sRef_unparseFull (e2)));
e2->defstate = SS_PDEFINED;
+ e2->definfo = stateInfo_update (e2->definfo, el->definfo);
}
else
{
{
sRef sr = sRef_leastCommon (el, e2);
- if (sRef_isValid (sr))
+ if (sRef_isReasonable (sr))
{
ret = sRefSet_insert (ret, sr);
}
}
else /* not defined */
{
- (void) checkDeadState (el, TRUE, loc);
+ DPRINTF (("Checking dead: %s", sRef_unparseFull (el)));
+ (void) checkDeadState (el, e2, TRUE, loc);
}
}
} end_sRefSet_allElements;
sRefSet_allElements (other, el)
{
- if (sRef_isValid (el))
+ if (sRef_isReasonable (el))
{
- (void) checkDeadState (el, FALSE, loc);
+ DPRINTF (("Checking dead: %s", sRef_unparseFull (el)));
+ (void) checkDeadState (el, sRef_undefined, FALSE, loc);
}
} end_sRefSet_allElements;
** Returns TRUE is there is an error.
*/
-static bool checkDeadState (/*@notnull@*/ sRef el, bool tbranch, fileloc loc)
+static bool checkDeadState (/*@notnull@*/ sRef el, sRef e2, bool tbranch, fileloc loc)
{
/*
** usymtab_isGuarded --- the utab should still be in the
if ((sRef_isDead (el) || sRef_isKept (el))
- && !sRef_isDeepUnionField (el) && !sRef_isThroughArrayFetch (el))
+ && !sRef_isDeepUnionField (el)
+ && !sRef_isThroughArrayFetch (el))
{
if (!tbranch)
? "kept" : "released")),
loc))
{
-
if (sRef_isKept (el))
{
sRef_showAliasInfo (el);
sRef_showStateInfo (el);
}
+ if (sRef_isValid (e2))
+ {
+ if (sRef_isKept (e2))
+ {
+ sRef_showAliasInfo (e2);
+ }
+ else
+ {
+ sRef_showStateInfo (e2);
+ }
+ }
+
/* prevent further errors */
el->defstate = SS_UNKNOWN;
- sRef_setAliasKind (el, AK_ERROR, fileloc_undefined);
-
+ sRef_setAliasKind (el, AK_ERROR, fileloc_undefined);
return FALSE;
}
}
static void
checkDerivDeadState (/*@notnull@*/ sRef el, bool tbranch, fileloc loc)
{
-
- if (checkDeadState (el, tbranch, loc))
+ if (checkDeadState (el, sRef_undefined, tbranch, loc))
{
sRefSet_allElements (el->deriv, t)
{
- if (sRef_isValid (t))
+ if (sRef_isReasonable (t))
{
- checkDerivDeadState (t, tbranch, loc);
+ checkDerivDeadState (t, tbranch, loc);
}
} end_sRefSet_allElements;
}
sRefSet_allElements (res, el)
{
- if (sRef_isValid (el))
+ if (sRef_isReasonable (el))
{
sRef e2 = sRefSet_lookupMember (other, el);
- if (sRef_isValid (e2))
+ if (sRef_isReasonable (e2))
{
if (sRef_isAllocated (el) && !sRef_isAllocated (e2))
{
{
if (!opt)
{
- checkDerivDeadState (el, (cl == FALSECLAUSE), loc);
+ checkDerivDeadState (el, (cl == FALSECLAUSE), loc);
}
ret = sRefSet_insert (ret, el);
sRefSet_allElements (other, el)
{
- if (sRef_isValid (el))
+ if (sRef_isReasonable (el))
{
if (!sRefSet_member (ret, el))
{
sRef sRef_makeConj (/*@exposed@*/ /*@returned@*/ sRef a, /*@exposed@*/ sRef b)
{
- llassert (sRef_isValid (a));
- llassert (sRef_isValid (b));
+ llassert (sRef_isReasonable (a));
+ llassert (sRef_isReasonable (b));
if (!sRef_equivalent (a, b))
{
s->kind = SK_CONJ;
s->info = (sinfo) dmalloc (sizeof (*s->info));
s->info->conj = (cjinfo) dmalloc (sizeof (*s->info->conj));
- s->info->conj->a = a; /* sRef_copy (a) */ /*@i32*/ ;
- s->info->conj->b = b; /* sRef_copy (b);*/ /*@i32@*/ ;
+ s->info->conj->a = a;
+ s->info->conj->b = b;
if (ctype_equal (a->type, b->type)) s->type = a->type;
else s->type = ctype_makeConj (a->type, b->type);
if (a->defstate == b->defstate)
{
s->defstate = a->defstate;
+ s->definfo = stateInfo_update (s->definfo, a->definfo);
+ s->definfo = stateInfo_update (s->definfo, b->definfo);
}
else
{
s->aliaskind = alkind_resolve (a->aliaskind, b->aliaskind);
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_MERGED));
return s;
}
else
return s;
}
-static /*@owned@*/ sRef
+static /*@owned@*/ /*@notnull@*/ sRef
sRef_makeSpecial (speckind sk) /*@*/
{
sRef s = sRef_new ();
{
sRef s = sRef_makeSpecial (SR_GLOBALMARKER);
llassert (valueTable_isUndefined (s->state));
- s->state = context_createGlobalMarkerValueTable ();
+ s->state = context_createGlobalMarkerValueTable (stateInfo_undefined);
return s;
}
-static sRef
-sRef_makeResultType (ctype ct)
-{
- sRef res = sRef_makeResult ();
-
- res->type = ct;
- return res;
-}
-
sRef
-sRef_makeResult ()
+sRef_makeResult (ctype c)
{
sRef s = sRef_newRef ();
s->kind = SK_RESULT;
- s->type = ctype_unknown;
+ s->type = c;
s->defstate = SS_UNKNOWN;
s->aliaskind = AK_UNKNOWN;
sRef_setNullStateN (s, NS_UNKNOWN);
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_DECLARED));
DPRINTF (("Result: [%p] %s", s, sRef_unparseFull (s)));
return s;
bool
sRef_isResult (sRef s)
{
- return (sRef_isValid (s) && s->kind == SK_RESULT);
+ return (sRef_isReasonable (s) && s->kind == SK_RESULT);
}
bool
usymId
sRef_getScopeIndex (sRef s)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
llassert (sRef_isCvar (s));
return (s->info->cvar->index);
void
sRef_makeSafe (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
s->safe = TRUE;
}
void
sRef_makeUnsafe (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
s->safe = FALSE;
}
{
if (sRef_isInvalid (s)) return (cstring_undefined);
- return (message ("[%d] %q - %q [%s] { %q } < %q >",
- (int) s,
+ return (message ("[%p] %q - %q { %q } [%s] { %q } < %q >",
+ s,
sRef_unparseDebug (s),
sRef_unparseState (s),
+ stateInfo_unparse (s->definfo),
exkind_unparse (s->oexpkind),
sRefSet_unparseDebug (s->deriv),
valueTable_unparse (s->state)));
st = message ("%q:", sRef_unparseFull (s));
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRefSet_allElements (s->deriv, el)
{
bool sRef_isStrictReadable (sRef s)
{
- return (ynm_toBoolStrict (sRef_isReadable (s)));
+ return (ynm_toBoolStrict (sRef_isValidLvalue (s)));
}
-ynm sRef_isReadable (sRef s)
+/*
+** Is this what is does?
+** Returns YES if s can be used as an rvalue,
+** MAYBE if its not clear
+** NO if s cannot be safely used as an rvalue.
+*/
+
+ynm sRef_isValidLvalue (sRef s)
{
sstate ss;
if (sRef_isConj (s) && s->defstate == SS_UNKNOWN)
{
- if (ynm_toBoolStrict (sRef_isReadable (sRef_getConjA (s))))
+ if (ynm_toBoolStrict (sRef_isValidLvalue (sRef_getConjA (s))))
{
- if (ynm_toBoolStrict (sRef_isReadable (sRef_getConjB (s))))
+ if (ynm_toBoolStrict (sRef_isValidLvalue (sRef_getConjB (s))))
{
return YES;
}
}
else
{
- if (ynm_toBoolStrict (sRef_isReadable (sRef_getConjB (s))))
+ if (ynm_toBoolStrict (sRef_isValidLvalue (sRef_getConjB (s))))
{
return MAYBE;
}
|| ss == SS_FIXED
|| ss == SS_RELDEF
|| ss == SS_PDEFINED
- || ss == SS_PARTIAL
+ || ss == SS_PARTIAL
|| ss == SS_SPECIAL
- || ss == SS_ALLOCATED
+ || ss == SS_ALLOCATED
|| ss == SS_KILLED /* evans 2001-05-26: added this for killed globals */
|| ss == SS_UNKNOWN));
}
("Warning: check definition limit exceeded, checking %q. "
"This either means there is a variable with at least "
"%d indirections apparent in the program text, or "
- "there is a bug in LCLint.",
+ "there is a bug in Splint.",
sRef_unparse (fref),
MAXDEPTH),
g_currentloc);
{
sRef wdef = whatUndefined (fldref, depth + 1);
- if (sRef_isValid (wdef))
+ if (sRef_isReasonable (wdef))
{
return wdef;
}
bool sRef_isReallyDefined (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (sRef_isAnyDefined (s))
{
void sRef_showNotReallyDefined (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (sRef_isAnyDefined (s))
{
/*@-temptrans@*/ /* the result of whatUndefined is lost */
sRef ref = whatUndefined (s, 0);
- llassert (sRef_isValid (ref));
+ llassert (sRef_isReasonable (ref));
if (ref != s)
{
void sRef_setAliasKindComplete (sRef s, alkind kind, fileloc loc)
{
sRef_checkMutable (s);
- sRef_aliasSetCompleteParam (sRef_setAliasKind, s, kind, loc);
+ sRef_aliasSetCompleteAlkParam (sRef_setAliasKind, s, kind, loc);
}
void sRef_setAliasKind (sRef s, alkind kind, fileloc loc)
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef_clearDerived (s);
if ((kind != s->aliaskind && kind != s->oaliaskind)
&& fileloc_isDefined (loc))
{
- s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+ s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, stateAction_fromAlkind (kind), loc);
}
s->aliaskind = kind;
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
s->oaliaskind = kind;
}
exkind sRef_getExKind (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
return (s->expkind);
}
exkind sRef_getOrigExKind (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
return (s->oexpkind);
}
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (s->expkind != exp)
{
- s->expinfo = stateInfo_updateLoc (s->expinfo, loc);
+ s->expinfo = stateInfo_updateLoc (s->expinfo, stateAction_fromExkind (exp), loc);
}
s->expkind = exp;
DPRINTF (("Copy real: %s / %s", sRef_unparse (s1), sRef_unparse (s2)));
sRef_checkMutable (s1);
- if (sRef_isValid (s1) && sRef_isValid (s2))
+ if (sRef_isReasonable (s1) && sRef_isReasonable (s2))
{
sRef sb = sRef_getRootBase (s1);
sRefSet_allElements (s2->deriv, el)
{
- if (sRef_isValid (el))
+ if (sRef_isReasonable (el))
{
sRef rb = sRef_getRootBase (el);
{
sRef fb = sRef_fixDirectBase (el, s1);
- if (sRef_isValid (fb))
+ if (sRef_isReasonable (fb))
{
sRef_copyRealDerived (fb, el);
sRef_addDeriv (s1, fb);
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
s->defstate = SS_UNDEFINED;
-
- if (fileloc_isDefined (loc))
- {
- s->definfo = stateInfo_updateLoc (s->definfo, loc);
- }
+ s->definfo = stateInfo_updateLoc (s->definfo, SA_UNDEFINED, loc);
sRef_clearDerived (s);
}
sRef_checkMutable (s);
if (sRef_isInvalid (s)) return;
- if (s->defstate != SS_DEFINED && fileloc_isDefined (loc))
- {
- s->definfo = stateInfo_updateLoc (s->definfo, loc);
- }
-
+ DPRINTF (("Set defined: %s", sRef_unparseFull (s)));
+
+ s->definfo = stateInfo_updateLoc (s->definfo, SA_DEFINED, loc);
s->defstate = SS_DEFINED;
+ DPRINTF (("Set defined: %s", sRef_unparseFull (s)));
+
/* e.g., if x is allocated, *x = 3 defines x */
if (s->kind == SK_PTR)
{
sRef p = s->info->ref;
-
- if (p->defstate == SS_ALLOCATED)
+ sRef arr;
+
+ if (p->defstate == SS_ALLOCATED
+ || p->defstate == SS_SPECIAL) /* evans 2001-07-12: shouldn't need this */
{
sRef_setDefinedAux (p, loc, clear);
}
+
+ /*
+ ** Defines a[0] also:
+ */
+
+ arr = sRef_findDerivedArrayFetch (p, FALSE, 0, FALSE);
+
+ if (sRef_isReasonable (arr))
+ {
+ sRef_setDefinedAux (arr, loc, clear);
+ }
}
else if (s->kind == SK_ARRAYFETCH)
{
{
sRef p = s->info->arrayfetch->arr;
sRef ptr = sRef_constructPointer (p);
-
- if (sRef_isValid (ptr))
+
+ if (sRef_isReasonable (ptr))
{
if (ptr->defstate == SS_ALLOCATED
- || ptr->defstate == SS_UNDEFINED)
+ || ptr->defstate == SS_UNDEFINED
+ || ptr->defstate == SS_SPECIAL) /* evans 2001-07-12: shouldn't need this */
{
sRef_setDefinedAux (ptr, loc, clear);
}
{
;
}
- else if (p->defstate == SS_ALLOCATED || p->defstate == SS_PDEFINED)
+ else if (p->defstate == SS_ALLOCATED || p->defstate == SS_PDEFINED
+ || p->defstate == SS_SPECIAL) /* evans 2001-07-12: shouldn't need this */
{
p->defstate = SS_DEFINED;
}
{
sRef parent = s->info->field->rec;
- if (sRef_isValid (parent))
+ if (sRef_isReasonable (parent))
{
if (ctype_isUnion (ctype_realType (parent->type)))
{
if (clear)
{
sRef_clearDerived (s);
- }
+ }
+ else
+ {
+ /* evans 2001-07-12: need to define the derived references */
+ sRefSet_elements (s->deriv, el)
+ {
+ llassert (sRef_isReasonable (el));
+ el->defstate = SS_DEFINED;
+ } end_sRefSet_elements ;
+ }
+
+ DPRINTF (("Set defined: %s", sRef_unparseFull (s)));
}
static void sRef_setPartialDefined (sRef s, fileloc loc)
sRef_innerAliasSetComplete (sRef_setDefined, s, loc);
}
+void sRef_setDefinedCompleteDirect (sRef s, fileloc loc)
+{
+ sRefSet aliases;
+
+ aliases = usymtab_allAliases (s);
+ DPRINTF (("Set defined complete: %s", sRef_unparseFull (s)));
+ DPRINTF (("All aliases: %s", sRefSet_unparseFull (aliases)));
+
+ sRef_setDefined (s, loc);
+
+ sRefSet_realElements (aliases, current)
+ {
+ if (sRef_isReasonable (current))
+ {
+ current = sRef_updateSref (current);
+ sRef_setDefined (current, loc);
+ }
+ } end_sRefSet_realElements;
+
+ sRefSet_free (aliases);
+ sRef_innerAliasSetComplete (sRef_setDefined, s, loc);
+}
+
void sRef_setDefined (sRef s, fileloc loc)
{
sRef_checkMutable (s);
bool sRef_isUnionField (sRef s)
{
- if (sRef_isValid (s) && s->kind == SK_FIELD)
+ if (sRef_isReasonable (s) && s->kind == SK_FIELD)
{
/*
** defining one field of a union defines the union
sRef base = s->info->field->rec;
- if (sRef_isValid (base))
+ if (sRef_isReasonable (base))
{
return (ctype_isUnion (ctype_realType (base->type)));
}
void sRef_setPdefined (sRef s, fileloc loc)
{
sRef_checkMutable (s);
- if (sRef_isValid (s) && !sRef_isPartial (s))
+ if (sRef_isReasonable (s) && !sRef_isPartial (s))
{
sRef base = sRef_getBaseSafe (s);
return;
}
- if (s->defstate != SS_PDEFINED && fileloc_isDefined (loc))
- {
- s->definfo = stateInfo_updateLoc (s->definfo, loc);
- }
-
- DPRINTF (("set pdefined: %s", sRef_unparseFull (s)));
+ s->definfo = stateInfo_updateLoc (s->definfo, SA_PDEFINED, loc);
s->defstate = SS_PDEFINED;
/* e.g., if x is allocated, *x = 3 defines x */
- while (sRef_isValid (base) && sRef_isKnown (base))
+ while (sRef_isReasonable (base) && sRef_isKnown (base))
{
if (base->defstate == SS_DEFINED)
{
sRef nb;
+ DPRINTF (("set pdefined: %s", sRef_unparseFull (base)));
base->defstate = SS_PDEFINED;
nb = sRef_getBaseSafe (base);
base = nb;
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ DPRINTF (("Set state: %s => %s", sRef_unparseFull (s), sstate_unparse (ss)));
+
+ if (sRef_isReasonable (s))
{
/* if (s->defstate == SS_RELDEF) return; */
if (s->defstate != ss && fileloc_isDefined (loc))
{
- s->definfo = stateInfo_updateLoc (s->definfo, loc);
+ s->definfo = stateInfo_updateLoc (s->definfo,
+ stateAction_fromSState (ss), loc);
}
s->defstate = ss;
{
sRef base = sRef_getBaseSafe (s);
- while (sRef_isValid (base) && sRef_isKnown (base))
+ while (sRef_isReasonable (base) && sRef_isKnown (base))
{
if (base->defstate == SS_DEFINED)
{
sRef nb;
-
+
+ DPRINTF (("set pdefined: %s", sRef_unparseFull (s)));
base->defstate = SS_PDEFINED;
-
nb = sRef_getBaseSafe (base);
base = nb;
}
}
}
}
-
- }
+ }
}
void sRef_setAllocatedComplete (sRef s, fileloc loc)
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (s->defstate == SS_DEAD || s->defstate == SS_UNDEFINED)
{
s->defstate = SS_ALLOCATED;
-
- if (fileloc_isDefined (loc))
- {
- s->definfo = stateInfo_updateLoc (s->definfo, loc);
- }
+ s->definfo = stateInfo_updateLoc (s->definfo, SA_ALLOCATED, loc);
}
}
}
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (s->aliaskind != AK_SHARED && fileloc_isDefined (loc))
{
- s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+ s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_SHARED, loc);
}
s->aliaskind = AK_SHARED;
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
s->aliaskind = sRef_getAliasKind (ref);
- s->aliasinfo = stateInfo_updateRefLoc (s->aliasinfo, ref, loc);
+ s->aliasinfo = stateInfo_updateRefLoc (s->aliasinfo, ref, stateAction_fromAlkind (s->aliaskind), loc);
}
}
static
void sRef_setNullStateAux (/*@notnull@*/ sRef s, nstate ns, fileloc loc)
{
- DPRINTF (("Set null state: %s / %s", sRef_unparse (s), nstate_unparse (ns)));
sRef_checkMutable (s);
s->nullstate = ns;
-
+ sRef_resetAliasKind (s);
+
if (fileloc_isDefined (loc))
{
- s->nullinfo = stateInfo_updateLoc (s->nullinfo, loc);
+ s->nullinfo = stateInfo_updateLoc (s->nullinfo, stateAction_fromNState (ns), loc);
}
}
void sRef_setNotNull (sRef s, fileloc loc)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef_setNullStateAux (s, NS_NOTNULL, loc);
}
void sRef_setNullStateN (sRef s, nstate n)
{
- sRef_checkMutable (s);
- s->nullstate = n;
+ if (sRef_isReasonable (s))
+ {
+ sRef_checkMutable (s);
+ s->nullstate = n;
+ sRef_resetAliasKind (s);
+ }
}
void sRef_setNullState (sRef s, nstate n, fileloc loc)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef_setNullStateAux (s, n, loc);
}
}
-void sRef_setNullTerminatedStateInnerComplete (sRef s, struct s_bbufinfo b, /*@unused@*/ fileloc loc) {
-
+void sRef_setNullTerminatedStateInnerComplete (sRef s, struct s_bbufinfo b, /*@unused@*/ fileloc loc)
+{
switch (b.bufstate) {
- case BB_NULLTERMINATED:
- sRef_setNullTerminatedState (s);
- sRef_setLen (s, b.len);
- break;
- case BB_POSSIBLYNULLTERMINATED:
- sRef_setPossiblyNullTerminatedState(s);
- break;
- case BB_NOTNULLTERMINATED:
- sRef_setNotNullTerminatedState (s);
- break;
+ case BB_NULLTERMINATED:
+ sRef_setNullTerminatedState (s);
+ sRef_setLen (s, b.len);
+ break;
+ case BB_POSSIBLYNULLTERMINATED:
+ sRef_setPossiblyNullTerminatedState(s);
+ break;
+ case BB_NOTNULLTERMINATED:
+ sRef_setNotNullTerminatedState (s);
+ break;
}
- sRef_setSize (s, b.size);
+ sRef_setSize (s, b.size);
+
/* PL: TO BE DONE : Aliases are not modified right now, have to be similar to
* setNullStateInnerComplete.
*/
void sRef_setPosNull (sRef s, fileloc loc)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef_setNullStateAux (s, NS_POSNULL, loc);
}
void sRef_setDefNull (sRef s, fileloc loc)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef_setNullStateAux (s, NS_DEFNULL, loc);
}
void sRef_setNullUnknown (sRef s, fileloc loc)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef_setNullStateAux (s, NS_UNKNOWN, loc);
}
void sRef_setNullError (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s) && !sRef_isConst (s))
{
sRef_setNullStateAux (s, NS_UNKNOWN, fileloc_undefined);
}
}
-void sRef_setNullErrorLoc (sRef s, /*@unused@*/ fileloc loc)
+void sRef_setNullErrorLoc (sRef s, fileloc loc)
{
- sRef_setNullError (s);
-}
+ if (sRef_isReasonable (s) && !sRef_isConst (s))
+ {
+ sRef_setNullStateAux (s, NS_UNKNOWN, loc);
+ }
+}
void sRef_setOnly (sRef s, fileloc loc)
{
- sRef_checkMutable (s);
-
- if (sRef_isValid (s) && s->aliaskind != AK_ONLY)
+ if (sRef_isReasonable (s) && s->aliaskind != AK_ONLY)
{
+ sRef_checkMutable (s);
s->aliaskind = AK_ONLY;
- s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
- }
+ s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_ONLY, loc);
+ }
}
void sRef_setDependent (sRef s, fileloc loc)
{
- sRef_checkMutable (s);
-
- if (sRef_isValid (s) && !sRef_isConst (s) && (s->aliaskind != AK_DEPENDENT))
+ if (sRef_isReasonable (s) && !sRef_isConst (s) && (s->aliaskind != AK_DEPENDENT))
{
+ sRef_checkMutable (s);
DPRINTF (("Setting dependent: %s", sRef_unparseFull (s)));
s->aliaskind = AK_DEPENDENT;
- s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+ s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_DEPENDENT, loc);
}
}
void sRef_setOwned (sRef s, fileloc loc)
{
- sRef_checkMutable (s);
-
- if (sRef_isValid (s) && !sRef_isConst (s) && (s->aliaskind != AK_OWNED))
+ if (sRef_isReasonable (s) && !sRef_isConst (s) && (s->aliaskind != AK_OWNED))
{
+ sRef_checkMutable (s);
s->aliaskind = AK_OWNED;
- s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+ s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_OWNED, loc);
}
}
void sRef_setKept (sRef s, fileloc loc)
{
- sRef_checkMutable (s);
-
- if (sRef_isValid (s) && !sRef_isConst (s) && (s->aliaskind != AK_KEPT))
+ if (sRef_isReasonable (s) && !sRef_isConst (s) && (s->aliaskind != AK_KEPT))
{
sRef base = sRef_getBaseSafe (s);
-
- while (sRef_isValid (base) && sRef_isKnown (base))
+
+ while (sRef_isReasonable (base) && sRef_isKnown (base))
{
if (base->defstate == SS_DEFINED)
{
+ sRef_checkMutable (base);
base->defstate = SS_PDEFINED;
- base = sRef_getBaseSafe (base);
+ base = sRef_getBaseSafe (base);
}
else
{
break;
}
-
}
+ sRef_checkMutable (s);
s->aliaskind = AK_KEPT;
- s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+ s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_KEPT, loc);
}
}
void sRef_setFresh (sRef s, fileloc loc)
{
- sRef_checkMutable (s);
-
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s) && !sRef_isConst (s))
{
+ sRef_checkMutable (s);
s->aliaskind = AK_FRESH;
- s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+ s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_CREATED, loc);
+ DPRINTF (("SetFresh: %s", sRef_unparseFull (s)));
}
}
void sRef_kill (sRef s, fileloc loc)
{
DPRINTF (("Kill: %s", sRef_unparseFull (s)));
- sRef_checkMutable (s);
- if (sRef_isValid (s) && !sRef_isShared (s) && !sRef_isConst (s))
+ if (sRef_isReasonable (s) && !sRef_isShared (s) && !sRef_isConst (s))
{
sRef base = sRef_getBaseSafe (s);
-
- while (sRef_isValid (base) && sRef_isKnown (base))
+ sRef_checkMutable (s);
+
+ while (sRef_isReasonable (base) && sRef_isKnown (base))
{
if (base->defstate == SS_DEFINED)
{
+ sRef_checkMutable (base);
base->defstate = SS_PDEFINED;
base = sRef_getBaseSafe (base);
}
s->aliaskind = s->oaliaskind;
s->defstate = SS_DEAD;
- s->definfo = stateInfo_updateLoc (s->definfo, loc);
-
+ s->definfo = stateInfo_updateLoc (s->definfo, SA_KILLED, loc);
+ DPRINTF (("State info: %s", stateInfo_unparse (s->definfo)));
sRef_clearDerived (s);
}
}
void sRef_maybeKill (sRef s, fileloc loc)
{
- sRef_checkMutable (s);
-
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef base = sRef_getBaseSafe (s);
-
+ sRef_checkMutable (s);
- while (sRef_isValid (base) && sRef_isKnown (base))
+ while (sRef_isReasonable (base) && sRef_isKnown (base))
{
if (base->defstate == SS_DEFINED || base->defstate == SS_RELDEF)
{
+ sRef_checkMutable (base);
base->defstate = SS_PDEFINED;
base = sRef_getBaseSafe (base);
}
s->aliaskind = s->oaliaskind;
s->defstate = SS_HOFFA;
- s->definfo = stateInfo_updateLoc (s->definfo, loc);
+ s->definfo = stateInfo_updateLoc (s->definfo, SA_PKILLED, loc);
+ DPRINTF (("State info: %s / %s", sRef_unparse (s),
+ stateInfo_unparse (s->definfo)));
sRef_clearDerived (s);
}
static void sRef_killAux (sRef s, fileloc loc)
{
- if (sRef_isValid (s) && !sRef_isShared (s))
+ if (sRef_isReasonable (s) && !sRef_isShared (s))
{
if (sRef_isUnknownArrayFetch (s))
{
{
sRef ret;
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
bool old = inFunction;
/*@=retalias@*/
}
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef t = sRef_alloc ();
t->modified = s->modified;
t->immut = FALSE; /* Note mutability is not copied. */
t->type = s->type;
+ t->val = multiVal_copy (s->val);
t->info = sinfo_copy (s);
t->defstate = s->defstate;
t->deriv = sRefSet_newDeepCopy (s->deriv);
t->state = valueTable_copy (s->state);
-
- DPRINTF (("Made copy: [%p] %s", t, sRef_unparse (t)));
+
+ DPRINTF (("Made copy: %s => %s", sRef_unparseFull (s), sRef_unparseFull (t)));
return t;
}
else
bool sRef_isThroughArrayFetch (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef tref = s;
lt = sRef_getBase (tref);
tref = lt;
- } while (sRef_isValid (tref));
+ } while (sRef_isReasonable (tref));
}
return FALSE;
return ((s->kind == SK_CVAR) &&
(s->info->cvar->lexlevel == functionScope) &&
(context_inFunction () &&
- (s->info->cvar->index <= uentryList_size (context_getParams ()))));
+ (s->info->cvar->index <= usymId_fromInt (uentryList_size (context_getParams ())))));
}
bool sRef_isPointer (sRef s)
DPRINTF (("Free sref: [%p]", s));
sRef_checkValid (s);
+
+ multiVal_free (s->val); /* evans 2002-07-12 */
stateInfo_free (s->expinfo);
stateInfo_free (s->aliasinfo);
sRefSet_free (s->deriv);
s->deriv = sRefSet_undefined;
- /*@i43@*/ /* valueTable_free (s->state); */
+ valueTable_free (s->state);
sinfo_free (s);
s->definfo = stateInfo_undefined;
s->nullinfo = stateInfo_undefined;
- /*@i32@*/ sfree (s);
+ sfree (s);
}
}
void sRef_setType (sRef s, ctype t)
{
- sRef_checkMutable (s);
-
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
+ sRef_checkMutable (s);
s->type = t;
}
}
void sRef_setTypeFull (sRef s, ctype t)
{
- sRef_checkMutable (s);
-
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
+ sRef_checkMutable (s);
s->type = t;
sRefSet_allElements (s->deriv, current)
static /*@exposed@*/ sRef
sRef_findDerivedField (/*@notnull@*/ sRef rec, cstring f)
{
- sRefSet_allElements (rec->deriv, sr)
+ sRefSet_allElements (sRef_derivedFields (rec), sr)
{
- if (sRef_isValid (sr))
+ if (sRef_isReasonable (sr))
{
- if (sr->info != NULL)
+ if (sRef_isReasonable (sr))
{
- if (sr->kind == SK_FIELD && cstring_equal (sr->info->field->field, f))
+ if (sr->info != NULL)
{
- return sr;
+ if (sr->kind == SK_FIELD && cstring_equal (sr->info->field->field, f))
+ {
+ return sr;
+ }
}
}
+ else
+ {
+ llcontbug (message ("Invalid sRef as derived field of %s", sRef_unparse (rec)));
+ }
}
} end_sRefSet_allElements;
/*@dependent@*/ /*@observer@*/ sRefSet sRef_derivedFields (/*@temp@*/ sRef rec)
{
- if (sRef_isValid (rec))
+ if (sRef_isReasonable (rec))
{
sRefSet ret;
ret = rec->deriv;
static /*@exposed@*/ sRef
sRef_findDerivedPointer (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRefSet_realElements (s->deriv, sr)
{
- if (sRef_isValid (sr) && sr->kind == SK_PTR)
+ if (sRef_isReasonable (sr) && sr->kind == SK_PTR)
{
return sr;
}
bool
sRef_isUnknownArrayFetch (sRef s)
{
- return (sRef_isValid (s)
+ return (sRef_isReasonable (s)
&& s->kind == SK_ARRAYFETCH
&& !s->info->arrayfetch->indknown);
}
{
sRefSet_realElements (s->deriv, sr)
{
- if (sRef_isValid (sr)
+ if (sRef_isReasonable (sr)
&& sr->kind == SK_ARRAYFETCH
&& sr->info->arrayfetch->indknown
&& (sr->info->arrayfetch->ind == idx))
{
sRefSet_realElements (s->deriv, sr)
{
- if (sRef_isValid (sr)
+ if (sRef_isReasonable (sr)
&& sr->kind == SK_ARRAYFETCH
&& (!sr->info->arrayfetch->indknown
|| (sr->info->arrayfetch->indknown &&
s = sRef_findDerivedField (rec, f);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
return s;
}
else
{
ctype ct = ctype_realType (rec->type);
-
+
DPRINTF (("Field of: %s", sRef_unparse (rec)));
s = sRef_newRef ();
s->kind = SK_FIELD;
s->info = (sinfo) dmalloc (sizeof (*s->info));
s->info->field = (fldinfo) dmalloc (sizeof (*s->info->field));
- s->info->field->rec = rec; /* sRef_copy (rec); */ /*@i32@*/
+ s->info->field->rec = rec;
s->info->field->field = f; /* doesn't copy f */
if (ctype_isKnown (ct) && ctype_isSU (ct))
bool
sRef_isStackAllocated (sRef s)
{
- return (sRef_isValid(s)
+ return (sRef_isReasonable(s)
&& s->defstate == SS_ALLOCATED && ctype_isStackAllocated (s->type));
}
}
/* a hack, methinks... makeArrayFetch (&a[0]) ==> a[] */
+ /* evans - 2001-08-27: not sure where this was necessary - it
+ ** causes an assertion in in aliasCheckPred to fail.
+ */
+
if (sRef_isAddress (arr))
{
sRef t = arr->info->ref;
{
sRef sp = sRef_findDerivedPointer (arr);
- if (sRef_isValid (sp))
+ if (sRef_isReasonable (sp))
{
if (ctype_isMutable (s->type))
{
- sRef_setExKind (s, sRef_getExKind (sp), fileloc_undefined);
-
+ s->expkind = sRef_getExKind (sp);
+ s->expinfo = stateInfo_copy (sp->expinfo);
+
s->aliaskind = sp->aliaskind;
+ s->aliasinfo = stateInfo_copy (sp->aliasinfo);
}
s->defstate = sp->defstate;
}
}
+ DPRINTF (("Set null state: %s / %s", sRef_unparseFull (s), sRef_unparseFull (sp)));
sRef_setNullStateN (s, sRef_getNullState (sp));
}
else
*/
}
- sRef_setExKind (s, sRef_getExKind (arr), g_currentloc);
-
+ s->expkind = sRef_getExKind (arr);
+ s->expinfo = stateInfo_copy (arr->expinfo);
+
if (arr->aliaskind == AK_LOCAL || arr->aliaskind == AK_FRESH)
{
s->aliaskind = AK_LOCAL;
sRefSet_allElements (arr->deriv, sr)
{
- if (sRef_isValid (sr))
+ if (sRef_isReasonable (sr))
{
- if (sr->defstate == SS_ALLOCATED)
+ if (sRef_isReasonable (sr))
{
- s->defstate = SS_ALLOCATED;
- }
- else
- {
- if (sr->defstate == SS_DEFINED)
+ if (sr->defstate == SS_ALLOCATED)
{
- if (context_getFlag (FLG_STRICTDESTROY))
- {
- s->defstate = SS_DEFINED;
- }
- else
+ s->defstate = SS_ALLOCATED;
+ }
+ else
+ {
+ if (sr->defstate == SS_DEFINED)
{
- s->defstate = SS_PARTIAL;
+ if (context_getFlag (FLG_STRICTDESTROY))
+ {
+ s->defstate = SS_DEFINED;
+ }
+ else
+ {
+ s->defstate = SS_PARTIAL;
+ }
+
+ break;
}
-
- break;
}
}
+ else
+ {
+ llcontbug (message ("Invalid sRef as derived element of %s", sRef_unparse (arr)));
+ }
}
} end_sRefSet_allElements;
-
- }
+ }
else
{
s->defstate = SS_UNDEFINED;
if (sRef_isObserver (arr))
{
s->expkind = XO_OBSERVER;
+ s->expinfo = stateInfo_copy (arr->expinfo);
}
}
{
sRef s;
- if (!sRef_isValid (arr)) {
+ if (!sRef_isReasonable (arr)) {
/*@-nullret@*/ return arr /*@=nullret@*/;
}
s = sRef_findDerivedArrayFetch (arr, FALSE, 0, FALSE);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
- sRef_setExKind (s, sRef_getExKind (arr), g_currentloc);
+ /* evans 2001-07-12: this is bogus, clean-up hack */
+ if (s->info->arrayfetch->arr != arr)
+ {
+ sRef res;
+ check (sRefSet_delete (arr->deriv, s));
+ res = sRef_buildArrayFetch (arr);
+ sRef_copyState (res, s);
+ llassert (res->info->arrayfetch->arr == arr);
+ return res;
+ }
+
+ s->expkind = sRef_getExKind (arr);
+ s->expinfo = stateInfo_copy (arr->expinfo);
+
return s;
}
else
s->info->arrayfetch = (ainfo) dmalloc (sizeof (*s->info->arrayfetch));
s->info->arrayfetch->indknown = FALSE;
s->info->arrayfetch->ind = 0;
- s->info->arrayfetch->arr = arr; /* sRef_copy (arr); */ /*@i32@*/
+ s->info->arrayfetch->arr = arr;
+
sRef_setArrayFetchState (s, arr);
+
s->oaliaskind = s->aliaskind;
s->oexpkind = s->expkind;
sRef_addDeriv (arr, s);
}
- llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
-
+ if (valueTable_isUndefined (s->state))
+ {
+ s->state = context_createValueTable
+ (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
+ }
+
return (s);
}
}
{
sRef s;
- if (!sRef_isValid (arr)) {
+ if (!sRef_isReasonable (arr)) {
/*@-nullret@*/ return arr /*@=nullret@*/;
}
if (ctype_isRealPointer (arr->type))
{
- (void) sRef_buildPointer (arr); /* do this to define arr! */
+ (void) sRef_buildPointer (arr); /* do this to define arr! */
}
s = sRef_findDerivedArrayFetch (arr, TRUE, i, FALSE);
-
- if (sRef_isValid (s))
+
+ if (sRef_isReasonable (s))
{
- sRef_setExKind (s, sRef_getExKind (arr), g_currentloc);
+ /* evans 2001-07-12: this is bogus, clean-up hack */
+ if (s->info->arrayfetch->arr != arr)
+ {
+ sRef res;
+
+ check (sRefSet_delete (arr->deriv, s));
+ res = sRef_buildArrayFetchKnown (arr, i);
+
+ llassert (res->info->arrayfetch->arr == arr);
+ sRef_copyState (res, s);
+ llassert (res->info->arrayfetch->arr == arr);
+ return res;
+ }
+
+ s->expkind = sRef_getExKind (arr);
+ s->expinfo = stateInfo_copy (arr->expinfo);
+
+ llassert (s->info->arrayfetch->arr == arr);
return s;
}
else
s->kind = SK_ARRAYFETCH;
s->info = (sinfo) dmalloc (sizeof (*s->info));
s->info->arrayfetch = (ainfo) dmalloc (sizeof (*s->info->arrayfetch));
- s->info->arrayfetch->arr = arr; /* sRef_copy (arr); */ /*@i32@*/
+ s->info->arrayfetch->arr = arr;
s->info->arrayfetch->indknown = TRUE;
s->info->arrayfetch->ind = i;
-
+
sRef_setArrayFetchState (s, arr);
-
+ /* evans 2001-08-27 no: can change this - llassert (s->info->arrayfetch->arr == arr); */
+
s->oaliaskind = s->aliaskind;
s->oexpkind = s->expkind;
sRef_addDeriv (arr, s);
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
-
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
return (s);
}
}
{
sRef uref = uentry_getSref (ue);
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
s->aliaskind = alkind_derive (s->aliaskind, uentry_getAliasKind (ue));
s->oaliaskind = s->aliaskind;
if (sRef_getNullState (s) == NS_UNKNOWN)
{
- DPRINTF (("Setting null state!"));
+ DPRINTF (("Set null state: %s / %s", sRef_unparseFull (s), uentry_unparseFull (ue)));
sRef_setNullStateN (s, sRef_getNullState (uentry_getSref (ue)));
}
else
s->oaliaskind = s->aliaskind = AK_IMPDEPENDENT;
}
- if (sRef_isValid (uref))
+ if (sRef_isReasonable (uref))
{
valueTable utable = uref->state;
valueTable_free (s->state);
static void
sRef_setStateFromAbstractUentry (sRef s, uentry ue)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
sRef_checkMutable (s);
sRef_setPartsFromUentry (s, ue);
sstate defstate;
sRef_checkMutable (s);
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
sRef_setPartsFromUentry (s, ue);
DPRINTF (("find derived: %s", sRef_unparse (s)));
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
-
- sRef_setExKind (s, sRef_getExKind (t), g_currentloc);
+ s->expkind = sRef_getExKind (t);
+ s->expinfo = stateInfo_copy (t->expinfo);
+
s->oaliaskind = s->aliaskind;
s->oexpkind = s->expkind;
DPRINTF (("construct: %s", sRef_unparse (s)));
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef_addDeriv (t, s);
static /*@exposed@*/ sRef sRef_constructDerefAux (sRef t, bool isdead)
{
- if (sRef_isValid (t))
+ if (sRef_isReasonable (t))
{
sRef s;
s = sRef_findDerivedArrayFetch (t, FALSE, 0, isdead);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
+ DPRINTF (("Found array fetch: %s", sRef_unparseFull (s)));
return s;
}
else
{
sRef ret = sRef_constructPointer (t);
- /*
- ** This is necessary to prevent infinite depth
- ** in checking complete destruction.
- */
+ DPRINTF (("Constructed pointer: %s", sRef_unparseFull (ret)));
- if (isdead)
- {
- /* ret->defstate = SS_UNKNOWN; */
- return ret;
- }
- else
- {
- return ret;
- }
+ return ret;
}
}
else
ctype rt = t->type;
ctype st;
+ llassert (valueTable_isUndefined (s->state));
+
s->kind = SK_PTR;
s->info = (sinfo) dmalloc (sizeof (*s->info));
- s->info->ref = t; /* sRef_copy (t); */ /*@i32*/
+ s->info->ref = t;
if (ctype_isRealAP (rt))
{
}
st = ctype_realType (s->type);
-
+
if (t->defstate == SS_UNDEFINED)
{
s->defstate = SS_UNUSEABLE;
+ s->definfo = stateInfo_copy (t->definfo);
}
else if ((t->defstate == SS_ALLOCATED) && !ctype_isSU (st))
{
s->defstate = SS_UNDEFINED;
+ s->definfo = stateInfo_copy (t->definfo);
}
else
{
s->defstate = t->defstate;
+ s->definfo = stateInfo_copy (t->definfo);
}
if (t->aliaskind == AK_LOCAL || t->aliaskind == AK_FRESH)
{
s->aliaskind = AK_UNKNOWN;
}
-
- sRef_setExKind (s, sRef_getExKind (t), fileloc_undefined);
+
+ s->expkind = sRef_getExKind (t);
+ s->expinfo = stateInfo_copy (t->expinfo);
+
sRef_setTypeState (s);
-
+
s->oaliaskind = s->aliaskind;
s->oexpkind = s->expkind;
- llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ if (valueTable_isUndefined (s->state))
+ {
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
+ }
+
+ DPRINTF (("pointer: %s", sRef_unparseFull (s)));
return s;
}
bool sRef_hasDerived (sRef s)
{
- return (sRef_isValid (s) && !sRefSet_isEmpty (s->deriv));
+ return (sRef_isReasonable (s) && !sRefSet_isEmpty (s->deriv));
}
void
sRef_clearDerived (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
+ DPRINTF (("Clear derived: [%p] %s", s, sRef_unparseDebug (s)));
sRefSet_clear (s->deriv);
}
}
void
sRef_clearDerivedComplete (sRef s)
{
-
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sRef base = sRef_getBaseSafe (s);
-
- while (sRef_isValid (base))
+
+ while (sRef_isReasonable (base))
{
+ DPRINTF (("Clear derived: [%p] %s", base, sRef_unparse (base)));
sRefSet_clear (base->deriv);
base = sRef_getBaseSafe (base);
}
+ DPRINTF (("Clear derived: [%p] %s", s, sRef_unparse (s)));
sRefSet_clear (s->deriv);
}
}
{
sRef res = sRef_buildPointer (s);
- DPRINTF (("Res: %s", sRef_unparse (res)));
+ DPRINTF (("Res: %s", sRef_unparseFull (res)));
return res;
}
/*@exposed@*/ sRef
sRef_makeAnyArrayFetch (/*@exposed@*/ sRef arr)
-{
-
+{
if (sRef_isAddress (arr))
{
return (arr->info->ref);
void
sRef_copyState (sRef s1, sRef s2)
{
- if (sRef_isValid (s1) && sRef_isValid (s2))
+ if (sRef_isReasonable (s1) && sRef_isReasonable (s2))
{
s1->defstate = s2->defstate;
s1->expkind = s2->expkind;
s1->expinfo = stateInfo_update (s1->expinfo, s2->expinfo);
-
+
s1->nullstate = s2->nullstate;
s1->nullinfo = stateInfo_update (s1->nullinfo, s2->nullinfo);
- /*@-mustfree@*/
- /*@i834 don't free it: valueTable_free (s1->state); */
- /*@i32@*/ s1->state = valueTable_copy (s2->state);
- /*@=mustfree@*/
+ valueTable_free (s1->state);
+ s1->state = valueTable_copy (s2->state);
s1->safe = s2->safe;
}
}
s->kind = SK_NEW;
s->type = ct;
- llassert (sRef_isValid (t));
+ llassert (sRef_isReasonable (t));
s->defstate = t->defstate;
s->aliaskind = t->aliaskind;
s->oaliaskind = s->aliaskind;
s->oexpkind = s->expkind;
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
DPRINTF (("Create: %s", sRef_unparseFull (s)));
return s;
s->bufinfo.bufstate = BB_NULLTERMINATED;
/* end modification */
-
- if (ctype_isUA (ct))
+ /* evans 2002-04-22: added isManifestBool to avoid errors for -boolfalse initializations */
+ if (!ctype_isManifestBool (ct) && ctype_isUA (ct))
{
typeId uid = ctype_typeId (ct);
uentry te = usymtab_getTypeEntrySafe (uid);
}
}
-
s->oaliaskind = s->aliaskind;
s->oexpkind = s->expkind;
llassert (valueTable_isUndefined (s->state));
- s->state = context_createValueTable (s);
+ s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
return s;
}
void
sRef_showRefKilled (sRef s)
{
- if (sRef_hasStateInfoLoc (s))
+ if (sRef_isValid (s))
{
- llgenindentmsg (message ("Storage %q released",
- sRef_unparse (s)), sRef_getStateInfoLoc (s));
+ DPRINTF (("Killed: %s", sRef_unparseFull (s)));
+ if (context_getLocIndentSpaces () == 0) {
+ stateInfo_display (s->definfo, message (" Storage %q", sRef_unparseOpt (s)));
+ } else {
+ stateInfo_display (s->definfo, message ("Storage %q", sRef_unparseOpt (s)));
+ }
}
}
void
sRef_showStateInfo (sRef s)
{
- if (sRef_hasStateInfoLoc (s))
- {
- if (s->defstate == SS_DEAD)
- {
- llgenindentmsg
- (message ("Storage %qis released", sRef_unparseOpt (s)),
- sRef_getStateInfoLoc (s));
- }
- else if (s->defstate == SS_ALLOCATED || s->defstate == SS_DEFINED)
- {
- llgenindentmsg
- (message ("Storage %qis %s", sRef_unparseOpt (s),
- sstate_unparse (s->defstate)),
- sRef_getStateInfoLoc (s));
- }
- else if (s->defstate == SS_UNUSEABLE)
- {
- llgenindentmsg
- (message ("Storage %qbecomes inconsistent (clauses merge with"
- "%qreleased on one branch)",
- sRef_unparseOpt (s),
- sRef_unparseOpt (s)),
- sRef_getStateInfoLoc (s));
- }
- else
- {
- llgenindentmsg (message ("Storage %qbecomes %s",
- sRef_unparseOpt (s),
- sstate_unparse (s->defstate)),
- sRef_getStateInfoLoc (s));
- }
+ if (sRef_isValid (s)) {
+ if (context_getLocIndentSpaces () == 0) {
+ stateInfo_display (s->definfo, message (" Storage %q", sRef_unparseOpt (s)));
+ } else {
+ stateInfo_display (s->definfo, message ("Storage %q", sRef_unparseOpt (s)));
}
+ }
}
void
sRef_showExpInfo (sRef s)
{
- if (sRef_hasExpInfoLoc (s))
- {
- llgenindentmsg (message ("Storage %qbecomes %s", sRef_unparseOpt (s),
- exkind_unparse (s->expkind)),
- sRef_getExpInfoLoc (s));
+ if (sRef_isValid (s)) {
+ if (context_getLocIndentSpaces () == 0) {
+ stateInfo_display (s->expinfo, message (" Storage %q", sRef_unparseOpt (s)));
+ } else {
+ stateInfo_display (s->expinfo, message ("Storage %q", sRef_unparseOpt (s)));
}
+ }
}
void
stateValue val;
metaStateInfo minfo = context_lookupMetaStateInfo (key);
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
llassert (valueTable_isDefined (s->state));
llassert (metaStateInfo_isDefined (minfo));
if (stateValue_hasLoc (val))
{
llgenindentmsg
- (message ("Meta state %qbecomes %s", sRef_unparseOpt (s),
- metaStateInfo_unparseValue (minfo, stateValue_getValue (val))),
+ (message ("%qbecomes %q", sRef_unparseOpt (s),
+ stateValue_unparseValue (val, minfo)),
stateValue_getLoc (val));
}
}
void
sRef_showAliasInfo (sRef s)
{
- if (sRef_hasAliasInfoLoc (s))
+ if (sRef_isValid (s))
{
if (sRef_isFresh (s))
{
- llgenindentmsg
- (message ("Fresh storage %qallocated", sRef_unparseOpt (s)),
- sRef_getAliasInfoLoc (s));
+ if (context_getLocIndentSpaces () == 0) {
+ stateInfo_display (s->aliasinfo, message (" Fresh storage %q", sRef_unparseOpt (s)));
+ } else {
+ stateInfo_display (s->aliasinfo, message ("Fresh storage %q", sRef_unparseOpt (s)));
+ }
}
- else
+ else
{
- if (!sRef_isRefCounted (s))
- {
- llgenindentmsg
- (message ("Storage %qbecomes %s",
- sRef_unparseOpt (s),
- alkind_unparse (sRef_getAliasKind (s))),
- sRef_getAliasInfoLoc (s));
- }
+ if (context_getLocIndentSpaces () == 0) {
+ stateInfo_display (s->aliasinfo, message (" Storage %q", sRef_unparseOpt (s)));
+ } else {
+ stateInfo_display (s->aliasinfo, message ("Storage %q", sRef_unparseOpt (s)));
+ }
}
}
}
void
sRef_mergeNullState (sRef s, nstate n)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
nstate old;
if (n != old && n != NS_UNKNOWN)
{
- sRef_setNullState (s, n, g_currentloc);
+ sRef_setNullState (s, n, g_currentloc);
}
}
else
bool
sRef_possiblyNull (sRef s)
{
- if (sRef_isValid (s))
- {
- if (sRef_getNullState (s) == NS_ABSNULL)
+ if (sRef_isReasonable (s))
+ {
+ if (sRef_getNullState (s) == NS_ABSNULL)
{
ctype rct = ctype_realType (s->type);
-
+
if (ctype_isAbstract (rct))
{
return FALSE;
return nstate_possiblyNull (sRef_getNullState (s));
}
}
-
+
return FALSE;
}
int
sRef_getScope (sRef s)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
if (sRef_isCvar (s))
{
bool
sRef_isDead (sRef s)
{
- return (sRef_isValid (s) && (s)->defstate == SS_DEAD);
+ return (sRef_isReasonable (s) && (s)->defstate == SS_DEAD);
}
bool
sRef_isDeadStorage (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (s->defstate == SS_DEAD
|| s->defstate == SS_UNUSEABLE
bool
sRef_isPossiblyDead (sRef s)
{
- return (sRef_isValid (s) && s->defstate == SS_HOFFA);
+ return (sRef_isReasonable (s) && s->defstate == SS_HOFFA);
}
bool sRef_isStateLive (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
sstate ds = s->defstate;
bool sRef_isStateUndefined (sRef s)
{
- return ((sRef_isValid(s)) && ((s)->defstate == SS_UNDEFINED));
+ return ((sRef_isReasonable(s)) && ((s)->defstate == SS_UNDEFINED));
}
bool sRef_isJustAllocated (sRef s)
static bool
sRef_isAllocatedStorage (sRef s)
{
- if (sRef_isValid (s) && ynm_toBoolStrict (sRef_isReadable (s)))
+ if (sRef_isReasonable (s) && ynm_toBoolStrict (sRef_isValidLvalue (s)))
{
return (ctype_isVisiblySharable (sRef_getType (s)));
}
bool
sRef_perhapsNull (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (sRef_getNullState (s) == NS_ABSNULL)
{
bool
sRef_definitelyNull (sRef s)
{
- return (sRef_isValid (s)
+ return (sRef_isReasonable (s)
&& (sRef_getNullState (s) == NS_DEFNULL || sRef_getNullState (s) == NS_CONSTNULL));
}
void
sRef_setDerivNullState (sRef set, sRef guide, nstate ns)
{
- if (sRef_isValid (set))
+ if (sRef_isReasonable (set))
{
sRef deriv = sRef_getDeriv (set, guide);
- if (sRef_isValid (deriv))
+ if (sRef_isReasonable (deriv))
{
sRef_setNullStateN (deriv, ns);
}
static /*@exposed@*/ sRef
sRef_getDeriv (/*@returned@*/ /*@notnull@*/ sRef set, sRef guide)
{
- llassert (sRef_isValid (set));
- llassert (sRef_isValid (guide));
+ llassert (sRef_isReasonable (set));
+ llassert (sRef_isReasonable (guide));
switch (guide->kind)
{
case SK_CVAR:
- llassert (set->kind == SK_CVAR);
-
+ llassert (set->kind == SK_CVAR);
return set;
case SK_PARAM:
llassert (set->kind == guide->kind);
llassert (set->info->paramno == guide->info->paramno);
-
return set;
case SK_ARRAYFETCH:
else
{
sRefSet aliases = usymtab_allAliases (s);
-
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
- if (!sRef_similar (current, s)
- || (error && sRef_sameName (current, s)))
+ if (sRef_isReasonable (current))
+ {
+ if (!sRef_similar (current, s)
+ || (error && sRef_sameName (current, s)))
+ {
+ (void) (*predf)(current, e, s, err);
+ }
+ }
+ else
{
- (void) (*predf)(current, e, s, err);
+ llcontbug (message ("Invalid sRef as alias field of %s", sRef_unparse (s)));
}
- }
+ }
} end_sRefSet_realElements;
sRefSet_free (aliases);
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
sRef cref = sRef_updateSref (current);
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
if ((*predf)(current)) result = TRUE;
return result;
}
-static void
+void
sRef_aliasSetComplete (void (predf) (sRef, fileloc), sRef s, fileloc loc)
{
sRefSet aliases;
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
((*predf)(current, loc));
+ DPRINTF (("Killed: %s", sRef_unparseFull (current)));
}
} end_sRefSet_realElements;
sRefSet_free (aliases);
}
-static void
-sRef_aliasSetCompleteParam (void (predf) (sRef, alkind, fileloc), sRef s,
- alkind kind, fileloc loc)
+void
+sRef_aliasSetCompleteParam (void (predf) (sRef, int, fileloc), sRef s,
+ int kind, fileloc loc)
{
sRefSet aliases;
+
+ if (sRef_isDeep (s))
+ {
+ aliases = usymtab_allAliases (s);
+ }
+ else
+ {
+ aliases = usymtab_aliasedBy (s);
+ }
+ (*predf)(s, kind, loc);
+
+ sRefSet_realElements (aliases, current)
+ {
+ if (sRef_isReasonable (current))
+ {
+ current = sRef_updateSref (current);
+ ((*predf)(current, kind, loc));
+ }
+ } end_sRefSet_realElements;
+
+ sRefSet_free (aliases);
+}
+
+/*
+** Version of aliasSetCompleteParam for alkind parameters
+*/
+
+void
+sRef_aliasSetCompleteAlkParam (void (predf) (sRef, alkind, fileloc), sRef s,
+ alkind kind, fileloc loc)
+{
+ sRefSet aliases;
if (sRef_isDeep (s))
{
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
((*predf)(current, kind, loc));
sRefSet aliases;
ctype ct;
- if (!sRef_isValid (s)) return;
+ if (!sRef_isReasonable (s)) return;
-
/*
** Type equivalence checking is necessary --- there might be casting.
*/
inner = s->info->ref;
aliases = usymtab_allAliases (inner);
ct = sRef_getType (inner);
-
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
aliases = usymtab_allAliases (inner);
ct = sRef_getType (inner);
+ DPRINTF (("Array fetch: %s", sRefSet_unparse (aliases)));
+
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
-
+ DPRINTF (("Current: %s", sRef_unparseFull (current)));
+
if (ctype_equal (ct, sRef_getType (current)))
{
-
if (s->info->arrayfetch->indknown)
{
sRef af = sRef_makeArrayFetchKnown (current, s->info->arrayfetch->ind);
-
+ DPRINTF (("Defining: %s", sRef_unparseFull (af)));
+ /* evans 2001-08-27 This isn't true:
+ llassert (af->info->arrayfetch->arr == current);
+ see comments in buildArrayFetchKnown
+ */
((*predf)(af, loc));
}
else
{
sRef af = sRef_makeArrayFetch (current);
-
+ /* evans 2001-08-27 This isn't true:
+ llassert (af->info->arrayfetch->arr == current);
+ see comments in buildArrayFetch
+ */
+ DPRINTF (("Defining: %s", sRef_unparseFull (af)));
((*predf)(af, loc));
}
}
+ else
+ {
+ DPRINTF (("Type mismatch: %s / %s",
+ ctype_unparse (ct),
+ ctype_unparse (sRef_getType (current))));
+ }
}
} end_sRefSet_realElements;
inner = s->info->field->rec;
aliases = usymtab_allAliases (inner);
ct = sRef_getType (inner);
-
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
sRefSet aliases;
ctype ct;
- if (!sRef_isValid (s)) return;
+ if (!sRef_isReasonable (s)) return;
-
/*
** Type equivalence checking is necessary --- there might be casting.
*/
inner = s->info->ref;
aliases = usymtab_allAliases (inner);
ct = sRef_getType (inner);
-
-
+
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
{
res->aliaskind = AK_KEPT;
}
+ else if ((ares == AK_OWNED && aother == AK_ONLY)
+ || (aother == AK_OWNED && ares == AK_ONLY))
+ {
+ res->aliaskind = AK_OWNED;
+
+ if (aother == AK_OWNED)
+ {
+ res->aliasinfo = stateInfo_update (res->aliasinfo, other->aliasinfo);
+ }
+ }
else
{
hasError = TRUE;
sRef_checkMutable (res);
+ DPRINTF (("Combine alias kinds: \n\t%s / \n\t%s",
+ sRef_unparseFull (res), sRef_unparseFull (other)));
if (alkind_equal (ares, aother)
|| aother == AK_UNKNOWN
|| aother == AK_ERROR)
res ->aliaskind = AK_ERROR;
}
else if (ares == AK_UNKNOWN || ares == AK_ERROR
- || sRef_isStateUndefined (res))
+ || sRef_isStateUndefined (res)
+ || sRef_isDefinitelyNull (res))
{
res->aliasinfo = stateInfo_update (res->aliasinfo, other->aliasinfo);
res->aliaskind = aother;
}
- else if (sRef_isStateUndefined (other))
+ else if (sRef_isStateUndefined (other)
+ || sRef_isDefinitelyNull (other))
{
;
}
p = sRef_makePointer (s);
ret = sRef_makeField (p, f);
+ DPRINTF (("Arrow: %s => %s",
+ sRef_unparseFull (s), sRef_unparseFull (ret)));
return ret;
}
ret->arrayfetch = (ainfo) dmalloc (sizeof (*ret->arrayfetch));
ret->arrayfetch->indknown = s->info->arrayfetch->indknown;
ret->arrayfetch->ind = s->info->arrayfetch->ind;
- ret->arrayfetch->arr = s->info->arrayfetch->arr; /* sRef_copy (s->info->arrayfetch->arr); */ /*@i32@*/
+ ret->arrayfetch->arr = s->info->arrayfetch->arr;
break;
case SK_FIELD:
ret = (sinfo) dmalloc (sizeof (*ret));
ret->field = (fldinfo) dmalloc (sizeof (*ret->field));
- ret->field->rec = s->info->field->rec; /* sRef_copy (s->info->field->rec); */ /*@i32@*/
+ ret->field->rec = s->info->field->rec;
ret->field->field = s->info->field->field;
break;
ret = (sinfo) dmalloc (sizeof (*ret));
ret->spec = s->info->spec;
break;
+
case SK_UNCONSTRAINED:
case SK_NEW:
ret = (sinfo) dmalloc (sizeof (*ret));
ret->fname = s->info->fname;
break;
+
case SK_RESULT:
case SK_CONST:
case SK_TYPE:
case SK_PTR:
case SK_ADR:
case SK_DERIVED:
- case SK_EXTERNAL: /*@i32 is copy now! */
+ case SK_EXTERNAL: /* is copy now! */
break;
case SK_CONJ:
}
-static void sRef_updateNullState (sRef res, sRef other)
+static void sRef_updateNullState (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other)
/*@modifies res@*/
{
res->nullstate = other->nullstate;
res->nullinfo = stateInfo_update (res->nullinfo, other->nullinfo);
+ sRef_resetAliasKind (res);
}
void sRef_combineNullState (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other)
}
res->nullstate = nn;
+ sRef_resetAliasKind (res);
}
cstring sRef_nullMessage (sRef s)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
switch (sRef_getNullState (s))
{
/*@observer@*/ cstring sRef_ntMessage (sRef s)
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
switch (s->nullstate)
{
sRef tmp = sRef_undefined;
sRef ret;
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
switch (s->kind)
{
bool sRef_isOwned (sRef s)
{
- return (sRef_isValid (s) && (s->aliaskind == AK_OWNED));
+ return (sRef_isReasonable (s) && (s->aliaskind == AK_OWNED));
}
bool sRef_isKeep (sRef s)
{
- return (sRef_isValid (s) && (s->aliaskind == AK_KEEP));
+ return (sRef_isReasonable (s) && (s->aliaskind == AK_KEEP));
}
bool sRef_isTemp (sRef s)
{
- return (sRef_isValid (s) && alkind_isTemp (s->aliaskind));
+ return (sRef_isReasonable (s) && alkind_isTemp (s->aliaskind));
}
bool sRef_isLocalState (sRef s)
{
- return (sRef_isValid (s) && (s->aliaskind == AK_LOCAL));
+ return (sRef_isReasonable (s) && (s->aliaskind == AK_LOCAL));
}
bool sRef_isUnique (sRef s)
{
- return (sRef_isValid (s) && (s->aliaskind == AK_UNIQUE));
+ return (sRef_isReasonable (s) && (s->aliaskind == AK_UNIQUE));
}
bool sRef_isShared (sRef s)
{
- return (sRef_isValid (s) && (s->aliaskind == AK_SHARED));
+ return (sRef_isReasonable (s) && (s->aliaskind == AK_SHARED));
}
bool sRef_isExposed (sRef s)
{
- return (sRef_isValid (s) && (s->expkind == XO_EXPOSED));
+ return (sRef_isReasonable (s) && (s->expkind == XO_EXPOSED));
}
bool sRef_isObserver (sRef s)
{
- return (sRef_isValid (s) && (s->expkind == XO_OBSERVER));
+ return (sRef_isReasonable (s) && (s->expkind == XO_OBSERVER));
}
bool sRef_isFresh (sRef s)
{
- return (sRef_isValid (s) && (s->aliaskind == AK_FRESH));
+ return (sRef_isReasonable (s) && (s->aliaskind == AK_FRESH));
}
bool sRef_isDefinitelyNull (sRef s)
{
- return (sRef_isValid (s) && (sRef_getNullState (s) == NS_DEFNULL
+ return (sRef_isReasonable (s) && (sRef_getNullState (s) == NS_DEFNULL
|| sRef_getNullState (s) == NS_CONSTNULL));
}
bool sRef_isAllocated (sRef s)
{
- return (sRef_isValid (s) && (s->defstate == SS_ALLOCATED));
+ return (sRef_isReasonable (s) && (s->defstate == SS_ALLOCATED));
}
bool sRef_isStack (sRef s)
{
- return (sRef_isValid (s) && (s->aliaskind == AK_STACK));
+ return (sRef_isReasonable (s) && (s->aliaskind == AK_STACK));
}
bool sRef_isNotNull (sRef s)
nstate sRef_getNullState (sRef s)
{
- if (sRef_isValid (s)) {
+ if (sRef_isReasonable (s)) {
llassert (nstate_isValid (s->nullstate));
return s->nullstate;
}
void sRef_reflectAnnotation (sRef s, annotationInfo a, fileloc loc)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (!valueTable_isDefined (s->state))
{
s->state = valueTable_create (1);
- valueTable_insert (s->state,
- cstring_copy (metaStateInfo_getName (annotationInfo_getState (a))),
- stateValue_create (annotationInfo_getValue (a), stateInfo_makeLoc (loc)));
+ valueTable_insert
+ (s->state,
+ cstring_copy (metaStateInfo_getName (annotationInfo_getState (a))),
+ stateValue_create (annotationInfo_getValue (a),
+ stateInfo_makeLoc (loc, SA_DECLARED)));
}
else
{
valueTable_update
(s->state,
metaStateInfo_getName (annotationInfo_getState (a)),
- stateValue_create (annotationInfo_getValue (a), stateInfo_makeLoc (loc)));
- DPRINTF (("state info: %s", stateInfo_unparse (stateInfo_makeLoc (loc))));
+ stateValue_create (annotationInfo_getValue (a),
+ stateInfo_makeLoc (loc, SA_DECLARED)));
+
DPRINTF (("sref: %s", sRef_unparse (s)));
DPRINTF (("sref: %s", sRef_unparseFull (s)));
}
sRefSet_realElements (aliases, current)
{
- if (sRef_isValid (current))
+ if (sRef_isReasonable (current))
{
current = sRef_updateSref (current);
sRef_setMetaStateValue (current, key, value, loc);
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (!valueTable_isDefined (s->state))
{
DPRINTF (("inserting state: %s: %s %d", sRef_unparse (s), key, value));
s->state = valueTable_create (1);
valueTable_insert (s->state, cstring_copy (key),
- stateValue_create (value, stateInfo_makeLoc (loc)));
+ stateValue_create (value,
+ stateInfo_makeLoc (loc, SA_CHANGED)));
}
else
{
DPRINTF (("Updating state: %s: %s %d / %s", sRef_unparse (s), key, value,
fileloc_unparse (loc)));
- valueTable_update
- (s->state, key, stateValue_create (value, stateInfo_makeLoc (loc)));
+ if (valueTable_contains (s->state, key))
+ {
+ valueTable_update
+ (s->state, key, stateValue_create (value,
+ stateInfo_makeLoc (loc, SA_CHANGED)));
+ }
+ else
+ {
+ valueTable_insert
+ (s->state, cstring_copy (key),
+ stateValue_create (value, stateInfo_makeLoc (loc, SA_CHANGED)));
+ }
+
DPRINTF (("After: %s", sRef_unparseFull (s)));
}
}
bool sRef_checkMetaStateValue (sRef s, cstring key, int value)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (valueTable_isDefined (s->state))
{
/*@observer@*/ stateValue sRef_getMetaStateValue (sRef s, cstring key)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (valueTable_isDefined (s->state))
{
stateValue val;
val = valueTable_lookup (s->state, key);
- llassert (stateValue_isDefined (val));
+ /* Okay if its not defined, just returns stateValue_undefined */
return val;
}
else
{
DPRINTF (("Get value table: %s", sRef_unparse (s)));
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
DPRINTF (("Value table: %s", valueTable_unparse (s->state)));
return s->state;
}
** Default defined state can be made special.
*/
- llassert (sRef_isValid (s)); /*@i523 why doesn't null-checking work!??? */
+ llassert (sRef_isReasonable (s));
if (s->defstate == SS_UNKNOWN || s->defstate == SS_DEFINED || s->defstate == SS_SPECIAL)
{
- s->aliaskind = AK_IMPTEMP;
+ /* s->aliaskind = AK_IMPTEMP; */ /* evans 2001-07-23 shouldn't effect alias state */
s->defstate = SS_SPECIAL;
DPRINTF (("Made special: %s", sRef_unparseFull (s)));
return TRUE;
}
else
{
- s->aliaskind = AK_IMPTEMP;
+ /* s->aliaskind = AK_IMPTEMP; */
s->defstate = SS_SPECIAL;
return FALSE;
}
void sRef_markImmutable (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
DPRINTF (("Mark immutable: %s", sRef_unparseFull (s)));
s->immut = TRUE;
}
void sRef_setNullTerminatedState(sRef p_s) {
- if(sRef_isValid (p_s)) {
+ if(sRef_isReasonable (p_s)) {
p_s->bufinfo.bufstate = BB_NULLTERMINATED;
} else {
llfatalbug( message("sRef_setNT passed a invalid sRef\n"));
void sRef_setPossiblyNullTerminatedState(sRef p_s) {
- if( sRef_isValid (p_s)) {
+ if( sRef_isReasonable (p_s)) {
p_s->bufinfo.bufstate = BB_POSSIBLYNULLTERMINATED;
} else {
llfatalbug( message("sRef_setPossNT passed a invalid sRef\n"));
}
void sRef_setNotNullTerminatedState(sRef p_s) {
- if( sRef_isValid (p_s)) {
+ if( sRef_isReasonable (p_s)) {
p_s->bufinfo.bufstate = BB_NOTNULLTERMINATED;
} else {
llfatalbug( message("sRef_unsetNT passed a invalid sRef\n"));
}
void sRef_setLen(sRef p_s, int len) {
- if( sRef_isValid (p_s) && sRef_isNullTerminated(p_s)) {
- p_s->bufinfo.len = len;
- } else {
- llfatalbug( message("sRef_setLen passed a invalid sRef\n"));
- }
+ if (sRef_isReasonable (p_s) && sRef_isNullTerminated(p_s))
+ {
+ p_s->bufinfo.len = len;
+ }
+ else
+ {
+ llfatalbug( message("sRef_setLen passed an invalid sRef\n"));
+ }
}
void sRef_setSize(sRef p_s, int size) {
- if( sRef_isValid(p_s)) {
+ if( sRef_isValid(p_s))
+ {
p_s->bufinfo.size = size;
- } else {
- llfatalbug( message("sRef_setSize passed a invalid sRef\n"));
- }
+ }
+ else
+ {
+ llfatalbug( message("sRef_setSize passed a invalid sRef\n"));
+ }
}
void sRef_resetLen(sRef p_s) {
- if (sRef_isValid (p_s)) {
- p_s->bufinfo.len = 0;
- } else {
- llfatalbug (message ("sRef_setLen passed an invalid sRef\n"));
- }
+ if (sRef_isReasonable (p_s))
+ {
+ p_s->bufinfo.len = 0;
+ }
+ else
+ {
+ llfatalbug (message ("sRef_setLen passed an invalid sRef\n"));
+ }
}
/*drl7x 11/28/2000 */
return ( ctype_isFixedArray (c) );
}
-long int sRef_getArraySize (sRef p_s) /*@*/ {
+size_t sRef_getArraySize (sRef p_s) /*@*/
+{
ctype c;
llassert (sRef_isFixedArray(p_s) );
DPRINTF (( message ("sRef_getArraySize getting array size for %s", sRef_unparse(p_s) ) ));
c = sRef_getType (p_s);
-
- return (ctype_getArraySize (c) );
+ return (ctype_getArraySize (c));
}
+void sRef_setValue (sRef s, multiVal val)
+{
+ if (!sRef_isReasonable (s))
+ {
+ llcontbuglit ("Unreasonable sRef");
+ llcontbug (message ("sRef: %s", sRef_unparse (s)));
+ return;
+ }
+ multiVal_free (s->val);
+ s->val = val;
+}
+bool sRef_hasValue (sRef s)
+{
+ return (sRef_isReasonable (s)
+ && multiVal_isDefined (s->val));
+}
+multiVal sRef_getValue (sRef s)
+{
+ if (sRef_isReasonable (s))
+ {
+ return s->val;
+ }
-
-
-
-
+ return multiVal_undefined;
+}
andersk / splint.git / blobdiff