/*
-** LCLint - annotation-assisted static program checker
-** Copyright (C) 1994-2001 University of Virginia,
+** Splint - annotation-assisted static program checker
+** Copyright (C) 1994-2002 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 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)));
{
llassert (FALSE);
- if (!sRef_isValid (s)) return;
+ if (!sRef_isReasonable (s)) return;
if (sRefSet_containsSameObject (checkedsofar, s))
{
/* start modifications */
s->bufinfo.bufstate = BB_NOTNULLTERMINATED;
+ s->bufinfo.size = -1; /*@i24 unknown@*/
+ s->bufinfo.len = -1; /*@i24 unknown@*/
/* 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);
}
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)
{
- return (sRef_isValid (s) && (s->aliasinfo != NULL)
+ return (sRef_isReasonable (s) && (s->aliasinfo != NULL)
&& (fileloc_isDefined (s->aliasinfo->loc)));
}
-static /*@falsenull@*/ bool
+static /*@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
+static /*@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);
}
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;
{
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)
{
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)
{
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)
{
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)));
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
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);
}
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);
}
{
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);
{
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 s = sRef_newRef ();
- llassert (sRef_isValid (t));
+ llassert (sRef_isReasonable (t));
s->kind = SK_EXTERNAL;
s->info = (sinfo) dmalloc (sizeof (*s->info));
/*@dependent@*/ sRef sRef_makeDerived (/*@exposed@*/ sRef t)
{
- if (sRef_isValid (t))
+ if (sRef_isReasonable (t))
{
sRef s = sRef_newRef ();
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)
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);
{
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);
} 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)
{
sRef sr = sRef_leastCommon (el, e2);
- if (sRef_isValid (sr))
+ if (sRef_isReasonable (sr))
{
ret = sRefSet_insert (ret, sr);
}
sRefSet_allElements (other, el)
{
- if (sRef_isValid (el))
+ if (sRef_isReasonable (el))
{
(void) checkDeadState (el, FALSE, loc);
}
{
sRefSet_allElements (el->deriv, t)
{
- if (sRef_isValid (t))
+ if (sRef_isReasonable (t))
{
checkDerivDeadState (t, tbranch, loc);
}
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))
{
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))
{
return s;
}
-static /*@owned@*/ sRef
+static /*@owned@*/ /*@notnull@*/ sRef
sRef_makeSpecial (speckind sk) /*@*/
{
sRef s = sRef_new ();
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 [%s] { %q } < %q >",
+ s,
sRef_unparseDebug (s),
sRef_unparseState (s),
exkind_unparse (s->oexpkind),
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);
{
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)
{
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;
arr = sRef_findDerivedArrayFetch (p, FALSE, 0, FALSE);
- if (sRef_isValid (arr))
+ if (sRef_isReasonable (arr))
{
sRef_setDefinedAux (arr, loc, clear);
}
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
{
sRef parent = s->info->field->rec;
- if (sRef_isValid (parent))
+ if (sRef_isReasonable (parent))
{
if (ctype_isUnion (ctype_realType (parent->type)))
{
/* 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 ;
}
void sRef_setDefinedComplete (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);
}
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);
/* 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))
+ if (sRef_isReasonable (s))
{
/* if (s->defstate == SS_RELDEF) return; */
{
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)
{
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
if (s->aliaskind != AK_SHARED && fileloc_isDefined (loc))
{
{
sRef_checkMutable (s);
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
s->aliaskind = sRef_getAliasKind (ref);
s->aliasinfo = stateInfo_updateRefLoc (s->aliasinfo, ref, 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);
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);
- }
+ }
}
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);
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);
}
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);
}
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);
}
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);
}
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);
}
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->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;
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->oaliaskind = s->aliaskind;
s->oexpkind = s->expkind;
-
+
DPRINTF (("sref: %s", sRef_unparseFull (s)));
}
else
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))
}
}
+ DPRINTF (("Set null state: %s / %s", sRef_unparseFull (s), sRef_unparseFull (sp)));
sRef_setNullStateN (s, sRef_getNullState (sp));
}
else
sRefSet_allElements (arr->deriv, sr)
{
- if (sRef_isValid (sr))
+ if (sRef_isReasonable (sr))
{
- if (sr->defstate == SS_ALLOCATED)
- {
- s->defstate = SS_ALLOCATED;
- }
- else
+ if (sRef_isReasonable (sr))
{
- 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;
{
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))
{
/* evans 2001-07-12: this is bogus, clean-up hack */
if (s->info->arrayfetch->arr != arr)
check (sRefSet_delete (arr->deriv, s));
res = sRef_buildArrayFetch (arr);
sRef_copyState (res, s);
+ llassert (res->info->arrayfetch->arr == arr);
return res;
}
s->info->arrayfetch->indknown = FALSE;
s->info->arrayfetch->ind = 0;
s->info->arrayfetch->arr = arr; /* sRef_copy (arr); */ /*@i32@*/
+
sRef_setArrayFetchState (s, arr);
+
s->oaliaskind = s->aliaskind;
s->oexpkind = s->expkind;
{
s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc));
}
-
+
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))
{
/* 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;
}
sRef_setExKind (s, sRef_getExKind (arr), g_currentloc);
-
llassert (s->info->arrayfetch->arr == arr);
return s;
}
s->info->arrayfetch->arr = arr; /* sRef_copy (arr); */ /*@i32@*/
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, stateInfo_makeLoc (g_currentloc));
-
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);
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;
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);
}
}
/*@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);
s->kind = SK_NEW;
s->type = ct;
- llassert (sRef_isValid (t));
+ llassert (sRef_isReasonable (t));
s->defstate = t->defstate;
s->aliaskind = t->aliaskind;
stateValue val;
metaStateInfo minfo = context_lookupMetaStateInfo (key);
- llassert (sRef_isValid (s));
+ llassert (sRef_isReasonable (s));
llassert (valueTable_isDefined (s->state));
llassert (metaStateInfo_isDefined (minfo));
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))
{
- (void) (*predf)(current, e, s, err);
+ if (!sRef_similar (current, s)
+ || (error && sRef_sameName (current, s)))
+ {
+ (void) (*predf)(current, e, s, err);
+ }
}
- }
+ else
+ {
+ 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.
*/
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);
DPRINTF (("Current: %s", sRef_unparseFull (current)));
{
sRef af = sRef_makeArrayFetchKnown (current, s->info->arrayfetch->ind);
DPRINTF (("Defining: %s", sRef_unparseFull (af)));
- llassert (af->info->arrayfetch->arr == current);
+ /* 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);
- llassert (af->info->arrayfetch->arr == 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));
}
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);
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;
}
}
-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))
{
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))
{
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))
{
{
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)); /*@i523 why doesn't null-checking work!??? */
if (s->defstate == SS_UNKNOWN || s->defstate == SS_DEFINED || s->defstate == SS_SPECIAL)
{
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"));
}
}
+/* these next three function are used by the nullterminated checking only.
+ They are not directly realted to the buffer bounds checking
+*/
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)
{
- llassert (sRef_isValid (s));
+ 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_isValid (s)
+ return (sRef_isReasonable (s)
&& multiVal_isDefined (s->val));
}
multiVal sRef_getValue (sRef s)
{
- if (sRef_isValid (s))
+ if (sRef_isReasonable (s))
{
return s->val;
}
andersk / splint.git / blobdiff