From c158f8054ea8e175f4c0d1ef648921f07dd54535 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 13:36:19 +0100 Subject: [PATCH 01/33] C++: Get rid of all the 'StdContainer' taint models. --- .../models/implementations/StdContainer.qll | 160 +----------------- 1 file changed, 2 insertions(+), 158 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll index 6fb17d80c5d2..63605a188cfd 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll @@ -2,7 +2,7 @@ * Provides models for C++ containers `std::array`, `std::vector`, `std::deque`, `std::list` and `std::forward_list`. */ -import semmle.code.cpp.models.interfaces.Taint +import semmle.code.cpp.models.interfaces.FlowSource import semmle.code.cpp.models.interfaces.Iterator /** @@ -63,7 +63,7 @@ private class Vector extends StdSequenceContainer { * std::vector v(100, potentially_tainted_string); * ``` */ -private class StdSequenceContainerConstructor extends Constructor, TaintFunction { +private class StdSequenceContainerConstructor extends Constructor { StdSequenceContainerConstructor() { this.getDeclaringType() instanceof Vector or this.getDeclaringType() instanceof Deque or @@ -84,42 +84,6 @@ private class StdSequenceContainerConstructor extends Constructor, TaintFunction * Gets the index of a parameter to this function that is an iterator. */ int getAnIteratorParameterIndex() { this.getParameter(result).getType() instanceof Iterator } - - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // taint flow from any parameter of the value type to the returned object - ( - input.isParameterDeref(this.getAValueTypeParameterIndex()) or - input.isParameter(this.getAnIteratorParameterIndex()) - ) and - ( - output.isReturnValue() // TODO: this is only needed for AST data flow, which treats constructors as returning the new object - or - output.isQualifierObject() - ) - } -} - -/** - * The standard container function `data`. - */ -private class StdSequenceContainerData extends TaintFunction { - StdSequenceContainerData() { - this.getClassAndName("data") instanceof Array or - this.getClassAndName("data") instanceof Vector - } - - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // flow from container itself (qualifier) to return value - input.isQualifierObject() and - output.isReturnValueDeref() - or - // reverse flow from returned reference to the qualifier (for writes to - // `data`) - input.isReturnValueDeref() and - output.isQualifierObject() - } - - override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } } /** @@ -143,35 +107,6 @@ class StdSequenceContainerPush extends MemberFunction { } } -private class StdSequenceContainerPushModel extends StdSequenceContainerPush, TaintFunction { - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // flow from parameter to qualifier - input.isParameterDeref(0) and - output.isQualifierObject() - } - - override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } -} - -/** - * The standard container functions `front` and `back`. - */ -private class StdSequenceContainerFrontBack extends TaintFunction { - StdSequenceContainerFrontBack() { - this.getClassAndName(["front", "back"]) instanceof Array or - this.getClassAndName(["front", "back"]) instanceof Deque or - this.getClassAndName("front") instanceof ForwardList or - this.getClassAndName(["front", "back"]) instanceof List or - this.getClassAndName(["front", "back"]) instanceof Vector - } - - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // flow from object to returned reference - input.isQualifierObject() and - output.isReturnValueDeref() - } -} - /** * The standard container functions `insert` and `insert_after`. */ @@ -198,58 +133,6 @@ class StdSequenceContainerInsert extends MemberFunction { int getAnIteratorParameterIndex() { this.getParameter(result).getType() instanceof Iterator } } -private class StdSequenceContainerInsertModel extends StdSequenceContainerInsert, TaintFunction { - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // flow from parameter to container itself (qualifier) and return value - ( - input.isQualifierObject() or - input.isParameterDeref(this.getAValueTypeParameterIndex()) or - input.isParameter(this.getAnIteratorParameterIndex()) - ) and - ( - output.isQualifierObject() or - output.isReturnValue() - ) - } - - override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } -} - -/** - * The standard container function `assign`. - */ -private class StdSequenceContainerAssign extends TaintFunction { - StdSequenceContainerAssign() { - this.getClassAndName("assign") instanceof Deque or - this.getClassAndName("assign") instanceof ForwardList or - this.getClassAndName("assign") instanceof List or - this.getClassAndName("assign") instanceof Vector - } - - /** - * Gets the index of a parameter to this function that is a reference to the - * value type of the container. - */ - int getAValueTypeParameterIndex() { - this.getParameter(result).getUnspecifiedType().(ReferenceType).getBaseType() = - this.getDeclaringType().getTemplateArgument(0).(Type).getUnspecifiedType() // i.e. the `T` of this `std::vector` - } - - /** - * Gets the index of a parameter to this function that is an iterator. - */ - int getAnIteratorParameterIndex() { this.getParameter(result).getType() instanceof Iterator } - - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // flow from parameter to container itself (qualifier) - ( - input.isParameterDeref(this.getAValueTypeParameterIndex()) or - input.isParameter(this.getAnIteratorParameterIndex()) - ) and - output.isQualifierObject() - } -} - /** * The standard container functions `at` and `operator[]`. */ @@ -261,20 +144,6 @@ class StdSequenceContainerAt extends MemberFunction { } } -private class StdSequenceContainerAtModel extends StdSequenceContainerAt, TaintFunction { - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // flow from qualifier to referenced return value - input.isQualifierObject() and - output.isReturnValueDeref() - or - // reverse flow from returned reference to the qualifier - input.isReturnValueDeref() and - output.isQualifierObject() - } - - override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } -} - /** * The standard `emplace` function. */ @@ -297,20 +166,6 @@ class StdSequenceEmplace extends MemberFunction { } } -private class StdSequenceEmplaceModel extends StdSequenceEmplace, TaintFunction { - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // flow from any parameter except the position iterator to qualifier and return value - // (here we assume taint flow from any constructor parameter to the constructed object) - input.isParameterDeref([1 .. this.getNumberOfParameters() - 1]) and - ( - output.isQualifierObject() or - output.isReturnValue() - ) - } - - override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } -} - /** * The standard vector `emplace` function. */ @@ -340,17 +195,6 @@ class StdSequenceEmplaceBack extends MemberFunction { } } -private class StdSequenceEmplaceBackModel extends StdSequenceEmplaceBack, TaintFunction { - override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { - // flow from any parameter to qualifier - // (here we assume taint flow from any constructor parameter to the constructed object) - input.isParameterDeref([0 .. this.getNumberOfParameters() - 1]) and - output.isQualifierObject() - } - - override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } -} - /** * The standard vector `emplace_back` function. */ From 013ee9c15e706580839a0312c22c47cc36732cfe Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 13:39:39 +0100 Subject: [PATCH 02/33] C++: Add support for 'Element' content in dataflow. --- .../ir/dataflow/internal/DataFlowPrivate.qll | 20 +++++++++++++++-- .../cpp/ir/dataflow/internal/DataFlowUtil.qll | 22 +++++++++++++++++++ .../dataflow/internal/TaintTrackingUtil.qll | 5 ++++- 3 files changed, 44 insertions(+), 3 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll index db8f0bd02139..bc363d86ee21 100644 --- a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll +++ b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll @@ -1325,7 +1325,7 @@ import IsUnreachableInCall * Holds if access paths with `c` at their head always should be tracked at high * precision. This disables adaptive access path precision for such access paths. */ -predicate forceHighPrecision(Content c) { none() } +predicate forceHighPrecision(Content c) { c instanceof ElementContent } /** Holds if `n` should be hidden from path explanations. */ predicate nodeIsHidden(Node n) { @@ -1396,7 +1396,8 @@ private predicate unionHasApproxName(Cpp::Union u, string s) { s = u.getName().c cached private newtype TContentApprox = TFieldApproxContent(string s) { fieldHasApproxName(_, s) } or - TUnionApproxContent(string s) { unionHasApproxName(_, s) } + TUnionApproxContent(string s) { unionHasApproxName(_, s) } or + TElementApproxContent() /** An approximated `Content`. */ class ContentApprox extends TContentApprox { @@ -1427,6 +1428,10 @@ private class UnionApproxContent extends ContentApprox, TUnionApproxContent { final override string toString() { result = s } } +private class ElementApproxContent extends ContentApprox, TElementApproxContent { + final override string toString() { result = "ElementApprox" } +} + /** Gets an approximated value for content `c`. */ pragma[inline] ContentApprox getContentApprox(Content c) { @@ -1441,6 +1446,9 @@ ContentApprox getContentApprox(Content c) { u = c.(UnionContent).getUnion() and unionHasApproxName(u, prefix) ) + or + c instanceof ElementContent and + result instanceof ElementApproxContent } /** @@ -1700,6 +1708,14 @@ class DataFlowSecondLevelScope extends TDataFlowSecondLevelScope { /** Gets the second-level scope containing the node `n`, if any. */ DataFlowSecondLevelScope getSecondLevelScope(Node n) { result.getANode() = n } +/** + * Gets the maximum number of indirections to use for `ElementContent`. + * + * This should be equal to the largest number of stars (i.e., `*`s) in any + * `Element` content across all of our MaD summaries, sources, and sinks. + */ +int getMaxElementContentIndirectionIndex() { result = 5 } + /** * Module that defines flow through iterators. * For example, diff --git a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowUtil.qll b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowUtil.qll index f798c4dba21b..f2263abf7f52 100644 --- a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowUtil.qll +++ b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowUtil.qll @@ -2083,6 +2083,9 @@ private newtype TContent = indirectionIndex = [1 .. max(Ssa::getMaxIndirectionsForType(getAFieldWithSize(u, bytes).getUnspecifiedType()))] ) + } or + TElementContent(int indirectionIndex) { + indirectionIndex = [1 .. getMaxElementContentIndirectionIndex()] } /** @@ -2193,6 +2196,25 @@ class UnionContent extends Content, TUnionContent { } } +/** + * A `Content` that represents one of the elements of a + * container (e.g., `std::vector`). + */ +class ElementContent extends Content, TElementContent { + int indirectionIndex; + + ElementContent() { this = TElementContent(indirectionIndex) } + + pragma[inline] + override int getIndirectionIndex() { + pragma[only_bind_into](result) = pragma[only_bind_out](indirectionIndex) + } + + override predicate impliesClearOf(Content c) { none() } + + override string toString() { result = contentStars(this) + "element" } +} + /** * An entity that represents a set of `Content`s. * diff --git a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/TaintTrackingUtil.qll b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/TaintTrackingUtil.qll index 4b421bbe5e58..e570ecb05423 100644 --- a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/TaintTrackingUtil.qll +++ b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/TaintTrackingUtil.qll @@ -147,7 +147,10 @@ predicate defaultAdditionalTaintStep(DataFlow::Node src, DataFlow::Node sink, st * of `c` at sinks and inputs to additional taint steps. */ bindingset[node] -predicate defaultImplicitTaintRead(DataFlow::Node node, DataFlow::ContentSet c) { none() } +predicate defaultImplicitTaintRead(DataFlow::Node node, DataFlow::ContentSet c) { + node instanceof ArgumentNode and + c.isSingleton(any(ElementContent ec)) +} /** * Holds if `node` should be a sanitizer in all global taint flow configurations From 901fac428242185243a65b91f4f63e2e3cf2d3f4 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 13:40:06 +0100 Subject: [PATCH 03/33] C++: Support 'Element' content in flow summaries. --- .../semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll index b0225f156577..2077f2067aad 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll @@ -35,6 +35,12 @@ module Input implements InputSig { result = "Field" and arg = repeatStars(c.getIndirectionIndex() - 1) + c.getField().getName() ) + or + exists(ElementContent ec | + cs.isSingleton(ec) and + result = "Element" and + arg = repeatStars(ec.getIndirectionIndex() - 1) + ) } string encodeWithoutContent(ContentSet c, string arg) { From 716df0c7ceeeb9b05558e8c4eb09ea5ff5f00a64 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 14:31:57 +0100 Subject: [PATCH 04/33] C++: Support a richer language in MaD summaries for selecting member functions. --- .../semmle/code/cpp/dataflow/ExternalFlow.qll | 332 ++++++++++++++++-- 1 file changed, 312 insertions(+), 20 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index d3d7d6b2442f..a6a8afb914c0 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -367,16 +367,154 @@ private predicate elementSpec( summaryModel(namespace, type, subtypes, name, signature, ext, _, _, _, _) } -private string paramsStringPart(Function c, int i) { - i = -1 and result = "(" and exists(c) +/** Gets the fully templated version of `f`. */ +private Function getFullyTemplatedMemberFunction(Function f) { + not f.isFromUninstantiatedTemplate(_) and + exists(Class c, Class templateClass, int i | + c.isConstructedFrom(templateClass) and + f = c.getAMember(i) and + result = templateClass.getCanonicalMember(i) + ) +} + +/** + * Gets the type name of the `n`'th parameter of `f` without any template + * arguments. + */ +bindingset[f] +pragma[inline_late] +string getParameterTypeWithoutTemplateArguments(Function f, int n) { + exists(string s, string base, string specifiers | + s = f.getParameter(n).getType().getName() and + parseAngles(s, base, _, specifiers) and + result = base + specifiers + ) +} + +/** + * Normalize the `n`'th parameter of `f` by replacing template names + * with `func:N` (where `N` is the index of the template). + */ +private string getTypeNameWithoutFunctionTemplates(Function f, int n, int remaining) { + exists(Function templateFunction | + templateFunction = getFullyTemplatedMemberFunction(f) and + remaining = templateFunction.getNumberOfTemplateArguments() and + result = getParameterTypeWithoutTemplateArguments(templateFunction, n) + ) or - exists(int n, string p | c.getParameter(n).getType().toString() = p | - i = 2 * n and result = p + exists(string mid, TemplateParameter tp, Function templateFunction | + mid = getTypeNameWithoutFunctionTemplates(f, n, remaining + 1) and + templateFunction = getFullyTemplatedMemberFunction(f) and + tp = templateFunction.getTemplateArgument(remaining) and + result = mid.replaceAll(tp.getName(), "func:" + remaining.toString()) + ) +} + +/** + * Normalize the `n`'th parameter of `f` by replacing template names + * with `class:N` (where `N` is the index of the template). + */ +private string getTypeNameWithoutClassTemplates(Function f, int n, int remaining) { + exists(Class template | + f.getDeclaringType().isConstructedFrom(template) and + remaining = template.getNumberOfTemplateArguments() and + result = getTypeNameWithoutFunctionTemplates(f, n, 0) + ) + or + exists(string mid, TemplateParameter tp, Class template | + mid = getTypeNameWithoutClassTemplates(f, n, remaining + 1) and + f.getDeclaringType().isConstructedFrom(template) and + tp = template.getTemplateArgument(remaining) and + result = mid.replaceAll(tp.getName(), "class:" + remaining.toString()) + ) +} + +private string getParameterTypeName(Function c, int i) { + result = getTypeNameWithoutClassTemplates(c, i, 0) +} + +/** Splits `s` by `,` and gets the `i`'th element. */ +bindingset[s] +pragma[inline_late] +private string getAtIndex(string s, int i) { + result = s.splitAt(",", i) and + // when `s` is `""` and `i` is `0` we get `result = ""` which we don't want. + not (s = "" and i = 0) +} + +/** + * Normalizes `partiallyNormalizedSignature` by replacing the `remaining` + * number of template arguments in `partiallyNormalizedSignature` with their + * index in `typeArgs`. + */ +private string getSignatureWithoutClassTemplateNames( + string partiallyNormalizedSignature, string typeArgs, string nameArgs, int remaining +) { + elementSpecWithArguments0(_, _, _, partiallyNormalizedSignature, typeArgs, nameArgs) and + remaining = count(partiallyNormalizedSignature.indexOf(",")) + 1 and + result = partiallyNormalizedSignature + or + exists(string mid | + mid = + getSignatureWithoutClassTemplateNames(partiallyNormalizedSignature, typeArgs, nameArgs, + remaining + 1) + | + exists(string typeArg | + typeArg = getAtIndex(typeArgs, remaining) and + result = mid.replaceAll(typeArg, "class:" + remaining.toString()) + ) or - i = 2 * n - 1 and result = "," and n != 0 + // Make sure `remaining` is properly bound + remaining = [0 .. count(partiallyNormalizedSignature.indexOf(",")) + 1] and + not exists(getAtIndex(typeArgs, remaining)) and + result = mid ) +} + +/** + * Normalizes `partiallyNormalizedSignature` by replacing: + * - _All_ the template arguments in `partiallyNormalizedSignature` that refer to + * template parameters in `typeArgs` with their index in `typeArgs`, and + * - The `remaining` number of template arguments in `partiallyNormalizedSignature` + * with their index in `nameArgs`. + */ +private string getSignatureWithoutFunctionTemplateNames( + string partiallyNormalizedSignature, string typeArgs, string nameArgs, int remaining +) { + remaining = count(partiallyNormalizedSignature.indexOf(",")) + 1 and + result = + getSignatureWithoutClassTemplateNames(partiallyNormalizedSignature, typeArgs, nameArgs, 0) or - i = 2 * c.getNumberOfParameters() and result = ")" + exists(string mid | + mid = + getSignatureWithoutFunctionTemplateNames(partiallyNormalizedSignature, typeArgs, nameArgs, + remaining + 1) + | + exists(string nameArg | + nameArg = getAtIndex(nameArgs, remaining) and + result = mid.replaceAll(nameArg, "func:" + remaining.toString()) + ) + or + // Make sure `remaining` is properly bound + remaining = [0 .. count(partiallyNormalizedSignature.indexOf(",")) + 1] and + not exists(getAtIndex(nameArgs, remaining)) and + result = mid + ) +} + +private string paramsStringPart(Function c, int i) { + not c.isFromUninstantiatedTemplate(_) and + ( + i = -1 and result = "(" and exists(c) + or + exists(int n, string p | getParameterTypeName(c, n) = p | + i = 2 * n and result = p + or + i = 2 * n - 1 and result = "," and n != 0 + ) + or + i = 2 * c.getNumberOfParameters() and result = ")" + ) } /** @@ -396,6 +534,152 @@ private predicate matchesSignature(Function func, string signature) { paramsString(func) = signature } +/** + * Holds if `elementSpec(_, type, _, name, signature, _)` holds and + * - `typeArgs` represents the named template parameters supplied to `type`, and + * - `nameArgs` represents the named template parameters supplied to `name`, and + * - `normalizedSignature` is `signature`, except with + * - template parameter names replaced by `func:i` if the template name is + * the `i`'th entry in `nameArgs`, and + * - template parameter names replaced by `class:i` if the template name is + * the `i`'th entry in `typeArgs`. + * + * In other words, the string `normalizedSignature` represents a "normalized" + * signature with no mention of any free template parameters. + * + * For example, consider a summary row such as: + * ``` + * elementSpec(_, "MyClass", _, myFunc, "(const A &,int,C,B *)", _) + * ``` + * In this case, `normalizedSignature` will be `"(const func:0 &,int,class:1,class:0 *)"`. + */ +private predicate elementSpecWithArguments( + string signature, string type, string name, string normalizedSignature, string typeArgs, + string nameArgs +) { + exists(string signatureWithoutParens | + elementSpecWithArguments0(signature, type, name, signatureWithoutParens, typeArgs, nameArgs) and + normalizedSignature = + getSignatureWithoutFunctionTemplateNames(signatureWithoutParens, typeArgs, nameArgs, 0) + ) +} + +/** Gets the `n`'th normalized signature parameter for the function `name` in class `type`. */ +private string getSignatureParameterName(string signature, string type, string name, int n) { + exists(string normalizedSignature | + elementSpecWithArguments(signature, type, name, normalizedSignature, _, _) and + result = getAtIndex(normalizedSignature, n) + ) +} + +/** + * Holds if the `i`'th name in `signature` matches the `i` name in `paramsString(func)`. + * + * When `paramsString(func)[i]` is `class:n` then the signature name is + * compared with the `n`'th name in `type`, and when `paramsString(func)[i]` + * is `func:n` then the signature name is compared with the `n`'th name + * in `name`. + */ +private predicate signatureMatches(Function func, string signature, string type, string name, int i) { + exists(string s | + s = getSignatureParameterName(signature, type, name, i) and + s = getParameterTypeName(func, i) + ) and + if exists(getParameterTypeName(func, i + 1)) + then signatureMatches(func, signature, type, name, i + 1) + else i = count(signature.indexOf(",")) +} + +/** + * Holds if `s` can be broken into a string of the form + * `beforeAngles`, + * or `s = beforeAngles` where `beforeAngles` does not have any brackets. + */ +bindingset[s] +pragma[inline_late] +private predicate parseAngles( + string s, string beforeAngles, string betweenAngles, string afterAngles +) { + beforeAngles = s.regexpCapture("([^<]+)(?:<([^>]+)>(.*))?", 1) and + ( + betweenAngles = s.regexpCapture("([^<]+)(?:<([^>]+)>(.*))?", 2) and + afterAngles = s.regexpCapture("([^<]+)(?:<([^>]+)>(.*))?", 3) + or + not exists(s.regexpCapture("([^<]+)(?:<([^>]+)>(.*))?", 2)) and + betweenAngles = "" and + afterAngles = "" + ) +} + +/** Holds if `s` can be broken into a string of the form `(betweenParens)`. */ +bindingset[s] +pragma[inline_late] +private predicate parseParens(string s, string betweenParens) { + betweenParens = s.regexpCapture("\\(([^\\)]+)\\)", 1) +} + +/** + * Holds if `elementSpec(_, type, _, name, signature, _)` and: + * - `type` introduces template parameters `typeArgs`, and + * - `name` introduces template parameters `nameArgs`, and + * - `signatureWithoutParens` equals `signature`, but with the surrounding + * parentheses removed. + */ +private predicate elementSpecWithArguments0( + string signature, string type, string name, string signatureWithoutParens, string typeArgs, + string nameArgs +) { + elementSpec(_, type, _, name, signature, _) and + parseAngles(name, _, nameArgs, "") and + ( + type = "" and typeArgs = "" + or + parseAngles(type, _, typeArgs, "") + ) and + parseParens(signature, signatureWithoutParens) +} + +/** + * Holds if `elementSpec(namespace, type, subtypes, name, signature, _)` and + * `method`'s signature matches `signature`. + * + * `signature` may contain template parameter names that are bound by `type` and `name`. + */ +pragma[nomagic] +private predicate elementSpecMatchesSignature( + Function method, string namespace, string type, boolean subtypes, string name, string signature +) { + elementSpec(namespace, pragma[only_bind_into](type), subtypes, pragma[only_bind_into](name), + pragma[only_bind_into](signature), _) and + signatureMatches(method, signature, type, name, 0) +} + +/** + * Holds if `classWithMethod` has `method` named `name` (excluding any + * template parameters). + */ +bindingset[name] +pragma[inline_late] +private predicate hasClassAndName(Class classWithMethod, Function method, string name) { + exists(string nameWithoutArgs | + parseAngles(name, nameWithoutArgs, _, "") and + classWithMethod = method.getClassAndName(nameWithoutArgs) + ) +} + +/** + * Holds if `nameClass` is in namespace `namespace` and has + * name `type` (excluding any template parameters). + */ +bindingset[type, namespace] +pragma[inline_late] +private predicate hasQualifiedName(Class namedClass, string namespace, string type) { + exists(string typeWithoutArgs | + parseAngles(type, typeWithoutArgs, _, "") and + namedClass.hasQualifiedName(namespace, typeWithoutArgs) + ) +} + /** * Gets the element in module `namespace` that satisfies the following properties: * 1. If the element is a member of a class-like type, then the class-like type has name `type` @@ -410,8 +694,8 @@ pragma[nomagic] private Element interpretElement0( string namespace, string type, boolean subtypes, string name, string signature ) { - elementSpec(namespace, type, subtypes, name, signature, _) and ( + elementSpec(namespace, type, subtypes, name, signature, _) and // Non-member functions exists(Function func | func.hasQualifiedName(namespace, name) and @@ -423,21 +707,28 @@ private Element interpretElement0( ) or // Member functions - exists(Class namedClass, Class classWithMethod, Function method | - classWithMethod = method.getClassAndName(name) and - namedClass.hasQualifiedName(namespace, type) and - matchesSignature(method, signature) and - result = method - | - // member declared in the named type or a subtype of it - subtypes = true and - classWithMethod = namedClass.getADerivedClass*() - or - // member declared directly in the named type - subtypes = false and - classWithMethod = namedClass + exists(Class namedClass, Class classWithMethod | + ( + elementSpecMatchesSignature(result, namespace, type, subtypes, name, signature) and + hasClassAndName(classWithMethod, result, name) + or + signature = "" and + elementSpec(namespace, type, subtypes, name, "", _) and + hasClassAndName(classWithMethod, result, name) + ) and + hasQualifiedName(namedClass, namespace, type) and + ( + // member declared in the named type or a subtype of it + subtypes = true and + classWithMethod = namedClass.getADerivedClass*() + or + // member declared directly in the named type + subtypes = false and + classWithMethod = namedClass + ) ) or + elementSpec(namespace, type, subtypes, name, signature, _) and // Member variables signature = "" and exists(Class namedClass, Class classWithMember, MemberVariable member | @@ -456,6 +747,7 @@ private Element interpretElement0( ) or // Global or namespace variables + elementSpec(namespace, type, subtypes, name, signature, _) and signature = "" and type = "" and subtypes = false and From 4dc13e850e7924f3060217c3b5c14d313ad371a3 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 14:34:07 +0100 Subject: [PATCH 05/33] C++: Add summaries for std dequence containers. --- cpp/ql/lib/ext/std.array.model.yml | 12 ++++ cpp/ql/lib/ext/std.deque.model .yml | 72 +++++++++++++++++++++++ cpp/ql/lib/ext/std.forward_list.model.yml | 55 +++++++++++++++++ cpp/ql/lib/ext/std.iterator.model.yml | 7 +++ cpp/ql/lib/ext/std.list.model.yml | 70 ++++++++++++++++++++++ cpp/ql/lib/ext/std.vector.model.yml | 59 +++++++++++++++++++ 6 files changed, 275 insertions(+) create mode 100644 cpp/ql/lib/ext/std.array.model.yml create mode 100644 cpp/ql/lib/ext/std.deque.model .yml create mode 100644 cpp/ql/lib/ext/std.forward_list.model.yml create mode 100644 cpp/ql/lib/ext/std.iterator.model.yml create mode 100644 cpp/ql/lib/ext/std.list.model.yml create mode 100644 cpp/ql/lib/ext/std.vector.model.yml diff --git a/cpp/ql/lib/ext/std.array.model.yml b/cpp/ql/lib/ext/std.array.model.yml new file mode 100644 index 000000000000..44ca55f85a11 --- /dev/null +++ b/cpp/ql/lib/ext/std.array.model.yml @@ -0,0 +1,12 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["std", "array", True, "at", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "array", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "array", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "array", True, "data", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "array", True, "operator[]", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "array", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "array", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.deque.model .yml b/cpp/ql/lib/ext/std.deque.model .yml new file mode 100644 index 000000000000..262391081e32 --- /dev/null +++ b/cpp/ql/lib/ext/std.deque.model .yml @@ -0,0 +1,72 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["std", "deque", True, "assign", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "at", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "operator=", "", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "operator[]", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "deque", True, "push_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "push_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "deque", "(const deque &,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "deque", "(deque &&,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "deque", "(size_type,const T &,const Allocator &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "deque", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.forward_list.model.yml b/cpp/ql/lib/ext/std.forward_list.model.yml new file mode 100644 index 000000000000..ef4304f39bd1 --- /dev/null +++ b/cpp/ql/lib/ext/std.forward_list.model.yml @@ -0,0 +1,55 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "assign", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(const forward_list &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(forward_list &&)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "operator=", "", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "push_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(const forward_list &,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(forward_list &&,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(size_type,const T &,const Allocator &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.iterator.model.yml b/cpp/ql/lib/ext/std.iterator.model.yml new file mode 100644 index 000000000000..1ed2f546985b --- /dev/null +++ b/cpp/ql/lib/ext/std.iterator.model.yml @@ -0,0 +1,7 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["std", "iterator", True, "operator*", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "iterator", True, "operator->", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.list.model.yml b/cpp/ql/lib/ext/std.list.model.yml new file mode 100644 index 000000000000..90d8eefb64b5 --- /dev/null +++ b/cpp/ql/lib/ext/std.list.model.yml @@ -0,0 +1,70 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["std", "list", True, "assign", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "list", "(const list &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "list", "(list &&)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "operator=", "", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "push_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "push_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "list", "(const list &,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "list", "(list &&,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "list", "(size_type,const T &,const Allocator &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.vector.model.yml b/cpp/ql/lib/ext/std.vector.model.yml new file mode 100644 index 000000000000..ac9b5be178a7 --- /dev/null +++ b/cpp/ql/lib/ext/std.vector.model.yml @@ -0,0 +1,59 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["std", "vector", True, "assign", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "at", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "data", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "operator=", "", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "operator[]", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] + - ["std", "vector", True, "push_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "vector", "(const vector &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "vector", "(vector &&)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "vector", "(const vector &,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "vector", "(size_type,const T &,const Allocator &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "vector", "(vector &&,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "vector", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] \ No newline at end of file From b0bd7a983f4e01eca9178e631505381b0ab3cc11 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 14:35:29 +0100 Subject: [PATCH 06/33] C++: Add MaD syntax for an arbitrary number of dereferences. --- .../semmle/code/cpp/dataflow/ExternalFlow.qll | 37 ++++++++++++++++++- 1 file changed, 35 insertions(+), 2 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index a6a8afb914c0..0bf707fd6e1a 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -74,6 +74,8 @@ import cpp private import new.DataFlow +private import semmle.code.cpp.ir.dataflow.internal.DataFlowPrivate as Private +private import semmle.code.cpp.ir.dataflow.internal.DataFlowUtil private import internal.FlowSummaryImpl private import internal.FlowSummaryImpl::Public private import internal.FlowSummaryImpl::Private @@ -166,8 +168,12 @@ predicate sinkModel( Extensions::sinkModel(namespace, type, subtypes, name, signature, ext, input, kind, provenance, _) } -/** Holds if a summary model exists for the given parameters. */ -predicate summaryModel( +/** + * Holds if a summary model exists for the given parameters. + * + * This predicate does not expand `@` to `*`s. + */ +private predicate summaryModel0( string namespace, string type, boolean subtypes, string name, string signature, string ext, string input, string output, string kind, string provenance ) { @@ -190,6 +196,33 @@ predicate summaryModel( provenance, _) } +/** + * Holds if `input` is `input0`, but with all occurences of `@` replaced + * by `n` repetitions of `*` (and similarly for `output` and `output0`). + */ +bindingset[input0, output0, n] +pragma[inline_late] +private predicate expandInputAndOutput( + string input0, string input, string output0, string output, int n +) { + input = input0.replaceAll("@", repeatStars(n)) and + output = output0.replaceAll("@", repeatStars(n)) +} + +/** + * Holds if a summary model exists for the given parameters. + */ +predicate summaryModel( + string namespace, string type, boolean subtypes, string name, string signature, string ext, + string input, string output, string kind, string provenance +) { + exists(string input0, string output0 | + summaryModel0(namespace, type, subtypes, name, signature, ext, input0, output0, kind, provenance) and + expandInputAndOutput(input0, input, output0, output, + [0 .. Private::getMaxElementContentIndirectionIndex() - 1]) + ) +} + private predicate relevantNamespace(string namespace) { sourceModel(namespace, _, _, _, _, _, _, _, _) or sinkModel(namespace, _, _, _, _, _, _, _, _) or From 85da3d2f13a9b8cd9ea55e22b50f9a939df1d631 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 14:35:56 +0100 Subject: [PATCH 07/33] C++: Update MaD models. --- cpp/ql/lib/ext/Boost.Asio.model.yml | 1 - cpp/ql/lib/ext/std.array.model.yml | 14 +-- cpp/ql/lib/ext/std.deque.model .yml | 134 +++++++++++----------- cpp/ql/lib/ext/std.forward_list.model.yml | 100 ++++++++-------- cpp/ql/lib/ext/std.iterator.model.yml | 4 +- cpp/ql/lib/ext/std.list.model.yml | 130 ++++++++++----------- cpp/ql/lib/ext/std.vector.model.yml | 108 ++++++++--------- 7 files changed, 245 insertions(+), 246 deletions(-) diff --git a/cpp/ql/lib/ext/Boost.Asio.model.yml b/cpp/ql/lib/ext/Boost.Asio.model.yml index 436d36fdfc2c..3b6fb77071fe 100644 --- a/cpp/ql/lib/ext/Boost.Asio.model.yml +++ b/cpp/ql/lib/ext/Boost.Asio.model.yml @@ -1,4 +1,3 @@ -extensions: # partial model of the Boost::Asio network library extensions: - addsTo: diff --git a/cpp/ql/lib/ext/std.array.model.yml b/cpp/ql/lib/ext/std.array.model.yml index 44ca55f85a11..1b00e4086212 100644 --- a/cpp/ql/lib/ext/std.array.model.yml +++ b/cpp/ql/lib/ext/std.array.model.yml @@ -3,10 +3,10 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "array", True, "at", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "array", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "array", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "array", True, "data", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "array", True, "operator[]", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "array", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "array", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] \ No newline at end of file + - ["std", "array", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "array", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "array", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "array", True, "data", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "array", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "array", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "array", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.deque.model .yml b/cpp/ql/lib/ext/std.deque.model .yml index 262391081e32..ec353f3cda63 100644 --- a/cpp/ql/lib/ext/std.deque.model .yml +++ b/cpp/ql/lib/ext/std.deque.model .yml @@ -3,70 +3,70 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "deque", True, "assign", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "at", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "operator=", "", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "operator[]", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "deque", True, "push_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "push_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "deque", "(const deque &,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "deque", "(deque &&,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "deque", "(size_type,const T &,const Allocator &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "deque", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] \ No newline at end of file + - ["std", "deque", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "deque", "(const deque &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "deque", "(deque &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "deque", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "deque", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.forward_list.model.yml b/cpp/ql/lib/ext/std.forward_list.model.yml index ef4304f39bd1..2e3e07f936e2 100644 --- a/cpp/ql/lib/ext/std.forward_list.model.yml +++ b/cpp/ql/lib/ext/std.forward_list.model.yml @@ -3,53 +3,53 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "assign", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(const forward_list &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(forward_list &&)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "operator=", "", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "push_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(const forward_list &,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(forward_list &&,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(size_type,const T &,const Allocator &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(const forward_list &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(forward_list &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(const forward_list &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(forward_list &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.iterator.model.yml b/cpp/ql/lib/ext/std.iterator.model.yml index 1ed2f546985b..83527917e77c 100644 --- a/cpp/ql/lib/ext/std.iterator.model.yml +++ b/cpp/ql/lib/ext/std.iterator.model.yml @@ -3,5 +3,5 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "iterator", True, "operator*", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "iterator", True, "operator->", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] \ No newline at end of file + - ["std", "iterator", True, "operator*", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "iterator", True, "operator->", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.list.model.yml b/cpp/ql/lib/ext/std.list.model.yml index 90d8eefb64b5..4e8d75f78f21 100644 --- a/cpp/ql/lib/ext/std.list.model.yml +++ b/cpp/ql/lib/ext/std.list.model.yml @@ -3,68 +3,68 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "list", True, "assign", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "list", "(const list &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "list", "(list &&)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "operator=", "", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "push_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "push_front", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "list", "(const list &,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "list", "(list &&,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "list", "(size_type,const T &,const Allocator &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] + - ["std", "list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "list", "(const list &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "list", "(list &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "list", "(const list &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "list", "(list &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.vector.model.yml b/cpp/ql/lib/ext/std.vector.model.yml index ac9b5be178a7..4f12f962bafc 100644 --- a/cpp/ql/lib/ext/std.vector.model.yml +++ b/cpp/ql/lib/ext/std.vector.model.yml @@ -3,57 +3,57 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "vector", True, "assign", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "at", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "begin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "cbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "data", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*0]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*1]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*2]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*3]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*3]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*4]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*4]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*5]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*5]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "front", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "operator=", "", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "operator[]", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] - - ["std", "vector", True, "push_back", "", "", "Argument[*0]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "rbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "rcbegin", "", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "vector", "(const vector &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "vector", "(vector &&)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "vector", "(const vector &,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "vector", "(size_type,const T &,const Allocator &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "vector", "(vector &&,const Allocator &)", "", "Argument[*0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "vector", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*2]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "Argument[-1].Element[*]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*1]", "ReturnValue.Element[*]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[-1].Element[*]", "ReturnValue[*]", "value", "manual"] \ No newline at end of file + - ["std", "vector", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "data", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "vector", "(const vector &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "vector", "(vector &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "vector", "(const vector &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "vector", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "vector", "(vector &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "vector", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file From 47309df2a98e7fad11f7487de83c9c0aaf580ec7 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 14:36:51 +0100 Subject: [PATCH 08/33] C++: Fix 'toString' on parameter and argument positions. --- .../cpp/ir/dataflow/internal/DataFlowPrivate.qll | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll index bc363d86ee21..ff9cbc6923ff 100644 --- a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll +++ b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll @@ -412,6 +412,8 @@ class ArgumentPosition = Position; abstract class Position extends TPosition { abstract string toString(); + + abstract int getIndirectionIndex(); } class DirectPosition extends Position, TDirectPosition { @@ -421,13 +423,15 @@ class DirectPosition extends Position, TDirectPosition { override string toString() { index = -1 and - result = "this" + result = "this pointer" or index != -1 and result = index.toString() } int getIndex() { result = index } + + final override int getIndirectionIndex() { result = 0 } } class IndirectionPosition extends Position, TIndirectionPosition { @@ -438,16 +442,13 @@ class IndirectionPosition extends Position, TIndirectionPosition { override string toString() { if argumentIndex = -1 - then if indirectionIndex > 0 then result = "this indirection" else result = "this" - else - if indirectionIndex > 0 - then result = argumentIndex.toString() + " indirection" - else result = argumentIndex.toString() + then result = repeatStars(indirectionIndex - 1) + "this" + else result = repeatStars(indirectionIndex) + argumentIndex.toString() } int getArgumentIndex() { result = argumentIndex } - int getIndirectionIndex() { result = indirectionIndex } + final override int getIndirectionIndex() { result = indirectionIndex } } newtype TPosition = From 6513c33d263cd15f635e7506d8a2175b30021709 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 14:37:17 +0100 Subject: [PATCH 09/33] C++: Accept test changes. --- .../dataflow-tests/type-bugs.expected | 10 + .../external-models/validatemodels.expected | 21 +++ .../models-as-data/FlowSummaryNode.expected | 52 +++--- .../dataflow/taint-tests/localTaint.expected | 146 --------------- .../dataflow/taint-tests/vector.cpp | 172 +++++++++--------- 5 files changed, 143 insertions(+), 258 deletions(-) diff --git a/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected b/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected index 05488e91ea41..9a409149f55e 100644 --- a/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected +++ b/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected @@ -1,5 +1,15 @@ astTypeBugs irTypeBugs +| ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary param] this in operator* | +| ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] read: Argument[this].Element[**] in operator* | +| ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] read: Argument[this].Element[*] in operator* | +| ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] to write: ReturnValue[**] in operator* | +| ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] to write: ReturnValue[*] in operator* | +| ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary param] this in operator-> | +| ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] read: Argument[this].Element[**] in operator-> | +| ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] read: Argument[this].Element[*] in operator-> | +| ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] to write: ReturnValue[**] in operator-> | +| ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] to write: ReturnValue[*] in operator-> | incorrectBaseType | clang.cpp:22:8:22:20 | *& ... | Expected 'Node.getType()' to be int, but it was int * | | clang.cpp:23:17:23:29 | *& ... | Expected 'Node.getType()' to be int, but it was int * | diff --git a/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected b/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected index e69de29bb2d1..f9ed615edeae 100644 --- a/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected +++ b/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected @@ -0,0 +1,21 @@ +| Dubious member name "operator*" in summary model. | +| Dubious member name "operator->" in summary model. | +| Dubious member name "operator=" in summary model. | +| Dubious member name "operator[]" in summary model. | +| Dubious signature "(InputIterator,InputIterator,const Allocator &)" in summary model. | +| Dubious signature "(const forward_list &)" in summary model. | +| Dubious signature "(const forward_list &,const Allocator &)" in summary model. | +| Dubious signature "(const list &)" in summary model. | +| Dubious signature "(const list &,const Allocator &)" in summary model. | +| Dubious signature "(const vector &)" in summary model. | +| Dubious signature "(const vector &,const Allocator &)" in summary model. | +| Dubious signature "(const_iterator,T &&)" in summary model. | +| Dubious signature "(const_iterator,const T &)" in summary model. | +| Dubious signature "(const_iterator,size_type,const T &)" in summary model. | +| Dubious signature "(forward_list &&)" in summary model. | +| Dubious signature "(forward_list &&,const Allocator &)" in summary model. | +| Dubious signature "(list &&)" in summary model. | +| Dubious signature "(list &&,const Allocator &)" in summary model. | +| Dubious signature "(size_type,const T &,const Allocator &)" in summary model. | +| Dubious signature "(vector &&)" in summary model. | +| Dubious signature "(vector &&,const Allocator &)" in summary model. | diff --git a/cpp/ql/test/library-tests/dataflow/models-as-data/FlowSummaryNode.expected b/cpp/ql/test/library-tests/dataflow/models-as-data/FlowSummaryNode.expected index 0b14373e9443..b79e76c0a682 100644 --- a/cpp/ql/test/library-tests/dataflow/models-as-data/FlowSummaryNode.expected +++ b/cpp/ql/test/library-tests/dataflow/models-as-data/FlowSummaryNode.expected @@ -4,29 +4,29 @@ | tests.cpp:145:6:145:28 | [summary] to write: ReturnValue[*] in madArg0ToReturnIndirect | ReturnNode | madArg0ToReturnIndirect | madArg0ToReturnIndirect | | tests.cpp:147:5:147:28 | [summary param] 0 in madArg0ToReturnValueFlow | ParameterNode | madArg0ToReturnValueFlow | madArg0ToReturnValueFlow | | tests.cpp:147:5:147:28 | [summary] to write: ReturnValue in madArg0ToReturnValueFlow | ReturnNode | madArg0ToReturnValueFlow | madArg0ToReturnValueFlow | -| tests.cpp:148:5:148:27 | [summary param] 0 indirection in madArg0IndirectToReturn | ParameterNode | madArg0IndirectToReturn | madArg0IndirectToReturn | +| tests.cpp:148:5:148:27 | [summary param] *0 in madArg0IndirectToReturn | ParameterNode | madArg0IndirectToReturn | madArg0IndirectToReturn | | tests.cpp:148:5:148:27 | [summary] to write: ReturnValue in madArg0IndirectToReturn | ReturnNode | madArg0IndirectToReturn | madArg0IndirectToReturn | -| tests.cpp:149:5:149:33 | [summary param] 0 indirection in madArg0DoubleIndirectToReturn | ParameterNode | madArg0DoubleIndirectToReturn | madArg0DoubleIndirectToReturn | +| tests.cpp:149:5:149:33 | [summary param] **0 in madArg0DoubleIndirectToReturn | ParameterNode | madArg0DoubleIndirectToReturn | madArg0DoubleIndirectToReturn | | tests.cpp:149:5:149:33 | [summary] to write: ReturnValue in madArg0DoubleIndirectToReturn | ReturnNode | madArg0DoubleIndirectToReturn | madArg0DoubleIndirectToReturn | | tests.cpp:150:5:150:30 | [summary param] 0 in madArg0NotIndirectToReturn | ParameterNode | madArg0NotIndirectToReturn | madArg0NotIndirectToReturn | | tests.cpp:150:5:150:30 | [summary] to write: ReturnValue in madArg0NotIndirectToReturn | ReturnNode | madArg0NotIndirectToReturn | madArg0NotIndirectToReturn | | tests.cpp:151:6:151:26 | [summary param] 0 in madArg0ToArg1Indirect | ParameterNode | madArg0ToArg1Indirect | madArg0ToArg1Indirect | -| tests.cpp:151:6:151:26 | [summary param] 1 indirection in madArg0ToArg1Indirect | ParameterNode | madArg0ToArg1Indirect | madArg0ToArg1Indirect | -| tests.cpp:151:6:151:26 | [summary] to write: Argument[1 indirection] in madArg0ToArg1Indirect | PostUpdateNode | madArg0ToArg1Indirect | madArg0ToArg1Indirect | -| tests.cpp:152:6:152:34 | [summary param] 0 indirection in madArg0IndirectToArg1Indirect | ParameterNode | madArg0IndirectToArg1Indirect | madArg0IndirectToArg1Indirect | -| tests.cpp:152:6:152:34 | [summary param] 1 indirection in madArg0IndirectToArg1Indirect | ParameterNode | madArg0IndirectToArg1Indirect | madArg0IndirectToArg1Indirect | -| tests.cpp:152:6:152:34 | [summary] to write: Argument[1 indirection] in madArg0IndirectToArg1Indirect | PostUpdateNode | madArg0IndirectToArg1Indirect | madArg0IndirectToArg1Indirect | -| tests.cpp:153:5:153:18 | [summary param] 0 indirection in madArgsComplex | ParameterNode | madArgsComplex | madArgsComplex | -| tests.cpp:153:5:153:18 | [summary param] 1 indirection in madArgsComplex | ParameterNode | madArgsComplex | madArgsComplex | +| tests.cpp:151:6:151:26 | [summary param] *1 in madArg0ToArg1Indirect | ParameterNode | madArg0ToArg1Indirect | madArg0ToArg1Indirect | +| tests.cpp:151:6:151:26 | [summary] to write: Argument[*1] in madArg0ToArg1Indirect | PostUpdateNode | madArg0ToArg1Indirect | madArg0ToArg1Indirect | +| tests.cpp:152:6:152:34 | [summary param] *0 in madArg0IndirectToArg1Indirect | ParameterNode | madArg0IndirectToArg1Indirect | madArg0IndirectToArg1Indirect | +| tests.cpp:152:6:152:34 | [summary param] *1 in madArg0IndirectToArg1Indirect | ParameterNode | madArg0IndirectToArg1Indirect | madArg0IndirectToArg1Indirect | +| tests.cpp:152:6:152:34 | [summary] to write: Argument[*1] in madArg0IndirectToArg1Indirect | PostUpdateNode | madArg0IndirectToArg1Indirect | madArg0IndirectToArg1Indirect | | tests.cpp:153:5:153:18 | [summary param] 2 in madArgsComplex | ParameterNode | madArgsComplex | madArgsComplex | +| tests.cpp:153:5:153:18 | [summary param] *0 in madArgsComplex | ParameterNode | madArgsComplex | madArgsComplex | +| tests.cpp:153:5:153:18 | [summary param] *1 in madArgsComplex | ParameterNode | madArgsComplex | madArgsComplex | | tests.cpp:153:5:153:18 | [summary] to write: ReturnValue in madArgsComplex | ReturnNode | madArgsComplex | madArgsComplex | | tests.cpp:155:5:155:28 | [summary param] 2 in madAndImplementedComplex | ParameterNode | madAndImplementedComplex | madAndImplementedComplex | | tests.cpp:155:5:155:28 | [summary] to write: ReturnValue in madAndImplementedComplex | ReturnNode | madAndImplementedComplex | madAndImplementedComplex | | tests.cpp:160:5:160:24 | [summary param] 0 in madArg0FieldToReturn | ParameterNode | madArg0FieldToReturn | madArg0FieldToReturn | | tests.cpp:160:5:160:24 | [summary] read: Argument[0].Field[value] in madArg0FieldToReturn | | madArg0FieldToReturn | madArg0FieldToReturn | | tests.cpp:160:5:160:24 | [summary] to write: ReturnValue in madArg0FieldToReturn | ReturnNode | madArg0FieldToReturn | madArg0FieldToReturn | -| tests.cpp:161:5:161:32 | [summary param] 0 indirection in madArg0IndirectFieldToReturn | ParameterNode | madArg0IndirectFieldToReturn | madArg0IndirectFieldToReturn | -| tests.cpp:161:5:161:32 | [summary] read: Argument[0 indirection].Field[value] in madArg0IndirectFieldToReturn | | madArg0IndirectFieldToReturn | madArg0IndirectFieldToReturn | +| tests.cpp:161:5:161:32 | [summary param] *0 in madArg0IndirectFieldToReturn | ParameterNode | madArg0IndirectFieldToReturn | madArg0IndirectFieldToReturn | +| tests.cpp:161:5:161:32 | [summary] read: Argument[*0].Field[value] in madArg0IndirectFieldToReturn | | madArg0IndirectFieldToReturn | madArg0IndirectFieldToReturn | | tests.cpp:161:5:161:32 | [summary] to write: ReturnValue in madArg0IndirectFieldToReturn | ReturnNode | madArg0IndirectFieldToReturn | madArg0IndirectFieldToReturn | | tests.cpp:162:5:162:32 | [summary param] 0 in madArg0FieldIndirectToReturn | ParameterNode | madArg0FieldIndirectToReturn | madArg0FieldIndirectToReturn | | tests.cpp:162:5:162:32 | [summary] read: Argument[0].Field[*ptr] in madArg0FieldIndirectToReturn | | madArg0FieldIndirectToReturn | madArg0FieldIndirectToReturn | @@ -41,36 +41,36 @@ | tests.cpp:165:13:165:40 | [summary] to write: ReturnValue in madArg0ToReturnFieldIndirect | ReturnNode | madArg0ToReturnFieldIndirect | madArg0ToReturnFieldIndirect | | tests.cpp:165:13:165:40 | [summary] to write: ReturnValue.Field[*ptr] in madArg0ToReturnFieldIndirect | | madArg0ToReturnFieldIndirect | madArg0ToReturnFieldIndirect | | tests.cpp:284:7:284:19 | [summary param] 0 in madArg0ToSelf | ParameterNode | madArg0ToSelf | madArg0ToSelf | -| tests.cpp:284:7:284:19 | [summary param] this indirection in madArg0ToSelf | ParameterNode | madArg0ToSelf | madArg0ToSelf | -| tests.cpp:284:7:284:19 | [summary] to write: Argument[this indirection] in madArg0ToSelf | PostUpdateNode | madArg0ToSelf | madArg0ToSelf | -| tests.cpp:285:6:285:20 | [summary param] this indirection in madSelfToReturn | ParameterNode | madSelfToReturn | madSelfToReturn | +| tests.cpp:284:7:284:19 | [summary param] this in madArg0ToSelf | ParameterNode | madArg0ToSelf | madArg0ToSelf | +| tests.cpp:284:7:284:19 | [summary] to write: Argument[this] in madArg0ToSelf | PostUpdateNode | madArg0ToSelf | madArg0ToSelf | +| tests.cpp:285:6:285:20 | [summary param] this in madSelfToReturn | ParameterNode | madSelfToReturn | madSelfToReturn | | tests.cpp:285:6:285:20 | [summary] to write: ReturnValue in madSelfToReturn | ReturnNode | madSelfToReturn | madSelfToReturn | | tests.cpp:287:7:287:20 | [summary param] 0 in madArg0ToField | ParameterNode | madArg0ToField | madArg0ToField | -| tests.cpp:287:7:287:20 | [summary param] this indirection in madArg0ToField | ParameterNode | madArg0ToField | madArg0ToField | -| tests.cpp:287:7:287:20 | [summary] to write: Argument[this indirection] in madArg0ToField | PostUpdateNode | madArg0ToField | madArg0ToField | -| tests.cpp:287:7:287:20 | [summary] to write: Argument[this indirection].Field[val] in madArg0ToField | | madArg0ToField | madArg0ToField | -| tests.cpp:288:6:288:21 | [summary param] this indirection in madFieldToReturn | ParameterNode | madFieldToReturn | madFieldToReturn | -| tests.cpp:288:6:288:21 | [summary] read: Argument[this indirection].Field[val] in madFieldToReturn | | madFieldToReturn | madFieldToReturn | +| tests.cpp:287:7:287:20 | [summary param] this in madArg0ToField | ParameterNode | madArg0ToField | madArg0ToField | +| tests.cpp:287:7:287:20 | [summary] to write: Argument[this] in madArg0ToField | PostUpdateNode | madArg0ToField | madArg0ToField | +| tests.cpp:287:7:287:20 | [summary] to write: Argument[this].Field[val] in madArg0ToField | | madArg0ToField | madArg0ToField | +| tests.cpp:288:6:288:21 | [summary param] this in madFieldToReturn | ParameterNode | madFieldToReturn | madFieldToReturn | +| tests.cpp:288:6:288:21 | [summary] read: Argument[this].Field[val] in madFieldToReturn | | madFieldToReturn | madFieldToReturn | | tests.cpp:288:6:288:21 | [summary] to write: ReturnValue in madFieldToReturn | ReturnNode | madFieldToReturn | madFieldToReturn | -| tests.cpp:313:7:313:30 | [summary param] this indirection in namespaceMadSelfToReturn | ParameterNode | namespaceMadSelfToReturn | namespaceMadSelfToReturn | +| tests.cpp:313:7:313:30 | [summary param] this in namespaceMadSelfToReturn | ParameterNode | namespaceMadSelfToReturn | namespaceMadSelfToReturn | | tests.cpp:313:7:313:30 | [summary] to write: ReturnValue in namespaceMadSelfToReturn | ReturnNode | namespaceMadSelfToReturn | namespaceMadSelfToReturn | | tests.cpp:434:5:434:29 | [summary param] 0 in madCallArg0ReturnToReturn | ParameterNode | madCallArg0ReturnToReturn | madCallArg0ReturnToReturn | -| tests.cpp:434:5:434:29 | [summary] read: Argument[0].Parameter[this] in madCallArg0ReturnToReturn | PostUpdateNode | madCallArg0ReturnToReturn | madCallArg0ReturnToReturn | +| tests.cpp:434:5:434:29 | [summary] read: Argument[0].Parameter[this pointer] in madCallArg0ReturnToReturn | PostUpdateNode | madCallArg0ReturnToReturn | madCallArg0ReturnToReturn | | tests.cpp:434:5:434:29 | [summary] read: Argument[0].ReturnValue in madCallArg0ReturnToReturn | OutNode | madCallArg0ReturnToReturn | madCallArg0ReturnToReturn | -| tests.cpp:434:5:434:29 | [summary] to write: Argument[0].Parameter[this] in madCallArg0ReturnToReturn | ArgumentNode | madCallArg0ReturnToReturn | madCallArg0ReturnToReturn | +| tests.cpp:434:5:434:29 | [summary] to write: Argument[0].Parameter[this pointer] in madCallArg0ReturnToReturn | ArgumentNode | madCallArg0ReturnToReturn | madCallArg0ReturnToReturn | | tests.cpp:434:5:434:29 | [summary] to write: ReturnValue in madCallArg0ReturnToReturn | ReturnNode | madCallArg0ReturnToReturn | madCallArg0ReturnToReturn | | tests.cpp:435:9:435:38 | [summary param] 0 in madCallArg0ReturnToReturnFirst | ParameterNode | madCallArg0ReturnToReturnFirst | madCallArg0ReturnToReturnFirst | -| tests.cpp:435:9:435:38 | [summary] read: Argument[0].Parameter[this] in madCallArg0ReturnToReturnFirst | PostUpdateNode | madCallArg0ReturnToReturnFirst | madCallArg0ReturnToReturnFirst | +| tests.cpp:435:9:435:38 | [summary] read: Argument[0].Parameter[this pointer] in madCallArg0ReturnToReturnFirst | PostUpdateNode | madCallArg0ReturnToReturnFirst | madCallArg0ReturnToReturnFirst | | tests.cpp:435:9:435:38 | [summary] read: Argument[0].ReturnValue in madCallArg0ReturnToReturnFirst | OutNode | madCallArg0ReturnToReturnFirst | madCallArg0ReturnToReturnFirst | -| tests.cpp:435:9:435:38 | [summary] to write: Argument[0].Parameter[this] in madCallArg0ReturnToReturnFirst | ArgumentNode | madCallArg0ReturnToReturnFirst | madCallArg0ReturnToReturnFirst | +| tests.cpp:435:9:435:38 | [summary] to write: Argument[0].Parameter[this pointer] in madCallArg0ReturnToReturnFirst | ArgumentNode | madCallArg0ReturnToReturnFirst | madCallArg0ReturnToReturnFirst | | tests.cpp:435:9:435:38 | [summary] to write: ReturnValue in madCallArg0ReturnToReturnFirst | ReturnNode | madCallArg0ReturnToReturnFirst | madCallArg0ReturnToReturnFirst | | tests.cpp:435:9:435:38 | [summary] to write: ReturnValue.Field[first] in madCallArg0ReturnToReturnFirst | | madCallArg0ReturnToReturnFirst | madCallArg0ReturnToReturnFirst | | tests.cpp:436:6:436:25 | [summary param] 0 in madCallArg0WithValue | ParameterNode | madCallArg0WithValue | madCallArg0WithValue | | tests.cpp:436:6:436:25 | [summary param] 1 in madCallArg0WithValue | ParameterNode | madCallArg0WithValue | madCallArg0WithValue | | tests.cpp:436:6:436:25 | [summary] read: Argument[0].Parameter[0] in madCallArg0WithValue | PostUpdateNode | madCallArg0WithValue | madCallArg0WithValue | -| tests.cpp:436:6:436:25 | [summary] read: Argument[0].Parameter[this] in madCallArg0WithValue | PostUpdateNode | madCallArg0WithValue | madCallArg0WithValue | +| tests.cpp:436:6:436:25 | [summary] read: Argument[0].Parameter[this pointer] in madCallArg0WithValue | PostUpdateNode | madCallArg0WithValue | madCallArg0WithValue | | tests.cpp:436:6:436:25 | [summary] to write: Argument[0].Parameter[0] in madCallArg0WithValue | ArgumentNode | madCallArg0WithValue | madCallArg0WithValue | -| tests.cpp:436:6:436:25 | [summary] to write: Argument[0].Parameter[this] in madCallArg0WithValue | ArgumentNode | madCallArg0WithValue | madCallArg0WithValue | +| tests.cpp:436:6:436:25 | [summary] to write: Argument[0].Parameter[this pointer] in madCallArg0WithValue | ArgumentNode | madCallArg0WithValue | madCallArg0WithValue | | tests.cpp:436:6:436:25 | [summary] to write: Argument[1] in madCallArg0WithValue | PostUpdateNode | madCallArg0WithValue | madCallArg0WithValue | | tests.cpp:437:5:437:36 | [summary param] 1 in madCallReturnValueIgnoreFunction | ParameterNode | madCallReturnValueIgnoreFunction | madCallReturnValueIgnoreFunction | | tests.cpp:437:5:437:36 | [summary] to write: ReturnValue in madCallReturnValueIgnoreFunction | ReturnNode | madCallReturnValueIgnoreFunction | madCallReturnValueIgnoreFunction | diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/localTaint.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/localTaint.expected index c11c39792863..d016143e9f44 100644 --- a/cpp/ql/test/library-tests/dataflow/taint-tests/localTaint.expected +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/localTaint.expected @@ -6684,7 +6684,6 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:17:21:17:33 | call to vector | vector.cpp:23:55:23:55 | v | | | vector.cpp:17:21:17:33 | call to vector | vector.cpp:27:15:27:15 | v | | | vector.cpp:17:21:17:33 | call to vector | vector.cpp:35:1:35:1 | v | | -| vector.cpp:17:26:17:32 | source1 | vector.cpp:17:21:17:33 | call to vector | TAINT | | vector.cpp:19:14:19:14 | (__begin) | vector.cpp:19:14:19:14 | call to operator* | TAINT | | vector.cpp:19:14:19:14 | (__begin) | vector.cpp:19:14:19:14 | call to operator++ | | | vector.cpp:19:14:19:14 | (__end) | vector.cpp:19:14:19:14 | call to iterator | | @@ -6746,7 +6745,6 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:27:15:27:15 | v | vector.cpp:27:15:27:15 | call to operator* | TAINT | | vector.cpp:31:33:31:45 | call to vector | vector.cpp:32:21:32:27 | const_v | | | vector.cpp:31:33:31:45 | call to vector | vector.cpp:35:1:35:1 | const_v | | -| vector.cpp:31:38:31:44 | source1 | vector.cpp:31:33:31:45 | call to vector | TAINT | | vector.cpp:32:21:32:21 | (__begin) | vector.cpp:32:21:32:21 | call to operator* | TAINT | | vector.cpp:32:21:32:21 | (__begin) | vector.cpp:32:21:32:21 | call to operator++ | | | vector.cpp:32:21:32:21 | (__range) | vector.cpp:32:21:32:21 | call to begin | TAINT | @@ -6837,9 +6835,7 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:40:2:40:3 | ref arg v1 | vector.cpp:48:7:48:8 | v1 | | | vector.cpp:40:2:40:3 | ref arg v1 | vector.cpp:49:7:49:8 | v1 | | | vector.cpp:40:2:40:3 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:40:2:40:3 | v1 | vector.cpp:40:4:40:4 | call to operator[] | TAINT | | vector.cpp:40:2:40:10 | ... = ... | vector.cpp:40:4:40:4 | call to operator[] [post update] | | -| vector.cpp:40:4:40:4 | call to operator[] [post update] | vector.cpp:40:2:40:3 | ref arg v1 | TAINT | | vector.cpp:40:10:40:10 | 0 | vector.cpp:40:2:40:10 | ... = ... | | | vector.cpp:41:2:41:3 | ref arg v1 | vector.cpp:42:2:42:3 | v1 | | | vector.cpp:41:2:41:3 | ref arg v1 | vector.cpp:43:2:43:3 | v1 | | @@ -6850,9 +6846,7 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:41:2:41:3 | ref arg v1 | vector.cpp:48:7:48:8 | v1 | | | vector.cpp:41:2:41:3 | ref arg v1 | vector.cpp:49:7:49:8 | v1 | | | vector.cpp:41:2:41:3 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:41:2:41:3 | v1 | vector.cpp:41:4:41:4 | call to operator[] | TAINT | | vector.cpp:41:2:41:10 | ... = ... | vector.cpp:41:4:41:4 | call to operator[] [post update] | | -| vector.cpp:41:4:41:4 | call to operator[] [post update] | vector.cpp:41:2:41:3 | ref arg v1 | TAINT | | vector.cpp:41:10:41:10 | 0 | vector.cpp:41:2:41:10 | ... = ... | | | vector.cpp:42:2:42:3 | ref arg v1 | vector.cpp:43:2:43:3 | v1 | | | vector.cpp:42:2:42:3 | ref arg v1 | vector.cpp:44:7:44:8 | v1 | | @@ -6862,9 +6856,7 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:42:2:42:3 | ref arg v1 | vector.cpp:48:7:48:8 | v1 | | | vector.cpp:42:2:42:3 | ref arg v1 | vector.cpp:49:7:49:8 | v1 | | | vector.cpp:42:2:42:3 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:42:2:42:3 | v1 | vector.cpp:42:4:42:4 | call to operator[] | TAINT | | vector.cpp:42:2:42:10 | ... = ... | vector.cpp:42:4:42:4 | call to operator[] [post update] | | -| vector.cpp:42:4:42:4 | call to operator[] [post update] | vector.cpp:42:2:42:3 | ref arg v1 | TAINT | | vector.cpp:42:10:42:10 | 0 | vector.cpp:42:2:42:10 | ... = ... | | | vector.cpp:43:2:43:3 | ref arg v1 | vector.cpp:44:7:44:8 | v1 | | | vector.cpp:43:2:43:3 | ref arg v1 | vector.cpp:45:7:45:8 | v1 | | @@ -6873,7 +6865,6 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:43:2:43:3 | ref arg v1 | vector.cpp:48:7:48:8 | v1 | | | vector.cpp:43:2:43:3 | ref arg v1 | vector.cpp:49:7:49:8 | v1 | | | vector.cpp:43:2:43:3 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:43:15:43:15 | 1 | vector.cpp:43:2:43:3 | ref arg v1 | TAINT | | vector.cpp:44:7:44:8 | ref arg v1 | vector.cpp:45:7:45:8 | v1 | | | vector.cpp:44:7:44:8 | ref arg v1 | vector.cpp:46:7:46:8 | v1 | | | vector.cpp:44:7:44:8 | ref arg v1 | vector.cpp:47:7:47:8 | v1 | | @@ -6885,30 +6876,23 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:45:7:45:8 | ref arg v1 | vector.cpp:48:7:48:8 | v1 | | | vector.cpp:45:7:45:8 | ref arg v1 | vector.cpp:49:7:49:8 | v1 | | | vector.cpp:45:7:45:8 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:45:7:45:8 | v1 | vector.cpp:45:9:45:9 | call to operator[] | TAINT | | vector.cpp:46:7:46:8 | ref arg v1 | vector.cpp:47:7:47:8 | v1 | | | vector.cpp:46:7:46:8 | ref arg v1 | vector.cpp:48:7:48:8 | v1 | | | vector.cpp:46:7:46:8 | ref arg v1 | vector.cpp:49:7:49:8 | v1 | | | vector.cpp:46:7:46:8 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:46:7:46:8 | v1 | vector.cpp:46:9:46:9 | call to operator[] | TAINT | | vector.cpp:47:7:47:8 | ref arg v1 | vector.cpp:48:7:48:8 | v1 | | | vector.cpp:47:7:47:8 | ref arg v1 | vector.cpp:49:7:49:8 | v1 | | | vector.cpp:47:7:47:8 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:47:7:47:8 | v1 | vector.cpp:47:9:47:9 | call to operator[] | TAINT | | vector.cpp:48:7:48:8 | ref arg v1 | vector.cpp:49:7:49:8 | v1 | | | vector.cpp:48:7:48:8 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:48:7:48:8 | v1 | vector.cpp:48:10:48:14 | call to front | TAINT | | vector.cpp:49:7:49:8 | ref arg v1 | vector.cpp:101:1:101:1 | v1 | | -| vector.cpp:49:7:49:8 | v1 | vector.cpp:49:10:49:13 | call to back | TAINT | | vector.cpp:51:2:51:3 | ref arg v2 | vector.cpp:52:7:52:8 | v2 | | | vector.cpp:51:2:51:3 | ref arg v2 | vector.cpp:53:7:53:8 | v2 | | | vector.cpp:51:2:51:3 | ref arg v2 | vector.cpp:54:7:54:8 | v2 | | | vector.cpp:51:2:51:3 | ref arg v2 | vector.cpp:55:7:55:8 | v2 | | | vector.cpp:51:2:51:3 | ref arg v2 | vector.cpp:57:7:57:8 | v2 | | | vector.cpp:51:2:51:3 | ref arg v2 | vector.cpp:101:1:101:1 | v2 | | -| vector.cpp:51:2:51:3 | v2 | vector.cpp:51:4:51:4 | call to operator[] | TAINT | | vector.cpp:51:2:51:17 | ... = ... | vector.cpp:51:4:51:4 | call to operator[] [post update] | | -| vector.cpp:51:4:51:4 | call to operator[] [post update] | vector.cpp:51:2:51:3 | ref arg v2 | TAINT | | vector.cpp:51:10:51:15 | call to source | vector.cpp:51:2:51:17 | ... = ... | | | vector.cpp:52:7:52:8 | ref arg v2 | vector.cpp:53:7:53:8 | v2 | | | vector.cpp:52:7:52:8 | ref arg v2 | vector.cpp:54:7:54:8 | v2 | | @@ -6919,14 +6903,11 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:53:7:53:8 | ref arg v2 | vector.cpp:55:7:55:8 | v2 | | | vector.cpp:53:7:53:8 | ref arg v2 | vector.cpp:57:7:57:8 | v2 | | | vector.cpp:53:7:53:8 | ref arg v2 | vector.cpp:101:1:101:1 | v2 | | -| vector.cpp:53:7:53:8 | v2 | vector.cpp:53:9:53:9 | call to operator[] | TAINT | | vector.cpp:54:7:54:8 | ref arg v2 | vector.cpp:55:7:55:8 | v2 | | | vector.cpp:54:7:54:8 | ref arg v2 | vector.cpp:57:7:57:8 | v2 | | | vector.cpp:54:7:54:8 | ref arg v2 | vector.cpp:101:1:101:1 | v2 | | -| vector.cpp:54:7:54:8 | v2 | vector.cpp:54:9:54:9 | call to operator[] | TAINT | | vector.cpp:55:7:55:8 | ref arg v2 | vector.cpp:57:7:57:8 | v2 | | | vector.cpp:55:7:55:8 | ref arg v2 | vector.cpp:101:1:101:1 | v2 | | -| vector.cpp:55:7:55:8 | v2 | vector.cpp:55:9:55:9 | call to operator[] | TAINT | | vector.cpp:57:2:57:3 | ref arg v3 | vector.cpp:58:7:58:8 | v3 | | | vector.cpp:57:2:57:3 | ref arg v3 | vector.cpp:59:7:59:8 | v3 | | | vector.cpp:57:2:57:3 | ref arg v3 | vector.cpp:60:7:60:8 | v3 | | @@ -6941,20 +6922,15 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:59:7:59:8 | ref arg v3 | vector.cpp:60:7:60:8 | v3 | | | vector.cpp:59:7:59:8 | ref arg v3 | vector.cpp:61:7:61:8 | v3 | | | vector.cpp:59:7:59:8 | ref arg v3 | vector.cpp:101:1:101:1 | v3 | | -| vector.cpp:59:7:59:8 | v3 | vector.cpp:59:9:59:9 | call to operator[] | TAINT | | vector.cpp:60:7:60:8 | ref arg v3 | vector.cpp:61:7:61:8 | v3 | | | vector.cpp:60:7:60:8 | ref arg v3 | vector.cpp:101:1:101:1 | v3 | | -| vector.cpp:60:7:60:8 | v3 | vector.cpp:60:9:60:9 | call to operator[] | TAINT | | vector.cpp:61:7:61:8 | ref arg v3 | vector.cpp:101:1:101:1 | v3 | | -| vector.cpp:61:7:61:8 | v3 | vector.cpp:61:9:61:9 | call to operator[] | TAINT | | vector.cpp:63:2:63:3 | ref arg v4 | vector.cpp:64:7:64:8 | v4 | | | vector.cpp:63:2:63:3 | ref arg v4 | vector.cpp:65:7:65:8 | v4 | | | vector.cpp:63:2:63:3 | ref arg v4 | vector.cpp:66:7:66:8 | v4 | | | vector.cpp:63:2:63:3 | ref arg v4 | vector.cpp:67:7:67:8 | v4 | | | vector.cpp:63:2:63:3 | ref arg v4 | vector.cpp:101:1:101:1 | v4 | | -| vector.cpp:63:2:63:3 | v4 | vector.cpp:63:4:63:4 | call to operator[] | TAINT | | vector.cpp:63:2:63:17 | ... = ... | vector.cpp:63:4:63:4 | call to operator[] [post update] | | -| vector.cpp:63:4:63:4 | call to operator[] [post update] | vector.cpp:63:2:63:3 | ref arg v4 | TAINT | | vector.cpp:63:10:63:15 | call to source | vector.cpp:63:2:63:17 | ... = ... | | | vector.cpp:64:7:64:8 | ref arg v4 | vector.cpp:65:7:65:8 | v4 | | | vector.cpp:64:7:64:8 | ref arg v4 | vector.cpp:66:7:66:8 | v4 | | @@ -6963,39 +6939,30 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:65:7:65:8 | ref arg v4 | vector.cpp:66:7:66:8 | v4 | | | vector.cpp:65:7:65:8 | ref arg v4 | vector.cpp:67:7:67:8 | v4 | | | vector.cpp:65:7:65:8 | ref arg v4 | vector.cpp:101:1:101:1 | v4 | | -| vector.cpp:65:7:65:8 | v4 | vector.cpp:65:9:65:9 | call to operator[] | TAINT | | vector.cpp:66:7:66:8 | ref arg v4 | vector.cpp:67:7:67:8 | v4 | | | vector.cpp:66:7:66:8 | ref arg v4 | vector.cpp:101:1:101:1 | v4 | | -| vector.cpp:66:7:66:8 | v4 | vector.cpp:66:9:66:9 | call to operator[] | TAINT | | vector.cpp:67:7:67:8 | ref arg v4 | vector.cpp:101:1:101:1 | v4 | | -| vector.cpp:67:7:67:8 | v4 | vector.cpp:67:9:67:9 | call to operator[] | TAINT | | vector.cpp:69:2:69:3 | ref arg v5 | vector.cpp:70:7:70:8 | v5 | | | vector.cpp:69:2:69:3 | ref arg v5 | vector.cpp:71:7:71:8 | v5 | | | vector.cpp:69:2:69:3 | ref arg v5 | vector.cpp:72:7:72:8 | v5 | | | vector.cpp:69:2:69:3 | ref arg v5 | vector.cpp:101:1:101:1 | v5 | | -| vector.cpp:69:15:69:20 | call to source | vector.cpp:69:2:69:3 | ref arg v5 | TAINT | | vector.cpp:70:7:70:8 | ref arg v5 | vector.cpp:71:7:71:8 | v5 | | | vector.cpp:70:7:70:8 | ref arg v5 | vector.cpp:72:7:72:8 | v5 | | | vector.cpp:70:7:70:8 | ref arg v5 | vector.cpp:101:1:101:1 | v5 | | | vector.cpp:71:7:71:8 | ref arg v5 | vector.cpp:72:7:72:8 | v5 | | | vector.cpp:71:7:71:8 | ref arg v5 | vector.cpp:101:1:101:1 | v5 | | -| vector.cpp:71:7:71:8 | v5 | vector.cpp:71:10:71:14 | call to front | TAINT | | vector.cpp:72:7:72:8 | ref arg v5 | vector.cpp:101:1:101:1 | v5 | | -| vector.cpp:72:7:72:8 | v5 | vector.cpp:72:10:72:13 | call to back | TAINT | | vector.cpp:74:2:74:3 | ref arg v6 | vector.cpp:75:7:75:8 | v6 | | | vector.cpp:74:2:74:3 | ref arg v6 | vector.cpp:76:7:76:8 | v6 | | | vector.cpp:74:2:74:3 | ref arg v6 | vector.cpp:101:1:101:1 | v6 | | -| vector.cpp:74:2:74:3 | v6 | vector.cpp:74:5:74:8 | call to data | TAINT | | vector.cpp:74:2:74:13 | access to array [post update] | vector.cpp:74:5:74:8 | call to data [inner post update] | | | vector.cpp:74:2:74:24 | ... = ... | vector.cpp:74:2:74:13 | access to array [post update] | | | vector.cpp:74:5:74:8 | call to data | vector.cpp:74:2:74:13 | access to array | TAINT | -| vector.cpp:74:5:74:8 | call to data [inner post update] | vector.cpp:74:2:74:3 | ref arg v6 | TAINT | | vector.cpp:74:12:74:12 | 2 | vector.cpp:74:2:74:13 | access to array | TAINT | | vector.cpp:74:17:74:22 | call to source | vector.cpp:74:2:74:24 | ... = ... | | | vector.cpp:75:7:75:8 | ref arg v6 | vector.cpp:76:7:76:8 | v6 | | | vector.cpp:75:7:75:8 | ref arg v6 | vector.cpp:101:1:101:1 | v6 | | | vector.cpp:76:7:76:8 | ref arg v6 | vector.cpp:101:1:101:1 | v6 | | -| vector.cpp:76:7:76:8 | v6 | vector.cpp:76:10:76:13 | call to data | TAINT | | vector.cpp:76:10:76:13 | call to data | vector.cpp:76:7:76:18 | access to array | TAINT | | vector.cpp:76:17:76:17 | 2 | vector.cpp:76:7:76:18 | access to array | TAINT | | vector.cpp:80:40:80:50 | call to iterator | vector.cpp:81:13:81:14 | it | | @@ -7010,17 +6977,12 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:81:3:81:4 | ref arg v7 | vector.cpp:84:7:84:8 | v7 | | | vector.cpp:81:3:81:4 | ref arg v7 | vector.cpp:85:7:85:8 | v7 | | | vector.cpp:81:3:81:4 | ref arg v7 | vector.cpp:101:1:101:1 | v7 | | -| vector.cpp:81:3:81:4 | v7 | vector.cpp:81:6:81:11 | call to insert | TAINT | -| vector.cpp:81:17:81:22 | call to source | vector.cpp:81:3:81:4 | ref arg v7 | TAINT | -| vector.cpp:81:17:81:22 | call to source | vector.cpp:81:6:81:11 | call to insert | TAINT | | vector.cpp:83:7:83:8 | ref arg v7 | vector.cpp:84:7:84:8 | v7 | | | vector.cpp:83:7:83:8 | ref arg v7 | vector.cpp:85:7:85:8 | v7 | | | vector.cpp:83:7:83:8 | ref arg v7 | vector.cpp:101:1:101:1 | v7 | | | vector.cpp:84:7:84:8 | ref arg v7 | vector.cpp:85:7:85:8 | v7 | | | vector.cpp:84:7:84:8 | ref arg v7 | vector.cpp:101:1:101:1 | v7 | | -| vector.cpp:84:7:84:8 | v7 | vector.cpp:84:10:84:14 | call to front | TAINT | | vector.cpp:85:7:85:8 | ref arg v7 | vector.cpp:101:1:101:1 | v7 | | -| vector.cpp:85:7:85:8 | v7 | vector.cpp:85:10:85:13 | call to back | TAINT | | vector.cpp:88:33:88:34 | v8 | vector.cpp:89:41:89:43 | v8c | | | vector.cpp:89:41:89:43 | v8c | vector.cpp:89:45:89:49 | call to begin | TAINT | | vector.cpp:89:45:89:49 | call to begin | vector.cpp:90:13:90:14 | it | | @@ -7028,23 +6990,18 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:90:3:90:4 | ref arg v8 | vector.cpp:93:7:93:8 | v8 | | | vector.cpp:90:3:90:4 | ref arg v8 | vector.cpp:94:7:94:8 | v8 | | | vector.cpp:90:3:90:4 | ref arg v8 | vector.cpp:101:1:101:1 | v8 | | -| vector.cpp:90:3:90:4 | v8 | vector.cpp:90:6:90:11 | call to insert | TAINT | | vector.cpp:92:7:92:8 | ref arg v8 | vector.cpp:93:7:93:8 | v8 | | | vector.cpp:92:7:92:8 | ref arg v8 | vector.cpp:94:7:94:8 | v8 | | | vector.cpp:92:7:92:8 | ref arg v8 | vector.cpp:101:1:101:1 | v8 | | | vector.cpp:93:7:93:8 | ref arg v8 | vector.cpp:94:7:94:8 | v8 | | | vector.cpp:93:7:93:8 | ref arg v8 | vector.cpp:101:1:101:1 | v8 | | -| vector.cpp:93:7:93:8 | v8 | vector.cpp:93:10:93:14 | call to front | TAINT | | vector.cpp:94:7:94:8 | ref arg v8 | vector.cpp:101:1:101:1 | v8 | | -| vector.cpp:94:7:94:8 | v8 | vector.cpp:94:10:94:13 | call to back | TAINT | | vector.cpp:96:2:96:3 | ref arg v9 | vector.cpp:97:7:97:8 | v9 | | | vector.cpp:96:2:96:3 | ref arg v9 | vector.cpp:98:7:98:8 | v9 | | | vector.cpp:96:2:96:3 | ref arg v9 | vector.cpp:99:7:99:8 | v9 | | | vector.cpp:96:2:96:3 | ref arg v9 | vector.cpp:100:7:100:8 | v9 | | | vector.cpp:96:2:96:3 | ref arg v9 | vector.cpp:101:1:101:1 | v9 | | -| vector.cpp:96:2:96:3 | v9 | vector.cpp:96:5:96:6 | call to at | TAINT | | vector.cpp:96:2:96:20 | ... = ... | vector.cpp:96:5:96:6 | call to at [post update] | | -| vector.cpp:96:5:96:6 | call to at [post update] | vector.cpp:96:2:96:3 | ref arg v9 | TAINT | | vector.cpp:96:13:96:18 | call to source | vector.cpp:96:2:96:20 | ... = ... | | | vector.cpp:97:7:97:8 | ref arg v9 | vector.cpp:98:7:98:8 | v9 | | | vector.cpp:97:7:97:8 | ref arg v9 | vector.cpp:99:7:99:8 | v9 | | @@ -7053,12 +7010,9 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:98:7:98:8 | ref arg v9 | vector.cpp:99:7:99:8 | v9 | | | vector.cpp:98:7:98:8 | ref arg v9 | vector.cpp:100:7:100:8 | v9 | | | vector.cpp:98:7:98:8 | ref arg v9 | vector.cpp:101:1:101:1 | v9 | | -| vector.cpp:98:7:98:8 | v9 | vector.cpp:98:10:98:11 | call to at | TAINT | | vector.cpp:99:7:99:8 | ref arg v9 | vector.cpp:100:7:100:8 | v9 | | | vector.cpp:99:7:99:8 | ref arg v9 | vector.cpp:101:1:101:1 | v9 | | -| vector.cpp:99:7:99:8 | v9 | vector.cpp:99:10:99:11 | call to at | TAINT | | vector.cpp:100:7:100:8 | ref arg v9 | vector.cpp:101:1:101:1 | v9 | | -| vector.cpp:100:7:100:8 | v9 | vector.cpp:100:10:100:11 | call to at | TAINT | | vector.cpp:104:22:104:24 | call to vector | vector.cpp:106:2:106:3 | v1 | | | vector.cpp:104:22:104:24 | call to vector | vector.cpp:109:7:109:8 | v1 | | | vector.cpp:104:22:104:24 | call to vector | vector.cpp:114:2:114:3 | v1 | | @@ -7081,12 +7035,10 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:106:2:106:3 | ref arg v1 | vector.cpp:114:2:114:3 | v1 | | | vector.cpp:106:2:106:3 | ref arg v1 | vector.cpp:117:7:117:8 | v1 | | | vector.cpp:106:2:106:3 | ref arg v1 | vector.cpp:121:1:121:1 | v1 | | -| vector.cpp:106:15:106:20 | call to source | vector.cpp:106:2:106:3 | ref arg v1 | TAINT | | vector.cpp:107:2:107:3 | ref arg v4 | vector.cpp:112:7:112:8 | v4 | | | vector.cpp:107:2:107:3 | ref arg v4 | vector.cpp:115:10:115:11 | v4 | | | vector.cpp:107:2:107:3 | ref arg v4 | vector.cpp:120:7:120:8 | v4 | | | vector.cpp:107:2:107:3 | ref arg v4 | vector.cpp:121:1:121:1 | v4 | | -| vector.cpp:107:15:107:20 | call to source | vector.cpp:107:2:107:3 | ref arg v4 | TAINT | | vector.cpp:109:7:109:8 | ref arg v1 | vector.cpp:114:2:114:3 | v1 | | | vector.cpp:109:7:109:8 | ref arg v1 | vector.cpp:117:7:117:8 | v1 | | | vector.cpp:109:7:109:8 | ref arg v1 | vector.cpp:121:1:121:1 | v1 | | @@ -7139,18 +7091,15 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:126:2:126:3 | ref arg v1 | vector.cpp:135:2:135:3 | v1 | | | vector.cpp:126:2:126:3 | ref arg v1 | vector.cpp:139:7:139:8 | v1 | | | vector.cpp:126:2:126:3 | ref arg v1 | vector.cpp:143:1:143:1 | v1 | | -| vector.cpp:126:15:126:20 | call to source | vector.cpp:126:2:126:3 | ref arg v1 | TAINT | | vector.cpp:127:2:127:3 | ref arg v2 | vector.cpp:131:7:131:8 | v2 | | | vector.cpp:127:2:127:3 | ref arg v2 | vector.cpp:136:2:136:3 | v2 | | | vector.cpp:127:2:127:3 | ref arg v2 | vector.cpp:136:7:136:8 | v2 | | | vector.cpp:127:2:127:3 | ref arg v2 | vector.cpp:140:7:140:8 | v2 | | | vector.cpp:127:2:127:3 | ref arg v2 | vector.cpp:143:1:143:1 | v2 | | -| vector.cpp:127:15:127:20 | call to source | vector.cpp:127:2:127:3 | ref arg v2 | TAINT | | vector.cpp:128:2:128:3 | ref arg v3 | vector.cpp:132:7:132:8 | v3 | | | vector.cpp:128:2:128:3 | ref arg v3 | vector.cpp:137:2:137:3 | v3 | | | vector.cpp:128:2:128:3 | ref arg v3 | vector.cpp:141:7:141:8 | v3 | | | vector.cpp:128:2:128:3 | ref arg v3 | vector.cpp:143:1:143:1 | v3 | | -| vector.cpp:128:15:128:20 | call to source | vector.cpp:128:2:128:3 | ref arg v3 | TAINT | | vector.cpp:130:7:130:8 | ref arg v1 | vector.cpp:135:2:135:3 | v1 | | | vector.cpp:130:7:130:8 | ref arg v1 | vector.cpp:139:7:139:8 | v1 | | | vector.cpp:130:7:130:8 | ref arg v1 | vector.cpp:143:1:143:1 | v1 | | @@ -7210,31 +7159,18 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:166:37:166:39 | call to vector | vector.cpp:170:3:170:4 | bb | | | vector.cpp:166:37:166:39 | call to vector | vector.cpp:171:8:171:9 | bb | | | vector.cpp:166:37:166:39 | call to vector | vector.cpp:172:2:172:2 | bb | | -| vector.cpp:168:3:168:4 | bb | vector.cpp:168:5:168:5 | call to operator[] | TAINT | | vector.cpp:168:3:168:4 | ref arg bb | vector.cpp:169:8:169:9 | bb | | | vector.cpp:168:3:168:4 | ref arg bb | vector.cpp:170:3:170:4 | bb | | | vector.cpp:168:3:168:4 | ref arg bb | vector.cpp:171:8:171:9 | bb | | | vector.cpp:168:3:168:4 | ref arg bb | vector.cpp:172:2:172:2 | bb | | -| vector.cpp:168:5:168:5 | ref arg call to operator[] | vector.cpp:168:3:168:4 | ref arg bb | TAINT | -| vector.cpp:168:19:168:19 | 0 | vector.cpp:168:5:168:5 | ref arg call to operator[] | TAINT | -| vector.cpp:169:8:169:9 | bb | vector.cpp:169:10:169:10 | call to operator[] | TAINT | | vector.cpp:169:8:169:9 | ref arg bb | vector.cpp:170:3:170:4 | bb | | | vector.cpp:169:8:169:9 | ref arg bb | vector.cpp:171:8:171:9 | bb | | | vector.cpp:169:8:169:9 | ref arg bb | vector.cpp:172:2:172:2 | bb | | -| vector.cpp:169:10:169:10 | call to operator[] | vector.cpp:169:13:169:13 | call to operator[] | TAINT | -| vector.cpp:169:10:169:10 | ref arg call to operator[] | vector.cpp:169:8:169:9 | ref arg bb | TAINT | -| vector.cpp:170:3:170:4 | bb | vector.cpp:170:5:170:5 | call to operator[] | TAINT | | vector.cpp:170:3:170:4 | ref arg bb | vector.cpp:171:8:171:9 | bb | | | vector.cpp:170:3:170:4 | ref arg bb | vector.cpp:172:2:172:2 | bb | | | vector.cpp:170:3:170:21 | ... = ... | vector.cpp:170:8:170:8 | call to operator[] [post update] | | -| vector.cpp:170:5:170:5 | call to operator[] | vector.cpp:170:8:170:8 | call to operator[] | TAINT | -| vector.cpp:170:5:170:5 | ref arg call to operator[] | vector.cpp:170:3:170:4 | ref arg bb | TAINT | -| vector.cpp:170:8:170:8 | call to operator[] [post update] | vector.cpp:170:5:170:5 | ref arg call to operator[] | TAINT | | vector.cpp:170:14:170:19 | call to source | vector.cpp:170:3:170:21 | ... = ... | | -| vector.cpp:171:8:171:9 | bb | vector.cpp:171:10:171:10 | call to operator[] | TAINT | | vector.cpp:171:8:171:9 | ref arg bb | vector.cpp:172:2:172:2 | bb | | -| vector.cpp:171:10:171:10 | call to operator[] | vector.cpp:171:13:171:13 | call to operator[] | TAINT | -| vector.cpp:171:10:171:10 | ref arg call to operator[] | vector.cpp:171:8:171:9 | ref arg bb | TAINT | | vector.cpp:175:20:175:21 | call to vector | vector.cpp:175:20:175:21 | {...} | TAINT | | vector.cpp:175:20:175:21 | {...} | vector.cpp:177:3:177:4 | cc | | | vector.cpp:175:20:175:21 | {...} | vector.cpp:178:8:178:9 | cc | | @@ -7248,25 +7184,20 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:177:3:177:7 | ref arg access to array | vector.cpp:180:8:180:9 | cc | | | vector.cpp:177:3:177:7 | ref arg access to array | vector.cpp:181:2:181:2 | cc | | | vector.cpp:177:6:177:6 | 0 | vector.cpp:177:3:177:7 | access to array | TAINT | -| vector.cpp:177:19:177:19 | 0 | vector.cpp:177:3:177:7 | ref arg access to array | TAINT | | vector.cpp:178:8:178:9 | cc | vector.cpp:178:8:178:12 | access to array | | -| vector.cpp:178:8:178:12 | access to array | vector.cpp:178:13:178:13 | call to operator[] | TAINT | | vector.cpp:178:8:178:12 | ref arg access to array | vector.cpp:178:8:178:9 | cc [inner post update] | | | vector.cpp:178:8:178:12 | ref arg access to array | vector.cpp:179:3:179:4 | cc | | | vector.cpp:178:8:178:12 | ref arg access to array | vector.cpp:180:8:180:9 | cc | | | vector.cpp:178:8:178:12 | ref arg access to array | vector.cpp:181:2:181:2 | cc | | | vector.cpp:178:11:178:11 | 0 | vector.cpp:178:8:178:12 | access to array | TAINT | | vector.cpp:179:3:179:4 | cc | vector.cpp:179:3:179:7 | access to array | | -| vector.cpp:179:3:179:7 | access to array | vector.cpp:179:8:179:8 | call to operator[] | TAINT | | vector.cpp:179:3:179:7 | ref arg access to array | vector.cpp:179:3:179:4 | cc [inner post update] | | | vector.cpp:179:3:179:7 | ref arg access to array | vector.cpp:180:8:180:9 | cc | | | vector.cpp:179:3:179:7 | ref arg access to array | vector.cpp:181:2:181:2 | cc | | | vector.cpp:179:3:179:21 | ... = ... | vector.cpp:179:8:179:8 | call to operator[] [post update] | | | vector.cpp:179:6:179:6 | 0 | vector.cpp:179:3:179:7 | access to array | TAINT | -| vector.cpp:179:8:179:8 | call to operator[] [post update] | vector.cpp:179:3:179:7 | ref arg access to array | TAINT | | vector.cpp:179:14:179:19 | call to source | vector.cpp:179:3:179:21 | ... = ... | | | vector.cpp:180:8:180:9 | cc | vector.cpp:180:8:180:12 | access to array | | -| vector.cpp:180:8:180:12 | access to array | vector.cpp:180:13:180:13 | call to operator[] | TAINT | | vector.cpp:180:8:180:12 | ref arg access to array | vector.cpp:180:8:180:9 | cc [inner post update] | | | vector.cpp:180:8:180:12 | ref arg access to array | vector.cpp:181:2:181:2 | cc | | | vector.cpp:180:11:180:11 | 0 | vector.cpp:180:8:180:12 | access to array | TAINT | @@ -7284,29 +7215,22 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:187:3:187:4 | ref arg dd | vector.cpp:191:8:191:9 | dd | | | vector.cpp:187:3:187:4 | ref arg dd | vector.cpp:192:8:192:9 | dd | | | vector.cpp:187:3:187:4 | ref arg dd | vector.cpp:193:2:193:2 | dd | | -| vector.cpp:187:16:187:17 | mp | vector.cpp:187:3:187:4 | ref arg dd | TAINT | -| vector.cpp:188:8:188:9 | dd | vector.cpp:188:10:188:10 | call to operator[] | TAINT | | vector.cpp:188:8:188:9 | ref arg dd | vector.cpp:189:8:189:9 | dd | | | vector.cpp:188:8:188:9 | ref arg dd | vector.cpp:190:3:190:4 | dd | | | vector.cpp:188:8:188:9 | ref arg dd | vector.cpp:191:8:191:9 | dd | | | vector.cpp:188:8:188:9 | ref arg dd | vector.cpp:192:8:192:9 | dd | | | vector.cpp:188:8:188:9 | ref arg dd | vector.cpp:193:2:193:2 | dd | | -| vector.cpp:189:8:189:9 | dd | vector.cpp:189:10:189:10 | call to operator[] | TAINT | | vector.cpp:189:8:189:9 | ref arg dd | vector.cpp:190:3:190:4 | dd | | | vector.cpp:189:8:189:9 | ref arg dd | vector.cpp:191:8:191:9 | dd | | | vector.cpp:189:8:189:9 | ref arg dd | vector.cpp:192:8:192:9 | dd | | | vector.cpp:189:8:189:9 | ref arg dd | vector.cpp:193:2:193:2 | dd | | -| vector.cpp:190:3:190:4 | dd | vector.cpp:190:5:190:5 | call to operator[] | TAINT | | vector.cpp:190:3:190:4 | ref arg dd | vector.cpp:191:8:191:9 | dd | | | vector.cpp:190:3:190:4 | ref arg dd | vector.cpp:192:8:192:9 | dd | | | vector.cpp:190:3:190:4 | ref arg dd | vector.cpp:193:2:193:2 | dd | | | vector.cpp:190:3:190:20 | ... = ... | vector.cpp:190:9:190:9 | a [post update] | | -| vector.cpp:190:5:190:5 | call to operator[] [post update] | vector.cpp:190:3:190:4 | ref arg dd | TAINT | | vector.cpp:190:13:190:18 | call to source | vector.cpp:190:3:190:20 | ... = ... | | -| vector.cpp:191:8:191:9 | dd | vector.cpp:191:10:191:10 | call to operator[] | TAINT | | vector.cpp:191:8:191:9 | ref arg dd | vector.cpp:192:8:192:9 | dd | | | vector.cpp:191:8:191:9 | ref arg dd | vector.cpp:193:2:193:2 | dd | | -| vector.cpp:192:8:192:9 | dd | vector.cpp:192:10:192:10 | call to operator[] | TAINT | | vector.cpp:192:8:192:9 | ref arg dd | vector.cpp:193:2:193:2 | dd | | | vector.cpp:196:21:196:22 | call to MyVectorContainer | vector.cpp:198:3:198:4 | ee | | | vector.cpp:196:21:196:22 | call to MyVectorContainer | vector.cpp:199:8:199:9 | ee | | @@ -7320,22 +7244,17 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:198:6:198:7 | ref arg vs | vector.cpp:199:11:199:12 | vs | | | vector.cpp:198:6:198:7 | ref arg vs | vector.cpp:200:6:200:7 | vs | | | vector.cpp:198:6:198:7 | ref arg vs | vector.cpp:201:11:201:12 | vs | | -| vector.cpp:198:19:198:19 | 0 | vector.cpp:198:6:198:7 | ref arg vs | TAINT | | vector.cpp:199:8:199:9 | ee [post update] | vector.cpp:200:3:200:4 | ee | | | vector.cpp:199:8:199:9 | ee [post update] | vector.cpp:201:8:201:9 | ee | | | vector.cpp:199:8:199:9 | ee [post update] | vector.cpp:202:2:202:2 | ee | | | vector.cpp:199:11:199:12 | ref arg vs | vector.cpp:200:6:200:7 | vs | | | vector.cpp:199:11:199:12 | ref arg vs | vector.cpp:201:11:201:12 | vs | | -| vector.cpp:199:11:199:12 | vs | vector.cpp:199:13:199:13 | call to operator[] | TAINT | | vector.cpp:200:3:200:4 | ee [post update] | vector.cpp:201:8:201:9 | ee | | | vector.cpp:200:3:200:4 | ee [post update] | vector.cpp:202:2:202:2 | ee | | | vector.cpp:200:3:200:21 | ... = ... | vector.cpp:200:8:200:8 | call to operator[] [post update] | | | vector.cpp:200:6:200:7 | ref arg vs | vector.cpp:201:11:201:12 | vs | | -| vector.cpp:200:6:200:7 | vs | vector.cpp:200:8:200:8 | call to operator[] | TAINT | -| vector.cpp:200:8:200:8 | call to operator[] [post update] | vector.cpp:200:6:200:7 | ref arg vs | TAINT | | vector.cpp:200:14:200:19 | call to source | vector.cpp:200:3:200:21 | ... = ... | | | vector.cpp:201:8:201:9 | ee [post update] | vector.cpp:202:2:202:2 | ee | | -| vector.cpp:201:11:201:12 | vs | vector.cpp:201:13:201:13 | call to operator[] | TAINT | | vector.cpp:205:34:205:35 | call to vector | vector.cpp:209:3:209:4 | ff | | | vector.cpp:205:34:205:35 | call to vector | vector.cpp:210:8:210:9 | ff | | | vector.cpp:205:34:205:35 | call to vector | vector.cpp:211:3:211:4 | ff | | @@ -7346,30 +7265,18 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:206:21:206:23 | call to MyVectorContainer | vector.cpp:213:2:213:2 | mvc | | | vector.cpp:208:3:208:5 | mvc [post update] | vector.cpp:209:16:209:18 | mvc | | | vector.cpp:208:3:208:5 | mvc [post update] | vector.cpp:213:2:213:2 | mvc | | -| vector.cpp:208:20:208:20 | 0 | vector.cpp:208:7:208:8 | ref arg vs | TAINT | | vector.cpp:209:3:209:4 | ref arg ff | vector.cpp:210:8:210:9 | ff | | | vector.cpp:209:3:209:4 | ref arg ff | vector.cpp:211:3:211:4 | ff | | | vector.cpp:209:3:209:4 | ref arg ff | vector.cpp:212:8:212:9 | ff | | | vector.cpp:209:3:209:4 | ref arg ff | vector.cpp:213:2:213:2 | ff | | -| vector.cpp:209:16:209:18 | mvc | vector.cpp:209:3:209:4 | ref arg ff | TAINT | -| vector.cpp:210:8:210:9 | ff | vector.cpp:210:10:210:10 | call to operator[] | TAINT | | vector.cpp:210:8:210:9 | ref arg ff | vector.cpp:211:3:211:4 | ff | | | vector.cpp:210:8:210:9 | ref arg ff | vector.cpp:212:8:212:9 | ff | | | vector.cpp:210:8:210:9 | ref arg ff | vector.cpp:213:2:213:2 | ff | | -| vector.cpp:210:10:210:10 | call to operator[] [post update] | vector.cpp:210:8:210:9 | ref arg ff | TAINT | -| vector.cpp:210:14:210:15 | vs | vector.cpp:210:16:210:16 | call to operator[] | TAINT | -| vector.cpp:211:3:211:4 | ff | vector.cpp:211:5:211:5 | call to operator[] | TAINT | | vector.cpp:211:3:211:4 | ref arg ff | vector.cpp:212:8:212:9 | ff | | | vector.cpp:211:3:211:4 | ref arg ff | vector.cpp:213:2:213:2 | ff | | | vector.cpp:211:3:211:24 | ... = ... | vector.cpp:211:11:211:11 | call to operator[] [post update] | | -| vector.cpp:211:5:211:5 | call to operator[] [post update] | vector.cpp:211:3:211:4 | ref arg ff | TAINT | -| vector.cpp:211:9:211:10 | vs | vector.cpp:211:11:211:11 | call to operator[] | TAINT | -| vector.cpp:211:11:211:11 | call to operator[] [post update] | vector.cpp:211:9:211:10 | ref arg vs | TAINT | | vector.cpp:211:17:211:22 | call to source | vector.cpp:211:3:211:24 | ... = ... | | -| vector.cpp:212:8:212:9 | ff | vector.cpp:212:10:212:10 | call to operator[] | TAINT | | vector.cpp:212:8:212:9 | ref arg ff | vector.cpp:213:2:213:2 | ff | | -| vector.cpp:212:10:212:10 | call to operator[] [post update] | vector.cpp:212:8:212:9 | ref arg ff | TAINT | -| vector.cpp:212:14:212:15 | vs | vector.cpp:212:16:212:16 | call to operator[] | TAINT | | vector.cpp:235:19:235:20 | call to vector | vector.cpp:237:2:237:3 | v1 | | | vector.cpp:235:19:235:20 | call to vector | vector.cpp:241:7:241:8 | v1 | | | vector.cpp:235:19:235:20 | call to vector | vector.cpp:249:13:249:14 | v1 | | @@ -7388,16 +7295,13 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:237:2:237:3 | ref arg v1 | vector.cpp:249:13:249:14 | v1 | | | vector.cpp:237:2:237:3 | ref arg v1 | vector.cpp:249:25:249:26 | v1 | | | vector.cpp:237:2:237:3 | ref arg v1 | vector.cpp:277:1:277:1 | v1 | | -| vector.cpp:237:17:237:17 | 0 | vector.cpp:237:2:237:3 | ref arg v1 | TAINT | | vector.cpp:238:2:238:3 | ref arg v2 | vector.cpp:242:7:242:8 | v2 | | | vector.cpp:238:2:238:3 | ref arg v2 | vector.cpp:277:1:277:1 | v2 | | -| vector.cpp:238:17:238:30 | call to source | vector.cpp:238:2:238:3 | ref arg v2 | TAINT | | vector.cpp:239:2:239:3 | ref arg v3 | vector.cpp:243:7:243:8 | v3 | | | vector.cpp:239:2:239:3 | ref arg v3 | vector.cpp:250:13:250:14 | v3 | | | vector.cpp:239:2:239:3 | ref arg v3 | vector.cpp:250:25:250:26 | v3 | | | vector.cpp:239:2:239:3 | ref arg v3 | vector.cpp:251:8:251:9 | v3 | | | vector.cpp:239:2:239:3 | ref arg v3 | vector.cpp:277:1:277:1 | v3 | | -| vector.cpp:239:15:239:20 | call to source | vector.cpp:239:2:239:3 | ref arg v3 | TAINT | | vector.cpp:241:7:241:8 | ref arg v1 | vector.cpp:249:13:249:14 | v1 | | | vector.cpp:241:7:241:8 | ref arg v1 | vector.cpp:249:25:249:26 | v1 | | | vector.cpp:241:7:241:8 | ref arg v1 | vector.cpp:277:1:277:1 | v1 | | @@ -7420,21 +7324,17 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:249:13:249:14 | ref arg v1 | vector.cpp:249:25:249:26 | v1 | | | vector.cpp:249:13:249:14 | ref arg v1 | vector.cpp:277:1:277:1 | v1 | | | vector.cpp:249:13:249:14 | v1 | vector.cpp:249:16:249:20 | call to begin | TAINT | -| vector.cpp:249:16:249:20 | call to begin | vector.cpp:249:3:249:4 | ref arg v4 | TAINT | | vector.cpp:249:25:249:26 | ref arg v1 | vector.cpp:277:1:277:1 | v1 | | | vector.cpp:249:25:249:26 | v1 | vector.cpp:249:28:249:30 | call to end | TAINT | -| vector.cpp:249:28:249:30 | call to end | vector.cpp:249:3:249:4 | ref arg v4 | TAINT | | vector.cpp:250:3:250:4 | ref arg v5 | vector.cpp:258:8:258:9 | v5 | | | vector.cpp:250:3:250:4 | ref arg v5 | vector.cpp:262:2:262:2 | v5 | | | vector.cpp:250:13:250:14 | ref arg v3 | vector.cpp:250:25:250:26 | v3 | | | vector.cpp:250:13:250:14 | ref arg v3 | vector.cpp:251:8:251:9 | v3 | | | vector.cpp:250:13:250:14 | ref arg v3 | vector.cpp:277:1:277:1 | v3 | | | vector.cpp:250:13:250:14 | v3 | vector.cpp:250:16:250:20 | call to begin | TAINT | -| vector.cpp:250:16:250:20 | call to begin | vector.cpp:250:3:250:4 | ref arg v5 | TAINT | | vector.cpp:250:25:250:26 | ref arg v3 | vector.cpp:251:8:251:9 | v3 | | | vector.cpp:250:25:250:26 | ref arg v3 | vector.cpp:277:1:277:1 | v3 | | | vector.cpp:250:25:250:26 | v3 | vector.cpp:250:28:250:30 | call to end | TAINT | -| vector.cpp:250:28:250:30 | call to end | vector.cpp:250:3:250:4 | ref arg v5 | TAINT | | vector.cpp:251:8:251:9 | ref arg v3 | vector.cpp:277:1:277:1 | v3 | | | vector.cpp:251:8:251:9 | v3 | vector.cpp:251:11:251:15 | call to begin | TAINT | | vector.cpp:251:11:251:15 | call to begin | vector.cpp:251:3:251:17 | ... = ... | | @@ -7455,11 +7355,9 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:254:3:254:4 | ref arg i2 | vector.cpp:260:8:260:9 | i2 | | | vector.cpp:255:3:255:4 | ref arg v6 | vector.cpp:261:8:261:9 | v6 | | | vector.cpp:255:3:255:4 | ref arg v6 | vector.cpp:262:2:262:2 | v6 | | -| vector.cpp:255:13:255:14 | call to iterator | vector.cpp:255:3:255:4 | ref arg v6 | TAINT | | vector.cpp:255:13:255:14 | call to iterator [post update] | vector.cpp:277:1:277:1 | v3 | | | vector.cpp:255:13:255:14 | i1 | vector.cpp:255:13:255:14 | call to iterator | | | vector.cpp:255:13:255:14 | i1 [post update] | vector.cpp:277:1:277:1 | v3 | | -| vector.cpp:255:17:255:18 | call to iterator | vector.cpp:255:3:255:4 | ref arg v6 | TAINT | | vector.cpp:255:17:255:18 | i2 | vector.cpp:255:17:255:18 | call to iterator | | | vector.cpp:257:8:257:9 | ref arg v4 | vector.cpp:262:2:262:2 | v4 | | | vector.cpp:258:8:258:9 | ref arg v5 | vector.cpp:262:2:262:2 | v5 | | @@ -7476,13 +7374,10 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:267:28:267:29 | call to vector | vector.cpp:276:2:276:2 | v9 | | | vector.cpp:269:3:269:4 | ref arg v7 | vector.cpp:273:8:273:9 | v7 | | | vector.cpp:269:3:269:4 | ref arg v7 | vector.cpp:276:2:276:2 | v7 | | -| vector.cpp:269:18:269:31 | call to source | vector.cpp:269:3:269:4 | ref arg v7 | TAINT | | vector.cpp:270:3:270:4 | ref arg v8 | vector.cpp:274:8:274:9 | v8 | | | vector.cpp:270:3:270:4 | ref arg v8 | vector.cpp:276:2:276:2 | v8 | | -| vector.cpp:270:18:270:35 | call to source | vector.cpp:270:3:270:4 | ref arg v8 | TAINT | | vector.cpp:271:3:271:4 | ref arg v9 | vector.cpp:275:8:275:9 | v9 | | | vector.cpp:271:3:271:4 | ref arg v9 | vector.cpp:276:2:276:2 | v9 | | -| vector.cpp:271:18:271:34 | call to source | vector.cpp:271:3:271:4 | ref arg v9 | TAINT | | vector.cpp:273:8:273:9 | ref arg v7 | vector.cpp:276:2:276:2 | v7 | | | vector.cpp:274:8:274:9 | ref arg v8 | vector.cpp:276:2:276:2 | v8 | | | vector.cpp:275:8:275:9 | ref arg v9 | vector.cpp:276:2:276:2 | v9 | | @@ -7500,16 +7395,12 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:284:2:284:3 | ref arg v1 | vector.cpp:286:7:286:8 | v1 | | | vector.cpp:284:2:284:3 | ref arg v1 | vector.cpp:287:7:287:8 | v1 | | | vector.cpp:284:2:284:3 | ref arg v1 | vector.cpp:293:1:293:1 | v1 | | -| vector.cpp:284:15:284:20 | call to source | vector.cpp:284:2:284:3 | ref arg v1 | TAINT | | vector.cpp:285:7:285:8 | ref arg v1 | vector.cpp:286:7:286:8 | v1 | | | vector.cpp:285:7:285:8 | ref arg v1 | vector.cpp:287:7:287:8 | v1 | | | vector.cpp:285:7:285:8 | ref arg v1 | vector.cpp:293:1:293:1 | v1 | | | vector.cpp:286:7:286:8 | ref arg v1 | vector.cpp:287:7:287:8 | v1 | | | vector.cpp:286:7:286:8 | ref arg v1 | vector.cpp:293:1:293:1 | v1 | | -| vector.cpp:286:7:286:8 | v1 | vector.cpp:286:10:286:13 | call to data | TAINT | -| vector.cpp:286:10:286:13 | ref arg call to data | vector.cpp:286:7:286:8 | ref arg v1 | TAINT | | vector.cpp:287:7:287:8 | ref arg v1 | vector.cpp:293:1:293:1 | v1 | | -| vector.cpp:287:7:287:8 | v1 | vector.cpp:287:10:287:13 | call to data | TAINT | | vector.cpp:287:10:287:13 | call to data | vector.cpp:287:7:287:18 | access to array | TAINT | | vector.cpp:287:17:287:17 | 2 | vector.cpp:287:7:287:18 | access to array | TAINT | | vector.cpp:289:2:289:13 | * ... [post update] | vector.cpp:289:7:289:10 | call to data [inner post update] | | @@ -7518,19 +7409,14 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:289:4:289:5 | ref arg v2 | vector.cpp:291:7:291:8 | v2 | | | vector.cpp:289:4:289:5 | ref arg v2 | vector.cpp:292:7:292:8 | v2 | | | vector.cpp:289:4:289:5 | ref arg v2 | vector.cpp:293:1:293:1 | v2 | | -| vector.cpp:289:4:289:5 | v2 | vector.cpp:289:7:289:10 | call to data | TAINT | | vector.cpp:289:7:289:10 | call to data | vector.cpp:289:2:289:13 | * ... | TAINT | -| vector.cpp:289:7:289:10 | call to data [inner post update] | vector.cpp:289:4:289:5 | ref arg v2 | TAINT | | vector.cpp:289:17:289:30 | call to source | vector.cpp:289:2:289:32 | ... = ... | | | vector.cpp:290:7:290:8 | ref arg v2 | vector.cpp:291:7:291:8 | v2 | | | vector.cpp:290:7:290:8 | ref arg v2 | vector.cpp:292:7:292:8 | v2 | | | vector.cpp:290:7:290:8 | ref arg v2 | vector.cpp:293:1:293:1 | v2 | | | vector.cpp:291:7:291:8 | ref arg v2 | vector.cpp:292:7:292:8 | v2 | | | vector.cpp:291:7:291:8 | ref arg v2 | vector.cpp:293:1:293:1 | v2 | | -| vector.cpp:291:7:291:8 | v2 | vector.cpp:291:10:291:13 | call to data | TAINT | -| vector.cpp:291:10:291:13 | ref arg call to data | vector.cpp:291:7:291:8 | ref arg v2 | TAINT | | vector.cpp:292:7:292:8 | ref arg v2 | vector.cpp:293:1:293:1 | v2 | | -| vector.cpp:292:7:292:8 | v2 | vector.cpp:292:10:292:13 | call to data | TAINT | | vector.cpp:292:10:292:13 | call to data | vector.cpp:292:7:292:18 | access to array | TAINT | | vector.cpp:292:17:292:17 | 2 | vector.cpp:292:7:292:18 | access to array | TAINT | | vector.cpp:298:19:298:19 | call to vector | vector.cpp:305:7:305:7 | a | | @@ -7559,8 +7445,6 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:303:2:303:2 | ref arg d | vector.cpp:311:16:311:16 | d | | | vector.cpp:303:2:303:2 | ref arg d | vector.cpp:312:7:312:7 | d | | | vector.cpp:303:2:303:2 | ref arg d | vector.cpp:313:1:313:1 | d | | -| vector.cpp:303:14:303:19 | call to source | vector.cpp:303:2:303:2 | ref arg d | TAINT | -| vector.cpp:305:7:305:7 | a | vector.cpp:305:9:305:14 | call to insert | TAINT | | vector.cpp:305:7:305:7 | ref arg a | vector.cpp:306:7:306:7 | a | | | vector.cpp:305:7:305:7 | ref arg a | vector.cpp:311:25:311:25 | a | | | vector.cpp:305:7:305:7 | ref arg a | vector.cpp:311:36:311:36 | a | | @@ -7575,16 +7459,11 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:305:25:305:25 | b | vector.cpp:305:27:305:31 | call to begin | TAINT | | vector.cpp:305:25:305:25 | ref arg b | vector.cpp:305:36:305:36 | b | | | vector.cpp:305:25:305:25 | ref arg b | vector.cpp:313:1:313:1 | b | | -| vector.cpp:305:27:305:31 | call to begin | vector.cpp:305:7:305:7 | ref arg a | TAINT | -| vector.cpp:305:27:305:31 | call to begin | vector.cpp:305:9:305:14 | call to insert | TAINT | | vector.cpp:305:36:305:36 | b | vector.cpp:305:38:305:40 | call to end | TAINT | | vector.cpp:305:36:305:36 | ref arg b | vector.cpp:313:1:313:1 | b | | -| vector.cpp:305:38:305:40 | call to end | vector.cpp:305:7:305:7 | ref arg a | TAINT | -| vector.cpp:305:38:305:40 | call to end | vector.cpp:305:9:305:14 | call to insert | TAINT | | vector.cpp:306:7:306:7 | ref arg a | vector.cpp:311:25:311:25 | a | | | vector.cpp:306:7:306:7 | ref arg a | vector.cpp:311:36:311:36 | a | | | vector.cpp:306:7:306:7 | ref arg a | vector.cpp:313:1:313:1 | a | | -| vector.cpp:308:7:308:7 | c | vector.cpp:308:9:308:14 | call to insert | TAINT | | vector.cpp:308:7:308:7 | ref arg c | vector.cpp:309:7:309:7 | c | | | vector.cpp:308:7:308:7 | ref arg c | vector.cpp:313:1:313:1 | c | | | vector.cpp:308:16:308:16 | c | vector.cpp:308:18:308:20 | call to end | TAINT | @@ -7598,17 +7477,12 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:308:25:308:25 | ref arg d | vector.cpp:311:16:311:16 | d | | | vector.cpp:308:25:308:25 | ref arg d | vector.cpp:312:7:312:7 | d | | | vector.cpp:308:25:308:25 | ref arg d | vector.cpp:313:1:313:1 | d | | -| vector.cpp:308:27:308:31 | call to begin | vector.cpp:308:7:308:7 | ref arg c | TAINT | -| vector.cpp:308:27:308:31 | call to begin | vector.cpp:308:9:308:14 | call to insert | TAINT | | vector.cpp:308:36:308:36 | d | vector.cpp:308:38:308:40 | call to end | TAINT | | vector.cpp:308:36:308:36 | ref arg d | vector.cpp:311:7:311:7 | d | | | vector.cpp:308:36:308:36 | ref arg d | vector.cpp:311:16:311:16 | d | | | vector.cpp:308:36:308:36 | ref arg d | vector.cpp:312:7:312:7 | d | | | vector.cpp:308:36:308:36 | ref arg d | vector.cpp:313:1:313:1 | d | | -| vector.cpp:308:38:308:40 | call to end | vector.cpp:308:7:308:7 | ref arg c | TAINT | -| vector.cpp:308:38:308:40 | call to end | vector.cpp:308:9:308:14 | call to insert | TAINT | | vector.cpp:309:7:309:7 | ref arg c | vector.cpp:313:1:313:1 | c | | -| vector.cpp:311:7:311:7 | d | vector.cpp:311:9:311:14 | call to insert | TAINT | | vector.cpp:311:7:311:7 | ref arg d | vector.cpp:312:7:312:7 | d | | | vector.cpp:311:7:311:7 | ref arg d | vector.cpp:313:1:313:1 | d | | | vector.cpp:311:16:311:16 | d | vector.cpp:311:18:311:20 | call to end | TAINT | @@ -7619,12 +7493,8 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:311:25:311:25 | a | vector.cpp:311:27:311:31 | call to begin | TAINT | | vector.cpp:311:25:311:25 | ref arg a | vector.cpp:311:36:311:36 | a | | | vector.cpp:311:25:311:25 | ref arg a | vector.cpp:313:1:313:1 | a | | -| vector.cpp:311:27:311:31 | call to begin | vector.cpp:311:7:311:7 | ref arg d | TAINT | -| vector.cpp:311:27:311:31 | call to begin | vector.cpp:311:9:311:14 | call to insert | TAINT | | vector.cpp:311:36:311:36 | a | vector.cpp:311:38:311:40 | call to end | TAINT | | vector.cpp:311:36:311:36 | ref arg a | vector.cpp:313:1:313:1 | a | | -| vector.cpp:311:38:311:40 | call to end | vector.cpp:311:7:311:7 | ref arg d | TAINT | -| vector.cpp:311:38:311:40 | call to end | vector.cpp:311:9:311:14 | call to insert | TAINT | | vector.cpp:312:7:312:7 | ref arg d | vector.cpp:313:1:313:1 | d | | | vector.cpp:316:19:316:20 | call to vector | vector.cpp:320:22:320:23 | v1 | | | vector.cpp:316:19:316:20 | call to vector | vector.cpp:320:34:320:35 | v1 | | @@ -7639,29 +7509,24 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:318:2:318:3 | ref arg v2 | vector.cpp:321:34:321:35 | v2 | | | vector.cpp:318:2:318:3 | ref arg v2 | vector.cpp:324:7:324:8 | v2 | | | vector.cpp:318:2:318:3 | ref arg v2 | vector.cpp:327:1:327:1 | v2 | | -| vector.cpp:318:15:318:20 | call to source | vector.cpp:318:2:318:3 | ref arg v2 | TAINT | | vector.cpp:320:22:320:23 | ref arg v1 | vector.cpp:320:34:320:35 | v1 | | | vector.cpp:320:22:320:23 | ref arg v1 | vector.cpp:323:7:323:8 | v1 | | | vector.cpp:320:22:320:23 | ref arg v1 | vector.cpp:327:1:327:1 | v1 | | | vector.cpp:320:22:320:23 | v1 | vector.cpp:320:25:320:29 | call to begin | TAINT | | vector.cpp:320:22:320:42 | call to vector | vector.cpp:325:7:325:8 | v3 | | | vector.cpp:320:22:320:42 | call to vector | vector.cpp:327:1:327:1 | v3 | | -| vector.cpp:320:25:320:29 | call to begin | vector.cpp:320:22:320:42 | call to vector | TAINT | | vector.cpp:320:34:320:35 | ref arg v1 | vector.cpp:323:7:323:8 | v1 | | | vector.cpp:320:34:320:35 | ref arg v1 | vector.cpp:327:1:327:1 | v1 | | | vector.cpp:320:34:320:35 | v1 | vector.cpp:320:37:320:39 | call to end | TAINT | -| vector.cpp:320:37:320:39 | call to end | vector.cpp:320:22:320:42 | call to vector | TAINT | | vector.cpp:321:22:321:23 | ref arg v2 | vector.cpp:321:34:321:35 | v2 | | | vector.cpp:321:22:321:23 | ref arg v2 | vector.cpp:324:7:324:8 | v2 | | | vector.cpp:321:22:321:23 | ref arg v2 | vector.cpp:327:1:327:1 | v2 | | | vector.cpp:321:22:321:23 | v2 | vector.cpp:321:25:321:29 | call to begin | TAINT | | vector.cpp:321:22:321:42 | call to vector | vector.cpp:326:7:326:8 | v4 | | | vector.cpp:321:22:321:42 | call to vector | vector.cpp:327:1:327:1 | v4 | | -| vector.cpp:321:25:321:29 | call to begin | vector.cpp:321:22:321:42 | call to vector | TAINT | | vector.cpp:321:34:321:35 | ref arg v2 | vector.cpp:324:7:324:8 | v2 | | | vector.cpp:321:34:321:35 | ref arg v2 | vector.cpp:327:1:327:1 | v2 | | | vector.cpp:321:34:321:35 | v2 | vector.cpp:321:37:321:39 | call to end | TAINT | -| vector.cpp:321:37:321:39 | call to end | vector.cpp:321:22:321:42 | call to vector | TAINT | | vector.cpp:323:7:323:8 | ref arg v1 | vector.cpp:327:1:327:1 | v1 | | | vector.cpp:324:7:324:8 | ref arg v2 | vector.cpp:327:1:327:1 | v2 | | | vector.cpp:325:7:325:8 | ref arg v3 | vector.cpp:327:1:327:1 | v3 | | @@ -8099,9 +7964,7 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:472:10:472:14 | ref arg & ... | vector.cpp:472:12:472:12 | call to operator[] [inner post update] | | | vector.cpp:472:11:472:11 | ref arg v | vector.cpp:473:8:473:8 | v | | | vector.cpp:472:11:472:11 | ref arg v | vector.cpp:474:2:474:2 | v | | -| vector.cpp:472:11:472:11 | v | vector.cpp:472:12:472:12 | call to operator[] | TAINT | | vector.cpp:472:12:472:12 | call to operator[] | vector.cpp:472:10:472:14 | & ... | | -| vector.cpp:472:12:472:12 | call to operator[] [inner post update] | vector.cpp:472:11:472:11 | ref arg v | TAINT | | vector.cpp:472:17:472:18 | & ... | vector.cpp:472:3:472:8 | call to memcpy | TAINT | | vector.cpp:472:17:472:18 | & ... | vector.cpp:472:10:472:14 | ref arg & ... | TAINT | | vector.cpp:472:18:472:18 | s | vector.cpp:472:10:472:14 | ref arg & ... | | @@ -8124,11 +7987,9 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:483:8:483:9 | ref arg cs | vector.cpp:487:2:487:2 | cs | | | vector.cpp:484:10:484:22 | & ... | vector.cpp:484:3:484:8 | call to memcpy | | | vector.cpp:484:10:484:22 | ref arg & ... | vector.cpp:484:13:484:13 | call to operator[] [inner post update] | | -| vector.cpp:484:11:484:12 | cs | vector.cpp:484:13:484:13 | call to operator[] | TAINT | | vector.cpp:484:11:484:12 | ref arg cs | vector.cpp:486:8:486:9 | cs | | | vector.cpp:484:11:484:12 | ref arg cs | vector.cpp:487:2:487:2 | cs | | | vector.cpp:484:13:484:13 | call to operator[] | vector.cpp:484:10:484:22 | & ... | | -| vector.cpp:484:13:484:13 | call to operator[] [inner post update] | vector.cpp:484:11:484:12 | ref arg cs | TAINT | | vector.cpp:484:14:484:17 | offs | vector.cpp:484:14:484:21 | ... + ... | TAINT | | vector.cpp:484:21:484:21 | 1 | vector.cpp:484:14:484:21 | ... + ... | TAINT | | vector.cpp:484:25:484:27 | src | vector.cpp:484:29:484:33 | call to c_str | TAINT | @@ -8144,7 +8005,6 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:491:30:491:32 | call to vector | vector.cpp:498:1:498:1 | v2 | | | vector.cpp:493:2:493:3 | ref arg v1 | vector.cpp:494:7:494:8 | v1 | | | vector.cpp:493:2:493:3 | ref arg v1 | vector.cpp:498:1:498:1 | v1 | | -| vector.cpp:493:18:493:23 | call to source | vector.cpp:493:2:493:3 | ref arg v1 | TAINT | | vector.cpp:494:7:494:8 | ref arg v1 | vector.cpp:498:1:498:1 | v1 | | | vector.cpp:496:2:496:3 | ref arg v2 | vector.cpp:497:7:497:8 | v2 | | | vector.cpp:496:2:496:3 | ref arg v2 | vector.cpp:498:1:498:1 | v2 | | @@ -8153,8 +8013,6 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:496:13:496:14 | ref arg v2 | vector.cpp:498:1:498:1 | v2 | | | vector.cpp:496:13:496:14 | v2 | vector.cpp:496:16:496:20 | call to begin | TAINT | | vector.cpp:496:16:496:20 | call to begin | vector.cpp:496:13:496:22 | call to iterator | TAINT | -| vector.cpp:496:25:496:30 | call to source | vector.cpp:496:2:496:3 | ref arg v2 | TAINT | -| vector.cpp:496:25:496:30 | call to source | vector.cpp:496:5:496:11 | call to emplace | TAINT | | vector.cpp:497:7:497:8 | ref arg v2 | vector.cpp:498:1:498:1 | v2 | | | vector.cpp:503:18:503:21 | {...} | vector.cpp:506:8:506:9 | as | | | vector.cpp:503:18:503:21 | {...} | vector.cpp:507:8:507:9 | as | | @@ -8185,16 +8043,13 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:520:25:520:31 | call to vector | vector.cpp:526:8:526:9 | vs | | | vector.cpp:520:25:520:31 | call to vector | vector.cpp:532:8:532:9 | vs | | | vector.cpp:520:25:520:31 | call to vector | vector.cpp:533:2:533:2 | vs | | -| vector.cpp:520:30:520:30 | 0 | vector.cpp:520:25:520:31 | call to vector | TAINT | | vector.cpp:523:8:523:9 | ref arg vs | vector.cpp:524:8:524:9 | vs | | | vector.cpp:523:8:523:9 | ref arg vs | vector.cpp:526:8:526:9 | vs | | | vector.cpp:523:8:523:9 | ref arg vs | vector.cpp:532:8:532:9 | vs | | | vector.cpp:523:8:523:9 | ref arg vs | vector.cpp:533:2:533:2 | vs | | -| vector.cpp:523:8:523:9 | vs | vector.cpp:523:10:523:10 | call to operator[] | TAINT | | vector.cpp:524:8:524:9 | ref arg vs | vector.cpp:526:8:526:9 | vs | | | vector.cpp:524:8:524:9 | ref arg vs | vector.cpp:532:8:532:9 | vs | | | vector.cpp:524:8:524:9 | ref arg vs | vector.cpp:533:2:533:2 | vs | | -| vector.cpp:524:8:524:9 | vs | vector.cpp:524:10:524:10 | call to operator[] | TAINT | | vector.cpp:526:8:526:9 | ref arg vs | vector.cpp:532:8:532:9 | vs | | | vector.cpp:526:8:526:9 | ref arg vs | vector.cpp:533:2:533:2 | vs | | | vector.cpp:526:8:526:9 | vs | vector.cpp:526:11:526:15 | call to begin | TAINT | @@ -8222,7 +8077,6 @@ WARNING: Module TaintTracking has been deprecated and may be removed in future ( | vector.cpp:530:9:530:14 | call to source | vector.cpp:530:3:530:4 | ref arg it | TAINT | | vector.cpp:531:9:531:10 | it | vector.cpp:531:8:531:8 | call to operator* | TAINT | | vector.cpp:532:8:532:9 | ref arg vs | vector.cpp:533:2:533:2 | vs | | -| vector.cpp:532:8:532:9 | vs | vector.cpp:532:10:532:10 | call to operator[] | TAINT | | zmq.cpp:17:21:17:26 | socket | zmq.cpp:17:21:17:26 | socket | | | zmq.cpp:17:35:17:46 | message_data | zmq.cpp:17:35:17:46 | message_data | | | zmq.cpp:17:35:17:46 | message_data | zmq.cpp:20:35:20:46 | message_data | | diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/vector.cpp b/cpp/ql/test/library-tests/dataflow/taint-tests/vector.cpp index c26eef5176ce..a5e0c428b710 100644 --- a/cpp/ql/test/library-tests/dataflow/taint-tests/vector.cpp +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/vector.cpp @@ -17,20 +17,20 @@ void test_range_based_for_loop_vector(int source1) { std::vector v(100, source1); for(int x : v) { - sink(x); // $ ast,ir + sink(x); // $ ir MISSING:ast } for(std::vector::iterator it = v.begin(); it != v.end(); ++it) { - sink(*it); // $ ast,ir + sink(*it); // $ ir MISSING:ast } for(int& x : v) { - sink(x); // $ ast,ir + sink(x); // $ ir MISSING:ast } const std::vector const_v(100, source1); for(const int& x : const_v) { - sink(x); // $ ast,ir + sink(x); // $ ir MISSING:ast } } @@ -49,40 +49,40 @@ void test_element_taint(int x) { sink(v1.back()); v2[0] = source(); - sink(v2); // $ ast,ir - sink(v2[0]); // $ ast,ir - sink(v2[1]); // $ SPURIOUS: ast,ir - sink(v2[x]); // $ ast,ir + sink(v2); // $ ir MISSING:ast + sink(v2[0]); // $ ir MISSING:ast + sink(v2[1]); // $ SPURIOUS: ir + sink(v2[x]); // $ ir MISSING:ast v3 = v2; - sink(v3); // $ ast,ir - sink(v3[0]); // $ ast,ir - sink(v3[1]); // $ SPURIOUS: ast,ir - sink(v3[x]); // $ ast,ir + sink(v3); // $ ir MISSING:ast + sink(v3[0]); // $ ir MISSING:ast + sink(v3[1]); // $ SPURIOUS: ir + sink(v3[x]); // $ ir MISSING:ast v4[x] = source(); - sink(v4); // $ ast,ir - sink(v4[0]); // $ ast,ir - sink(v4[1]); // $ ast,ir - sink(v4[x]); // $ ast,ir + sink(v4); // $ ir MISSING:ast + sink(v4[0]); // $ ir MISSING:ast + sink(v4[1]); // $ ir MISSING:ast + sink(v4[x]); // $ ir MISSING:ast v5.push_back(source()); - sink(v5); // $ ast,ir - sink(v5.front()); // $ SPURIOUS: ast,ir - sink(v5.back()); // $ ast,ir + sink(v5); // $ ir MISSING:ast + sink(v5.front()); // $ SPURIOUS: ir + sink(v5.back()); // $ ir MISSING:ast v6.data()[2] = source(); - sink(v6); // $ ast,ir - sink(v6.data()[2]); // $ ast,ir + sink(v6); // $ ir MISSING:ast + sink(v6.data()[2]); // $ ir MISSING:ast { std::vector::const_iterator it = v7.begin(); v7.insert(it, source()); } - sink(v7); // $ ast,ir - sink(v7.front()); // $ ast,ir - sink(v7.back()); // $ SPURIOUS: ast,ir + sink(v7); // $ ir MISSING:ast + sink(v7.front()); // $ ir MISSING:ast + sink(v7.back()); // $ SPURIOUS: ir { const std::vector &v8c = v8; @@ -94,10 +94,10 @@ void test_element_taint(int x) { sink(v8.back()); // $ MISSING: ast,ir v9.at(x) = source(); - sink(v9); // $ ast,ir - sink(v9.at(0)); // $ ast,ir - sink(v9.at(1)); // $ ast,ir - sink(v9.at(x)); // $ ast,ir + sink(v9); // $ ir MISSING:ast + sink(v9.at(0)); // $ ir MISSING:ast + sink(v9.at(1)); // $ ir MISSING:ast + sink(v9.at(x)); // $ ir MISSING:ast } void test_vector_swap() { @@ -106,18 +106,18 @@ void test_vector_swap() { v1.push_back(source()); v4.push_back(source()); - sink(v1); // $ ast,ir + sink(v1); // $ ir MISSING:ast sink(v2); sink(v3); - sink(v4); // $ ast,ir + sink(v4); // $ ir MISSING:ast v1.swap(v2); v3.swap(v4); - sink(v1); // $ SPURIOUS: ast - sink(v2); // $ ast,ir - sink(v3); // $ ast,ir - sink(v4); // $ SPURIOUS: ast + sink(v1); + sink(v2); // $ ir MISSING:ast + sink(v3); // $ ir MISSING:ast + sink(v4); } void test_vector_clear() { @@ -127,18 +127,18 @@ void test_vector_clear() { v2.push_back(source()); v3.push_back(source()); - sink(v1); // $ ast,ir - sink(v2); // $ ast,ir - sink(v3); // $ ast,ir + sink(v1); // $ ir MISSING:ast + sink(v2); // $ ir MISSING:ast + sink(v3); // $ ir MISSING:ast sink(v4); v1.clear(); v2 = v2; v3 = v4; - sink(v1); // $ SPURIOUS: ast,ir - sink(v2); // $ ast,ir - sink(v3); // $ SPURIOUS: ast + sink(v1); // $ SPURIOUS: ir + sink(v2); // $ ir MISSING:ast + sink(v3); sink(v4); } @@ -159,7 +159,7 @@ void test_nested_vectors() sink(aa[0][0]); aa[0][0] = source(); - sink(aa[0][0]); // $ ast,ir + sink(aa[0][0]); // $ ir,ast } { @@ -168,7 +168,7 @@ void test_nested_vectors() bb[0].push_back(0); sink(bb[0][0]); bb[0][0] = source(); - sink(bb[0][0]); // $ ast,ir + sink(bb[0][0]); // $ ir MISSING:ast } { @@ -177,7 +177,7 @@ void test_nested_vectors() cc[0].push_back(0); sink(cc[0][0]); cc[0][0] = source(); - sink(cc[0][0]); // $ ast,ir + sink(cc[0][0]); // $ ir MISSING:ast } { @@ -188,7 +188,7 @@ void test_nested_vectors() sink(dd[0].a); sink(dd[0].b); dd[0].a = source(); - sink(dd[0].a); // $ MISSING: ast,ir + sink(dd[0].a); // $ ir MISSING: ast sink(dd[0].b); } @@ -198,7 +198,7 @@ void test_nested_vectors() ee.vs.push_back(0); sink(ee.vs[0]); ee.vs[0] = source(); - sink(ee.vs[0]); // $ ast,ir + sink(ee.vs[0]); // $ ir MISSING:ast } { @@ -209,7 +209,7 @@ void test_nested_vectors() ff.push_back(mvc); sink(ff[0].vs[0]); ff[0].vs[0] = source(); - sink(ff[0].vs[0]); // $ MISSING: ast,ir + sink(ff[0].vs[0]); // $ ir MISSING: ast } } @@ -239,8 +239,8 @@ void test_vector_assign() { v3.push_back(source()); sink(v1); - sink(v2); // $ ast,ir - sink(v3); // $ ast,ir + sink(v2); // $ ir MISSING:ast + sink(v3); // $ ir MISSING:ast { std::vector v4, v5, v6; @@ -255,10 +255,10 @@ void test_vector_assign() { v6.assign(i1, i2); sink(v4); - sink(v5); // $ ast,ir - sink(i1); // $ ast,ir - sink(i2); // $ ast,ir - sink(v6); // $ ast,ir + sink(v5); // $ ir MISSING:ast + sink(i1); // $ ir MISSING:ast + sink(i2); // $ ir MISSING:ast + sink(v6); // $ ir MISSING:ast } { @@ -270,9 +270,9 @@ void test_vector_assign() { v8.assign(100, ns_myFloat::source()); v9.assign(100, ns_ci_ptr::source()); - sink(v7); // $ ast,ir - sink(v8); // $ ast,ir - sink(v9); // $ ast,ir + sink(v7); // $ ir MISSING:ast + sink(v8); // $ ir MISSING:ast + sink(v9); // $ ir MISSING:ast } } @@ -282,14 +282,14 @@ void test_data_more() { std::vector v1, v2; v1.push_back(source()); - sink(v1); // $ ast,ir - sink(v1.data()); // $ ast,ir - sink(v1.data()[2]); // $ ast,ir + sink(v1); // $ ir MISSING:ast + sink(v1.data()); // $ ir MISSING:ast + sink(v1.data()[2]); // $ ir MISSING:ast *(v2.data()) = ns_int::source(); - sink(v2); // $ ast,ir - sink(v2.data()); // $ ast,ir - sink(v2.data()[2]); // $ ast,ir + sink(v2); // $ ir + sink(v2.data()); // $ ir MISSING:ast + sink(v2.data()[2]); // $ ir MISSING:ast } void sink(std::vector::iterator); @@ -305,11 +305,11 @@ void test_vector_insert() { sink(a.insert(a.end(), b.begin(), b.end())); sink(a); - sink(c.insert(c.end(), d.begin(), d.end())); // $ ast,ir - sink(c); // $ ast,ir + sink(c.insert(c.end(), d.begin(), d.end())); // $ ir MISSING:ast + sink(c); // $ ir MISSING:ast - sink(d.insert(d.end(), a.begin(), a.end())); // $ ast,ir - sink(d); // $ ast,ir + sink(d.insert(d.end(), a.begin(), a.end())); // $ ir MISSING:ast + sink(d); // $ ir MISSING:ast } void test_vector_constructors_more() { @@ -321,9 +321,9 @@ void test_vector_constructors_more() { std::vector v4(v2.begin(), v2.end()); sink(v1); - sink(v2); // $ ast,ir + sink(v2); // $ ir MISSING:ast sink(v3); - sink(v4); // $ ast,ir + sink(v4); // $ ir MISSING:ast } void taint_vector_output_iterator(std::vector::iterator iter) { @@ -339,12 +339,12 @@ void test_vector_output_iterator(int b) { std::vector::iterator i1 = v1.begin(); *i1 = source(); - sink(v1); // $ ast,ir + sink(v1); // $ ir,ast for(std::vector::iterator it = v2.begin(); it != v2.end(); ++it) { *it = source(); } - sink(v2); // $ ast,ir + sink(v2); // $ ir,ast for(int& x : v3) { x = source(); @@ -358,29 +358,29 @@ void test_vector_output_iterator(int b) { std::vector::iterator i5 = v5.begin(); *i5 = source(); - sink(v5); // $ ast,ir + sink(v5); // $ ir,ast *i5 = 1; - sink(v5); // $ ast,ir + sink(v5); // $ ir,ast std::vector::iterator i6 = v6.begin(); *i6 = source(); - sink(v6); // $ ast,ir + sink(v6); // $ ir,ast v6 = std::vector(10); sink(v6); // $ SPURIOUS: ast,ir std::vector::iterator i7 = v7.begin(); if(b) { *i7 = source(); - sink(v7); // $ ast,ir + sink(v7); // $ ir,ast } else { *i7 = 1; sink(v7); } - sink(v7); // $ ast,ir + sink(v7); // $ ir,ast std::vector::iterator i8 = v8.begin(); *i8 = source(); - sink(v8); // $ ast,ir + sink(v8); // $ ir,ast *i8 = 1; sink(v8); // $ SPURIOUS: ast,ir @@ -402,16 +402,16 @@ void test_vector_output_iterator(int b) { std::vector::iterator i12 = v12.begin(); *i12++ = 0; *i12 = source(); - sink(v12); // $ ast,ir + sink(v12); // $ ir,ast std::vector::iterator i13 = v13.begin(); *i13++ = source(); - sink(v13); // $ ast,ir + sink(v13); // $ ir,ast std::vector::iterator i14 = v14.begin(); i14++; *i14++ = source(); - sink(v14); // $ ast,ir + sink(v14); // $ ir,ast } void test_vector_inserter(char *source_string) { @@ -419,28 +419,28 @@ void test_vector_inserter(char *source_string) { std::vector out; auto it = out.end(); *it++ = std::string(source_string); - sink(out); // $ ast,ir + sink(out); // $ ir,ast } { std::vector out; auto it = std::back_inserter(out); *it++ = std::string(source_string); - sink(out); // $ ast,ir + sink(out); // $ ir,ast } { std::vector out; auto it = std::back_inserter(out); *it++ = source(); - sink(out); // $ ast,ir + sink(out); // $ ir,ast } { std::vector out; auto it = std::back_inserter(out); *++it = std::string(source_string); - sink(out); // $ ast,ir + sink(out); // $ ir,ast } { @@ -470,7 +470,7 @@ void test_vector_memcpy() sink(v); memcpy(&v[i], &s, sizeof(int)); - sink(v); // $ ast,ir + sink(v); // $ ir MISSING: ast } { @@ -483,7 +483,7 @@ void test_vector_memcpy() sink(cs); memcpy(&cs[offs + 1], src.c_str(), len); sink(src); // $ ast,ir - sink(cs); // $ ast,ir + sink(cs); // $ ir MISSING: ast } } @@ -491,10 +491,10 @@ void test_vector_emplace() { std::vector v1(10), v2(10); v1.emplace_back(source()); - sink(v1); // $ ast,ir + sink(v1); // $ ir MISSING: ast v2.emplace(v2.begin(), source()); - sink(v2); // $ ast,ir + sink(v2); // $ ir MISSING: ast } void test_vector_iterator() { From 3e9862391b359fec0ec64f5d5d6d7216d6cdfbdc Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 17:56:28 +0100 Subject: [PATCH 10/33] C++: No need for 'decodeUnknownContent' if we specify the MaD summary rows correctly. This avoids a bad join in a compiler-generated predicate. --- .../cpp/dataflow/internal/FlowSummaryImpl.qll | 23 ++---------------- .../dataflow/models-as-data/testModels.qll | 24 +++++++++---------- 2 files changed, 14 insertions(+), 33 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll index 2077f2067aad..dc8e8aaa3143 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/internal/FlowSummaryImpl.qll @@ -45,12 +45,12 @@ module Input implements InputSig { string encodeWithoutContent(ContentSet c, string arg) { // used for type tracking, not currently used in C/C++. - result = "WithoutContent" + c and arg = "" + none() } string encodeWithContent(ContentSet c, string arg) { // used for type tracking, not currently used in C/C++. - result = "WithContent" + c and arg = "" + none() } /** @@ -85,25 +85,6 @@ module Input implements InputSig { token.getName() = "Parameter" and result = decodePosition(token.getAnArgument()) } - - bindingset[token] - ContentSet decodeUnknownContent(AccessPath::AccessPathTokenBase token) { - // field content (no indirection support) - exists(FieldContent c | - result.isSingleton(c) and - token.getName() = c.getField().getName() and - not exists(token.getArgumentList()) and - c.getIndirectionIndex() = 1 - ) - or - // field content (with indirection support) - exists(FieldContent c | - result.isSingleton(c) and - token.getName() = c.getField().getName() and - // FieldContent indices have 0 for the address, 1 for content, so we need to subtract one. - token.getAnArgument() = repeatStars(c.getIndirectionIndex() - 1) - ) - } } private import Make as Impl diff --git a/cpp/ql/test/library-tests/dataflow/models-as-data/testModels.qll b/cpp/ql/test/library-tests/dataflow/models-as-data/testModels.qll index 1d8f463c252e..562fd298060a 100644 --- a/cpp/ql/test/library-tests/dataflow/models-as-data/testModels.qll +++ b/cpp/ql/test/library-tests/dataflow/models-as-data/testModels.qll @@ -80,22 +80,22 @@ private class TestSummaries extends SummaryModelCsv { ";;false;madArgsComplex;;;Argument[*0..1,2];ReturnValue;taint", ";;false;madAndImplementedComplex;;;Argument[2];ReturnValue;taint", ";;false;madArgsAny;;;Argument;ReturnValue;taint", // (syntax not supported) - ";;false;madArg0FieldToReturn;;;Argument[0].value;ReturnValue;taint", - ";;false;madArg0IndirectFieldToReturn;;;Argument[*0].value;ReturnValue;taint", - ";;false;madArg0FieldIndirectToReturn;;;Argument[0].ptr[*];ReturnValue;taint", - ";;false;madArg0ToReturnField;;;Argument[0];ReturnValue.value;taint", - ";;false;madArg0ToReturnIndirectField;;;Argument[0];ReturnValue[*].value;taint", - ";;false;madArg0ToReturnFieldIndirect;;;Argument[0];ReturnValue.ptr[*];taint", - ";;false;madFieldToFieldVar;;;value;value2;taint", - ";;false;madFieldToIndirectFieldVar;;;value;ptr[*];taint", - ";;false;madIndirectFieldToFieldVar;;;;value;value2;taint", // not correctly expressed + ";;false;madArg0FieldToReturn;;;Argument[0].Field[value];ReturnValue;taint", + ";;false;madArg0IndirectFieldToReturn;;;Argument[*0].Field[value];ReturnValue;taint", + ";;false;madArg0FieldIndirectToReturn;;;Argument[0].Field[*ptr];ReturnValue;taint", + ";;false;madArg0ToReturnField;;;Argument[0];ReturnValue.Field[value];taint", + ";;false;madArg0ToReturnIndirectField;;;Argument[0];ReturnValue[*].Field[value];taint", + ";;false;madArg0ToReturnFieldIndirect;;;Argument[0];ReturnValue.Field[*ptr];taint", + ";;false;madFieldToFieldVar;;;Field[value];Field[value2];taint", + ";;false;madFieldToIndirectFieldVar;;;Field[value];Field[*ptr];taint", + ";;false;madIndirectFieldToFieldVar;;;;Field[value];Field[value2];taint", // not correctly expressed ";MyClass;true;madArg0ToSelf;;;Argument[0];Argument[-1];taint", ";MyClass;true;madSelfToReturn;;;Argument[-1];ReturnValue;taint", - ";MyClass;true;madArg0ToField;;;Argument[0];Argument[-1].val;taint", - ";MyClass;true;madFieldToReturn;;;Argument[-1].val;ReturnValue;taint", + ";MyClass;true;madArg0ToField;;;Argument[0];Argument[-1].Field[val];taint", + ";MyClass;true;madFieldToReturn;;;Argument[-1].Field[val];ReturnValue;taint", "MyNamespace;MyClass;true;namespaceMadSelfToReturn;;;Argument[-1];ReturnValue;taint", ";;false;madCallArg0ReturnToReturn;;;Argument[0].ReturnValue;ReturnValue;value", - ";;false;madCallArg0ReturnToReturnFirst;;;Argument[0].ReturnValue;ReturnValue.first;value", + ";;false;madCallArg0ReturnToReturnFirst;;;Argument[0].ReturnValue;ReturnValue.Field[first];value", ";;false;madCallArg0WithValue;;;Argument[1];Argument[0].Parameter[0];value", ";;false;madCallReturnValueIgnoreFunction;;;Argument[1];ReturnValue;value", ] From f507b5117070ff3fecca6a135ca8c770c0a61f9d Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 19:17:01 +0100 Subject: [PATCH 11/33] C++: Fix Code Scanning errors. --- .../semmle/code/cpp/dataflow/ExternalFlow.qll | 4 +-- .../models/implementations/StdContainer.qll | 31 ------------------- 2 files changed, 2 insertions(+), 33 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index 0bf707fd6e1a..1cf2ad1699f8 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -197,7 +197,7 @@ private predicate summaryModel0( } /** - * Holds if `input` is `input0`, but with all occurences of `@` replaced + * Holds if `input` is `input0`, but with all occurrences of `@` replaced * by `n` repetitions of `*` (and similarly for `output` and `output0`). */ bindingset[input0, output0, n] @@ -701,7 +701,7 @@ private predicate hasClassAndName(Class classWithMethod, Function method, string } /** - * Holds if `nameClass` is in namespace `namespace` and has + * Holds if `namedClass` is in namespace `namespace` and has * name `type` (excluding any template parameters). */ bindingset[type, namespace] diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll index 63605a188cfd..bf9e05991b4c 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll @@ -55,37 +55,6 @@ private class Vector extends StdSequenceContainer { Vector() { this.hasQualifiedName(["std", "bsl"], "vector") } } -/** - * Additional model for standard container constructors that reference the - * value type of the container (that is, the `T` in `std::vector`). For - * example the fill constructor: - * ``` - * std::vector v(100, potentially_tainted_string); - * ``` - */ -private class StdSequenceContainerConstructor extends Constructor { - StdSequenceContainerConstructor() { - this.getDeclaringType() instanceof Vector or - this.getDeclaringType() instanceof Deque or - this.getDeclaringType() instanceof List or - this.getDeclaringType() instanceof ForwardList - } - - /** - * Gets the index of a parameter to this function that is a reference to the - * value type of the container. - */ - int getAValueTypeParameterIndex() { - this.getParameter(result).getUnspecifiedType().(ReferenceType).getBaseType() = - this.getDeclaringType().getTemplateArgument(0).(Type).getUnspecifiedType() // i.e. the `T` of this `std::vector` - } - - /** - * Gets the index of a parameter to this function that is an iterator. - */ - int getAnIteratorParameterIndex() { this.getParameter(result).getType() instanceof Iterator } -} - /** * The standard container functions `push_back` and `push_front`. */ From c8f3c1a7981a1bee5bea22bca42f154c6318fb0a Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 19 Jun 2024 19:18:59 +0100 Subject: [PATCH 12/33] C++: Accept test changes. Nothing exciting to see here. --- .../syntax-zoo/dataflow-ir-consistency.expected | 4 ++-- .../CWE-497/semmle/tests/ExposedSystemData.expected | 10 +++++----- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/cpp/ql/test/library-tests/syntax-zoo/dataflow-ir-consistency.expected b/cpp/ql/test/library-tests/syntax-zoo/dataflow-ir-consistency.expected index c9fd8e3dbbe8..e154e42247be 100644 --- a/cpp/ql/test/library-tests/syntax-zoo/dataflow-ir-consistency.expected +++ b/cpp/ql/test/library-tests/syntax-zoo/dataflow-ir-consistency.expected @@ -29,8 +29,8 @@ postWithInFlow | try_catch.cpp:7:8:7:8 | call to exception | PostUpdateNode should not be the target of local flow. | viableImplInCallContextTooLarge uniqueParameterNodeAtPosition -| ir.cpp:726:6:726:13 | TryCatch | 0 indirection | ir.cpp:737:22:737:22 | *s | Parameters with overlapping positions. | -| ir.cpp:726:6:726:13 | TryCatch | 0 indirection | ir.cpp:740:24:740:24 | *e | Parameters with overlapping positions. | +| ir.cpp:726:6:726:13 | TryCatch | *0 | ir.cpp:737:22:737:22 | *s | Parameters with overlapping positions. | +| ir.cpp:726:6:726:13 | TryCatch | *0 | ir.cpp:740:24:740:24 | *e | Parameters with overlapping positions. | uniqueParameterNodePosition uniqueContentApprox identityLocalStep diff --git a/cpp/ql/test/query-tests/Security/CWE/CWE-497/semmle/tests/ExposedSystemData.expected b/cpp/ql/test/query-tests/Security/CWE/CWE-497/semmle/tests/ExposedSystemData.expected index 802546c92e51..4ae072c6ce48 100644 --- a/cpp/ql/test/query-tests/Security/CWE/CWE-497/semmle/tests/ExposedSystemData.expected +++ b/cpp/ql/test/query-tests/Security/CWE/CWE-497/semmle/tests/ExposedSystemData.expected @@ -12,7 +12,7 @@ edges | tests2.cpp:111:14:111:15 | *c1 [*ptr] | tests2.cpp:111:14:111:19 | *ptr | provenance | | | tests2.cpp:111:14:111:15 | *c1 [*ptr] | tests2.cpp:111:17:111:19 | *ptr | provenance | | | tests2.cpp:111:17:111:19 | *ptr | tests2.cpp:111:14:111:19 | *ptr | provenance | | -| tests2.cpp:120:5:120:21 | [summary param] 1 indirection in zmq_msg_init_data | tests2.cpp:120:5:120:21 | [summary param] 0 indirection in zmq_msg_init_data [Return] | provenance | | +| tests2.cpp:120:5:120:21 | [summary param] *1 in zmq_msg_init_data | tests2.cpp:120:5:120:21 | [summary param] *0 in zmq_msg_init_data [Return] | provenance | | | tests2.cpp:134:2:134:30 | *... = ... | tests2.cpp:138:23:138:34 | *message_data | provenance | | | tests2.cpp:134:2:134:30 | *... = ... | tests2.cpp:143:34:143:45 | *message_data | provenance | | | tests2.cpp:134:17:134:22 | *call to getenv | tests2.cpp:134:2:134:30 | *... = ... | provenance | | @@ -20,7 +20,7 @@ edges | tests2.cpp:143:24:143:31 | zmq_msg_init_data output argument | tests2.cpp:147:20:147:27 | *& ... | provenance | | | tests2.cpp:143:24:143:31 | zmq_msg_init_data output argument | tests2.cpp:155:32:155:39 | *& ... | provenance | | | tests2.cpp:143:24:143:31 | zmq_msg_init_data output argument | tests2.cpp:158:20:158:27 | *& ... | provenance | | -| tests2.cpp:143:34:143:45 | *message_data | tests2.cpp:120:5:120:21 | [summary param] 1 indirection in zmq_msg_init_data | provenance | | +| tests2.cpp:143:34:143:45 | *message_data | tests2.cpp:120:5:120:21 | [summary param] *1 in zmq_msg_init_data | provenance | | | tests2.cpp:143:34:143:45 | *message_data | tests2.cpp:143:24:143:31 | zmq_msg_init_data output argument | provenance | | | tests_sockets.cpp:26:15:26:20 | *call to getenv | tests_sockets.cpp:26:15:26:20 | *call to getenv | provenance | | | tests_sockets.cpp:26:15:26:20 | *call to getenv | tests_sockets.cpp:39:19:39:22 | *path | provenance | | @@ -52,8 +52,8 @@ nodes | tests2.cpp:111:14:111:15 | *c1 [*ptr] | semmle.label | *c1 [*ptr] | | tests2.cpp:111:14:111:19 | *ptr | semmle.label | *ptr | | tests2.cpp:111:17:111:19 | *ptr | semmle.label | *ptr | -| tests2.cpp:120:5:120:21 | [summary param] 0 indirection in zmq_msg_init_data [Return] | semmle.label | [summary param] 0 indirection in zmq_msg_init_data [Return] | -| tests2.cpp:120:5:120:21 | [summary param] 1 indirection in zmq_msg_init_data | semmle.label | [summary param] 1 indirection in zmq_msg_init_data | +| tests2.cpp:120:5:120:21 | [summary param] *0 in zmq_msg_init_data [Return] | semmle.label | [summary param] *0 in zmq_msg_init_data [Return] | +| tests2.cpp:120:5:120:21 | [summary param] *1 in zmq_msg_init_data | semmle.label | [summary param] *1 in zmq_msg_init_data | | tests2.cpp:134:2:134:30 | *... = ... | semmle.label | *... = ... | | tests2.cpp:134:17:134:22 | *call to getenv | semmle.label | *call to getenv | | tests2.cpp:138:23:138:34 | *message_data | semmle.label | *message_data | @@ -74,7 +74,7 @@ nodes | tests_sysconf.cpp:36:21:36:27 | confstr output argument | semmle.label | confstr output argument | | tests_sysconf.cpp:39:19:39:25 | *pathbuf | semmle.label | *pathbuf | subpaths -| tests2.cpp:143:34:143:45 | *message_data | tests2.cpp:120:5:120:21 | [summary param] 1 indirection in zmq_msg_init_data | tests2.cpp:120:5:120:21 | [summary param] 0 indirection in zmq_msg_init_data [Return] | tests2.cpp:143:24:143:31 | zmq_msg_init_data output argument | +| tests2.cpp:143:34:143:45 | *message_data | tests2.cpp:120:5:120:21 | [summary param] *1 in zmq_msg_init_data | tests2.cpp:120:5:120:21 | [summary param] *0 in zmq_msg_init_data [Return] | tests2.cpp:143:24:143:31 | zmq_msg_init_data output argument | #select | tests2.cpp:63:13:63:26 | *call to getenv | tests2.cpp:63:13:63:26 | *call to getenv | tests2.cpp:63:13:63:26 | *call to getenv | This operation exposes system data from $@. | tests2.cpp:63:13:63:26 | *call to getenv | *call to getenv | | tests2.cpp:64:13:64:26 | *call to getenv | tests2.cpp:64:13:64:26 | *call to getenv | tests2.cpp:64:13:64:26 | *call to getenv | This operation exposes system data from $@. | tests2.cpp:64:13:64:26 | *call to getenv | *call to getenv | From 40fb59dc0bb7ed1d3d07e4047f2c854a1ae37b33 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Fri, 21 Jun 2024 14:03:07 +0100 Subject: [PATCH 13/33] C++: Add gnu iterator models to regain TP. --- cpp/ql/lib/ext/std.iterator.model.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/cpp/ql/lib/ext/std.iterator.model.yml b/cpp/ql/lib/ext/std.iterator.model.yml index 83527917e77c..927050245637 100644 --- a/cpp/ql/lib/ext/std.iterator.model.yml +++ b/cpp/ql/lib/ext/std.iterator.model.yml @@ -4,4 +4,8 @@ extensions: extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - ["std", "iterator", True, "operator*", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "iterator", True, "operator->", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file + - ["std", "iterator", True, "operator->", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "iterator", True, "iterator", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["__gnu_cxx", "__normal_iterator", True, "operator*", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["__gnu_cxx", "__normal_iterator", True, "operator->", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["__gnu_cxx", "__normal_iterator", True, "__normal_iterator", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] \ No newline at end of file From 2e74ae448c01b9a05fee1490d57f8e6219c7769f Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Fri, 21 Jun 2024 14:03:47 +0100 Subject: [PATCH 14/33] C++: Accept more test changes. --- .../dataflow-tests/type-bugs.expected | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected b/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected index 9a409149f55e..2e4776464f88 100644 --- a/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected +++ b/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected @@ -1,5 +1,27 @@ astTypeBugs irTypeBugs +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary param] *0 in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary param] this in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element[****] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element[***] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element[**] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element[*] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element[****] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element[***] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element[**] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element[*] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary param] *0 in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary param] this in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element[****] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element[***] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element[**] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element[*] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element[****] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element[***] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element[**] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element[*] in iterator | | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary param] this in operator* | | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] read: Argument[this].Element[**] in operator* | | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] read: Argument[this].Element[*] in operator* | From 9a2c7d34af080833b9ba63bfe2605b595a56f7e1 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Fri, 21 Jun 2024 15:45:43 +0100 Subject: [PATCH 15/33] C++: Simplify 'parseParens'. --- cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index 1cf2ad1699f8..c691f96036b3 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -647,9 +647,7 @@ private predicate parseAngles( /** Holds if `s` can be broken into a string of the form `(betweenParens)`. */ bindingset[s] pragma[inline_late] -private predicate parseParens(string s, string betweenParens) { - betweenParens = s.regexpCapture("\\(([^\\)]+)\\)", 1) -} +private predicate parseParens(string s, string betweenParens) { s = "(" + betweenParens + ")" } /** * Holds if `elementSpec(_, type, _, name, signature, _)` and: From d38ce61e032c7b393b434f43fa746465ed9f85e2 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 26 Jun 2024 13:54:28 +0100 Subject: [PATCH 16/33] C++: Mention in the QLDoc that you cannot instantiate templates in the signature string. --- cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index c691f96036b3..ccf06b2236f1 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -22,8 +22,8 @@ * 5. The `signature` column optionally restricts the named member. If * `signature` is blank then no such filtering is done. The format of the * signature is a comma-separated list of types enclosed in parentheses. The - * types can be short names or fully qualified names (mixing these two options - * is not allowed within a single signature). + * types must be stripped of template names. That is, write `const vector &` + * instead of `const vector &`. * 6. The `ext` column specifies additional API-graph-like edges. Currently * there is only one valid value: "". * 7. The `input` column specifies how data enters the element selected by the From e845204ec962fa18595a1dfd2fed95bceb6019e5 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 26 Jun 2024 14:10:31 +0100 Subject: [PATCH 17/33] C++: Add tests of internal MaD predicates and accept test changes. --- .../semmle/code/cpp/dataflow/ExternalFlow.qll | 28 + .../taint-tests/test_mad-signatures.expected | 487 ++++++++++++++++++ .../taint-tests/test_mad-signatures.ql | 9 + 3 files changed, 524 insertions(+) create mode 100644 cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected create mode 100644 cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.ql diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index ccf06b2236f1..bae3c67add11 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -623,6 +623,34 @@ private predicate signatureMatches(Function func, string signature, string type, else i = count(signature.indexOf(",")) } +/** + * Internal: Do not use. + * + * This module only exists to expose internal predicates for testing purposes. + */ +module ExternalFlowDebug { + /** + * INTERNAL: Do not use. + * + * Exposed for testing purposes. + */ + predicate signatureMatches_debug = signatureMatches/5; + + /** + * INTERNAL: Do not use. + * + * Exposed for testing purposes. + */ + predicate getSignatureParameterName_debug = getSignatureParameterName/4; + + /** + * INTERNAL: Do not use. + * + * Exposed for testing purposes. + */ + predicate getParameterTypeName_debug = getParameterTypeName/2; +} + /** * Holds if `s` can be broken into a string of the form * `beforeAngles`, diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected new file mode 100644 index 000000000000..ea5235dd15b5 --- /dev/null +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected @@ -0,0 +1,487 @@ +signatureMatches +| stl.h:182:17:182:22 | assign | (InputIt,InputIt) | forward_list | assign | 0 | +| stl.h:182:17:182:22 | assign | (InputIt,InputIt) | forward_list | assign | 1 | +| stl.h:182:17:182:22 | assign | (InputIt,InputIt) | list | assign | 0 | +| stl.h:182:17:182:22 | assign | (InputIt,InputIt) | list | assign | 1 | +| stl.h:182:17:182:22 | assign | (InputIt,InputIt) | vector | assign | 0 | +| stl.h:182:17:182:22 | assign | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:185:17:185:22 | insert | (InputIt,InputIt) | forward_list | assign | 0 | +| stl.h:185:17:185:22 | insert | (InputIt,InputIt) | forward_list | assign | 1 | +| stl.h:185:17:185:22 | insert | (InputIt,InputIt) | list | assign | 0 | +| stl.h:185:17:185:22 | insert | (InputIt,InputIt) | list | assign | 1 | +| stl.h:185:17:185:22 | insert | (InputIt,InputIt) | vector | assign | 0 | +| stl.h:185:17:185:22 | insert | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 0 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 1 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 2 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | list | insert | 0 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | list | insert | 1 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | list | insert | 2 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | vector | insert | 0 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | vector | insert | 1 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | vector | insert | 2 | +| stl.h:294:12:294:17 | vector | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:294:12:294:17 | vector | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:294:12:294:17 | vector | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:294:12:294:17 | vector | (const list &,const Allocator &) | list | list | 1 | +| stl.h:294:12:294:17 | vector | (const list &,const Allocator &) | list | list | 1 | +| stl.h:294:12:294:17 | vector | (const list &,const Allocator &) | list | list | 1 | +| stl.h:294:12:294:17 | vector | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:294:12:294:17 | vector | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:294:12:294:17 | vector | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:294:12:294:17 | vector | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:294:12:294:17 | vector | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:294:12:294:17 | vector | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:294:12:294:17 | vector | (list &&,const Allocator &) | list | list | 1 | +| stl.h:294:12:294:17 | vector | (list &&,const Allocator &) | list | list | 1 | +| stl.h:294:12:294:17 | vector | (list &&,const Allocator &) | list | list | 1 | +| stl.h:294:12:294:17 | vector | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:294:12:294:17 | vector | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:294:12:294:17 | vector | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 2 | +| stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 2 | +| stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 2 | +| stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 2 | +| stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 2 | +| stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 2 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 0 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 0 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 2 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 2 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | list | list | 0 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | list | list | 0 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | list | list | 1 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | list | list | 1 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | list | list | 2 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | list | list | 2 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 0 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 0 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 1 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 1 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 2 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 2 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 2 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 0 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 1 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 2 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 0 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 1 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 2 | +| stl.h:296:101:296:106 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 2 | +| stl.h:296:101:296:106 | vector | (size_type,const T &,const Allocator &) | list | list | 2 | +| stl.h:296:101:296:106 | vector | (size_type,const T &,const Allocator &) | vector | vector | 2 | +| stl.h:301:11:301:19 | operator= | (const vector &) | vector | vector | 0 | +| stl.h:302:11:302:19 | operator= | (vector &&) | vector | vector | 0 | +| stl.h:303:106:303:111 | assign | (InputIt,InputIt) | forward_list | assign | 0 | +| stl.h:303:106:303:111 | assign | (InputIt,InputIt) | forward_list | assign | 1 | +| stl.h:303:106:303:111 | assign | (InputIt,InputIt) | list | assign | 0 | +| stl.h:303:106:303:111 | assign | (InputIt,InputIt) | list | assign | 1 | +| stl.h:303:106:303:111 | assign | (InputIt,InputIt) | vector | assign | 0 | +| stl.h:303:106:303:111 | assign | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | forward_list | insert_after | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | forward_list | insert_after | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | forward_list | insert_after | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | list | insert | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | list | insert | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | list | insert | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | +| stl.h:331:12:331:17 | insert | (const_iterator,T &&) | forward_list | insert_after | 0 | +| stl.h:331:12:331:17 | insert | (const_iterator,T &&) | forward_list | insert_after | 1 | +| stl.h:331:12:331:17 | insert | (const_iterator,T &&) | list | insert | 0 | +| stl.h:331:12:331:17 | insert | (const_iterator,T &&) | list | insert | 1 | +| stl.h:331:12:331:17 | insert | (const_iterator,T &&) | vector | insert | 0 | +| stl.h:331:12:331:17 | insert | (const_iterator,T &&) | vector | insert | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 0 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 0 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 2 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 2 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | list | insert | 0 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | list | insert | 0 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | list | insert | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | list | insert | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | list | insert | 2 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | list | insert | 2 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 0 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 0 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 2 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 2 | +| stl.h:396:3:396:3 | pair | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (const list &,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (const list &,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (const list &,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (const list &,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (const list &,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | +| stl.h:396:3:396:3 | pair | (list &&,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (list &&,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (list &&,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (list &&,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (list &&,const Allocator &) | list | list | 1 | +| stl.h:396:3:396:3 | pair | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:557:33:557:35 | set | (InputIt,InputIt) | forward_list | assign | 0 | +| stl.h:557:33:557:35 | set | (InputIt,InputIt) | forward_list | assign | 1 | +| stl.h:557:33:557:35 | set | (InputIt,InputIt) | list | assign | 0 | +| stl.h:557:33:557:35 | set | (InputIt,InputIt) | list | assign | 1 | +| stl.h:557:33:557:35 | set | (InputIt,InputIt) | vector | assign | 0 | +| stl.h:557:33:557:35 | set | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:574:38:574:43 | insert | (InputIt,InputIt) | forward_list | assign | 0 | +| stl.h:574:38:574:43 | insert | (InputIt,InputIt) | forward_list | assign | 1 | +| stl.h:574:38:574:43 | insert | (InputIt,InputIt) | list | assign | 0 | +| stl.h:574:38:574:43 | insert | (InputIt,InputIt) | list | assign | 1 | +| stl.h:574:38:574:43 | insert | (InputIt,InputIt) | vector | assign | 0 | +| stl.h:574:38:574:43 | insert | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:628:38:628:43 | insert | (InputIt,InputIt) | forward_list | assign | 0 | +| stl.h:628:38:628:43 | insert | (InputIt,InputIt) | forward_list | assign | 1 | +| stl.h:628:38:628:43 | insert | (InputIt,InputIt) | list | assign | 0 | +| stl.h:628:38:628:43 | insert | (InputIt,InputIt) | list | assign | 1 | +| stl.h:628:38:628:43 | insert | (InputIt,InputIt) | vector | assign | 0 | +| stl.h:628:38:628:43 | insert | (InputIt,InputIt) | vector | assign | 1 | +getSignatureParameterName +| (InputIt,InputIt) | forward_list | assign | 0 | func:0 | +| (InputIt,InputIt) | forward_list | assign | 1 | func:0 | +| (InputIt,InputIt) | list | assign | 0 | func:0 | +| (InputIt,InputIt) | list | assign | 1 | func:0 | +| (InputIt,InputIt) | vector | assign | 0 | func:0 | +| (InputIt,InputIt) | vector | assign | 1 | func:0 | +| (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 0 | InputIterator | +| (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 1 | InputIterator | +| (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 2 | const class:1 & | +| (InputIterator,InputIterator,const Allocator &) | list | list | 0 | func:0 | +| (InputIterator,InputIterator,const Allocator &) | list | list | 1 | func:0 | +| (InputIterator,InputIterator,const Allocator &) | list | list | 2 | const class:1 & | +| (InputIterator,InputIterator,const Allocator &) | vector | vector | 0 | func:0 | +| (InputIterator,InputIterator,const Allocator &) | vector | vector | 1 | func:0 | +| (InputIterator,InputIterator,const Allocator &) | vector | vector | 2 | const class:1 & | +| (const forward_list &) | forward_list | forward_list | 0 | const forward_list & | +| (const forward_list &,const Allocator &) | forward_list | forward_list | 0 | const forward_list & | +| (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | const class:1 & | +| (const list &) | list | list | 0 | const list & | +| (const list &,const Allocator &) | list | list | 0 | const list & | +| (const list &,const Allocator &) | list | list | 1 | const class:1 & | +| (const vector &) | vector | vector | 0 | const vector & | +| (const vector &,const Allocator &) | vector | vector | 0 | const vector & | +| (const vector &,const Allocator &) | vector | vector | 1 | const class:1 & | +| (const_iterator,InputIt,InputIt) | forward_list | insert_after | 0 | const_iterator | +| (const_iterator,InputIt,InputIt) | forward_list | insert_after | 1 | func:0 | +| (const_iterator,InputIt,InputIt) | forward_list | insert_after | 2 | func:0 | +| (const_iterator,InputIt,InputIt) | list | insert | 0 | const_iterator | +| (const_iterator,InputIt,InputIt) | list | insert | 1 | func:0 | +| (const_iterator,InputIt,InputIt) | list | insert | 2 | func:0 | +| (const_iterator,InputIt,InputIt) | vector | insert | 0 | const_iterator | +| (const_iterator,InputIt,InputIt) | vector | insert | 1 | func:0 | +| (const_iterator,InputIt,InputIt) | vector | insert | 2 | func:0 | +| (const_iterator,T &&) | forward_list | insert_after | 0 | const_iterator | +| (const_iterator,T &&) | forward_list | insert_after | 1 | class:0 && | +| (const_iterator,T &&) | list | insert | 0 | const_iterator | +| (const_iterator,T &&) | list | insert | 1 | class:0 && | +| (const_iterator,T &&) | vector | insert | 0 | const_iterator | +| (const_iterator,T &&) | vector | insert | 1 | class:0 && | +| (const_iterator,const T &) | forward_list | insert_after | 0 | const_iterator | +| (const_iterator,const T &) | forward_list | insert_after | 1 | const class:0 & | +| (const_iterator,const T &) | list | insert | 0 | const_iterator | +| (const_iterator,const T &) | list | insert | 1 | const class:0 & | +| (const_iterator,const T &) | vector | insert | 0 | const_iterator | +| (const_iterator,const T &) | vector | insert | 1 | const class:0 & | +| (const_iterator,size_type,const T &) | forward_list | insert_after | 0 | const_iterator | +| (const_iterator,size_type,const T &) | forward_list | insert_after | 1 | size_type | +| (const_iterator,size_type,const T &) | forward_list | insert_after | 2 | const class:0 & | +| (const_iterator,size_type,const T &) | list | insert | 0 | const_iterator | +| (const_iterator,size_type,const T &) | list | insert | 1 | size_type | +| (const_iterator,size_type,const T &) | list | insert | 2 | const class:0 & | +| (const_iterator,size_type,const T &) | vector | insert | 0 | const_iterator | +| (const_iterator,size_type,const T &) | vector | insert | 1 | size_type | +| (const_iterator,size_type,const T &) | vector | insert | 2 | const class:0 & | +| (forward_list &&) | forward_list | forward_list | 0 | forward_list && | +| (forward_list &&,const Allocator &) | forward_list | forward_list | 0 | forward_list && | +| (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | const class:1 & | +| (list &&) | list | list | 0 | list && | +| (list &&,const Allocator &) | list | list | 0 | list && | +| (list &&,const Allocator &) | list | list | 1 | const class:1 & | +| (size_type,const T &,const Allocator &) | forward_list | forward_list | 0 | size_type | +| (size_type,const T &,const Allocator &) | forward_list | forward_list | 1 | const class:0 & | +| (size_type,const T &,const Allocator &) | forward_list | forward_list | 2 | const class:1 & | +| (size_type,const T &,const Allocator &) | list | list | 0 | size_type | +| (size_type,const T &,const Allocator &) | list | list | 1 | const class:0 & | +| (size_type,const T &,const Allocator &) | list | list | 2 | const class:1 & | +| (size_type,const T &,const Allocator &) | vector | vector | 0 | size_type | +| (size_type,const T &,const Allocator &) | vector | vector | 1 | const class:0 & | +| (size_type,const T &,const Allocator &) | vector | vector | 2 | const class:1 & | +| (vector &&) | vector | vector | 0 | vector && | +| (vector &&,const Allocator &) | vector | vector | 0 | vector && | +| (vector &&,const Allocator &) | vector | vector | 1 | const class:1 & | +getParameterTypeName +| stl.h:49:3:49:10 | iterator | 0 | const iterator & | +| stl.h:49:3:49:10 | iterator | 0 | const iterator & | +| stl.h:49:3:49:10 | iterator | 0 | const iterator & | +| stl.h:49:3:49:10 | iterator | 0 | const iterator & | +| stl.h:49:3:49:10 | iterator | 0 | const iterator & | +| stl.h:49:3:49:10 | iterator | 0 | const iterator & | +| stl.h:49:3:49:10 | iterator | 0 | const iterator & | +| stl.h:49:3:49:10 | iterator | 0 | const iterator & | +| stl.h:52:12:52:21 | operator++ | 0 | int | +| stl.h:52:12:52:21 | operator++ | 0 | int | +| stl.h:52:12:52:21 | operator++ | 0 | int | +| stl.h:52:12:52:21 | operator++ | 0 | int | +| stl.h:52:12:52:21 | operator++ | 0 | int | +| stl.h:54:12:54:21 | operator-- | 0 | int | +| stl.h:56:8:56:17 | operator!= | 0 | iterator | +| stl.h:56:8:56:17 | operator!= | 0 | iterator | +| stl.h:56:8:56:17 | operator!= | 0 | iterator | +| stl.h:56:8:56:17 | operator!= | 0 | iterator | +| stl.h:56:8:56:17 | operator!= | 0 | iterator | +| stl.h:56:8:56:17 | operator!= | 0 | iterator | +| stl.h:59:12:59:20 | operator+ | 0 | int | +| stl.h:60:12:60:20 | operator- | 0 | int | +| stl.h:61:13:61:22 | operator+= | 0 | int | +| stl.h:61:13:61:22 | operator+= | 0 | int | +| stl.h:62:13:62:22 | operator-= | 0 | int | +| stl.h:64:18:64:27 | operator[] | 0 | int | +| stl.h:86:22:86:41 | back_insert_iterator | 0 | class:0 & | +| stl.h:86:22:86:41 | back_insert_iterator | 0 | class:0 & | +| stl.h:88:25:88:33 | operator= | 0 | value_type && | +| stl.h:88:25:88:33 | operator= | 0 | value_type && | +| stl.h:91:24:91:33 | operator++ | 0 | int | +| stl.h:91:24:91:33 | operator++ | 0 | int | +| stl.h:139:8:139:8 | basic_string | 0 | basic_string & | +| stl.h:148:3:148:14 | basic_string | 0 | const class:2 & | +| stl.h:149:33:149:44 | basic_string | 0 | const class:0 * | +| stl.h:149:33:149:44 | basic_string | 1 | const class:2 & | +| stl.h:151:16:151:20 | c_str | 0 | func:0 | +| stl.h:151:16:151:20 | c_str | 1 | func:0 | +| stl.h:151:16:151:20 | c_str | 2 | const class:2 & | +| stl.h:173:13:173:22 | operator[] | 0 | size_type | +| stl.h:175:13:175:14 | at | 0 | size_type | +| stl.h:176:35:176:44 | operator+= | 0 | size_type | +| stl.h:176:35:176:44 | operator+= | 0 | size_type | +| stl.h:177:17:177:26 | operator+= | 0 | const func:0 & | +| stl.h:178:17:178:22 | append | 0 | const class:0 * | +| stl.h:179:17:179:22 | append | 0 | const basic_string & | +| stl.h:180:17:180:22 | append | 0 | const class:0 * | +| stl.h:181:47:181:52 | append | 0 | size_type | +| stl.h:181:47:181:52 | append | 1 | class:0 | +| stl.h:182:17:182:22 | assign | 0 | func:0 | +| stl.h:182:17:182:22 | assign | 1 | func:0 | +| stl.h:183:17:183:22 | assign | 0 | const basic_string & | +| stl.h:184:47:184:52 | assign | 0 | size_type | +| stl.h:184:47:184:52 | assign | 1 | class:0 | +| stl.h:185:17:185:22 | insert | 0 | func:0 | +| stl.h:185:17:185:22 | insert | 1 | func:0 | +| stl.h:186:17:186:22 | insert | 0 | size_type | +| stl.h:186:17:186:22 | insert | 1 | const basic_string & | +| stl.h:187:17:187:22 | insert | 0 | size_type | +| stl.h:187:17:187:22 | insert | 1 | size_type | +| stl.h:187:17:187:22 | insert | 2 | class:0 | +| stl.h:188:12:188:17 | insert | 0 | size_type | +| stl.h:188:12:188:17 | insert | 1 | const class:0 * | +| stl.h:189:42:189:47 | insert | 0 | const_iterator | +| stl.h:189:42:189:47 | insert | 1 | size_type | +| stl.h:189:42:189:47 | insert | 2 | class:0 | +| stl.h:190:17:190:23 | replace | 0 | const_iterator | +| stl.h:190:17:190:23 | replace | 1 | func:0 | +| stl.h:190:17:190:23 | replace | 2 | func:0 | +| stl.h:191:17:191:23 | replace | 0 | size_type | +| stl.h:191:17:191:23 | replace | 1 | size_type | +| stl.h:191:17:191:23 | replace | 2 | const basic_string & | +| stl.h:192:13:192:16 | copy | 0 | size_type | +| stl.h:192:13:192:16 | copy | 1 | size_type | +| stl.h:192:13:192:16 | copy | 2 | size_type | +| stl.h:192:13:192:16 | copy | 3 | class:0 | +| stl.h:193:8:193:12 | clear | 0 | class:0 * | +| stl.h:193:8:193:12 | clear | 1 | size_type | +| stl.h:193:8:193:12 | clear | 2 | size_type | +| stl.h:195:8:195:11 | swap | 0 | size_type | +| stl.h:195:8:195:11 | swap | 1 | size_type | +| stl.h:214:33:214:42 | operator>> | 0 | int & | +| stl.h:217:33:217:35 | get | 0 | char_type & | +| stl.h:218:33:218:35 | get | 0 | char_type * | +| stl.h:218:33:218:35 | get | 1 | streamsize | +| stl.h:220:33:220:36 | read | 0 | char_type * | +| stl.h:220:33:220:36 | read | 1 | streamsize | +| stl.h:221:14:221:21 | readsome | 0 | char_type * | +| stl.h:221:14:221:21 | readsome | 1 | streamsize | +| stl.h:222:33:222:39 | putback | 0 | char_type | +| stl.h:225:32:225:38 | getline | 0 | char_type * | +| stl.h:225:32:225:38 | getline | 1 | streamsize | +| stl.h:226:32:226:38 | getline | 0 | char_type * | +| stl.h:226:32:226:38 | getline | 1 | streamsize | +| stl.h:226:32:226:38 | getline | 2 | char_type | +| stl.h:240:33:240:42 | operator<< | 0 | int | +| stl.h:242:33:242:35 | put | 0 | char_type | +| stl.h:243:33:243:37 | write | 0 | const char_type * | +| stl.h:243:33:243:37 | write | 1 | streamsize | +| stl.h:259:12:259:29 | basic_stringstream | 0 | const basic_string & | +| stl.h:263:23:263:31 | operator= | 0 | basic_stringstream && | +| stl.h:265:8:265:11 | swap | 0 | basic_stringstream & | +| stl.h:268:8:268:10 | str | 0 | const basic_string & | +| stl.h:293:12:293:17 | vector | 0 | const class:1 & | +| stl.h:293:12:293:17 | vector | 0 | const class:1 & | +| stl.h:293:12:293:17 | vector | 0 | const class:1 & | +| stl.h:293:12:293:17 | vector | 0 | const class:1 & | +| stl.h:293:12:293:17 | vector | 0 | const class:1 & | +| stl.h:293:12:293:17 | vector | 0 | const class:1 & | +| stl.h:294:12:294:17 | vector | 0 | size_type | +| stl.h:294:12:294:17 | vector | 0 | size_type | +| stl.h:294:12:294:17 | vector | 0 | size_type | +| stl.h:294:12:294:17 | vector | 1 | const class:1 & | +| stl.h:294:12:294:17 | vector | 1 | const class:1 & | +| stl.h:294:12:294:17 | vector | 1 | const class:1 & | +| stl.h:295:3:295:8 | vector | 0 | size_type | +| stl.h:295:3:295:8 | vector | 0 | size_type | +| stl.h:295:3:295:8 | vector | 1 | const class:0 & | +| stl.h:295:3:295:8 | vector | 1 | const class:0 & | +| stl.h:295:3:295:8 | vector | 2 | const class:1 & | +| stl.h:295:3:295:8 | vector | 2 | const class:1 & | +| stl.h:296:101:296:106 | vector | 0 | func:0 | +| stl.h:296:101:296:106 | vector | 1 | func:0 | +| stl.h:296:101:296:106 | vector | 2 | const class:1 & | +| stl.h:301:11:301:19 | operator= | 0 | const vector & | +| stl.h:302:11:302:19 | operator= | 0 | vector && | +| stl.h:303:106:303:111 | assign | 0 | func:0 | +| stl.h:303:106:303:111 | assign | 1 | func:0 | +| stl.h:306:8:306:13 | assign | 0 | size_type | +| stl.h:306:8:306:13 | assign | 0 | size_type | +| stl.h:306:8:306:13 | assign | 0 | size_type | +| stl.h:306:8:306:13 | assign | 1 | const class:0 & | +| stl.h:306:8:306:13 | assign | 1 | const class:0 & | +| stl.h:306:8:306:13 | assign | 1 | const class:0 & | +| stl.h:315:13:315:22 | operator[] | 0 | size_type | +| stl.h:315:13:315:22 | operator[] | 0 | size_type | +| stl.h:315:13:315:22 | operator[] | 0 | size_type | +| stl.h:315:13:315:22 | operator[] | 0 | size_type | +| stl.h:315:13:315:22 | operator[] | 0 | size_type | +| stl.h:315:13:315:22 | operator[] | 0 | size_type | +| stl.h:318:13:318:14 | at | 0 | size_type | +| stl.h:327:8:327:16 | push_back | 0 | const class:0 & | +| stl.h:327:8:327:16 | push_back | 0 | const class:0 & | +| stl.h:328:8:328:16 | push_back | 0 | class:0 && | +| stl.h:331:12:331:17 | insert | 0 | const_iterator | +| stl.h:331:12:331:17 | insert | 1 | class:0 && | +| stl.h:333:42:333:47 | insert | 0 | const_iterator | +| stl.h:333:42:333:47 | insert | 0 | const_iterator | +| stl.h:333:42:333:47 | insert | 1 | func:0 | +| stl.h:333:42:333:47 | insert | 1 | func:0 | +| stl.h:333:42:333:47 | insert | 2 | func:0 | +| stl.h:333:42:333:47 | insert | 2 | func:0 | +| stl.h:338:8:338:11 | swap | 0 | vector & | +| stl.h:351:12:351:21 | shared_ptr | 0 | class:0 * | +| stl.h:352:3:352:12 | shared_ptr | 0 | const shared_ptr & | +| stl.h:352:3:352:12 | shared_ptr | 0 | const shared_ptr & | +| stl.h:369:12:369:21 | unique_ptr | 0 | class:0 * | +| stl.h:396:3:396:3 | pair | 0 | const class:0 & | +| stl.h:396:3:396:3 | pair | 0 | const class:0 & | +| stl.h:396:3:396:3 | pair | 0 | const class:0 & | +| stl.h:396:3:396:3 | pair | 0 | const class:0 & | +| stl.h:396:3:396:3 | pair | 0 | const class:0 & | +| stl.h:396:3:396:3 | pair | 1 | const class:1 & | +| stl.h:396:3:396:3 | pair | 1 | const class:1 & | +| stl.h:396:3:396:3 | pair | 1 | const class:1 & | +| stl.h:396:3:396:3 | pair | 1 | const class:1 & | +| stl.h:396:3:396:3 | pair | 1 | const class:1 & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:397:30:397:33 | pair | 0 | const pair & | +| stl.h:399:8:399:11 | swap | 0 | pair & | +| stl.h:422:3:422:5 | map | 0 | const map & | +| stl.h:426:8:426:16 | operator= | 0 | const map & | +| stl.h:435:6:435:15 | operator[] | 0 | key_type && | +| stl.h:435:6:435:15 | operator[] | 0 | key_type && | +| stl.h:436:6:436:7 | at | 0 | const key_type & | +| stl.h:443:24:443:29 | insert | 0 | value_type && | +| stl.h:445:12:445:17 | insert | 0 | const_iterator | +| stl.h:445:12:445:17 | insert | 1 | value_type && | +| stl.h:452:42:452:57 | insert_or_assign | 0 | key_type && | +| stl.h:452:42:452:57 | insert_or_assign | 1 | func:0 && | +| stl.h:454:30:454:45 | insert_or_assign | 0 | const_iterator | +| stl.h:454:30:454:45 | insert_or_assign | 1 | key_type && | +| stl.h:454:30:454:45 | insert_or_assign | 2 | func:0 && | +| stl.h:456:12:456:16 | erase | 0 | iterator | +| stl.h:459:8:459:11 | swap | 0 | map & | +| stl.h:462:27:462:31 | merge | 0 | map & | +| stl.h:465:12:465:15 | find | 0 | const key_type & | +| stl.h:468:12:468:22 | lower_bound | 0 | const key_type & | +| stl.h:470:12:470:22 | upper_bound | 0 | const key_type & | +| stl.h:473:28:473:38 | equal_range | 0 | const key_type & | +| stl.h:490:3:490:15 | unordered_map | 0 | const unordered_map & | +| stl.h:490:3:490:15 | unordered_map | 0 | const unordered_map & | +| stl.h:494:18:494:26 | operator= | 0 | const unordered_map & | +| stl.h:503:16:503:25 | operator[] | 0 | key_type && | +| stl.h:503:16:503:25 | operator[] | 0 | key_type && | +| stl.h:504:16:504:17 | at | 0 | const key_type & | +| stl.h:511:24:511:29 | insert | 0 | value_type && | +| stl.h:513:12:513:17 | insert | 0 | const_iterator | +| stl.h:513:12:513:17 | insert | 1 | value_type && | +| stl.h:520:42:520:57 | insert_or_assign | 0 | key_type && | +| stl.h:520:42:520:57 | insert_or_assign | 1 | func:0 && | +| stl.h:522:30:522:45 | insert_or_assign | 0 | const_iterator | +| stl.h:522:30:522:45 | insert_or_assign | 1 | key_type && | +| stl.h:522:30:522:45 | insert_or_assign | 2 | func:0 && | +| stl.h:524:12:524:16 | erase | 0 | iterator | +| stl.h:527:8:527:11 | swap | 0 | unordered_map & | +| stl.h:530:37:530:41 | merge | 0 | unordered_map & | +| stl.h:533:12:533:15 | find | 0 | const key_type & | +| stl.h:536:28:536:38 | equal_range | 0 | const key_type & | +| stl.h:555:3:555:5 | set | 0 | const set & | +| stl.h:557:33:557:35 | set | 0 | func:0 | +| stl.h:557:33:557:35 | set | 1 | func:0 | +| stl.h:560:8:560:16 | operator= | 0 | const set & | +| stl.h:571:23:571:28 | insert | 0 | value_type && | +| stl.h:573:12:573:17 | insert | 0 | const_iterator | +| stl.h:573:12:573:17 | insert | 1 | value_type && | +| stl.h:574:38:574:43 | insert | 0 | func:0 | +| stl.h:574:38:574:43 | insert | 1 | func:0 | +| stl.h:576:12:576:16 | erase | 0 | iterator | +| stl.h:579:8:579:11 | swap | 0 | set & | +| stl.h:582:27:582:31 | merge | 0 | set & | +| stl.h:585:12:585:15 | find | 0 | const key_type & | +| stl.h:588:12:588:22 | lower_bound | 0 | const key_type & | +| stl.h:590:12:590:22 | upper_bound | 0 | const key_type & | +| stl.h:592:28:592:38 | equal_range | 0 | const key_type & | +| stl.h:609:3:609:15 | unordered_set | 0 | const unordered_set & | +| stl.h:611:33:611:45 | unordered_set | 0 | func:0 | +| stl.h:611:33:611:45 | unordered_set | 1 | func:0 | +| stl.h:611:33:611:45 | unordered_set | 2 | size_type | +| stl.h:614:18:614:26 | operator= | 0 | const unordered_set & | +| stl.h:625:24:625:29 | insert | 0 | value_type && | +| stl.h:627:12:627:17 | insert | 0 | const_iterator | +| stl.h:627:12:627:17 | insert | 1 | value_type && | +| stl.h:628:38:628:43 | insert | 0 | func:0 | +| stl.h:628:38:628:43 | insert | 1 | func:0 | +| stl.h:630:12:630:16 | erase | 0 | iterator | +| stl.h:633:8:633:11 | swap | 0 | unordered_set & | +| stl.h:636:37:636:41 | merge | 0 | unordered_set & | +| stl.h:639:12:639:15 | find | 0 | const key_type & | +| stl.h:641:28:641:38 | equal_range | 0 | const key_type & | diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.ql b/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.ql new file mode 100644 index 000000000000..32c0e59c158d --- /dev/null +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.ql @@ -0,0 +1,9 @@ +import cpp +import semmle.code.cpp.dataflow.ExternalFlow +import ExternalFlowDebug + +query predicate signatureMatches = signatureMatches_debug/5; + +query predicate getSignatureParameterName = getSignatureParameterName_debug/4; + +query predicate getParameterTypeName = getParameterTypeName_debug/2; From 2ad8704325fe740f0ae43b987ae9d86993732fe9 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Thu, 27 Jun 2024 19:48:27 +0100 Subject: [PATCH 18/33] C++: Add bsl models. --- cpp/ql/lib/ext/bsl.array.model.yml | 12 ++++ cpp/ql/lib/ext/bsl.deque.model.yml | 72 +++++++++++++++++++++++ cpp/ql/lib/ext/bsl.forward_list.model.yml | 55 +++++++++++++++++ cpp/ql/lib/ext/bsl.list.model.yml | 70 ++++++++++++++++++++++ cpp/ql/lib/ext/bsl.vector.model.yml | 59 +++++++++++++++++++ 5 files changed, 268 insertions(+) create mode 100644 cpp/ql/lib/ext/bsl.array.model.yml create mode 100644 cpp/ql/lib/ext/bsl.deque.model.yml create mode 100644 cpp/ql/lib/ext/bsl.forward_list.model.yml create mode 100644 cpp/ql/lib/ext/bsl.list.model.yml create mode 100644 cpp/ql/lib/ext/bsl.vector.model.yml diff --git a/cpp/ql/lib/ext/bsl.array.model.yml b/cpp/ql/lib/ext/bsl.array.model.yml new file mode 100644 index 000000000000..1c47fdc9ad5e --- /dev/null +++ b/cpp/ql/lib/ext/bsl.array.model.yml @@ -0,0 +1,12 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["bsl", "array", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "array", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "array", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "array", True, "data", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "array", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "array", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "array", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/bsl.deque.model.yml b/cpp/ql/lib/ext/bsl.deque.model.yml new file mode 100644 index 000000000000..b24d95ebad15 --- /dev/null +++ b/cpp/ql/lib/ext/bsl.deque.model.yml @@ -0,0 +1,72 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["bsl", "deque", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(const deque &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(deque &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/bsl.forward_list.model.yml b/cpp/ql/lib/ext/bsl.forward_list.model.yml new file mode 100644 index 000000000000..08993ebfbb4d --- /dev/null +++ b/cpp/ql/lib/ext/bsl.forward_list.model.yml @@ -0,0 +1,55 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(const forward_list &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(forward_list &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(const forward_list &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(forward_list &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/bsl.list.model.yml b/cpp/ql/lib/ext/bsl.list.model.yml new file mode 100644 index 000000000000..e3873de14ac8 --- /dev/null +++ b/cpp/ql/lib/ext/bsl.list.model.yml @@ -0,0 +1,70 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["bsl", "list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "list", "(const list &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "list", "(list &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "list", "(const list &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "list", "(list &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/bsl.vector.model.yml b/cpp/ql/lib/ext/bsl.vector.model.yml new file mode 100644 index 000000000000..0b23f46d76a8 --- /dev/null +++ b/cpp/ql/lib/ext/bsl.vector.model.yml @@ -0,0 +1,59 @@ +extensions: + - addsTo: + pack: codeql/cpp-all + extensible: summaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["bsl", "vector", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "data", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(const vector &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(vector &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(const vector &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(vector &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file From 4535043e90aa81639e078e71825f2956c2dc1f90 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Thu, 27 Jun 2024 20:15:58 +0100 Subject: [PATCH 19/33] C++: Accept test changes. --- .../external-models/validatemodels.expected | 4 + .../taint-tests/test_mad-signatures.expected | 78 +++++++++++++++++++ 2 files changed, 82 insertions(+) diff --git a/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected b/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected index f9ed615edeae..04c4cb3bfbb5 100644 --- a/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected +++ b/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected @@ -3,6 +3,8 @@ | Dubious member name "operator=" in summary model. | | Dubious member name "operator[]" in summary model. | | Dubious signature "(InputIterator,InputIterator,const Allocator &)" in summary model. | +| Dubious signature "(const deque &)" in summary model. | +| Dubious signature "(const deque &,const Allocator &)" in summary model. | | Dubious signature "(const forward_list &)" in summary model. | | Dubious signature "(const forward_list &,const Allocator &)" in summary model. | | Dubious signature "(const list &)" in summary model. | @@ -12,6 +14,8 @@ | Dubious signature "(const_iterator,T &&)" in summary model. | | Dubious signature "(const_iterator,const T &)" in summary model. | | Dubious signature "(const_iterator,size_type,const T &)" in summary model. | +| Dubious signature "(deque &&)" in summary model. | +| Dubious signature "(deque &&,const Allocator &)" in summary model. | | Dubious signature "(forward_list &&)" in summary model. | | Dubious signature "(forward_list &&,const Allocator &)" in summary model. | | Dubious signature "(list &&)" in summary model. | diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected index ea5235dd15b5..82fef0dd4ab0 100644 --- a/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected @@ -1,16 +1,23 @@ signatureMatches +| stl.h:182:17:182:22 | assign | (InputIt,InputIt) | deque | assign | 0 | +| stl.h:182:17:182:22 | assign | (InputIt,InputIt) | deque | assign | 1 | | stl.h:182:17:182:22 | assign | (InputIt,InputIt) | forward_list | assign | 0 | | stl.h:182:17:182:22 | assign | (InputIt,InputIt) | forward_list | assign | 1 | | stl.h:182:17:182:22 | assign | (InputIt,InputIt) | list | assign | 0 | | stl.h:182:17:182:22 | assign | (InputIt,InputIt) | list | assign | 1 | | stl.h:182:17:182:22 | assign | (InputIt,InputIt) | vector | assign | 0 | | stl.h:182:17:182:22 | assign | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:185:17:185:22 | insert | (InputIt,InputIt) | deque | assign | 0 | +| stl.h:185:17:185:22 | insert | (InputIt,InputIt) | deque | assign | 1 | | stl.h:185:17:185:22 | insert | (InputIt,InputIt) | forward_list | assign | 0 | | stl.h:185:17:185:22 | insert | (InputIt,InputIt) | forward_list | assign | 1 | | stl.h:185:17:185:22 | insert | (InputIt,InputIt) | list | assign | 0 | | stl.h:185:17:185:22 | insert | (InputIt,InputIt) | list | assign | 1 | | stl.h:185:17:185:22 | insert | (InputIt,InputIt) | vector | assign | 0 | | stl.h:185:17:185:22 | insert | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | deque | insert | 0 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | deque | insert | 1 | +| stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | deque | insert | 2 | | stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 0 | | stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 1 | | stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 2 | @@ -20,6 +27,9 @@ signatureMatches | stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | vector | insert | 0 | | stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | vector | insert | 1 | | stl.h:190:17:190:23 | replace | (const_iterator,InputIt,InputIt) | vector | insert | 2 | +| stl.h:294:12:294:17 | vector | (const deque &,const Allocator &) | deque | deque | 1 | +| stl.h:294:12:294:17 | vector | (const deque &,const Allocator &) | deque | deque | 1 | +| stl.h:294:12:294:17 | vector | (const deque &,const Allocator &) | deque | deque | 1 | | stl.h:294:12:294:17 | vector | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | | stl.h:294:12:294:17 | vector | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | | stl.h:294:12:294:17 | vector | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | @@ -29,6 +39,9 @@ signatureMatches | stl.h:294:12:294:17 | vector | (const vector &,const Allocator &) | vector | vector | 1 | | stl.h:294:12:294:17 | vector | (const vector &,const Allocator &) | vector | vector | 1 | | stl.h:294:12:294:17 | vector | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:294:12:294:17 | vector | (deque &&,const Allocator &) | deque | deque | 1 | +| stl.h:294:12:294:17 | vector | (deque &&,const Allocator &) | deque | deque | 1 | +| stl.h:294:12:294:17 | vector | (deque &&,const Allocator &) | deque | deque | 1 | | stl.h:294:12:294:17 | vector | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | | stl.h:294:12:294:17 | vector | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | | stl.h:294:12:294:17 | vector | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | @@ -38,12 +51,20 @@ signatureMatches | stl.h:294:12:294:17 | vector | (vector &&,const Allocator &) | vector | vector | 1 | | stl.h:294:12:294:17 | vector | (vector &&,const Allocator &) | vector | vector | 1 | | stl.h:294:12:294:17 | vector | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | deque | deque | 2 | +| stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | deque | deque | 2 | | stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 2 | | stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 2 | | stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 2 | | stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 2 | | stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 2 | | stl.h:295:3:295:8 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 2 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | deque | deque | 0 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | deque | deque | 0 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | deque | deque | 1 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | deque | deque | 1 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | deque | deque | 2 | +| stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | deque | deque | 2 | | stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 0 | | stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 0 | | stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 1 | @@ -62,6 +83,9 @@ signatureMatches | stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 1 | | stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 2 | | stl.h:295:3:295:8 | vector | (size_type,const T &,const Allocator &) | vector | vector | 2 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | deque | deque | 0 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | deque | deque | 1 | +| stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | deque | deque | 2 | | stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 2 | | stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 0 | | stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | list | list | 1 | @@ -69,17 +93,23 @@ signatureMatches | stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 0 | | stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 1 | | stl.h:296:101:296:106 | vector | (InputIterator,InputIterator,const Allocator &) | vector | vector | 2 | +| stl.h:296:101:296:106 | vector | (size_type,const T &,const Allocator &) | deque | deque | 2 | | stl.h:296:101:296:106 | vector | (size_type,const T &,const Allocator &) | forward_list | forward_list | 2 | | stl.h:296:101:296:106 | vector | (size_type,const T &,const Allocator &) | list | list | 2 | | stl.h:296:101:296:106 | vector | (size_type,const T &,const Allocator &) | vector | vector | 2 | | stl.h:301:11:301:19 | operator= | (const vector &) | vector | vector | 0 | | stl.h:302:11:302:19 | operator= | (vector &&) | vector | vector | 0 | +| stl.h:303:106:303:111 | assign | (InputIt,InputIt) | deque | assign | 0 | +| stl.h:303:106:303:111 | assign | (InputIt,InputIt) | deque | assign | 1 | | stl.h:303:106:303:111 | assign | (InputIt,InputIt) | forward_list | assign | 0 | | stl.h:303:106:303:111 | assign | (InputIt,InputIt) | forward_list | assign | 1 | | stl.h:303:106:303:111 | assign | (InputIt,InputIt) | list | assign | 0 | | stl.h:303:106:303:111 | assign | (InputIt,InputIt) | list | assign | 1 | | stl.h:303:106:303:111 | assign | (InputIt,InputIt) | vector | assign | 0 | | stl.h:303:106:303:111 | assign | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | deque | insert | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | deque | insert | 1 | +| stl.h:306:8:306:13 | assign | (const_iterator,const T &) | deque | insert | 1 | | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | forward_list | insert_after | 1 | | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | forward_list | insert_after | 1 | | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | forward_list | insert_after | 1 | @@ -89,12 +119,20 @@ signatureMatches | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | +| stl.h:331:12:331:17 | insert | (const_iterator,T &&) | deque | insert | 0 | +| stl.h:331:12:331:17 | insert | (const_iterator,T &&) | deque | insert | 1 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | forward_list | insert_after | 0 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | forward_list | insert_after | 1 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | list | insert | 0 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | list | insert | 1 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | vector | insert | 0 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | vector | insert | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | deque | insert | 0 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | deque | insert | 0 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | deque | insert | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | deque | insert | 1 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | deque | insert | 2 | +| stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | deque | insert | 2 | | stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 0 | | stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 0 | | stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 1 | @@ -113,6 +151,11 @@ signatureMatches | stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 1 | | stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 2 | | stl.h:333:42:333:47 | insert | (const_iterator,InputIt,InputIt) | vector | insert | 2 | +| stl.h:396:3:396:3 | pair | (const deque &,const Allocator &) | deque | deque | 1 | +| stl.h:396:3:396:3 | pair | (const deque &,const Allocator &) | deque | deque | 1 | +| stl.h:396:3:396:3 | pair | (const deque &,const Allocator &) | deque | deque | 1 | +| stl.h:396:3:396:3 | pair | (const deque &,const Allocator &) | deque | deque | 1 | +| stl.h:396:3:396:3 | pair | (const deque &,const Allocator &) | deque | deque | 1 | | stl.h:396:3:396:3 | pair | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | | stl.h:396:3:396:3 | pair | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | | stl.h:396:3:396:3 | pair | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | @@ -128,6 +171,11 @@ signatureMatches | stl.h:396:3:396:3 | pair | (const vector &,const Allocator &) | vector | vector | 1 | | stl.h:396:3:396:3 | pair | (const vector &,const Allocator &) | vector | vector | 1 | | stl.h:396:3:396:3 | pair | (const vector &,const Allocator &) | vector | vector | 1 | +| stl.h:396:3:396:3 | pair | (deque &&,const Allocator &) | deque | deque | 1 | +| stl.h:396:3:396:3 | pair | (deque &&,const Allocator &) | deque | deque | 1 | +| stl.h:396:3:396:3 | pair | (deque &&,const Allocator &) | deque | deque | 1 | +| stl.h:396:3:396:3 | pair | (deque &&,const Allocator &) | deque | deque | 1 | +| stl.h:396:3:396:3 | pair | (deque &&,const Allocator &) | deque | deque | 1 | | stl.h:396:3:396:3 | pair | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | | stl.h:396:3:396:3 | pair | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | | stl.h:396:3:396:3 | pair | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | @@ -143,18 +191,24 @@ signatureMatches | stl.h:396:3:396:3 | pair | (vector &&,const Allocator &) | vector | vector | 1 | | stl.h:396:3:396:3 | pair | (vector &&,const Allocator &) | vector | vector | 1 | | stl.h:396:3:396:3 | pair | (vector &&,const Allocator &) | vector | vector | 1 | +| stl.h:557:33:557:35 | set | (InputIt,InputIt) | deque | assign | 0 | +| stl.h:557:33:557:35 | set | (InputIt,InputIt) | deque | assign | 1 | | stl.h:557:33:557:35 | set | (InputIt,InputIt) | forward_list | assign | 0 | | stl.h:557:33:557:35 | set | (InputIt,InputIt) | forward_list | assign | 1 | | stl.h:557:33:557:35 | set | (InputIt,InputIt) | list | assign | 0 | | stl.h:557:33:557:35 | set | (InputIt,InputIt) | list | assign | 1 | | stl.h:557:33:557:35 | set | (InputIt,InputIt) | vector | assign | 0 | | stl.h:557:33:557:35 | set | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:574:38:574:43 | insert | (InputIt,InputIt) | deque | assign | 0 | +| stl.h:574:38:574:43 | insert | (InputIt,InputIt) | deque | assign | 1 | | stl.h:574:38:574:43 | insert | (InputIt,InputIt) | forward_list | assign | 0 | | stl.h:574:38:574:43 | insert | (InputIt,InputIt) | forward_list | assign | 1 | | stl.h:574:38:574:43 | insert | (InputIt,InputIt) | list | assign | 0 | | stl.h:574:38:574:43 | insert | (InputIt,InputIt) | list | assign | 1 | | stl.h:574:38:574:43 | insert | (InputIt,InputIt) | vector | assign | 0 | | stl.h:574:38:574:43 | insert | (InputIt,InputIt) | vector | assign | 1 | +| stl.h:628:38:628:43 | insert | (InputIt,InputIt) | deque | assign | 0 | +| stl.h:628:38:628:43 | insert | (InputIt,InputIt) | deque | assign | 1 | | stl.h:628:38:628:43 | insert | (InputIt,InputIt) | forward_list | assign | 0 | | stl.h:628:38:628:43 | insert | (InputIt,InputIt) | forward_list | assign | 1 | | stl.h:628:38:628:43 | insert | (InputIt,InputIt) | list | assign | 0 | @@ -162,12 +216,17 @@ signatureMatches | stl.h:628:38:628:43 | insert | (InputIt,InputIt) | vector | assign | 0 | | stl.h:628:38:628:43 | insert | (InputIt,InputIt) | vector | assign | 1 | getSignatureParameterName +| (InputIt,InputIt) | deque | assign | 0 | func:0 | +| (InputIt,InputIt) | deque | assign | 1 | func:0 | | (InputIt,InputIt) | forward_list | assign | 0 | func:0 | | (InputIt,InputIt) | forward_list | assign | 1 | func:0 | | (InputIt,InputIt) | list | assign | 0 | func:0 | | (InputIt,InputIt) | list | assign | 1 | func:0 | | (InputIt,InputIt) | vector | assign | 0 | func:0 | | (InputIt,InputIt) | vector | assign | 1 | func:0 | +| (InputIterator,InputIterator,const Allocator &) | deque | deque | 0 | func:0 | +| (InputIterator,InputIterator,const Allocator &) | deque | deque | 1 | func:0 | +| (InputIterator,InputIterator,const Allocator &) | deque | deque | 2 | const class:1 & | | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 0 | InputIterator | | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 1 | InputIterator | | (InputIterator,InputIterator,const Allocator &) | forward_list | forward_list | 2 | const class:1 & | @@ -177,6 +236,9 @@ getSignatureParameterName | (InputIterator,InputIterator,const Allocator &) | vector | vector | 0 | func:0 | | (InputIterator,InputIterator,const Allocator &) | vector | vector | 1 | func:0 | | (InputIterator,InputIterator,const Allocator &) | vector | vector | 2 | const class:1 & | +| (const deque &) | deque | deque | 0 | const deque & | +| (const deque &,const Allocator &) | deque | deque | 0 | const deque & | +| (const deque &,const Allocator &) | deque | deque | 1 | const class:1 & | | (const forward_list &) | forward_list | forward_list | 0 | const forward_list & | | (const forward_list &,const Allocator &) | forward_list | forward_list | 0 | const forward_list & | | (const forward_list &,const Allocator &) | forward_list | forward_list | 1 | const class:1 & | @@ -186,6 +248,9 @@ getSignatureParameterName | (const vector &) | vector | vector | 0 | const vector & | | (const vector &,const Allocator &) | vector | vector | 0 | const vector & | | (const vector &,const Allocator &) | vector | vector | 1 | const class:1 & | +| (const_iterator,InputIt,InputIt) | deque | insert | 0 | const_iterator | +| (const_iterator,InputIt,InputIt) | deque | insert | 1 | func:0 | +| (const_iterator,InputIt,InputIt) | deque | insert | 2 | func:0 | | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 0 | const_iterator | | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 1 | func:0 | | (const_iterator,InputIt,InputIt) | forward_list | insert_after | 2 | func:0 | @@ -195,18 +260,25 @@ getSignatureParameterName | (const_iterator,InputIt,InputIt) | vector | insert | 0 | const_iterator | | (const_iterator,InputIt,InputIt) | vector | insert | 1 | func:0 | | (const_iterator,InputIt,InputIt) | vector | insert | 2 | func:0 | +| (const_iterator,T &&) | deque | insert | 0 | const_iterator | +| (const_iterator,T &&) | deque | insert | 1 | class:0 && | | (const_iterator,T &&) | forward_list | insert_after | 0 | const_iterator | | (const_iterator,T &&) | forward_list | insert_after | 1 | class:0 && | | (const_iterator,T &&) | list | insert | 0 | const_iterator | | (const_iterator,T &&) | list | insert | 1 | class:0 && | | (const_iterator,T &&) | vector | insert | 0 | const_iterator | | (const_iterator,T &&) | vector | insert | 1 | class:0 && | +| (const_iterator,const T &) | deque | insert | 0 | const_iterator | +| (const_iterator,const T &) | deque | insert | 1 | const class:0 & | | (const_iterator,const T &) | forward_list | insert_after | 0 | const_iterator | | (const_iterator,const T &) | forward_list | insert_after | 1 | const class:0 & | | (const_iterator,const T &) | list | insert | 0 | const_iterator | | (const_iterator,const T &) | list | insert | 1 | const class:0 & | | (const_iterator,const T &) | vector | insert | 0 | const_iterator | | (const_iterator,const T &) | vector | insert | 1 | const class:0 & | +| (const_iterator,size_type,const T &) | deque | insert | 0 | const_iterator | +| (const_iterator,size_type,const T &) | deque | insert | 1 | size_type | +| (const_iterator,size_type,const T &) | deque | insert | 2 | const class:0 & | | (const_iterator,size_type,const T &) | forward_list | insert_after | 0 | const_iterator | | (const_iterator,size_type,const T &) | forward_list | insert_after | 1 | size_type | | (const_iterator,size_type,const T &) | forward_list | insert_after | 2 | const class:0 & | @@ -216,12 +288,18 @@ getSignatureParameterName | (const_iterator,size_type,const T &) | vector | insert | 0 | const_iterator | | (const_iterator,size_type,const T &) | vector | insert | 1 | size_type | | (const_iterator,size_type,const T &) | vector | insert | 2 | const class:0 & | +| (deque &&) | deque | deque | 0 | deque && | +| (deque &&,const Allocator &) | deque | deque | 0 | deque && | +| (deque &&,const Allocator &) | deque | deque | 1 | const class:1 & | | (forward_list &&) | forward_list | forward_list | 0 | forward_list && | | (forward_list &&,const Allocator &) | forward_list | forward_list | 0 | forward_list && | | (forward_list &&,const Allocator &) | forward_list | forward_list | 1 | const class:1 & | | (list &&) | list | list | 0 | list && | | (list &&,const Allocator &) | list | list | 0 | list && | | (list &&,const Allocator &) | list | list | 1 | const class:1 & | +| (size_type,const T &,const Allocator &) | deque | deque | 0 | size_type | +| (size_type,const T &,const Allocator &) | deque | deque | 1 | const class:0 & | +| (size_type,const T &,const Allocator &) | deque | deque | 2 | const class:1 & | | (size_type,const T &,const Allocator &) | forward_list | forward_list | 0 | size_type | | (size_type,const T &,const Allocator &) | forward_list | forward_list | 1 | const class:0 & | | (size_type,const T &,const Allocator &) | forward_list | forward_list | 2 | const class:1 & | From 0b4459db7587c20acf3219dc50f43f4a8968f42a Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Mon, 1 Jul 2024 10:13:32 +0100 Subject: [PATCH 20/33] C++: Add more QLDoc. --- .../semmle/code/cpp/dataflow/ExternalFlow.qll | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index bae3c67add11..02916411cd63 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -14,11 +14,17 @@ * The interpretation of a row is similar to API-graphs with a left-to-right * reading. * 1. The `namespace` column selects a namespace. - * 2. The `type` column selects a type within that namespace. + * 2. The `type` column selects a type within that namespace. This column can + * introduce template names that can be mentioned in the `signature` column. + * For example, `vector` introduces the template names `T` and + * `Allocator`. * 3. The `subtypes` is a boolean that indicates whether to jump to an * arbitrary subtype of that type. Set this to `false` if leaving the `type` * blank (for example, a free function). * 4. The `name` column optionally selects a specific named member of the type. + * Like the `type` column, this column can introduce template names that can + * be mentioned in the `signature` column. For example, `insert` + * introduces the template name `InputIt`. * 5. The `signature` column optionally restricts the named member. If * `signature` is blank then no such filtering is done. The format of the * signature is a comma-separated list of types enclosed in parentheses. The @@ -44,6 +50,9 @@ * One or more "*" can be added as an argument to indicate indirection, for * example, "ReturnValue[*]" indicates the first indirection of the return * value. + * The special symbol `@` can be used to specify an arbitrary (but fixed) + * number of indirections. For example, the `input` column `Argument[*@0]` + * indicates one or more indirections of the 0th argument. * * An `output` can be either: * - "": Selects a read of a selected field. @@ -65,6 +74,17 @@ * One or more "*" can be added as an argument to indicate indirection, for * example, "ReturnValue[*]" indicates the first indirection of the return * value. + * The special symbol `@` can be used to specify an arbitrary (but fixed) + * number of indirections. For example, the `output` column + * `ReturnValue[*@0]` indicates one or more indirections of the return + * value. + * Note: The symbol `@` only ever takes a single value across a row. Thus, + * the (`input`, `output`) pair `("Argument[*@0]", "ReturnValue[@]")` + * represents: + * - flow from the _first_ indirection of the 0th argument to the return + * value, and + * - flow from the _second_ indirection of the 0th argument to the first + * indirection of the return value, etc. * 8. The `kind` column is a tag that can be referenced from QL to determine to * which classes the interpreted elements should be added. For example, for * sources "remote" indicates a default remote flow source, and for summaries From c104a0a74c6d272b1423ffec3276031f73ec02b4 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Tue, 2 Jul 2024 14:23:04 +0100 Subject: [PATCH 21/33] C++: Expand QLDoc on 'signatureMatches'. --- .../semmle/code/cpp/dataflow/ExternalFlow.qll | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index 02916411cd63..0dcbe177e5ad 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -626,7 +626,22 @@ private string getSignatureParameterName(string signature, string type, string n } /** - * Holds if the `i`'th name in `signature` matches the `i` name in `paramsString(func)`. + * Holds if the suffix containing the entries in `signature` starting at entry + * `i` matches the suffix containing the parameters of `func` starting at entry `i`. + * + * For example, consider the signature `(int,bool,char)` and a function: + * ``` + * void f(int a, bool b, char c); + * ``` + * 1. The predicate holds for `i = 2` because the suffix containing all the entries + * in `signature` starting at `2` is `char`, and suffix containing all the parameters + * of `func` starting at `2` is `char`. + * 2. The predicate holds for `i = 1` because the suffix containing all the entries + * in `signature` starting at `1` is `bool,char`, and the suffix containing all the + * parameters of `func` starting at `1` is `bool, char`. + * 3. The predicate holds for `i = 0` because the suffix containing all the entries + * in `signature` starting at `0` is `int,bool,char` and the suffix containing all + * the parameters of `func` starting at `0` is `int, bool, char`. * * When `paramsString(func)[i]` is `class:n` then the signature name is * compared with the `n`'th name in `type`, and when `paramsString(func)[i]` From 6b025db824a5526c6bab70518701745c9c723934 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Tue, 2 Jul 2024 14:26:15 +0100 Subject: [PATCH 22/33] C++: Add QLDoc to 'getParameterTypeName'. --- cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll | 1 + 1 file changed, 1 insertion(+) diff --git a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll index 0dcbe177e5ad..3d9a648ea6ce 100644 --- a/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll +++ b/cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll @@ -482,6 +482,7 @@ private string getTypeNameWithoutClassTemplates(Function f, int n, int remaining ) } +/** Gets the string representation of the `i`'th parameter of `c`. */ private string getParameterTypeName(Function c, int i) { result = getTypeNameWithoutClassTemplates(c, i, 0) } From 5be948533c22525716758721635fe69095c11492 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 11:18:13 +0100 Subject: [PATCH 23/33] C++: Replace 'Element[*@]' with 'Element[@]'. --- cpp/ql/lib/ext/bsl.array.model.yml | 14 +-- cpp/ql/lib/ext/bsl.deque.model.yml | 100 +++++++++++----------- cpp/ql/lib/ext/bsl.forward_list.model.yml | 78 ++++++++--------- cpp/ql/lib/ext/bsl.list.model.yml | 96 ++++++++++----------- cpp/ql/lib/ext/bsl.vector.model.yml | 86 +++++++++---------- cpp/ql/lib/ext/std.array.model.yml | 14 +-- cpp/ql/lib/ext/std.deque.model .yml | 100 +++++++++++----------- cpp/ql/lib/ext/std.forward_list.model.yml | 78 ++++++++--------- cpp/ql/lib/ext/std.iterator.model.yml | 12 +-- cpp/ql/lib/ext/std.list.model.yml | 96 ++++++++++----------- cpp/ql/lib/ext/std.vector.model.yml | 86 +++++++++---------- 11 files changed, 380 insertions(+), 380 deletions(-) diff --git a/cpp/ql/lib/ext/bsl.array.model.yml b/cpp/ql/lib/ext/bsl.array.model.yml index 1c47fdc9ad5e..067906bcc0d8 100644 --- a/cpp/ql/lib/ext/bsl.array.model.yml +++ b/cpp/ql/lib/ext/bsl.array.model.yml @@ -3,10 +3,10 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["bsl", "array", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "array", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "array", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "array", True, "data", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "array", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "array", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "array", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] \ No newline at end of file + - ["bsl", "array", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "array", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "array", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "array", True, "data", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "array", True, "operator[]", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "array", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "array", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/bsl.deque.model.yml b/cpp/ql/lib/ext/bsl.deque.model.yml index b24d95ebad15..517f5b7802d9 100644 --- a/cpp/ql/lib/ext/bsl.deque.model.yml +++ b/cpp/ql/lib/ext/bsl.deque.model.yml @@ -3,70 +3,70 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["bsl", "deque", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "deque", "(const deque &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "deque", "(deque &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "deque", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "deque", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] \ No newline at end of file + - ["bsl", "deque", True, "emplace_front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "operator=", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "operator[]", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(const deque &,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(deque &&,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "deque", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/bsl.forward_list.model.yml b/cpp/ql/lib/ext/bsl.forward_list.model.yml index 08993ebfbb4d..645bf89c9a0b 100644 --- a/cpp/ql/lib/ext/bsl.forward_list.model.yml +++ b/cpp/ql/lib/ext/bsl.forward_list.model.yml @@ -3,53 +3,53 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "forward_list", "(const forward_list &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "forward_list", "(forward_list &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "forward_list", "(const forward_list &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "forward_list", "(forward_list &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "forward_list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "forward_list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(const forward_list &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(forward_list &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "operator=", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(const forward_list &,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(forward_list &&,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "forward_list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/bsl.list.model.yml b/cpp/ql/lib/ext/bsl.list.model.yml index e3873de14ac8..7112a06bc077 100644 --- a/cpp/ql/lib/ext/bsl.list.model.yml +++ b/cpp/ql/lib/ext/bsl.list.model.yml @@ -3,68 +3,68 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["bsl", "list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "list", "(const list &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "list", "(list &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "list", "(const list &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "list", "(list &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["bsl", "list", True, "emplace_front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "list", "(const list &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "list", "(list &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "operator=", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "list", "(const list &,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "list", "(list &&,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/bsl.vector.model.yml b/cpp/ql/lib/ext/bsl.vector.model.yml index 0b23f46d76a8..ac5f6053e68e 100644 --- a/cpp/ql/lib/ext/bsl.vector.model.yml +++ b/cpp/ql/lib/ext/bsl.vector.model.yml @@ -3,57 +3,57 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["bsl", "vector", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "data", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "data", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "vector", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "vector", "(const vector &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "vector", "(vector &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "vector", "(const vector &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "vector", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "vector", "(vector &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "vector", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file + - ["bsl", "vector", True, "emplace_back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "operator=", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "operator[]", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(const vector &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(vector &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(const vector &,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(vector &&,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "vector", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.array.model.yml b/cpp/ql/lib/ext/std.array.model.yml index 1b00e4086212..d38947981c81 100644 --- a/cpp/ql/lib/ext/std.array.model.yml +++ b/cpp/ql/lib/ext/std.array.model.yml @@ -3,10 +3,10 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "array", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "array", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "array", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "array", True, "data", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "array", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "array", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "array", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] \ No newline at end of file + - ["std", "array", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "array", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "array", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "array", True, "data", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "array", True, "operator[]", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "array", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "array", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.deque.model .yml b/cpp/ql/lib/ext/std.deque.model .yml index ec353f3cda63..eb113c4ee8c6 100644 --- a/cpp/ql/lib/ext/std.deque.model .yml +++ b/cpp/ql/lib/ext/std.deque.model .yml @@ -3,70 +3,70 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "deque", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "deque", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "deque", "(const deque &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "deque", "(deque &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "deque", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "deque", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] \ No newline at end of file + - ["std", "deque", True, "emplace_front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "operator=", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "operator[]", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "deque", "(const deque &,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "deque", "(deque &&,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "deque", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "deque", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.forward_list.model.yml b/cpp/ql/lib/ext/std.forward_list.model.yml index 2e3e07f936e2..e461123cd4eb 100644 --- a/cpp/ql/lib/ext/std.forward_list.model.yml +++ b/cpp/ql/lib/ext/std.forward_list.model.yml @@ -3,53 +3,53 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(const forward_list &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(forward_list &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(const forward_list &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(forward_list &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "forward_list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(const forward_list &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(forward_list &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "operator=", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(const forward_list &,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(forward_list &&,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "forward_list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.iterator.model.yml b/cpp/ql/lib/ext/std.iterator.model.yml index 927050245637..6c4056cc88f0 100644 --- a/cpp/ql/lib/ext/std.iterator.model.yml +++ b/cpp/ql/lib/ext/std.iterator.model.yml @@ -3,9 +3,9 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "iterator", True, "operator*", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "iterator", True, "operator->", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "iterator", True, "iterator", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["__gnu_cxx", "__normal_iterator", True, "operator*", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["__gnu_cxx", "__normal_iterator", True, "operator->", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["__gnu_cxx", "__normal_iterator", True, "__normal_iterator", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] \ No newline at end of file + - ["std", "iterator", True, "operator*", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "iterator", True, "operator->", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "iterator", True, "iterator", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["__gnu_cxx", "__normal_iterator", True, "operator*", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["__gnu_cxx", "__normal_iterator", True, "operator->", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["__gnu_cxx", "__normal_iterator", True, "__normal_iterator", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.list.model.yml b/cpp/ql/lib/ext/std.list.model.yml index 4e8d75f78f21..402ac9152f68 100644 --- a/cpp/ql/lib/ext/std.list.model.yml +++ b/cpp/ql/lib/ext/std.list.model.yml @@ -3,68 +3,68 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_front", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_front", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_front", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_front", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_front", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace_front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "list", "(const list &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "list", "(list &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "list", "(const list &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "list", "(list &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] + - ["std", "list", True, "emplace_front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "list", "(const list &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "list", "(list &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "operator=", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "push_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "list", "(const list &,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "list", "(list &&,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "list", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "list", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.vector.model.yml b/cpp/ql/lib/ext/std.vector.model.yml index 4f12f962bafc..0f5c0a55454f 100644 --- a/cpp/ql/lib/ext/std.vector.model.yml +++ b/cpp/ql/lib/ext/std.vector.model.yml @@ -3,57 +3,57 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "vector", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "at", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "begin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "cbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "data", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "data", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[*@]", "value", "manual"] + - ["std", "vector", True, "emplace_back", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "emplace_back", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "front", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "operator=", "", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "operator[]", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] - - ["std", "vector", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "rbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "rcbegin", "", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "vector", "(const vector &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "vector", "(vector &&)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "vector", "(const vector &,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "vector", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "vector", "(vector &&,const Allocator &)", "", "Argument[*0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "vector", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[*@]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[*@]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[*@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[*@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[-1].Element[*@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file + - ["std", "vector", True, "emplace_back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,InputIt,InputIt)", "", "Argument[1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "operator=", "", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "operator[]", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "push_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "vector", "(const vector &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "vector", "(vector &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "vector", "(const vector &,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "vector", "(size_type,const T &,const Allocator &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "vector", "(vector &&,const Allocator &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "vector", "(InputIterator,InputIterator,const Allocator &)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file From b8c01e290194038616b8426a930755bd93b4036b Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 11:18:21 +0100 Subject: [PATCH 24/33] C++: Accept test changes. --- .../dataflow/dataflow-tests/type-bugs.expected | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected b/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected index 2e4776464f88..b79e7cd42714 100644 --- a/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected +++ b/cpp/ql/test/library-tests/dataflow/dataflow-tests/type-bugs.expected @@ -2,33 +2,37 @@ astTypeBugs irTypeBugs | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary param] *0 in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary param] this in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element[****] in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element[***] in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element[**] in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] read: Argument[*0].Element[*] in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this] in iterator | +| ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element[****] in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element[***] in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element[**] in iterator | | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | ../../../include/iterator.h:21:3:21:10 | [summary] to write: Argument[this].Element[*] in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary param] *0 in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary param] this in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element[****] in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element[***] in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element[**] in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] read: Argument[*0].Element[*] in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this] in iterator | +| ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element[****] in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element[***] in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element[**] in iterator | | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | ../../../include/iterator.h:22:3:22:10 | [summary] to write: Argument[this].Element[*] in iterator | | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary param] this in operator* | -| ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] read: Argument[this].Element[**] in operator* | +| ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] read: Argument[this].Element in operator* | | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] read: Argument[this].Element[*] in operator* | | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] to write: ReturnValue[**] in operator* | | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | ../../../include/iterator.h:30:18:30:26 | [summary] to write: ReturnValue[*] in operator* | | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary param] this in operator-> | -| ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] read: Argument[this].Element[**] in operator-> | +| ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] read: Argument[this].Element in operator-> | | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] read: Argument[this].Element[*] in operator-> | | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] to write: ReturnValue[**] in operator-> | | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | ../../../include/iterator.h:31:16:31:25 | [summary] to write: ReturnValue[*] in operator-> | From d7eac4d56772fad63e698a8cdbe97b9f2ab3764a Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 11:33:52 +0100 Subject: [PATCH 25/33] C++: Add change note. --- cpp/ql/lib/change-notes/2024-07-03-extended-mad-syntax.md | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 cpp/ql/lib/change-notes/2024-07-03-extended-mad-syntax.md diff --git a/cpp/ql/lib/change-notes/2024-07-03-extended-mad-syntax.md b/cpp/ql/lib/change-notes/2024-07-03-extended-mad-syntax.md new file mode 100644 index 000000000000..e29106e94af1 --- /dev/null +++ b/cpp/ql/lib/change-notes/2024-07-03-extended-mad-syntax.md @@ -0,0 +1,4 @@ +--- +category: feature +--- +* The syntax for models-as-data rows has been extended to make it easier to select sources, sinks, and summaries that involve templated functions and classes. Additionally, the syntax has also been extended to make it easier to specify models with arbitrary levels of indirection. See `dataflow/ExternalFlow.qll` for the updated documentation and specification for the model format. \ No newline at end of file From c4dabb94d6ea8626382fc71f6d851ad08740f724 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 16:03:25 +0100 Subject: [PATCH 26/33] C++: Add models for 'array::front' and 'array::back'. --- cpp/ql/lib/ext/std.array.model.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/cpp/ql/lib/ext/std.array.model.yml b/cpp/ql/lib/ext/std.array.model.yml index d38947981c81..adb4c2526baf 100644 --- a/cpp/ql/lib/ext/std.array.model.yml +++ b/cpp/ql/lib/ext/std.array.model.yml @@ -9,4 +9,6 @@ extensions: - ["std", "array", True, "data", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["std", "array", True, "operator[]", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["std", "array", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - - ["std", "array", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file + - ["std", "array", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "array", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "array", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file From e03f8084e62f087bfed247ad7c9e39b4202fb51d Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 16:04:14 +0100 Subject: [PATCH 27/33] C++: Fix yml file name. --- cpp/ql/lib/ext/{std.deque.model .yml => std.deque.model.yml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename cpp/ql/lib/ext/{std.deque.model .yml => std.deque.model.yml} (100%) diff --git a/cpp/ql/lib/ext/std.deque.model .yml b/cpp/ql/lib/ext/std.deque.model.yml similarity index 100% rename from cpp/ql/lib/ext/std.deque.model .yml rename to cpp/ql/lib/ext/std.deque.model.yml From 6d053247244c9bc3e4db727451a0edc96a076001 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 16:47:18 +0100 Subject: [PATCH 28/33] C++: Make sure the 'emplace' functions that return iterators are modeled via Element content. --- cpp/ql/lib/ext/bsl.deque.model.yml | 12 ++++++------ cpp/ql/lib/ext/bsl.vector.model.yml | 14 +++++++------- cpp/ql/lib/ext/std.deque.model.yml | 12 ++++++------ cpp/ql/lib/ext/std.forward_list.model.yml | 12 ++++++------ cpp/ql/lib/ext/std.list.model.yml | 12 ++++++------ cpp/ql/lib/ext/std.vector.model.yml | 14 +++++++------- 6 files changed, 38 insertions(+), 38 deletions(-) diff --git a/cpp/ql/lib/ext/bsl.deque.model.yml b/cpp/ql/lib/ext/bsl.deque.model.yml index 517f5b7802d9..37ecbefea536 100644 --- a/cpp/ql/lib/ext/bsl.deque.model.yml +++ b/cpp/ql/lib/ext/bsl.deque.model.yml @@ -12,16 +12,16 @@ extensions: - ["bsl", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@3]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@4]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "deque", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[*@5]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "deque", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/bsl.vector.model.yml b/cpp/ql/lib/ext/bsl.vector.model.yml index ac5f6053e68e..dbff1c550802 100644 --- a/cpp/ql/lib/ext/bsl.vector.model.yml +++ b/cpp/ql/lib/ext/bsl.vector.model.yml @@ -11,15 +11,16 @@ extensions: - ["bsl", "vector", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "data", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@3]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@4]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[*@5]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "vector", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] @@ -55,5 +56,4 @@ extensions: - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - - ["bsl", "vector", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file + - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.deque.model.yml b/cpp/ql/lib/ext/std.deque.model.yml index eb113c4ee8c6..9d5b52f5ab3c 100644 --- a/cpp/ql/lib/ext/std.deque.model.yml +++ b/cpp/ql/lib/ext/std.deque.model.yml @@ -12,16 +12,16 @@ extensions: - ["std", "deque", True, "deque", "(const deque &)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "deque", "(deque &&)", "", "Argument[*0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@3]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@4]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "deque", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "deque", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[*@5]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - ["std", "deque", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.forward_list.model.yml b/cpp/ql/lib/ext/std.forward_list.model.yml index e461123cd4eb..38352ddc716e 100644 --- a/cpp/ql/lib/ext/std.forward_list.model.yml +++ b/cpp/ql/lib/ext/std.forward_list.model.yml @@ -11,16 +11,16 @@ extensions: - ["std", "forward_list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - ["std", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.list.model.yml b/cpp/ql/lib/ext/std.list.model.yml index 402ac9152f68..aa9e5b4a5120 100644 --- a/cpp/ql/lib/ext/std.list.model.yml +++ b/cpp/ql/lib/ext/std.list.model.yml @@ -9,16 +9,16 @@ extensions: - ["std", "list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@3]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@4]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["std", "list", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[*@5]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - ["std", "list", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.vector.model.yml b/cpp/ql/lib/ext/std.vector.model.yml index 0f5c0a55454f..f1ca9a8efca3 100644 --- a/cpp/ql/lib/ext/std.vector.model.yml +++ b/cpp/ql/lib/ext/std.vector.model.yml @@ -11,15 +11,16 @@ extensions: - ["std", "vector", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "data", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@3]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@4]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "emplace", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[*@5]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - ["std", "vector", True, "emplace_back", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] @@ -55,5 +56,4 @@ extensions: - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - - ["std", "vector", True, "emplace", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file From 5351c2734f551870fbbe90222af06ea2e71f3787 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 17:01:43 +0100 Subject: [PATCH 29/33] C++: Fix 'assign' models. --- cpp/ql/lib/ext/bsl.deque.model.yml | 4 ++-- cpp/ql/lib/ext/bsl.forward_list.model.yml | 4 ++-- cpp/ql/lib/ext/bsl.list.model.yml | 4 ++-- cpp/ql/lib/ext/bsl.vector.model.yml | 4 ++-- cpp/ql/lib/ext/std.deque.model.yml | 4 ++-- cpp/ql/lib/ext/std.forward_list.model.yml | 4 ++-- cpp/ql/lib/ext/std.list.model.yml | 4 ++-- cpp/ql/lib/ext/std.vector.model.yml | 4 ++-- 8 files changed, 16 insertions(+), 16 deletions(-) diff --git a/cpp/ql/lib/ext/bsl.deque.model.yml b/cpp/ql/lib/ext/bsl.deque.model.yml index 37ecbefea536..dd7761913779 100644 --- a/cpp/ql/lib/ext/bsl.deque.model.yml +++ b/cpp/ql/lib/ext/bsl.deque.model.yml @@ -3,8 +3,8 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["bsl", "deque", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "assign", "(size_type,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "deque", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "deque", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "deque", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/bsl.forward_list.model.yml b/cpp/ql/lib/ext/bsl.forward_list.model.yml index 645bf89c9a0b..23d15afce5a8 100644 --- a/cpp/ql/lib/ext/bsl.forward_list.model.yml +++ b/cpp/ql/lib/ext/bsl.forward_list.model.yml @@ -6,8 +6,8 @@ extensions: - ["bsl", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - - ["bsl", "forward_list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "assign", "(size_type,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/bsl.list.model.yml b/cpp/ql/lib/ext/bsl.list.model.yml index 7112a06bc077..9a0b24f8c4dc 100644 --- a/cpp/ql/lib/ext/bsl.list.model.yml +++ b/cpp/ql/lib/ext/bsl.list.model.yml @@ -3,8 +3,8 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["bsl", "list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "assign", "(size_type,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/bsl.vector.model.yml b/cpp/ql/lib/ext/bsl.vector.model.yml index dbff1c550802..dafb07762275 100644 --- a/cpp/ql/lib/ext/bsl.vector.model.yml +++ b/cpp/ql/lib/ext/bsl.vector.model.yml @@ -3,8 +3,8 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["bsl", "vector", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "assign", "(size_type,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["bsl", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "vector", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "vector", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "vector", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.deque.model.yml b/cpp/ql/lib/ext/std.deque.model.yml index 9d5b52f5ab3c..ffc787b2818f 100644 --- a/cpp/ql/lib/ext/std.deque.model.yml +++ b/cpp/ql/lib/ext/std.deque.model.yml @@ -3,8 +3,8 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "deque", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "assign", "(size_type,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "deque", True, "assign", "(InputIt,InputIt)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "deque", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["std", "deque", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["std", "deque", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.forward_list.model.yml b/cpp/ql/lib/ext/std.forward_list.model.yml index 38352ddc716e..8307f56f45d9 100644 --- a/cpp/ql/lib/ext/std.forward_list.model.yml +++ b/cpp/ql/lib/ext/std.forward_list.model.yml @@ -6,8 +6,8 @@ extensions: - ["std", "forward_list", True, "insert_after", "(const_iterator,InputIt,InputIt)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "insert_after", "(const_iterator,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - - ["std", "forward_list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "assign", "(size_type,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "forward_list", True, "assign", "(InputIt,InputIt)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.list.model.yml b/cpp/ql/lib/ext/std.list.model.yml index aa9e5b4a5120..76d10f3180dd 100644 --- a/cpp/ql/lib/ext/std.list.model.yml +++ b/cpp/ql/lib/ext/std.list.model.yml @@ -3,8 +3,8 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "list", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "assign", "(size_type,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "list", True, "assign", "(InputIt,InputIt)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["std", "list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] diff --git a/cpp/ql/lib/ext/std.vector.model.yml b/cpp/ql/lib/ext/std.vector.model.yml index f1ca9a8efca3..e910d24db335 100644 --- a/cpp/ql/lib/ext/std.vector.model.yml +++ b/cpp/ql/lib/ext/std.vector.model.yml @@ -3,8 +3,8 @@ extensions: pack: codeql/cpp-all extensible: summaryModel data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance - - ["std", "vector", True, "assign", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "assign", "(size_type,const T &)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] + - ["std", "vector", True, "assign", "(InputIt,InputIt)", "", "Argument[0].Element[@]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "vector", True, "at", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["std", "vector", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["std", "vector", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] From 246f3fd3e23a50cba7249111b526734c2e8e2884 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 17:18:50 +0100 Subject: [PATCH 30/33] C++: Fix 'emplace_after' model in bsl. --- cpp/ql/lib/ext/bsl.forward_list.model.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/cpp/ql/lib/ext/bsl.forward_list.model.yml b/cpp/ql/lib/ext/bsl.forward_list.model.yml index 23d15afce5a8..2c04c230098d 100644 --- a/cpp/ql/lib/ext/bsl.forward_list.model.yml +++ b/cpp/ql/lib/ext/bsl.forward_list.model.yml @@ -11,16 +11,16 @@ extensions: - ["bsl", "forward_list", True, "begin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "cbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@3]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@4]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "ReturnValue[*@]", "value", "manual"] - - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[*@5]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "emplace_after", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@0]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "forward_list", True, "emplace_front", "", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] From f9d6c63cbb353c6f921faa12b086db09a973a0ec Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 17:27:22 +0100 Subject: [PATCH 31/33] C++: Add more 'Argument[-1]' to 'ReturnValue' flow. --- cpp/ql/lib/ext/bsl.deque.model.yml | 3 ++- cpp/ql/lib/ext/bsl.forward_list.model.yml | 1 + cpp/ql/lib/ext/bsl.list.model.yml | 1 + cpp/ql/lib/ext/bsl.vector.model.yml | 3 ++- cpp/ql/lib/ext/std.deque.model.yml | 3 ++- cpp/ql/lib/ext/std.forward_list.model.yml | 1 + cpp/ql/lib/ext/std.list.model.yml | 1 + cpp/ql/lib/ext/std.vector.model.yml | 3 ++- 8 files changed, 12 insertions(+), 4 deletions(-) diff --git a/cpp/ql/lib/ext/bsl.deque.model.yml b/cpp/ql/lib/ext/bsl.deque.model.yml index dd7761913779..54ac89da5111 100644 --- a/cpp/ql/lib/ext/bsl.deque.model.yml +++ b/cpp/ql/lib/ext/bsl.deque.model.yml @@ -69,4 +69,5 @@ extensions: - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file + - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/bsl.forward_list.model.yml b/cpp/ql/lib/ext/bsl.forward_list.model.yml index 2c04c230098d..0f34f944626f 100644 --- a/cpp/ql/lib/ext/bsl.forward_list.model.yml +++ b/cpp/ql/lib/ext/bsl.forward_list.model.yml @@ -53,3 +53,4 @@ extensions: - ["bsl", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/bsl.list.model.yml b/cpp/ql/lib/ext/bsl.list.model.yml index 9a0b24f8c4dc..f4bc683db9f9 100644 --- a/cpp/ql/lib/ext/bsl.list.model.yml +++ b/cpp/ql/lib/ext/bsl.list.model.yml @@ -68,3 +68,4 @@ extensions: - ["bsl", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/bsl.vector.model.yml b/cpp/ql/lib/ext/bsl.vector.model.yml index dafb07762275..dc1c44ab0bea 100644 --- a/cpp/ql/lib/ext/bsl.vector.model.yml +++ b/cpp/ql/lib/ext/bsl.vector.model.yml @@ -56,4 +56,5 @@ extensions: - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file + - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.deque.model.yml b/cpp/ql/lib/ext/std.deque.model.yml index ffc787b2818f..e630f224192d 100644 --- a/cpp/ql/lib/ext/std.deque.model.yml +++ b/cpp/ql/lib/ext/std.deque.model.yml @@ -69,4 +69,5 @@ extensions: - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "deque", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file + - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "deque", True, "insert", "(const_iterator,T &&)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.forward_list.model.yml b/cpp/ql/lib/ext/std.forward_list.model.yml index 8307f56f45d9..7d0e560a6d7e 100644 --- a/cpp/ql/lib/ext/std.forward_list.model.yml +++ b/cpp/ql/lib/ext/std.forward_list.model.yml @@ -53,3 +53,4 @@ extensions: - ["std", "forward_list", True, "insert_after", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "forward_list", True, "insert_after", "(const_iterator,T &&)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.list.model.yml b/cpp/ql/lib/ext/std.list.model.yml index 76d10f3180dd..d9ed194fe1e9 100644 --- a/cpp/ql/lib/ext/std.list.model.yml +++ b/cpp/ql/lib/ext/std.list.model.yml @@ -68,3 +68,4 @@ extensions: - ["std", "list", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "list", True, "insert", "(const_iterator,T &&)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file diff --git a/cpp/ql/lib/ext/std.vector.model.yml b/cpp/ql/lib/ext/std.vector.model.yml index e910d24db335..0c8a82eca415 100644 --- a/cpp/ql/lib/ext/std.vector.model.yml +++ b/cpp/ql/lib/ext/std.vector.model.yml @@ -56,4 +56,5 @@ extensions: - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[*@2]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "insert", "(const_iterator,size_type,const T &)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "Argument[-1].Element[@]", "value", "manual"] - - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[*@1]", "ReturnValue.Element[@]", "value", "manual"] + - ["std", "vector", True, "insert", "(const_iterator,T &&)", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file From af28dd8eb4c85e4a9ab14280f3e2540dcd57fb58 Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 18:14:10 +0100 Subject: [PATCH 32/33] C++: Add bsl models for 'array::front' and 'array::back'. --- cpp/ql/lib/ext/bsl.array.model.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/cpp/ql/lib/ext/bsl.array.model.yml b/cpp/ql/lib/ext/bsl.array.model.yml index 067906bcc0d8..bfe87b93eca4 100644 --- a/cpp/ql/lib/ext/bsl.array.model.yml +++ b/cpp/ql/lib/ext/bsl.array.model.yml @@ -9,4 +9,6 @@ extensions: - ["bsl", "array", True, "data", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "array", True, "operator[]", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] - ["bsl", "array", True, "rbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] - - ["bsl", "array", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] \ No newline at end of file + - ["bsl", "array", True, "rcbegin", "", "", "Argument[-1].Element[@]", "ReturnValue.Element[@]", "value", "manual"] + - ["bsl", "array", True, "front", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] + - ["bsl", "array", True, "back", "", "", "Argument[-1].Element[@]", "ReturnValue[*@]", "value", "manual"] \ No newline at end of file From 356d92854412d5aa4b9ca9ad08c8bc36b43365ae Mon Sep 17 00:00:00 2001 From: Mathias Vorreiter Pedersen Date: Wed, 3 Jul 2024 18:16:20 +0100 Subject: [PATCH 33/33] C++: Accept test changes. --- .../external-models/validatemodels.expected | 1 + .../taint-tests/test_mad-signatures.expected | 32 +++++++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected b/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected index 04c4cb3bfbb5..4086b2c99568 100644 --- a/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected +++ b/cpp/ql/test/library-tests/dataflow/external-models/validatemodels.expected @@ -20,6 +20,7 @@ | Dubious signature "(forward_list &&,const Allocator &)" in summary model. | | Dubious signature "(list &&)" in summary model. | | Dubious signature "(list &&,const Allocator &)" in summary model. | +| Dubious signature "(size_type,const T &)" in summary model. | | Dubious signature "(size_type,const T &,const Allocator &)" in summary model. | | Dubious signature "(vector &&)" in summary model. | | Dubious signature "(vector &&,const Allocator &)" in summary model. | diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected index 82fef0dd4ab0..e00434dd75fb 100644 --- a/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/test_mad-signatures.expected @@ -119,6 +119,30 @@ signatureMatches | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | | stl.h:306:8:306:13 | assign | (const_iterator,const T &) | vector | insert | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | deque | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | deque | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | deque | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | deque | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | deque | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | deque | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | forward_list | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | forward_list | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | forward_list | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | forward_list | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | forward_list | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | forward_list | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | list | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | list | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | list | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | list | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | list | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | list | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | vector | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | vector | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | vector | assign | 0 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | vector | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | vector | assign | 1 | +| stl.h:306:8:306:13 | assign | (size_type,const T &) | vector | assign | 1 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | deque | insert | 0 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | deque | insert | 1 | | stl.h:331:12:331:17 | insert | (const_iterator,T &&) | forward_list | insert_after | 0 | @@ -297,6 +321,14 @@ getSignatureParameterName | (list &&) | list | list | 0 | list && | | (list &&,const Allocator &) | list | list | 0 | list && | | (list &&,const Allocator &) | list | list | 1 | const class:1 & | +| (size_type,const T &) | deque | assign | 0 | size_type | +| (size_type,const T &) | deque | assign | 1 | const class:0 & | +| (size_type,const T &) | forward_list | assign | 0 | size_type | +| (size_type,const T &) | forward_list | assign | 1 | const class:0 & | +| (size_type,const T &) | list | assign | 0 | size_type | +| (size_type,const T &) | list | assign | 1 | const class:0 & | +| (size_type,const T &) | vector | assign | 0 | size_type | +| (size_type,const T &) | vector | assign | 1 | const class:0 & | | (size_type,const T &,const Allocator &) | deque | deque | 0 | size_type | | (size_type,const T &,const Allocator &) | deque | deque | 1 | const class:0 & | | (size_type,const T &,const Allocator &) | deque | deque | 2 | const class:1 & |