This is an archive of the discontinued LLVM Phabricator instance.

Differential D88100

[analyzer][StdLibraryFunctionsChecker] Separate the signature from the summaries
ClosedPublic

Authored by martong on Sep 22 2020, 8:28 AM.

Details

Reviewers
balazske
Szelethus
steakhal
NoQ
vsavchenko
Commits
rG11d2e63ab006: [analyzer][StdLibraryFunctionsChecker] Separate the signature from the summaries
Summary

The signature should not be part of the summaries as many FIXME comments
suggests. By separating the signature, we open up the way to a generic
matching implementation which could be used later under the hoods of
CallDescriptionMap.

Diff Detail

Event Timeline

martong created this revision.Sep 22 2020, 8:28 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 22 2020, 8:28 AM
Herald added subscribers: cfe-commits, ASDenysPetrov, Charusso and 10 others. · View Herald Transcript
martong requested review of this revision.Sep 22 2020, 8:28 AM
martong added a parent revision: D88092: [analyzer][StdLibraryFunctionsChecker] Fix getline/getdelim signatures.Sep 22 2020, 8:29 AM
Harbormaster completed remote builds in B72520: Diff 293464.Sep 22 2020, 8:38 AM
Szelethus accepted this revision.Sep 22 2020, 10:30 PM

Yup, we've talked about this before. This is indeed a better interface design. LGTM!

This revision is now accepted and ready to land.Sep 22 2020, 10:30 PM
martong added a comment.Sep 23 2020, 1:41 AM

Thanks for the review! :)

This revision was landed with ongoing or failed builds.Sep 23 2020, 2:02 AM
Closed by commit rG11d2e63ab006: [analyzer][StdLibraryFunctionsChecker] Separate the signature from the summaries (authored by martong). · Explain Why
This revision was automatically updated to reflect the committed changes.
martong added a commit: rG11d2e63ab006: [analyzer][StdLibraryFunctionsChecker] Separate the signature from the summaries.

Revision Contents

PathSize
clang/
lib/
StaticAnalyzer/
Checkers/
849 lines

Diff 293673

clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp

Show First 20 Lines • Show All 436 Lines • ▼ Show 20 Linesclass StdLibraryFunctionsChecker
/// The signature and argument constraints together contain information /// The signature and argument constraints together contain information
/// about which functions are handled by the summary. The signature can use /// about which functions are handled by the summary. The signature can use
/// "wildcards", i.e. Irrelevant types. Irrelevant type of a parameter in /// "wildcards", i.e. Irrelevant types. Irrelevant type of a parameter in
/// a signature means that type is not compared to the type of the parameter /// a signature means that type is not compared to the type of the parameter
/// in the found FunctionDecl. Argument constraints may specify additional /// in the found FunctionDecl. Argument constraints may specify additional
/// rules for the given parameter's type, those rules are checked once the /// rules for the given parameter's type, those rules are checked once the
/// signature is matched. /// signature is matched.
class Summary { class Summary {
// FIXME Probably the Signature should not be part of the Summary,
// We can remove once all overload of addToFunctionSummaryMap requires the
// Signature explicitly given.
Optional<Signature> Sign;
const InvalidationKind InvalidationKd; const InvalidationKind InvalidationKd;
Cases CaseConstraints; Cases CaseConstraints;
ConstraintSet ArgConstraints; ConstraintSet ArgConstraints;
// The function to which the summary applies. This is set after lookup and // The function to which the summary applies. This is set after lookup and
// match to the signature. // match to the signature.
const FunctionDecl *FD = nullptr; const FunctionDecl *FD = nullptr;
public: public:
Summary(ArgTypes ArgTys, RetType RetTy, InvalidationKind InvalidationKd)
: Sign(Signature(ArgTys, RetTy)), InvalidationKd(InvalidationKd) {}
Summary(InvalidationKind InvalidationKd) : InvalidationKd(InvalidationKd) {} Summary(InvalidationKind InvalidationKd) : InvalidationKd(InvalidationKd) {}
// FIXME Remove, once all overload of addToFunctionSummaryMap requires the
// Signature explicitly given.
Summary &setSignature(const Signature &S) {
Sign = S;
return *this;
}
Summary &Case(ConstraintSet &&CS) { Summary &Case(ConstraintSet &&CS) {
CaseConstraints.push_back(std::move(CS)); CaseConstraints.push_back(std::move(CS));
return *this; return *this;
} }
Summary &ArgConstraint(ValueConstraintPtr VC) { Summary &ArgConstraint(ValueConstraintPtr VC) {
assert(VC->getArgNo() != Ret && assert(VC->getArgNo() != Ret &&
"Arg constraint should not refer to the return value"); "Arg constraint should not refer to the return value");
ArgConstraints.push_back(VC); ArgConstraints.push_back(VC);
return *this; return *this;
} }
InvalidationKind getInvalidationKd() const { return InvalidationKd; } InvalidationKind getInvalidationKd() const { return InvalidationKd; }
const Cases &getCaseConstraints() const { return CaseConstraints; } const Cases &getCaseConstraints() const { return CaseConstraints; }
const ConstraintSet &getArgConstraints() const { return ArgConstraints; } const ConstraintSet &getArgConstraints() const { return ArgConstraints; }
QualType getArgType(ArgNo ArgN) const { QualType getArgType(ArgNo ArgN) const {
return StdLibraryFunctionsChecker::getArgType(FD, ArgN); return StdLibraryFunctionsChecker::getArgType(FD, ArgN);
} }
// Returns true if the summary should be applied to the given function. // Returns true if the summary should be applied to the given function.
// And if yes then store the function declaration. // And if yes then store the function declaration.
bool matchesAndSet(const FunctionDecl *FD) { bool matchesAndSet(const Signature &Sign, const FunctionDecl *FD) {
assert(Sign && bool Result = Sign.matches(FD) && validateByConstraints(FD);
"Signature must be set before comparing to a FunctionDecl");
bool Result = Sign->matches(FD) && validateByConstraints(FD);
if (Result) { if (Result) {
assert(!this->FD && "FD must not be set more than once"); assert(!this->FD && "FD must not be set more than once");
this->FD = FD; this->FD = FD;
} }
return Result; return Result;
} }
// FIXME Remove, once all overload of addToFunctionSummaryMap requires the
// Signature explicitly given.
bool hasInvalidSignature() {
assert(Sign && "Signature must be set before this query");
return Sign->isInvalid();
}
private: private:
// Once we know the exact type of the function then do sanity check on all // Once we know the exact type of the function then do sanity check on all
// the given constraints. // the given constraints.
bool validateByConstraints(const FunctionDecl *FD) const { bool validateByConstraints(const FunctionDecl *FD) const {
for (const ConstraintSet &Case : CaseConstraints) for (const ConstraintSet &Case : CaseConstraints)
for (const ValueConstraintPtr &Constraint : Case) for (const ValueConstraintPtr &Constraint : Case)
if (!Constraint->checkValidity(FD)) if (!Constraint->checkValidity(FD))
return false; return false;
▲ Show 20 Lines • Show All 485 Lines • ▼ Show 20 Lines AddToFunctionSummaryMap(const ASTContext &ACtx, FunctionSummaryMapType &FSM,
: ACtx(ACtx), Map(FSM), DisplayLoadedSummaries(DisplayLoadedSummaries) { : ACtx(ACtx), Map(FSM), DisplayLoadedSummaries(DisplayLoadedSummaries) {
} }
// Add a summary to a FunctionDecl found by lookup. The lookup is performed // Add a summary to a FunctionDecl found by lookup. The lookup is performed
// by the given Name, and in the global scope. The summary will be attached // by the given Name, and in the global scope. The summary will be attached
// to the found FunctionDecl only if the signatures match. // to the found FunctionDecl only if the signatures match.
// //
// Returns true if the summary has been added, false otherwise. // Returns true if the summary has been added, false otherwise.
// FIXME remove all overloads without the explicit Signature parameter. bool operator()(StringRef Name, Signature Sign, Summary Sum) {
bool operator()(StringRef Name, Summary S) { if (Sign.isInvalid())
if (S.hasInvalidSignature())
return false; return false;
IdentifierInfo &II = ACtx.Idents.get(Name); IdentifierInfo &II = ACtx.Idents.get(Name);
auto LookupRes = ACtx.getTranslationUnitDecl()->lookup(&II); auto LookupRes = ACtx.getTranslationUnitDecl()->lookup(&II);
if (LookupRes.size() == 0) if (LookupRes.size() == 0)
return false; return false;
for (Decl *D : LookupRes) { for (Decl *D : LookupRes) {
if (auto *FD = dyn_cast<FunctionDecl>(D)) { if (auto *FD = dyn_cast<FunctionDecl>(D)) {
if (S.matchesAndSet(FD)) { if (Sum.matchesAndSet(Sign, FD)) {
auto Res = Map.insert({FD->getCanonicalDecl(), S}); auto Res = Map.insert({FD->getCanonicalDecl(), Sum});
assert(Res.second && "Function already has a summary set!"); assert(Res.second && "Function already has a summary set!");
(void)Res; (void)Res;
if (DisplayLoadedSummaries) { if (DisplayLoadedSummaries) {
llvm::errs() << "Loaded summary for: "; llvm::errs() << "Loaded summary for: ";
FD->print(llvm::errs()); FD->print(llvm::errs());
llvm::errs() << "\n"; llvm::errs() << "\n";
} }
return true; return true;
} }
} }
} }
return false; return false;
} }
// Add the summary with the Signature explicitly given.
bool operator()(StringRef Name, Signature Sign, Summary Sum) {
return operator()(Name, Sum.setSignature(Sign));
}
// Add several summaries for the given name.
void operator()(StringRef Name, const std::vector<Summary> &Summaries) {
for (const Summary &S : Summaries)
operator()(Name, S);
}
// Add the same summary for different names with the Signature explicitly // Add the same summary for different names with the Signature explicitly
// given. // given.
void operator()(std::vector<StringRef> Names, Signature Sign, Summary Sum) { void operator()(std::vector<StringRef> Names, Signature Sign, Summary Sum) {
for (StringRef Name : Names) for (StringRef Name : Names)
operator()(Name, Sign, Sum); operator()(Name, Sign, Sum);
} }
} addToFunctionSummaryMap(ACtx, FunctionSummaryMap, DisplayLoadedSummaries); } addToFunctionSummaryMap(ACtx, FunctionSummaryMap, DisplayLoadedSummaries);
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Linesvoid StdLibraryFunctionsChecker::initFunctionSummaries(
// for every range set, and each range line in the range set // for every range set, and each range line in the range set
// corresponds to a specific constraint within this state. // corresponds to a specific constraint within this state.
// The isascii() family of functions. // The isascii() family of functions.
// The behavior is undefined if the value of the argument is not // The behavior is undefined if the value of the argument is not
// representable as unsigned char or is not equal to EOF. See e.g. C99 // representable as unsigned char or is not equal to EOF. See e.g. C99
// 7.4.1.2 The isalpha function (p: 181-182). // 7.4.1.2 The isalpha function (p: 181-182).
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isalnum", "isalnum", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
// Boils down to isupper() or islower() or isdigit(). // Boils down to isupper() or islower() or isdigit().
.Case({ArgumentCondition(0U, WithinRange, .Case({ArgumentCondition(0U, WithinRange,
{{'0', '9'}, {'A', 'Z'}, {'a', 'z'}}), {{'0', '9'}, {'A', 'Z'}, {'a', 'z'}}),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
// The locale-specific range. // The locale-specific range.
// No post-condition. We are completely unaware of // No post-condition. We are completely unaware of
// locale-specific return values. // locale-specific return values.
.Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})}) .Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})})
.Case( .Case(
{ArgumentCondition( {ArgumentCondition(
0U, OutOfRange, 0U, OutOfRange,
{{'0', '9'}, {'A', 'Z'}, {'a', 'z'}, {128, UCharRangeMax}}), {{'0', '9'}, {'A', 'Z'}, {'a', 'z'}, {128, UCharRangeMax}}),
ReturnValueCondition(WithinRange, SingleValue(0))}) ReturnValueCondition(WithinRange, SingleValue(0))})
.ArgConstraint(ArgumentCondition( .ArgConstraint(ArgumentCondition(
0U, WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}}))); 0U, WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}})));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isalpha", "isalpha", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition(0U, WithinRange, {{'A', 'Z'}, {'a', 'z'}}), .Case({ArgumentCondition(0U, WithinRange, {{'A', 'Z'}, {'a', 'z'}}),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
// The locale-specific range. // The locale-specific range.
.Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})}) .Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})})
.Case({ArgumentCondition( .Case({ArgumentCondition(
0U, OutOfRange, 0U, OutOfRange,
{{'A', 'Z'}, {'a', 'z'}, {128, UCharRangeMax}}), {{'A', 'Z'}, {'a', 'z'}, {128, UCharRangeMax}}),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isascii", "isascii", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition(0U, WithinRange, Range(0, 127)), .Case({ArgumentCondition(0U, WithinRange, Range(0, 127)),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
.Case({ArgumentCondition(0U, OutOfRange, Range(0, 127)), .Case({ArgumentCondition(0U, OutOfRange, Range(0, 127)),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isblank", "isblank", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition(0U, WithinRange, {{'\t', '\t'}, {' ', ' '}}), .Case({ArgumentCondition(0U, WithinRange, {{'\t', '\t'}, {' ', ' '}}),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
.Case({ArgumentCondition(0U, OutOfRange, {{'\t', '\t'}, {' ', ' '}}), .Case({ArgumentCondition(0U, OutOfRange, {{'\t', '\t'}, {' ', ' '}}),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"iscntrl", "iscntrl", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition(0U, WithinRange, {{0, 32}, {127, 127}}), .Case({ArgumentCondition(0U, WithinRange, {{0, 32}, {127, 127}}),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
.Case({ArgumentCondition(0U, OutOfRange, {{0, 32}, {127, 127}}), .Case({ArgumentCondition(0U, OutOfRange, {{0, 32}, {127, 127}}),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isdigit", "isdigit", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition(0U, WithinRange, Range('0', '9')), .Case({ArgumentCondition(0U, WithinRange, Range('0', '9')),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
.Case({ArgumentCondition(0U, OutOfRange, Range('0', '9')), .Case({ArgumentCondition(0U, OutOfRange, Range('0', '9')),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isgraph", "isgraph", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition(0U, WithinRange, Range(33, 126)), .Case({ArgumentCondition(0U, WithinRange, Range(33, 126)),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
.Case({ArgumentCondition(0U, OutOfRange, Range(33, 126)), .Case({ArgumentCondition(0U, OutOfRange, Range(33, 126)),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"islower", "islower", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
// Is certainly lowercase. // Is certainly lowercase.
.Case({ArgumentCondition(0U, WithinRange, Range('a', 'z')), .Case({ArgumentCondition(0U, WithinRange, Range('a', 'z')),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
// Is ascii but not lowercase. // Is ascii but not lowercase.
.Case({ArgumentCondition(0U, WithinRange, Range(0, 127)), .Case({ArgumentCondition(0U, WithinRange, Range(0, 127)),
ArgumentCondition(0U, OutOfRange, Range('a', 'z')), ArgumentCondition(0U, OutOfRange, Range('a', 'z')),
ReturnValueCondition(WithinRange, SingleValue(0))}) ReturnValueCondition(WithinRange, SingleValue(0))})
// The locale-specific range. // The locale-specific range.
.Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})}) .Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})})
// Is not an unsigned char. // Is not an unsigned char.
.Case({ArgumentCondition(0U, OutOfRange, Range(0, UCharRangeMax)), .Case({ArgumentCondition(0U, OutOfRange, Range(0, UCharRangeMax)),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isprint", "isprint", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition(0U, WithinRange, Range(32, 126)), .Case({ArgumentCondition(0U, WithinRange, Range(32, 126)),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
.Case({ArgumentCondition(0U, OutOfRange, Range(32, 126)), .Case({ArgumentCondition(0U, OutOfRange, Range(32, 126)),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"ispunct", "ispunct", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition( .Case({ArgumentCondition(
0U, WithinRange, 0U, WithinRange,
{{'!', '/'}, {':', '@'}, {'[', '`'}, {'{', '~'}}), {{'!', '/'}, {':', '@'}, {'[', '`'}, {'{', '~'}}),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
.Case({ArgumentCondition( .Case({ArgumentCondition(
0U, OutOfRange, 0U, OutOfRange,
{{'!', '/'}, {':', '@'}, {'[', '`'}, {'{', '~'}}), {{'!', '/'}, {':', '@'}, {'[', '`'}, {'{', '~'}}),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isspace", "isspace", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
// Space, '\f', '\n', '\r', '\t', '\v'. // Space, '\f', '\n', '\r', '\t', '\v'.
.Case({ArgumentCondition(0U, WithinRange, {{9, 13}, {' ', ' '}}), .Case({ArgumentCondition(0U, WithinRange, {{9, 13}, {' ', ' '}}),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
// The locale-specific range. // The locale-specific range.
.Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})}) .Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})})
.Case({ArgumentCondition(0U, OutOfRange, .Case({ArgumentCondition(0U, OutOfRange,
{{9, 13}, {' ', ' '}, {128, UCharRangeMax}}), {{9, 13}, {' ', ' '}, {128, UCharRangeMax}}),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isupper", "isupper", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
// Is certainly uppercase. // Is certainly uppercase.
.Case({ArgumentCondition(0U, WithinRange, Range('A', 'Z')), .Case({ArgumentCondition(0U, WithinRange, Range('A', 'Z')),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
// The locale-specific range. // The locale-specific range.
.Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})}) .Case({ArgumentCondition(0U, WithinRange, {{128, UCharRangeMax}})})
// Other. // Other.
.Case({ArgumentCondition(0U, OutOfRange, .Case({ArgumentCondition(0U, OutOfRange,
{{'A', 'Z'}, {128, UCharRangeMax}}), {{'A', 'Z'}, {128, UCharRangeMax}}),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"isxdigit", "isxdigit", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.Case({ArgumentCondition(0U, WithinRange, .Case({ArgumentCondition(0U, WithinRange,
{{'0', '9'}, {'A', 'F'}, {'a', 'f'}}), {{'0', '9'}, {'A', 'F'}, {'a', 'f'}}),
ReturnValueCondition(OutOfRange, SingleValue(0))}) ReturnValueCondition(OutOfRange, SingleValue(0))})
.Case({ArgumentCondition(0U, OutOfRange, .Case({ArgumentCondition(0U, OutOfRange,
{{'0', '9'}, {'A', 'F'}, {'a', 'f'}}), {{'0', '9'}, {'A', 'F'}, {'a', 'f'}}),
ReturnValueCondition(WithinRange, SingleValue(0))})); ReturnValueCondition(WithinRange, SingleValue(0))}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"toupper", Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) "toupper", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(EvalCallAsPure)
.ArgConstraint(ArgumentCondition( .ArgConstraint(ArgumentCondition(
0U, WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}}))); 0U, WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}})));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"tolower", Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) "tolower", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(EvalCallAsPure)
.ArgConstraint(ArgumentCondition( .ArgConstraint(ArgumentCondition(
0U, WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}}))); 0U, WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}})));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"toascii", Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) "toascii", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(EvalCallAsPure)
.ArgConstraint(ArgumentCondition( .ArgConstraint(ArgumentCondition(
0U, WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}}))); 0U, WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}})));
// The getc() family of functions that returns either a char or an EOF. // The getc() family of functions that returns either a char or an EOF.
addToFunctionSummaryMap( addToFunctionSummaryMap(
{"getc", "fgetc"}, Signature(ArgTypes{FilePtrTy}, RetType{IntTy}), {"getc", "fgetc"}, Signature(ArgTypes{FilePtrTy}, RetType{IntTy}),
Summary(NoEvalCall) Summary(NoEvalCall)
.Case({ReturnValueCondition(WithinRange, .Case({ReturnValueCondition(WithinRange,
{{EOFv, EOFv}, {0, UCharRangeMax}})})); {{EOFv, EOFv}, {0, UCharRangeMax}})}));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"getchar", Summary(ArgTypes{}, RetType{IntTy}, NoEvalCall) "getchar", Signature(ArgTypes{}, RetType{IntTy}),
.Case({ReturnValueCondition( Summary(NoEvalCall)
WithinRange, {{EOFv, EOFv}, {0, UCharRangeMax}})})); .Case({ReturnValueCondition(WithinRange,
{{EOFv, EOFv}, {0, UCharRangeMax}})}));
// read()-like functions that never return more than buffer size. // read()-like functions that never return more than buffer size.
auto FreadSummary = auto FreadSummary =
Summary(NoEvalCall) Summary(NoEvalCall)
.Case({ .Case({
ReturnValueCondition(LessThanOrEq, ArgNo(2)), ReturnValueCondition(LessThanOrEq, ArgNo(2)),
}) })
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines addToFunctionSummaryMap(
FilePtrRestrictTy}, FilePtrRestrictTy},
RetType{Ssize_tTy}), RetType{Ssize_tTy}),
GetLineSummary); GetLineSummary);
if (ModelPOSIX) { if (ModelPOSIX) {
// long a64l(const char *str64); // long a64l(const char *str64);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"a64l", Summary(ArgTypes{ConstCharPtrTy}, RetType{LongTy}, NoEvalCall) "a64l", Signature(ArgTypes{ConstCharPtrTy}, RetType{LongTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// char *l64a(long value); // char *l64a(long value);
addToFunctionSummaryMap( addToFunctionSummaryMap("l64a",
"l64a", Summary(ArgTypes{LongTy}, RetType{CharPtrTy}, NoEvalCall) Signature(ArgTypes{LongTy}, RetType{CharPtrTy}),
.ArgConstraint( Summary(NoEvalCall)
ArgumentCondition(0, WithinRange, Range(0, LongMax)))); .ArgConstraint(ArgumentCondition(
0, WithinRange, Range(0, LongMax))));
// int access(const char *pathname, int amode); // int access(const char *pathname, int amode);
addToFunctionSummaryMap("access", Summary(ArgTypes{ConstCharPtrTy, IntTy}, addToFunctionSummaryMap(
RetType{IntTy}, NoEvalCall) "access", Signature(ArgTypes{ConstCharPtrTy, IntTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int faccessat(int dirfd, const char *pathname, int mode, int flags); // int faccessat(int dirfd, const char *pathname, int mode, int flags);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"faccessat", Summary(ArgTypes{IntTy, ConstCharPtrTy, IntTy, IntTy}, "faccessat",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, ConstCharPtrTy, IntTy, IntTy},
.ArgConstraint(NotNull(ArgNo(1)))); RetType{IntTy}),
Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(1))));
// int dup(int fildes); // int dup(int fildes);
addToFunctionSummaryMap( addToFunctionSummaryMap("dup", Signature(ArgTypes{IntTy}, RetType{IntTy}),
"dup", Summary(ArgTypes{IntTy}, RetType{IntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(ArgumentCondition(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); 0, WithinRange, Range(0, IntMax))));
// int dup2(int fildes1, int filedes2); // int dup2(int fildes1, int filedes2);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"dup2", "dup2", Signature(ArgTypes{IntTy, IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy, IntTy}, RetType{IntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(1, WithinRange, Range(0, IntMax)))); ArgumentCondition(1, WithinRange, Range(0, IntMax))));
// int fdatasync(int fildes); // int fdatasync(int fildes);
addToFunctionSummaryMap( addToFunctionSummaryMap("fdatasync",
"fdatasync", Summary(ArgTypes{IntTy}, RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy}, RetType{IntTy}),
.ArgConstraint(ArgumentCondition(0, WithinRange, Summary(NoEvalCall)
Range(0, IntMax)))); .ArgConstraint(ArgumentCondition(
0, WithinRange, Range(0, IntMax))));
// int fnmatch(const char *pattern, const char *string, int flags); // int fnmatch(const char *pattern, const char *string, int flags);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fnmatch", Summary(ArgTypes{ConstCharPtrTy, ConstCharPtrTy, IntTy}, "fnmatch",
RetType{IntTy}, EvalCallAsPure) Signature(ArgTypes{ConstCharPtrTy, ConstCharPtrTy, IntTy},
RetType{IntTy}),
Summary(EvalCallAsPure)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int fsync(int fildes); // int fsync(int fildes);
addToFunctionSummaryMap( addToFunctionSummaryMap("fsync", Signature(ArgTypes{IntTy}, RetType{IntTy}),
"fsync", Summary(ArgTypes{IntTy}, RetType{IntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(ArgumentCondition(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); 0, WithinRange, Range(0, IntMax))));
Optional<QualType> Off_tTy = lookupTy("off_t"); Optional<QualType> Off_tTy = lookupTy("off_t");
// int truncate(const char *path, off_t length); // int truncate(const char *path, off_t length);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"truncate", "truncate",
Summary(ArgTypes{ConstCharPtrTy, Off_tTy}, RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, Off_tTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int symlink(const char *oldpath, const char *newpath); // int symlink(const char *oldpath, const char *newpath);
addToFunctionSummaryMap("symlink", addToFunctionSummaryMap(
Summary(ArgTypes{ConstCharPtrTy, ConstCharPtrTy}, "symlink",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, ConstCharPtrTy}, RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int symlinkat(const char *oldpath, int newdirfd, const char *newpath); // int symlinkat(const char *oldpath, int newdirfd, const char *newpath);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"symlinkat", "symlinkat",
Summary(ArgTypes{ConstCharPtrTy, IntTy, ConstCharPtrTy}, RetType{IntTy}, Signature(ArgTypes{ConstCharPtrTy, IntTy, ConstCharPtrTy},
NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(ArgumentCondition(1, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(1, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(2)))); .ArgConstraint(NotNull(ArgNo(2))));
// int lockf(int fd, int cmd, off_t len); // int lockf(int fd, int cmd, off_t len);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"lockf", "lockf", Signature(ArgTypes{IntTy, IntTy, Off_tTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy, IntTy, Off_tTy}, RetType{IntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); ArgumentCondition(0, WithinRange, Range(0, IntMax))));
Optional<QualType> Mode_tTy = lookupTy("mode_t"); Optional<QualType> Mode_tTy = lookupTy("mode_t");
// int creat(const char *pathname, mode_t mode); // int creat(const char *pathname, mode_t mode);
addToFunctionSummaryMap("creat", Summary(ArgTypes{ConstCharPtrTy, Mode_tTy}, addToFunctionSummaryMap(
RetType{IntTy}, NoEvalCall) "creat", Signature(ArgTypes{ConstCharPtrTy, Mode_tTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// unsigned int sleep(unsigned int seconds); // unsigned int sleep(unsigned int seconds);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"sleep", "sleep", Signature(ArgTypes{UnsignedIntTy}, RetType{UnsignedIntTy}),
Summary(ArgTypes{UnsignedIntTy}, RetType{UnsignedIntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, UnsignedIntMax)))); ArgumentCondition(0, WithinRange, Range(0, UnsignedIntMax))));
Optional<QualType> DirTy = lookupTy("DIR"); Optional<QualType> DirTy = lookupTy("DIR");
Optional<QualType> DirPtrTy = getPointerTy(DirTy); Optional<QualType> DirPtrTy = getPointerTy(DirTy);
// int dirfd(DIR *dirp); // int dirfd(DIR *dirp);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"dirfd", Summary(ArgTypes{DirPtrTy}, RetType{IntTy}, NoEvalCall) "dirfd", Signature(ArgTypes{DirPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// unsigned int alarm(unsigned int seconds); // unsigned int alarm(unsigned int seconds);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"alarm", "alarm", Signature(ArgTypes{UnsignedIntTy}, RetType{UnsignedIntTy}),
Summary(ArgTypes{UnsignedIntTy}, RetType{UnsignedIntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, UnsignedIntMax)))); ArgumentCondition(0, WithinRange, Range(0, UnsignedIntMax))));
// int closedir(DIR *dir); // int closedir(DIR *dir);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"closedir", Summary(ArgTypes{DirPtrTy}, RetType{IntTy}, NoEvalCall) "closedir", Signature(ArgTypes{DirPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// char *strdup(const char *s); // char *strdup(const char *s);
addToFunctionSummaryMap("strdup", Summary(ArgTypes{ConstCharPtrTy}, addToFunctionSummaryMap(
RetType{CharPtrTy}, NoEvalCall) "strdup", Signature(ArgTypes{ConstCharPtrTy}, RetType{CharPtrTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// char *strndup(const char *s, size_t n); // char *strndup(const char *s, size_t n);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"strndup", Summary(ArgTypes{ConstCharPtrTy, SizeTy}, RetType{CharPtrTy}, "strndup",
NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, SizeTy}, RetType{CharPtrTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(ArgumentCondition(1, WithinRange, .ArgConstraint(
Range(0, SizeMax)))); ArgumentCondition(1, WithinRange, Range(0, SizeMax))));
// wchar_t *wcsdup(const wchar_t *s); // wchar_t *wcsdup(const wchar_t *s);
addToFunctionSummaryMap("wcsdup", Summary(ArgTypes{ConstWchar_tPtrTy}, addToFunctionSummaryMap(
RetType{Wchar_tPtrTy}, NoEvalCall) "wcsdup", Signature(ArgTypes{ConstWchar_tPtrTy}, RetType{Wchar_tPtrTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int mkstemp(char *template); // int mkstemp(char *template);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"mkstemp", Summary(ArgTypes{CharPtrTy}, RetType{IntTy}, NoEvalCall) "mkstemp", Signature(ArgTypes{CharPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// char *mkdtemp(char *template); // char *mkdtemp(char *template);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"mkdtemp", Summary(ArgTypes{CharPtrTy}, RetType{CharPtrTy}, NoEvalCall) "mkdtemp", Signature(ArgTypes{CharPtrTy}, RetType{CharPtrTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// char *getcwd(char *buf, size_t size); // char *getcwd(char *buf, size_t size);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"getcwd", "getcwd", Signature(ArgTypes{CharPtrTy, SizeTy}, RetType{CharPtrTy}),
Summary(ArgTypes{CharPtrTy, SizeTy}, RetType{CharPtrTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(1, WithinRange, Range(0, SizeMax)))); ArgumentCondition(1, WithinRange, Range(0, SizeMax))));
// int mkdir(const char *pathname, mode_t mode); // int mkdir(const char *pathname, mode_t mode);
addToFunctionSummaryMap("mkdir", Summary(ArgTypes{ConstCharPtrTy, Mode_tTy}, addToFunctionSummaryMap(
RetType{IntTy}, NoEvalCall) "mkdir", Signature(ArgTypes{ConstCharPtrTy, Mode_tTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int mkdirat(int dirfd, const char *pathname, mode_t mode); // int mkdirat(int dirfd, const char *pathname, mode_t mode);
addToFunctionSummaryMap("mkdirat", addToFunctionSummaryMap(
Summary(ArgTypes{IntTy, ConstCharPtrTy, Mode_tTy}, "mkdirat",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, ConstCharPtrTy, Mode_tTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(1)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(1))));
Optional<QualType> Dev_tTy = lookupTy("dev_t"); Optional<QualType> Dev_tTy = lookupTy("dev_t");
// int mknod(const char *pathname, mode_t mode, dev_t dev); // int mknod(const char *pathname, mode_t mode, dev_t dev);
addToFunctionSummaryMap("mknod", addToFunctionSummaryMap(
Summary(ArgTypes{ConstCharPtrTy, Mode_tTy, Dev_tTy}, "mknod",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, Mode_tTy, Dev_tTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int mknodat(int dirfd, const char *pathname, mode_t mode, dev_t dev); // int mknodat(int dirfd, const char *pathname, mode_t mode, dev_t dev);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"mknodat", Summary(ArgTypes{IntTy, ConstCharPtrTy, Mode_tTy, Dev_tTy}, "mknodat",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, ConstCharPtrTy, Mode_tTy, Dev_tTy},
.ArgConstraint(NotNull(ArgNo(1)))); RetType{IntTy}),
Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(1))));
// int chmod(const char *path, mode_t mode); // int chmod(const char *path, mode_t mode);
addToFunctionSummaryMap("chmod", Summary(ArgTypes{ConstCharPtrTy, Mode_tTy}, addToFunctionSummaryMap(
RetType{IntTy}, NoEvalCall) "chmod", Signature(ArgTypes{ConstCharPtrTy, Mode_tTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int fchmodat(int dirfd, const char *pathname, mode_t mode, int flags); // int fchmodat(int dirfd, const char *pathname, mode_t mode, int flags);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fchmodat", "fchmodat",
Summary(ArgTypes{IntTy, ConstCharPtrTy, Mode_tTy, IntTy}, Signature(ArgTypes{IntTy, ConstCharPtrTy, Mode_tTy, IntTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int fchmod(int fildes, mode_t mode); // int fchmod(int fildes, mode_t mode);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fchmod", Summary(ArgTypes{IntTy, Mode_tTy}, RetType{IntTy}, NoEvalCall) "fchmod", Signature(ArgTypes{IntTy, Mode_tTy}, RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); ArgumentCondition(0, WithinRange, Range(0, IntMax))));
Optional<QualType> Uid_tTy = lookupTy("uid_t"); Optional<QualType> Uid_tTy = lookupTy("uid_t");
Optional<QualType> Gid_tTy = lookupTy("gid_t"); Optional<QualType> Gid_tTy = lookupTy("gid_t");
// int fchownat(int dirfd, const char *pathname, uid_t owner, gid_t group, // int fchownat(int dirfd, const char *pathname, uid_t owner, gid_t group,
// int flags); // int flags);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fchownat", "fchownat",
Summary(ArgTypes{IntTy, ConstCharPtrTy, Uid_tTy, Gid_tTy, IntTy}, Signature(ArgTypes{IntTy, ConstCharPtrTy, Uid_tTy, Gid_tTy, IntTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int chown(const char *path, uid_t owner, gid_t group); // int chown(const char *path, uid_t owner, gid_t group);
addToFunctionSummaryMap("chown", addToFunctionSummaryMap(
Summary(ArgTypes{ConstCharPtrTy, Uid_tTy, Gid_tTy}, "chown",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, Uid_tTy, Gid_tTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int lchown(const char *path, uid_t owner, gid_t group); // int lchown(const char *path, uid_t owner, gid_t group);
addToFunctionSummaryMap("lchown", addToFunctionSummaryMap(
Summary(ArgTypes{ConstCharPtrTy, Uid_tTy, Gid_tTy}, "lchown",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, Uid_tTy, Gid_tTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int fchown(int fildes, uid_t owner, gid_t group); // int fchown(int fildes, uid_t owner, gid_t group);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fchown", "fchown", Signature(ArgTypes{IntTy, Uid_tTy, Gid_tTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy, Uid_tTy, Gid_tTy}, RetType{IntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); ArgumentCondition(0, WithinRange, Range(0, IntMax))));
// int rmdir(const char *pathname); // int rmdir(const char *pathname);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"rmdir", Summary(ArgTypes{ConstCharPtrTy}, RetType{IntTy}, NoEvalCall) "rmdir", Signature(ArgTypes{ConstCharPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int chdir(const char *path); // int chdir(const char *path);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"chdir", Summary(ArgTypes{ConstCharPtrTy}, RetType{IntTy}, NoEvalCall) "chdir", Signature(ArgTypes{ConstCharPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int link(const char *oldpath, const char *newpath); // int link(const char *oldpath, const char *newpath);
addToFunctionSummaryMap("link", addToFunctionSummaryMap(
Summary(ArgTypes{ConstCharPtrTy, ConstCharPtrTy}, "link",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, ConstCharPtrTy}, RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int linkat(int fd1, const char *path1, int fd2, const char *path2, // int linkat(int fd1, const char *path1, int fd2, const char *path2,
// int flag); // int flag);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"linkat", "linkat",
Summary(ArgTypes{IntTy, ConstCharPtrTy, IntTy, ConstCharPtrTy, IntTy}, Signature(ArgTypes{IntTy, ConstCharPtrTy, IntTy, ConstCharPtrTy, IntTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(ArgumentCondition(2, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(2, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(3)))); .ArgConstraint(NotNull(ArgNo(3))));
// int unlink(const char *pathname); // int unlink(const char *pathname);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"unlink", Summary(ArgTypes{ConstCharPtrTy}, RetType{IntTy}, NoEvalCall) "unlink", Signature(ArgTypes{ConstCharPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int unlinkat(int fd, const char *path, int flag); // int unlinkat(int fd, const char *path, int flag);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"unlinkat", "unlinkat",
Summary(ArgTypes{IntTy, ConstCharPtrTy, IntTy}, RetType{IntTy}, Signature(ArgTypes{IntTy, ConstCharPtrTy, IntTy}, RetType{IntTy}),
NoEvalCall) Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
Optional<QualType> StructStatTy = lookupTy("stat"); Optional<QualType> StructStatTy = lookupTy("stat");
Optional<QualType> StructStatPtrTy = getPointerTy(StructStatTy); Optional<QualType> StructStatPtrTy = getPointerTy(StructStatTy);
Optional<QualType> StructStatPtrRestrictTy = getRestrictTy(StructStatPtrTy); Optional<QualType> StructStatPtrRestrictTy = getRestrictTy(StructStatPtrTy);
// int fstat(int fd, struct stat *statbuf); // int fstat(int fd, struct stat *statbuf);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fstat", "fstat", Signature(ArgTypes{IntTy, StructStatPtrTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy, StructStatPtrTy}, RetType{IntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int stat(const char *restrict path, struct stat *restrict buf); // int stat(const char *restrict path, struct stat *restrict buf);
addToFunctionSummaryMap("stat", Summary(ArgTypes{ConstCharPtrRestrictTy, addToFunctionSummaryMap(
StructStatPtrRestrictTy}, "stat",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrRestrictTy, StructStatPtrRestrictTy},
RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int lstat(const char *restrict path, struct stat *restrict buf); // int lstat(const char *restrict path, struct stat *restrict buf);
addToFunctionSummaryMap("lstat", Summary(ArgTypes{ConstCharPtrRestrictTy, addToFunctionSummaryMap(
StructStatPtrRestrictTy}, "lstat",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrRestrictTy, StructStatPtrRestrictTy},
RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int fstatat(int fd, const char *restrict path, // int fstatat(int fd, const char *restrict path,
// struct stat *restrict buf, int flag); // struct stat *restrict buf, int flag);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fstatat", "fstatat",
Summary(ArgTypes{IntTy, ConstCharPtrRestrictTy, StructStatPtrRestrictTy, Signature(ArgTypes{IntTy, ConstCharPtrRestrictTy,
IntTy}, StructStatPtrRestrictTy, IntTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(NotNull(ArgNo(2)))); .ArgConstraint(NotNull(ArgNo(2))));
// DIR *opendir(const char *name); // DIR *opendir(const char *name);
addToFunctionSummaryMap("opendir", Summary(ArgTypes{ConstCharPtrTy}, addToFunctionSummaryMap(
RetType{DirPtrTy}, NoEvalCall) "opendir", Signature(ArgTypes{ConstCharPtrTy}, RetType{DirPtrTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// DIR *fdopendir(int fd); // DIR *fdopendir(int fd);
addToFunctionSummaryMap( addToFunctionSummaryMap("fdopendir",
"fdopendir", Summary(ArgTypes{IntTy}, RetType{DirPtrTy}, NoEvalCall) Signature(ArgTypes{IntTy}, RetType{DirPtrTy}),
.ArgConstraint(ArgumentCondition(0, WithinRange, Summary(NoEvalCall)
Range(0, IntMax)))); .ArgConstraint(ArgumentCondition(
0, WithinRange, Range(0, IntMax))));
// int isatty(int fildes); // int isatty(int fildes);
addToFunctionSummaryMap( addToFunctionSummaryMap("isatty",
"isatty", Summary(ArgTypes{IntTy}, RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy}, RetType{IntTy}),
.ArgConstraint( Summary(NoEvalCall)
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); .ArgConstraint(ArgumentCondition(
0, WithinRange, Range(0, IntMax))));
// FILE *popen(const char *command, const char *type); // FILE *popen(const char *command, const char *type);
addToFunctionSummaryMap("popen", addToFunctionSummaryMap(
Summary(ArgTypes{ConstCharPtrTy, ConstCharPtrTy}, "popen",
RetType{FilePtrTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, ConstCharPtrTy}, RetType{FilePtrTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// int pclose(FILE *stream); // int pclose(FILE *stream);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"pclose", Summary(ArgTypes{FilePtrTy}, RetType{IntTy}, NoEvalCall) "pclose", Signature(ArgTypes{FilePtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int close(int fildes); // int close(int fildes);
addToFunctionSummaryMap( addToFunctionSummaryMap("close", Signature(ArgTypes{IntTy}, RetType{IntTy}),
"close", Summary(ArgTypes{IntTy}, RetType{IntTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(ArgumentCondition(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); 0, WithinRange, Range(0, IntMax))));
// long fpathconf(int fildes, int name); // long fpathconf(int fildes, int name);
addToFunctionSummaryMap( addToFunctionSummaryMap("fpathconf",
"fpathconf", Signature(ArgTypes{IntTy, IntTy}, RetType{LongTy}),
Summary(ArgTypes{IntTy, IntTy}, RetType{LongTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(ArgumentCondition(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); 0, WithinRange, Range(0, IntMax))));
// long pathconf(const char *path, int name); // long pathconf(const char *path, int name);
addToFunctionSummaryMap("pathconf", Summary(ArgTypes{ConstCharPtrTy, IntTy}, addToFunctionSummaryMap(
RetType{LongTy}, NoEvalCall) "pathconf", Signature(ArgTypes{ConstCharPtrTy, IntTy}, RetType{LongTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// FILE *fdopen(int fd, const char *mode); // FILE *fdopen(int fd, const char *mode);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fdopen", "fdopen",
Summary(ArgTypes{IntTy, ConstCharPtrTy}, RetType{FilePtrTy}, NoEvalCall) Signature(ArgTypes{IntTy, ConstCharPtrTy}, RetType{FilePtrTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// void rewinddir(DIR *dir); // void rewinddir(DIR *dir);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"rewinddir", Summary(ArgTypes{DirPtrTy}, RetType{VoidTy}, NoEvalCall) "rewinddir", Signature(ArgTypes{DirPtrTy}, RetType{VoidTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// void seekdir(DIR *dirp, long loc); // void seekdir(DIR *dirp, long loc);
addToFunctionSummaryMap("seekdir", Summary(ArgTypes{DirPtrTy, LongTy}, addToFunctionSummaryMap(
RetType{VoidTy}, NoEvalCall) "seekdir", Signature(ArgTypes{DirPtrTy, LongTy}, RetType{VoidTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int rand_r(unsigned int *seedp); // int rand_r(unsigned int *seedp);
addToFunctionSummaryMap("rand_r", Summary(ArgTypes{UnsignedIntPtrTy}, addToFunctionSummaryMap(
RetType{IntTy}, NoEvalCall) "rand_r", Signature(ArgTypes{UnsignedIntPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int fileno(FILE *stream); // int fileno(FILE *stream);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fileno", Summary(ArgTypes{FilePtrTy}, RetType{IntTy}, NoEvalCall) "fileno", Signature(ArgTypes{FilePtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int fseeko(FILE *stream, off_t offset, int whence); // int fseeko(FILE *stream, off_t offset, int whence);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"fseeko", "fseeko",
Summary(ArgTypes{FilePtrTy, Off_tTy, IntTy}, RetType{IntTy}, NoEvalCall) Signature(ArgTypes{FilePtrTy, Off_tTy, IntTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// off_t ftello(FILE *stream); // off_t ftello(FILE *stream);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"ftello", Summary(ArgTypes{FilePtrTy}, RetType{Off_tTy}, NoEvalCall) "ftello", Signature(ArgTypes{FilePtrTy}, RetType{Off_tTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
Optional<RangeInt> Off_tMax = getMaxValue(Off_tTy); Optional<RangeInt> Off_tMax = getMaxValue(Off_tTy);
// void *mmap(void *addr, size_t length, int prot, int flags, int fd, // void *mmap(void *addr, size_t length, int prot, int flags, int fd,
// off_t offset); // off_t offset);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"mmap", "mmap",
Summary(ArgTypes{VoidPtrTy, SizeTy, IntTy, IntTy, IntTy, Off_tTy}, Signature(ArgTypes{VoidPtrTy, SizeTy, IntTy, IntTy, IntTy, Off_tTy},
RetType{VoidPtrTy}, NoEvalCall) RetType{VoidPtrTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(1, WithinRange, Range(1, SizeMax))) .ArgConstraint(ArgumentCondition(1, WithinRange, Range(1, SizeMax)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(4, WithinRange, Range(0, Off_tMax)))); ArgumentCondition(4, WithinRange, Range(0, Off_tMax))));
Optional<QualType> Off64_tTy = lookupTy("off64_t"); Optional<QualType> Off64_tTy = lookupTy("off64_t");
Optional<RangeInt> Off64_tMax = getMaxValue(Off_tTy); Optional<RangeInt> Off64_tMax = getMaxValue(Off_tTy);
// void *mmap64(void *addr, size_t length, int prot, int flags, int fd, // void *mmap64(void *addr, size_t length, int prot, int flags, int fd,
// off64_t offset); // off64_t offset);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"mmap64", "mmap64",
Summary(ArgTypes{VoidPtrTy, SizeTy, IntTy, IntTy, IntTy, Off64_tTy}, Signature(ArgTypes{VoidPtrTy, SizeTy, IntTy, IntTy, IntTy, Off64_tTy},
RetType{VoidPtrTy}, NoEvalCall) RetType{VoidPtrTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(1, WithinRange, Range(1, SizeMax))) .ArgConstraint(ArgumentCondition(1, WithinRange, Range(1, SizeMax)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(4, WithinRange, Range(0, Off64_tMax)))); ArgumentCondition(4, WithinRange, Range(0, Off64_tMax))));
// int pipe(int fildes[2]); // int pipe(int fildes[2]);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"pipe", Summary(ArgTypes{IntPtrTy}, RetType{IntTy}, NoEvalCall) "pipe", Signature(ArgTypes{IntPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// off_t lseek(int fildes, off_t offset, int whence); // off_t lseek(int fildes, off_t offset, int whence);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"lseek", "lseek", Signature(ArgTypes{IntTy, Off_tTy, IntTy}, RetType{Off_tTy}),
Summary(ArgTypes{IntTy, Off_tTy, IntTy}, RetType{Off_tTy}, NoEvalCall) Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); ArgumentCondition(0, WithinRange, Range(0, IntMax))));
// ssize_t readlink(const char *restrict path, char *restrict buf, // ssize_t readlink(const char *restrict path, char *restrict buf,
// size_t bufsize); // size_t bufsize);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"readlink", "readlink",
Summary(ArgTypes{ConstCharPtrRestrictTy, CharPtrRestrictTy, SizeTy}, Signature(ArgTypes{ConstCharPtrRestrictTy, CharPtrRestrictTy, SizeTy},
RetType{Ssize_tTy}, NoEvalCall) RetType{Ssize_tTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1), .ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1),
/*BufSize=*/ArgNo(2))) /*BufSize=*/ArgNo(2)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(2, WithinRange, Range(0, SizeMax)))); ArgumentCondition(2, WithinRange, Range(0, SizeMax))));
// ssize_t readlinkat(int fd, const char *restrict path, // ssize_t readlinkat(int fd, const char *restrict path,
// char *restrict buf, size_t bufsize); // char *restrict buf, size_t bufsize);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"readlinkat", "readlinkat",
Summary( Signature(
ArgTypes{IntTy, ConstCharPtrRestrictTy, CharPtrRestrictTy, SizeTy}, ArgTypes{IntTy, ConstCharPtrRestrictTy, CharPtrRestrictTy, SizeTy},
RetType{Ssize_tTy}, NoEvalCall) RetType{Ssize_tTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(NotNull(ArgNo(2))) .ArgConstraint(NotNull(ArgNo(2)))
.ArgConstraint(BufferSize(/*Buffer=*/ArgNo(2), .ArgConstraint(BufferSize(/*Buffer=*/ArgNo(2),
/*BufSize=*/ArgNo(3))) /*BufSize=*/ArgNo(3)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(3, WithinRange, Range(0, SizeMax)))); ArgumentCondition(3, WithinRange, Range(0, SizeMax))));
// int renameat(int olddirfd, const char *oldpath, int newdirfd, const char // int renameat(int olddirfd, const char *oldpath, int newdirfd, const char
// *newpath); // *newpath);
addToFunctionSummaryMap("renameat", Summary(ArgTypes{IntTy, ConstCharPtrTy, addToFunctionSummaryMap(
IntTy, ConstCharPtrTy}, "renameat",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, ConstCharPtrTy, IntTy, ConstCharPtrTy},
RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(NotNull(ArgNo(3)))); .ArgConstraint(NotNull(ArgNo(3))));
// char *realpath(const char *restrict file_name, // char *realpath(const char *restrict file_name,
// char *restrict resolved_name); // char *restrict resolved_name);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"realpath", Summary(ArgTypes{ConstCharPtrRestrictTy, CharPtrRestrictTy}, "realpath",
RetType{CharPtrTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrRestrictTy, CharPtrRestrictTy},
.ArgConstraint(NotNull(ArgNo(0)))); RetType{CharPtrTy}),
Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
QualType CharPtrConstPtr = getPointerTy(getConstTy(CharPtrTy)); QualType CharPtrConstPtr = getPointerTy(getConstTy(CharPtrTy));
// int execv(const char *path, char *const argv[]); // int execv(const char *path, char *const argv[]);
addToFunctionSummaryMap("execv", addToFunctionSummaryMap(
Summary(ArgTypes{ConstCharPtrTy, CharPtrConstPtr}, "execv",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, CharPtrConstPtr}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int execvp(const char *file, char *const argv[]); // int execvp(const char *file, char *const argv[]);
addToFunctionSummaryMap("execvp", addToFunctionSummaryMap(
Summary(ArgTypes{ConstCharPtrTy, CharPtrConstPtr}, "execvp",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, CharPtrConstPtr}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int getopt(int argc, char * const argv[], const char *optstring); // int getopt(int argc, char * const argv[], const char *optstring);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"getopt", "getopt",
Summary(ArgTypes{IntTy, CharPtrConstPtr, ConstCharPtrTy}, Signature(ArgTypes{IntTy, CharPtrConstPtr, ConstCharPtrTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(NotNull(ArgNo(2)))); .ArgConstraint(NotNull(ArgNo(2))));
Optional<QualType> StructSockaddrTy = lookupTy("sockaddr"); Optional<QualType> StructSockaddrTy = lookupTy("sockaddr");
Optional<QualType> StructSockaddrPtrTy = getPointerTy(StructSockaddrTy); Optional<QualType> StructSockaddrPtrTy = getPointerTy(StructSockaddrTy);
Optional<QualType> ConstStructSockaddrPtrTy = Optional<QualType> ConstStructSockaddrPtrTy =
getPointerTy(getConstTy(StructSockaddrTy)); getPointerTy(getConstTy(StructSockaddrTy));
Show All 28 Lines if (!addToFunctionSummaryMap(
Signature(ArgTypes{IntTy, Irrelevant, Socklen_tPtrRestrictTy}, Signature(ArgTypes{IntTy, Irrelevant, Socklen_tPtrRestrictTy},
RetType{IntTy}), RetType{IntTy}),
Accept); Accept);
// int bind(int socket, const struct sockaddr *address, socklen_t // int bind(int socket, const struct sockaddr *address, socklen_t
// address_len); // address_len);
if (!addToFunctionSummaryMap( if (!addToFunctionSummaryMap(
"bind", "bind",
Summary(ArgTypes{IntTy, ConstStructSockaddrPtrTy, Socklen_tTy}, Signature(ArgTypes{IntTy, ConstStructSockaddrPtrTy, Socklen_tTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax))) ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint( .ArgConstraint(
BufferSize(/*Buffer=*/ArgNo(1), /*BufSize=*/ArgNo(2))) BufferSize(/*Buffer=*/ArgNo(1), /*BufSize=*/ArgNo(2)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(2, WithinRange, Range(0, Socklen_tMax))))) ArgumentCondition(2, WithinRange, Range(0, Socklen_tMax)))))
// Do not add constraints on sockaddr. // Do not add constraints on sockaddr.
addToFunctionSummaryMap( addToFunctionSummaryMap(
"bind", Summary(ArgTypes{IntTy, Irrelevant, Socklen_tTy}, "bind",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, Irrelevant, Socklen_tTy}, RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax))) ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(ArgumentCondition( .ArgConstraint(
2, WithinRange, Range(0, Socklen_tMax)))); ArgumentCondition(2, WithinRange, Range(0, Socklen_tMax))));
// int getpeername(int socket, struct sockaddr *restrict address, // int getpeername(int socket, struct sockaddr *restrict address,
// socklen_t *restrict address_len); // socklen_t *restrict address_len);
if (!addToFunctionSummaryMap( if (!addToFunctionSummaryMap(
"getpeername", Summary(ArgTypes{IntTy, StructSockaddrPtrRestrictTy, "getpeername",
Signature(ArgTypes{IntTy, StructSockaddrPtrRestrictTy,
Socklen_tPtrRestrictTy}, Socklen_tPtrRestrictTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
.ArgConstraint(ArgumentCondition( Summary(NoEvalCall)
0, WithinRange, Range(0, IntMax))) .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(NotNull(ArgNo(2))))) .ArgConstraint(NotNull(ArgNo(2)))))
addToFunctionSummaryMap( addToFunctionSummaryMap(
"getpeername", "getpeername",
Summary(ArgTypes{IntTy, Irrelevant, Socklen_tPtrRestrictTy}, Signature(ArgTypes{IntTy, Irrelevant, Socklen_tPtrRestrictTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); ArgumentCondition(0, WithinRange, Range(0, IntMax))));
// int getsockname(int socket, struct sockaddr *restrict address, // int getsockname(int socket, struct sockaddr *restrict address,
// socklen_t *restrict address_len); // socklen_t *restrict address_len);
if (!addToFunctionSummaryMap( if (!addToFunctionSummaryMap(
"getsockname", Summary(ArgTypes{IntTy, StructSockaddrPtrRestrictTy, "getsockname",
Signature(ArgTypes{IntTy, StructSockaddrPtrRestrictTy,
Socklen_tPtrRestrictTy}, Socklen_tPtrRestrictTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
.ArgConstraint(ArgumentCondition( Summary(NoEvalCall)
0, WithinRange, Range(0, IntMax))) .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(NotNull(ArgNo(2))))) .ArgConstraint(NotNull(ArgNo(2)))))
addToFunctionSummaryMap( addToFunctionSummaryMap(
"getsockname", "getsockname",
Summary(ArgTypes{IntTy, Irrelevant, Socklen_tPtrRestrictTy}, Signature(ArgTypes{IntTy, Irrelevant, Socklen_tPtrRestrictTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); ArgumentCondition(0, WithinRange, Range(0, IntMax))));
// int connect(int socket, const struct sockaddr *address, socklen_t // int connect(int socket, const struct sockaddr *address, socklen_t
// address_len); // address_len);
if (!addToFunctionSummaryMap( if (!addToFunctionSummaryMap(
"connect", "connect",
Summary(ArgTypes{IntTy, ConstStructSockaddrPtrTy, Socklen_tTy}, Signature(ArgTypes{IntTy, ConstStructSockaddrPtrTy, Socklen_tTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax))) ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(NotNull(ArgNo(1))))) .ArgConstraint(NotNull(ArgNo(1)))))
addToFunctionSummaryMap( addToFunctionSummaryMap(
"connect", Summary(ArgTypes{IntTy, Irrelevant, Socklen_tTy}, "connect",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, Irrelevant, Socklen_tTy}, RetType{IntTy}),
.ArgConstraint(ArgumentCondition(0, WithinRange, Summary(NoEvalCall)
Range(0, IntMax)))); .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax))));
auto Recvfrom = auto Recvfrom =
Summary(NoEvalCall) Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1), .ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1),
/*BufSize=*/ArgNo(2))); /*BufSize=*/ArgNo(2)));
if (!addToFunctionSummaryMap( if (!addToFunctionSummaryMap(
"recvfrom", "recvfrom",
Show All 30 Lines if (!addToFunctionSummaryMap(
addToFunctionSummaryMap( addToFunctionSummaryMap(
"sendto", "sendto",
Signature(ArgTypes{IntTy, ConstVoidPtrTy, SizeTy, IntTy, Irrelevant, Signature(ArgTypes{IntTy, ConstVoidPtrTy, SizeTy, IntTy, Irrelevant,
Socklen_tTy}, Socklen_tTy},
RetType{Ssize_tTy}), RetType{Ssize_tTy}),
Sendto); Sendto);
// int listen(int sockfd, int backlog); // int listen(int sockfd, int backlog);
addToFunctionSummaryMap( addToFunctionSummaryMap("listen",
"listen", Summary(ArgTypes{IntTy, IntTy}, RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, IntTy}, RetType{IntTy}),
.ArgConstraint( Summary(NoEvalCall)
ArgumentCondition(0, WithinRange, Range(0, IntMax)))); .ArgConstraint(ArgumentCondition(
0, WithinRange, Range(0, IntMax))));
// ssize_t recv(int sockfd, void *buf, size_t len, int flags); // ssize_t recv(int sockfd, void *buf, size_t len, int flags);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"recv", "recv",
Summary(ArgTypes{IntTy, VoidPtrTy, SizeTy, IntTy}, RetType{Ssize_tTy}, Signature(ArgTypes{IntTy, VoidPtrTy, SizeTy, IntTy},
NoEvalCall) RetType{Ssize_tTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1), .ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1),
/*BufSize=*/ArgNo(2)))); /*BufSize=*/ArgNo(2))));
Optional<QualType> StructMsghdrTy = lookupTy("msghdr"); Optional<QualType> StructMsghdrTy = lookupTy("msghdr");
Optional<QualType> StructMsghdrPtrTy = getPointerTy(StructMsghdrTy); Optional<QualType> StructMsghdrPtrTy = getPointerTy(StructMsghdrTy);
Optional<QualType> ConstStructMsghdrPtrTy = Optional<QualType> ConstStructMsghdrPtrTy =
getPointerTy(getConstTy(StructMsghdrTy)); getPointerTy(getConstTy(StructMsghdrTy));
// ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags); // ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
addToFunctionSummaryMap( addToFunctionSummaryMap("recvmsg",
"recvmsg", Summary(ArgTypes{IntTy, StructMsghdrPtrTy, IntTy}, Signature(ArgTypes{IntTy, StructMsghdrPtrTy, IntTy},
RetType{Ssize_tTy}, NoEvalCall) RetType{Ssize_tTy}),
.ArgConstraint(ArgumentCondition(0, WithinRange, Summary(NoEvalCall)
Range(0, IntMax)))); .ArgConstraint(ArgumentCondition(
0, WithinRange, Range(0, IntMax))));
// ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags); // ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"sendmsg", Summary(ArgTypes{IntTy, ConstStructMsghdrPtrTy, IntTy}, "sendmsg",
RetType{Ssize_tTy}, NoEvalCall) Signature(ArgTypes{IntTy, ConstStructMsghdrPtrTy, IntTy},
.ArgConstraint(ArgumentCondition(0, WithinRange, RetType{Ssize_tTy}),
Range(0, IntMax)))); Summary(NoEvalCall)
.ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax))));
// int setsockopt(int socket, int level, int option_name, // int setsockopt(int socket, int level, int option_name,
// const void *option_value, socklen_t option_len); // const void *option_value, socklen_t option_len);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"setsockopt", "setsockopt",
Summary(ArgTypes{IntTy, IntTy, IntTy, ConstVoidPtrTy, Socklen_tTy}, Signature(ArgTypes{IntTy, IntTy, IntTy, ConstVoidPtrTy, Socklen_tTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(3))) .ArgConstraint(NotNull(ArgNo(3)))
.ArgConstraint( .ArgConstraint(
BufferSize(/*Buffer=*/ArgNo(3), /*BufSize=*/ArgNo(4))) BufferSize(/*Buffer=*/ArgNo(3), /*BufSize=*/ArgNo(4)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(4, WithinRange, Range(0, Socklen_tMax)))); ArgumentCondition(4, WithinRange, Range(0, Socklen_tMax))));
// int getsockopt(int socket, int level, int option_name, // int getsockopt(int socket, int level, int option_name,
// void *restrict option_value, // void *restrict option_value,
// socklen_t *restrict option_len); // socklen_t *restrict option_len);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"getsockopt", Summary(ArgTypes{IntTy, IntTy, IntTy, VoidPtrRestrictTy, "getsockopt",
Signature(ArgTypes{IntTy, IntTy, IntTy, VoidPtrRestrictTy,
Socklen_tPtrRestrictTy}, Socklen_tPtrRestrictTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(3))) .ArgConstraint(NotNull(ArgNo(3)))
.ArgConstraint(NotNull(ArgNo(4)))); .ArgConstraint(NotNull(ArgNo(4))));
// ssize_t send(int sockfd, const void *buf, size_t len, int flags); // ssize_t send(int sockfd, const void *buf, size_t len, int flags);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"send", "send",
Summary(ArgTypes{IntTy, ConstVoidPtrTy, SizeTy, IntTy}, Signature(ArgTypes{IntTy, ConstVoidPtrTy, SizeTy, IntTy},
RetType{Ssize_tTy}, NoEvalCall) RetType{Ssize_tTy}),
Summary(NoEvalCall)
.ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax))) .ArgConstraint(ArgumentCondition(0, WithinRange, Range(0, IntMax)))
.ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1), .ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1),
/*BufSize=*/ArgNo(2)))); /*BufSize=*/ArgNo(2))));
// int socketpair(int domain, int type, int protocol, int sv[2]); // int socketpair(int domain, int type, int protocol, int sv[2]);
addToFunctionSummaryMap("socketpair", addToFunctionSummaryMap(
Summary(ArgTypes{IntTy, IntTy, IntTy, IntPtrTy}, "socketpair",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, IntTy, IntTy, IntPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(3)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(3))));
// int getnameinfo(const struct sockaddr *restrict sa, socklen_t salen, // int getnameinfo(const struct sockaddr *restrict sa, socklen_t salen,
// char *restrict node, socklen_t nodelen, // char *restrict node, socklen_t nodelen,
// char *restrict service, // char *restrict service,
// socklen_t servicelen, int flags); // socklen_t servicelen, int flags);
// //
// This is defined in netdb.h. And contrary to 'socket.h', the sockaddr // This is defined in netdb.h. And contrary to 'socket.h', the sockaddr
// parameter is never handled as a transparent union in netdb.h // parameter is never handled as a transparent union in netdb.h
addToFunctionSummaryMap( addToFunctionSummaryMap(
"getnameinfo", "getnameinfo",
Summary(ArgTypes{ConstStructSockaddrPtrRestrictTy, Socklen_tTy, Signature(ArgTypes{ConstStructSockaddrPtrRestrictTy, Socklen_tTy,
CharPtrRestrictTy, Socklen_tTy, CharPtrRestrictTy, CharPtrRestrictTy, Socklen_tTy, CharPtrRestrictTy,
Socklen_tTy, IntTy}, Socklen_tTy, IntTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
Summary(NoEvalCall)
.ArgConstraint( .ArgConstraint(
BufferSize(/*Buffer=*/ArgNo(0), /*BufSize=*/ArgNo(1))) BufferSize(/*Buffer=*/ArgNo(0), /*BufSize=*/ArgNo(1)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(1, WithinRange, Range(0, Socklen_tMax))) ArgumentCondition(1, WithinRange, Range(0, Socklen_tMax)))
.ArgConstraint( .ArgConstraint(
BufferSize(/*Buffer=*/ArgNo(2), /*BufSize=*/ArgNo(3))) BufferSize(/*Buffer=*/ArgNo(2), /*BufSize=*/ArgNo(3)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(3, WithinRange, Range(0, Socklen_tMax))) ArgumentCondition(3, WithinRange, Range(0, Socklen_tMax)))
.ArgConstraint( .ArgConstraint(
BufferSize(/*Buffer=*/ArgNo(4), /*BufSize=*/ArgNo(5))) BufferSize(/*Buffer=*/ArgNo(4), /*BufSize=*/ArgNo(5)))
.ArgConstraint( .ArgConstraint(
ArgumentCondition(5, WithinRange, Range(0, Socklen_tMax)))); ArgumentCondition(5, WithinRange, Range(0, Socklen_tMax))));
Optional<QualType> StructUtimbufTy = lookupTy("utimbuf"); Optional<QualType> StructUtimbufTy = lookupTy("utimbuf");
Optional<QualType> StructUtimbufPtrTy = getPointerTy(StructUtimbufTy); Optional<QualType> StructUtimbufPtrTy = getPointerTy(StructUtimbufTy);
// int utime(const char *filename, struct utimbuf *buf); // int utime(const char *filename, struct utimbuf *buf);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"utime", Summary(ArgTypes{ConstCharPtrTy, StructUtimbufPtrTy}, "utime",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, StructUtimbufPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
Optional<QualType> StructTimespecTy = lookupTy("timespec"); Optional<QualType> StructTimespecTy = lookupTy("timespec");
Optional<QualType> StructTimespecPtrTy = getPointerTy(StructTimespecTy); Optional<QualType> StructTimespecPtrTy = getPointerTy(StructTimespecTy);
Optional<QualType> ConstStructTimespecPtrTy = Optional<QualType> ConstStructTimespecPtrTy =
getPointerTy(getConstTy(StructTimespecTy)); getPointerTy(getConstTy(StructTimespecTy));
// int futimens(int fd, const struct timespec times[2]); // int futimens(int fd, const struct timespec times[2]);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"futimens", Summary(ArgTypes{IntTy, ConstStructTimespecPtrTy}, "futimens",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, ConstStructTimespecPtrTy}, RetType{IntTy}),
.ArgConstraint(ArgumentCondition(0, WithinRange, Summary(NoEvalCall)
Range(0, IntMax)))); .ArgConstraint(
ArgumentCondition(0, WithinRange, Range(0, IntMax))));
// int utimensat(int dirfd, const char *pathname, // int utimensat(int dirfd, const char *pathname,
// const struct timespec times[2], int flags); // const struct timespec times[2], int flags);
addToFunctionSummaryMap("utimensat", addToFunctionSummaryMap(
Summary(ArgTypes{IntTy, ConstCharPtrTy, "utimensat",
ConstStructTimespecPtrTy, IntTy}, Signature(
RetType{IntTy}, NoEvalCall) ArgTypes{IntTy, ConstCharPtrTy, ConstStructTimespecPtrTy, IntTy},
.ArgConstraint(NotNull(ArgNo(1)))); RetType{IntTy}),
Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(1))));
Optional<QualType> StructTimevalTy = lookupTy("timeval"); Optional<QualType> StructTimevalTy = lookupTy("timeval");
Optional<QualType> ConstStructTimevalPtrTy = Optional<QualType> ConstStructTimevalPtrTy =
getPointerTy(getConstTy(StructTimevalTy)); getPointerTy(getConstTy(StructTimevalTy));
// int utimes(const char *filename, const struct timeval times[2]); // int utimes(const char *filename, const struct timeval times[2]);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"utimes", Summary(ArgTypes{ConstCharPtrTy, ConstStructTimevalPtrTy}, "utimes",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{ConstCharPtrTy, ConstStructTimevalPtrTy},
.ArgConstraint(NotNull(ArgNo(0)))); RetType{IntTy}),
Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); // int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"nanosleep", "nanosleep",
Summary(ArgTypes{ConstStructTimespecPtrTy, StructTimespecPtrTy}, Signature(ArgTypes{ConstStructTimespecPtrTy, StructTimespecPtrTy},
RetType{IntTy}, NoEvalCall) RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
Optional<QualType> Time_tTy = lookupTy("time_t"); Optional<QualType> Time_tTy = lookupTy("time_t");
Optional<QualType> ConstTime_tPtrTy = getPointerTy(getConstTy(Time_tTy)); Optional<QualType> ConstTime_tPtrTy = getPointerTy(getConstTy(Time_tTy));
Optional<QualType> ConstTime_tPtrRestrictTy = Optional<QualType> ConstTime_tPtrRestrictTy =
getRestrictTy(ConstTime_tPtrTy); getRestrictTy(ConstTime_tPtrTy);
Optional<QualType> StructTmTy = lookupTy("tm"); Optional<QualType> StructTmTy = lookupTy("tm");
Optional<QualType> StructTmPtrTy = getPointerTy(StructTmTy); Optional<QualType> StructTmPtrTy = getPointerTy(StructTmTy);
Optional<QualType> StructTmPtrRestrictTy = getRestrictTy(StructTmPtrTy); Optional<QualType> StructTmPtrRestrictTy = getRestrictTy(StructTmPtrTy);
Optional<QualType> ConstStructTmPtrTy = Optional<QualType> ConstStructTmPtrTy =
getPointerTy(getConstTy(StructTmTy)); getPointerTy(getConstTy(StructTmTy));
Optional<QualType> ConstStructTmPtrRestrictTy = Optional<QualType> ConstStructTmPtrRestrictTy =
getRestrictTy(ConstStructTmPtrTy); getRestrictTy(ConstStructTmPtrTy);
// struct tm * localtime(const time_t *tp); // struct tm * localtime(const time_t *tp);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"localtime", "localtime",
Summary(ArgTypes{ConstTime_tPtrTy}, RetType{StructTmPtrTy}, NoEvalCall) Signature(ArgTypes{ConstTime_tPtrTy}, RetType{StructTmPtrTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
// struct tm *localtime_r(const time_t *restrict timer, // struct tm *localtime_r(const time_t *restrict timer,
// struct tm *restrict result); // struct tm *restrict result);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"localtime_r", "localtime_r",
Summary(ArgTypes{ConstTime_tPtrRestrictTy, StructTmPtrRestrictTy}, Signature(ArgTypes{ConstTime_tPtrRestrictTy, StructTmPtrRestrictTy},
RetType{StructTmPtrTy}, NoEvalCall) RetType{StructTmPtrTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// char *asctime_r(const struct tm *restrict tm, char *restrict buf); // char *asctime_r(const struct tm *restrict tm, char *restrict buf);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"asctime_r", "asctime_r",
Summary(ArgTypes{ConstStructTmPtrRestrictTy, CharPtrRestrictTy}, Signature(ArgTypes{ConstStructTmPtrRestrictTy, CharPtrRestrictTy},
RetType{CharPtrTy}, NoEvalCall) RetType{CharPtrTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1), .ArgConstraint(BufferSize(/*Buffer=*/ArgNo(1),
/*MinBufSize=*/BVF.getValue(26, IntTy)))); /*MinBufSize=*/BVF.getValue(26, IntTy))));
// char *ctime_r(const time_t *timep, char *buf); // char *ctime_r(const time_t *timep, char *buf);
addToFunctionSummaryMap("ctime_r", addToFunctionSummaryMap(
Summary(ArgTypes{ConstTime_tPtrTy, CharPtrTy}, "ctime_r",
RetType{CharPtrTy}, NoEvalCall) Signature(ArgTypes{ConstTime_tPtrTy, CharPtrTy}, RetType{CharPtrTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1))) .ArgConstraint(NotNull(ArgNo(1)))
.ArgConstraint(BufferSize( .ArgConstraint(BufferSize(
/*Buffer=*/ArgNo(1), /*Buffer=*/ArgNo(1),
/*MinBufSize=*/BVF.getValue(26, IntTy)))); /*MinBufSize=*/BVF.getValue(26, IntTy))));
// struct tm *gmtime_r(const time_t *restrict timer, // struct tm *gmtime_r(const time_t *restrict timer,
// struct tm *restrict result); // struct tm *restrict result);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"gmtime_r", "gmtime_r",
Summary(ArgTypes{ConstTime_tPtrRestrictTy, StructTmPtrRestrictTy}, Signature(ArgTypes{ConstTime_tPtrRestrictTy, StructTmPtrRestrictTy},
RetType{StructTmPtrTy}, NoEvalCall) RetType{StructTmPtrTy}),
Summary(NoEvalCall)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
// struct tm * gmtime(const time_t *tp); // struct tm * gmtime(const time_t *tp);
addToFunctionSummaryMap( addToFunctionSummaryMap(
"gmtime", "gmtime", Signature(ArgTypes{ConstTime_tPtrTy}, RetType{StructTmPtrTy}),
Summary(ArgTypes{ConstTime_tPtrTy}, RetType{StructTmPtrTy}, NoEvalCall) Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
.ArgConstraint(NotNull(ArgNo(0))));
Optional<QualType> Clockid_tTy = lookupTy("clockid_t"); Optional<QualType> Clockid_tTy = lookupTy("clockid_t");
// int clock_gettime(clockid_t clock_id, struct timespec *tp); // int clock_gettime(clockid_t clock_id, struct timespec *tp);
addToFunctionSummaryMap("clock_gettime", addToFunctionSummaryMap(
Summary(ArgTypes{Clockid_tTy, StructTimespecPtrTy}, "clock_gettime",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{Clockid_tTy, StructTimespecPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(1)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(1))));
Optional<QualType> StructItimervalTy = lookupTy("itimerval"); Optional<QualType> StructItimervalTy = lookupTy("itimerval");
Optional<QualType> StructItimervalPtrTy = getPointerTy(StructItimervalTy); Optional<QualType> StructItimervalPtrTy = getPointerTy(StructItimervalTy);
// int getitimer(int which, struct itimerval *curr_value); // int getitimer(int which, struct itimerval *curr_value);
addToFunctionSummaryMap("getitimer", addToFunctionSummaryMap(
Summary(ArgTypes{IntTy, StructItimervalPtrTy}, "getitimer",
RetType{IntTy}, NoEvalCall) Signature(ArgTypes{IntTy, StructItimervalPtrTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(1)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(1))));
Optional<QualType> Pthread_cond_tTy = lookupTy("pthread_cond_t"); Optional<QualType> Pthread_cond_tTy = lookupTy("pthread_cond_t");
Optional<QualType> Pthread_cond_tPtrTy = getPointerTy(Pthread_cond_tTy); Optional<QualType> Pthread_cond_tPtrTy = getPointerTy(Pthread_cond_tTy);
Optional<QualType> Pthread_tTy = lookupTy("pthread_t"); Optional<QualType> Pthread_tTy = lookupTy("pthread_t");
Optional<QualType> Pthread_tPtrTy = getPointerTy(Pthread_tTy); Optional<QualType> Pthread_tPtrTy = getPointerTy(Pthread_tTy);
Optional<QualType> Pthread_tPtrRestrictTy = getRestrictTy(Pthread_tPtrTy); Optional<QualType> Pthread_tPtrRestrictTy = getRestrictTy(Pthread_tPtrTy);
Optional<QualType> Pthread_mutex_tTy = lookupTy("pthread_mutex_t"); Optional<QualType> Pthread_mutex_tTy = lookupTy("pthread_mutex_t");
Optional<QualType> Pthread_mutex_tPtrTy = getPointerTy(Pthread_mutex_tTy); Optional<QualType> Pthread_mutex_tPtrTy = getPointerTy(Pthread_mutex_tTy);
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines addToFunctionSummaryMap(
Signature(ArgTypes{Pthread_mutex_tPtrTy}, RetType{IntTy}), Signature(ArgTypes{Pthread_mutex_tPtrTy}, RetType{IntTy}),
Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0)))); Summary(NoEvalCall).ArgConstraint(NotNull(ArgNo(0))));
} }
// Functions for testing. // Functions for testing.
if (ChecksEnabled[CK_StdCLibraryFunctionsTesterChecker]) { if (ChecksEnabled[CK_StdCLibraryFunctionsTesterChecker]) {
addToFunctionSummaryMap( addToFunctionSummaryMap(
"__two_constrained_args", "__two_constrained_args",
Summary(ArgTypes{IntTy, IntTy}, RetType{IntTy}, EvalCallAsPure) Signature(ArgTypes{IntTy, IntTy}, RetType{IntTy}),
Summary(EvalCallAsPure)
.ArgConstraint(ArgumentCondition(0U, WithinRange, SingleValue(1))) .ArgConstraint(ArgumentCondition(0U, WithinRange, SingleValue(1)))
.ArgConstraint(ArgumentCondition(1U, WithinRange, SingleValue(1)))); .ArgConstraint(ArgumentCondition(1U, WithinRange, SingleValue(1))));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"__arg_constrained_twice", "__arg_constrained_twice", Signature(ArgTypes{IntTy}, RetType{IntTy}),
Summary(ArgTypes{IntTy}, RetType{IntTy}, EvalCallAsPure) Summary(EvalCallAsPure)
.ArgConstraint(ArgumentCondition(0U, OutOfRange, SingleValue(1))) .ArgConstraint(ArgumentCondition(0U, OutOfRange, SingleValue(1)))
.ArgConstraint(ArgumentCondition(0U, OutOfRange, SingleValue(2)))); .ArgConstraint(ArgumentCondition(0U, OutOfRange, SingleValue(2))));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"__defaultparam", "__defaultparam",
Summary(ArgTypes{Irrelevant, IntTy}, RetType{IntTy}, EvalCallAsPure) Signature(ArgTypes{Irrelevant, IntTy}, RetType{IntTy}),
.ArgConstraint(NotNull(ArgNo(0)))); Summary(EvalCallAsPure).ArgConstraint(NotNull(ArgNo(0))));
addToFunctionSummaryMap("__variadic", addToFunctionSummaryMap(
Summary(ArgTypes{VoidPtrTy, ConstCharPtrTy}, "__variadic",
RetType{IntTy}, EvalCallAsPure) Signature(ArgTypes{VoidPtrTy, ConstCharPtrTy}, RetType{IntTy}),
Summary(EvalCallAsPure)
.ArgConstraint(NotNull(ArgNo(0))) .ArgConstraint(NotNull(ArgNo(0)))
.ArgConstraint(NotNull(ArgNo(1)))); .ArgConstraint(NotNull(ArgNo(1))));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"__buf_size_arg_constraint", "__buf_size_arg_constraint",
Summary(ArgTypes{ConstVoidPtrTy, SizeTy}, RetType{IntTy}, Signature(ArgTypes{ConstVoidPtrTy, SizeTy}, RetType{IntTy}),
EvalCallAsPure) Summary(EvalCallAsPure)
.ArgConstraint( .ArgConstraint(
BufferSize(/*Buffer=*/ArgNo(0), /*BufSize=*/ArgNo(1)))); BufferSize(/*Buffer=*/ArgNo(0), /*BufSize=*/ArgNo(1))));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"__buf_size_arg_constraint_mul", "__buf_size_arg_constraint_mul",
Summary(ArgTypes{ConstVoidPtrTy, SizeTy, SizeTy}, RetType{IntTy}, Signature(ArgTypes{ConstVoidPtrTy, SizeTy, SizeTy}, RetType{IntTy}),
EvalCallAsPure) Summary(EvalCallAsPure)
.ArgConstraint(BufferSize(/*Buffer=*/ArgNo(0), /*BufSize=*/ArgNo(1), .ArgConstraint(BufferSize(/*Buffer=*/ArgNo(0), /*BufSize=*/ArgNo(1),
/*BufSizeMultiplier=*/ArgNo(2)))); /*BufSizeMultiplier=*/ArgNo(2))));
addToFunctionSummaryMap( addToFunctionSummaryMap(
"__buf_size_arg_constraint_concrete", "__buf_size_arg_constraint_concrete",
Summary(ArgTypes{ConstVoidPtrTy}, RetType{IntTy}, EvalCallAsPure) Signature(ArgTypes{ConstVoidPtrTy}, RetType{IntTy}),
Summary(EvalCallAsPure)
.ArgConstraint(BufferSize(/*Buffer=*/ArgNo(0), .ArgConstraint(BufferSize(/*Buffer=*/ArgNo(0),
/*BufSize=*/BVF.getValue(10, IntTy)))); /*BufSize=*/BVF.getValue(10, IntTy))));
addToFunctionSummaryMap( addToFunctionSummaryMap(
{"__test_restrict_param_0", "__test_restrict_param_1", {"__test_restrict_param_0", "__test_restrict_param_1",
"__test_restrict_param_2"}, "__test_restrict_param_2"},
Signature(ArgTypes{VoidPtrRestrictTy}, RetType{VoidTy}), Signature(ArgTypes{VoidPtrRestrictTy}, RetType{VoidTy}),
Summary(EvalCallAsPure)); Summary(EvalCallAsPure));
} }
Show All 29 Lines