diff --git a/extensions/ql-vscode/package-lock.json b/extensions/ql-vscode/package-lock.json index 603ce702c..4d9a4af28 100644 --- a/extensions/ql-vscode/package-lock.json +++ b/extensions/ql-vscode/package-lock.json @@ -21,6 +21,7 @@ "d3-graphviz": "^2.6.1", "fs-extra": "^10.0.1", "glob-promise": "^4.2.2", + "immutable": "^4.0.0", "js-yaml": "^4.1.0", "minimist": "~1.2.6", "nanoid": "^3.2.0", @@ -7403,6 +7404,11 @@ "node": ">= 4" } }, + "node_modules/immutable": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.0.0.tgz", + "integrity": "sha512-zIE9hX70qew5qTUjSS7wi1iwj/l7+m54KWU247nhM3v806UdGj1yDndXj+IOYxxtW9zyLI+xqFNZjTuDaLUqFw==" + }, "node_modules/import-fresh": { "version": "3.2.1", "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.2.1.tgz", @@ -20516,6 +20522,11 @@ "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==", "dev": true }, + "immutable": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.0.0.tgz", + "integrity": "sha512-zIE9hX70qew5qTUjSS7wi1iwj/l7+m54KWU247nhM3v806UdGj1yDndXj+IOYxxtW9zyLI+xqFNZjTuDaLUqFw==" + }, "import-fresh": { "version": "3.2.1", "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.2.1.tgz", diff --git a/extensions/ql-vscode/package.json b/extensions/ql-vscode/package.json index b7bef2764..866d9fec8 100644 --- a/extensions/ql-vscode/package.json +++ b/extensions/ql-vscode/package.json @@ -1211,6 +1211,7 @@ "d3-graphviz": "^2.6.1", "fs-extra": "^10.0.1", "glob-promise": "^4.2.2", + "immutable": "^4.0.0", "js-yaml": "^4.1.0", "minimist": "~1.2.6", "nanoid": "^3.2.0", diff --git a/extensions/ql-vscode/src/cli.ts b/extensions/ql-vscode/src/cli.ts index 9c7357dfa..f52c1c36b 100644 --- a/extensions/ql-vscode/src/cli.ts +++ b/extensions/ql-vscode/src/cli.ts @@ -695,7 +695,7 @@ export class CodeQLCliServer implements Disposable { * @param inputPath The path of an evaluation event log. * @param outputPath The path to write a JSON summary of it to. */ - async generateJsonLogSummary( + async generateJsonLogSummary( inputPath: string, outputPath: string, ): Promise { diff --git a/extensions/ql-vscode/src/extension.ts b/extensions/ql-vscode/src/extension.ts index e74a8c687..4da5e8ab9 100644 --- a/extensions/ql-vscode/src/extension.ts +++ b/extensions/ql-vscode/src/extension.ts @@ -100,6 +100,8 @@ import { exportRemoteQueryResults } from './remote-queries/export-results'; import { RemoteQuery } from './remote-queries/remote-query'; import { EvalLogViewer } from './eval-log-viewer'; import { SummaryLanguageSupport } from './log-insights/summary-language-support'; +import { JoinOrderScannerProvider } from './log-insights/join-order'; +import { LogScannerService } from './log-insights/log-scanner-service'; /** * extension.ts @@ -483,6 +485,11 @@ async function activateWithInstalledDistribution( ctx.subscriptions.push(qhm); + void logger.log('Initializing evaluation log scanners.'); + const logScannerService = new LogScannerService(qhm); + ctx.subscriptions.push(logScannerService); + ctx.subscriptions.push(logScannerService.scanners.registerLogScannerProvider(new JoinOrderScannerProvider())); + void logger.log('Reading query history'); await qhm.readQueryHistory(); @@ -556,7 +563,7 @@ async function activateWithInstalledDistribution( undefined, item, ); - item.completeThisQuery(completedQueryInfo); + qhm.completeQuery(item, completedQueryInfo); await showResultsForCompletedQuery(item as CompletedLocalQueryInfo, WebviewReveal.NotForced); // Note we must update the query history view after showing results as the // display and sorting might depend on the number of results diff --git a/extensions/ql-vscode/src/log-insights/join-order.ts b/extensions/ql-vscode/src/log-insights/join-order.ts new file mode 100644 index 000000000..7234a95be --- /dev/null +++ b/extensions/ql-vscode/src/log-insights/join-order.ts @@ -0,0 +1,460 @@ +import * as I from 'immutable'; +import { EvaluationLogProblemReporter, EvaluationLogScanner, EvaluationLogScannerProvider } from './log-scanner'; +import { InLayer, ComputeRecursive, SummaryEvent, PipelineRun, ComputeSimple } from './log-summary'; + +const DEFAULT_WARNING_THRESHOLD = 50; + +/** + * Like `max`, but returns 0 if no meaningful maximum can be computed. + */ +function safeMax(it: Iterable) { + const m = Math.max(...it); + return Number.isFinite(m) ? m : 0; +} + +/** + * Compute a key for the maps that that is sent to report generation. + * Should only be used on events that are known to define queryCausingWork. + */ +function makeKey( + queryCausingWork: string | undefined, + predicate: string, + suffix = '' +): string { + if (queryCausingWork === undefined) { + throw new Error( + 'queryCausingWork was not defined on an event we expected it to be defined for!' + ); + } + return `${queryCausingWork}:${predicate}${suffix ? ' ' + suffix : ''}`; +} + +const DEPENDENT_PREDICATES_REGEXP = (() => { + const regexps = [ + // SCAN id + String.raw`SCAN\s+([0-9a-zA-Z:#_]+)\s`, + // JOIN id WITH id + String.raw`JOIN\s+([0-9a-zA-Z:#_]+)\s+WITH\s+([0-9a-zA-Z:#_]+)\s`, + // AGGREGATE id, id + String.raw`AGGREGATE\s+([0-9a-zA-Z:#_]+)\s*,\s+([0-9a-zA-Z:#_]+)`, + // id AND NOT id + String.raw`([0-9a-zA-Z:#_]+)\s+AND\s+NOT\s+([0-9a-zA-Z:#_]+)`, + // INVOKE HIGHER-ORDER RELATION rel ON + String.raw`INVOKE\s+HIGHER-ORDER\s+RELATION\s[^\s]+\sON\s+<([0-9a-zA-Z:#_<>]+)((?:,[0-9a-zA-Z:#_<>]+)*)>`, + // SELECT id + String.raw`SELECT\s+([0-9a-zA-Z:#_]+)` + ]; + return new RegExp( + `${String.raw`\{[0-9]+\}\s+[0-9a-zA-Z]+\s=\s(?:` + regexps.join('|')})` + ); +})(); + +function getDependentPredicates(operations: string[]): I.List { + return I.List(operations).flatMap(operation => { + const matches = DEPENDENT_PREDICATES_REGEXP.exec(operation.trim()); + if (matches !== null) { + return I.List(matches) + .rest() // Skip the first group as it's just the entire string + .filter(x => !!x && !x.match('r[0-9]+|PRIMITIVE')) // Only keep the references to predicates. + .flatMap(x => x.split(',')) // Group 2 in the INVOKE HIGHER_ORDER RELATION case is a comma-separated list of identifiers. + .filter(x => !!x); // Remove empty strings + } else { + return I.List(); + } + }); +} + +function getMainHash(event: InLayer | ComputeRecursive): string { + switch (event.evaluationStrategy) { + case 'IN_LAYER': + return event.mainHash; + case 'COMPUTE_RECURSIVE': + return event.raHash; + } +} + +/** + * Sum arrays a and b element-wise. The shorter array is padded with 0s if the arrays are not the same length. + */ +function pointwiseSum(a: Int32Array, b: Int32Array, problemReporter: EvaluationLogProblemReporter): Int32Array { + function reportIfInconsistent(ai: number, bi: number) { + if (ai === -1 && bi !== -1) { + problemReporter.log( + `Operation was not evaluated in the first pipeline, but it was evaluated in the accumulated pipeline (with tuple count ${bi}).` + ); + } + if (ai !== -1 && bi === -1) { + problemReporter.log( + `Operation was evaluated in the first pipeline (with tuple count ${ai}), but it was not evaluated in the accumulated pipeline.` + ); + } + } + + const length = Math.max(a.length, b.length); + const result = new Int32Array(length); + for (let i = 0; i < length; i++) { + const ai = a[i] || 0; + const bi = b[i] || 0; + // -1 is used to represent the absence of a tuple count for a line in the pretty-printed RA (e.g. an empty line), so we ignore those. + if (i < a.length && i < b.length && (ai === -1 || bi === -1)) { + result[i] = -1; + reportIfInconsistent(ai, bi); + } else { + result[i] = ai + bi; + } + } + return result; +} + +function pushValue(m: Map, k: K, v: V) { + if (!m.has(k)) { + m.set(k, []); + } + m.get(k)!.push(v); + return m; +} + +function computeJoinOrderBadness( + maxTupleCount: number, + maxDependentPredicateSize: number, + resultSize: number +): number { + return maxTupleCount / Math.max(maxDependentPredicateSize, resultSize); +} + +/** + * A bucket contains the pointwise sum of the tuple counts, result sizes and dependent predicate sizes + * For each (predicate, order) in an SCC, we will compute a bucket. + */ +interface Bucket { + tupleCounts: Int32Array; + resultSize: number; + dependentPredicateSizes: I.Map; +} + +class JoinOrderScanner implements EvaluationLogScanner { + // Map a predicate hash to its result size + private readonly predicateSizes = new Map(); + private readonly layerEvents = new Map(); + // Map a key of the form 'query-with-demand : predicate name' to its badness input. + private readonly maxTupleCountMap = new Map(); + private readonly resultSizeMap = new Map(); + private readonly maxDependentPredicateSizeMap = new Map(); + private readonly joinOrderMetricMap = new Map(); + + constructor( + private readonly problemReporter: EvaluationLogProblemReporter, + private readonly warningThreshold: number) { + } + + public onEvent(event: SummaryEvent): void { + if ( + event.completionType !== undefined && + event.completionType !== 'SUCCESS' + ) { + return; // Skip any evaluation that wasn't successful + } + + this.recordPredicateSizes(event); + this.computeBadnessMetric(event); + } + + public onDone(): void { + void this; + } + + private recordPredicateSizes(event: SummaryEvent): void { + switch (event.evaluationStrategy) { + case 'EXTENSIONAL': + case 'COMPUTED_EXTENSIONAL': + case 'COMPUTE_SIMPLE': + case 'CACHACA': + case 'CACHE_HIT': { + this.predicateSizes.set(event.raHash, event.resultSize); + break; + } + case 'SENTINEL_EMPTY': { + this.predicateSizes.set(event.raHash, 0); + break; + } + case 'COMPUTE_RECURSIVE': + case 'IN_LAYER': { + this.predicateSizes.set(event.raHash, event.resultSize); + // layerEvents are indexed by the mainHash. + const hash = getMainHash(event); + if (!this.layerEvents.has(hash)) { + this.layerEvents.set(hash, []); + } + this.layerEvents.get(hash)!.push(event); + break; + } + } + } + + private reportProblemIfNecessary(event: SummaryEvent, iteration: number, metric: number): void { + if (metric >= this.warningThreshold) { + this.problemReporter.reportProblem(event.predicateName, event.raHash, iteration, + `Relation '${event.predicateName}' has an inefficient join order. Its join order metric is ${metric.toFixed(2)}, which is larger than the threshold of ${this.warningThreshold.toFixed(2)}.`); + } + } + + private computeBadnessMetric(event: SummaryEvent): void { + if ( + event.completionType !== undefined && + event.completionType !== 'SUCCESS' + ) { + return; // Skip any evaluation that wasn't successful + } + switch (event.evaluationStrategy) { + case 'COMPUTE_SIMPLE': { + if (!event.pipelineRuns) { + // skip if the optional pipelineRuns field is not present. + break; + } + // Compute the badness metric for a non-recursive predicate. The metric in this case is defined as: + // badness = (max tuple count in the pipeline) / (largest predicate this pipeline depends on) + const key = makeKey(event.queryCausingWork, event.predicateName); + const resultSize = event.resultSize; + + // There is only one entry in `pipelineRuns` if it's a non-recursive predicate. + const { maxTupleCount, maxDependentPredicateSize } = + this.badnessInputsForNonRecursiveDelta(event.pipelineRuns[0], event); + + if (maxDependentPredicateSize > 0) { + pushValue(this.maxTupleCountMap, key, maxTupleCount); + pushValue(this.resultSizeMap, key, resultSize); + pushValue( + this.maxDependentPredicateSizeMap, + key, + maxDependentPredicateSize + ); + const metric = computeJoinOrderBadness(maxTupleCount, maxDependentPredicateSize, resultSize!); + this.joinOrderMetricMap.set(key, metric); + this.reportProblemIfNecessary(event, 0, metric); + } + break; + } + + case 'COMPUTE_RECURSIVE': { + // Compute the badness metric for a recursive predicate for each ordering. + const sccMetricInput = this.badnessInputsForRecursiveDelta(event); + // Loop through each predicate in the SCC + sccMetricInput.forEach((buckets, predicate) => { + // Loop through each ordering of the predicate + buckets.forEach((bucket, raReference) => { + // Format the key as demanding-query:name (ordering) + const key = makeKey( + event.queryCausingWork, + predicate, + `(${raReference})` + ); + const maxTupleCount = Math.max(...bucket.tupleCounts); + const resultSize = bucket.resultSize; + const maxDependentPredicateSize = Math.max( + ...bucket.dependentPredicateSizes.values() + ); + + if (maxDependentPredicateSize > 0) { + pushValue(this.maxTupleCountMap, key, maxTupleCount); + pushValue(this.resultSizeMap, key, resultSize); + pushValue( + this.maxDependentPredicateSizeMap, + key, + maxDependentPredicateSize + ); + const metric = computeJoinOrderBadness(maxTupleCount, maxDependentPredicateSize, resultSize); + const oldMetric = this.joinOrderMetricMap.get(key); + if ((oldMetric === undefined) || (metric > oldMetric)) { + this.joinOrderMetricMap.set(key, metric); + } + } + }); + }); + break; + } + } + } + + /** + * Iterate through an SCC with main node `event`. + */ + private iterateSCC( + event: ComputeRecursive, + func: ( + inLayerEvent: ComputeRecursive | InLayer, + run: PipelineRun, + iteration: number + ) => void + ): void { + const sccEvents = this.layerEvents.get(event.raHash)!; + const nextPipeline: number[] = new Array(sccEvents.length).fill(0); + + const maxIteration = Math.max( + ...sccEvents.map(e => e.predicateIterationMillis.length) + ); + + for (let iteration = 0; iteration < maxIteration; ++iteration) { + // Loop through each predicate in this iteration + for (let predicate = 0; predicate < sccEvents.length; ++predicate) { + const inLayerEvent = sccEvents[predicate]; + const iterationTime = + inLayerEvent.predicateIterationMillis.length <= iteration + ? -1 + : inLayerEvent.predicateIterationMillis[iteration]; + if (iterationTime != -1) { + const run: PipelineRun = + inLayerEvent.pipelineRuns[nextPipeline[predicate]++]; + func(inLayerEvent, run, iteration); + } + } + } + } + + /** + * Compute the maximum tuple count and maximum dependent predicate size for a non-recursive pipeline + */ + private badnessInputsForNonRecursiveDelta( + pipelineRun: PipelineRun, + event: ComputeSimple + ): { maxTupleCount: number; maxDependentPredicateSize: number } { + const dependentPredicateSizes = Object.values(event.dependencies).map(hash => + this.predicateSizes.get(hash) ?? 0 // Should always be present, but zero is a safe default. + ); + const maxDependentPredicateSize = safeMax(dependentPredicateSizes); + return { + maxTupleCount: safeMax(pipelineRun.counts), + maxDependentPredicateSize: maxDependentPredicateSize + }; + } + + private prevDeltaSizes(event: ComputeRecursive, predicate: string, i: number) { + // If an iteration isn't present in the map it means it was skipped because the optimizer + // inferred that it was empty. So its size is 0. + return this.curDeltaSizes(event, predicate, i - 1); + } + + private curDeltaSizes(event: ComputeRecursive, predicate: string, i: number) { + // If an iteration isn't present in the map it means it was skipped because the optimizer + // inferred that it was empty. So its size is 0. + return ( + this.layerEvents.get(event.raHash)?.find(x => x.predicateName === predicate)?.deltaSizes[i] ?? 0 + ); + } + + /** + * Compute the metric dependent predicate sizes and the result size for a predicate in an SCC. + */ + private badnessInputsForLayer( + event: ComputeRecursive, + inLayerEvent: InLayer | ComputeRecursive, + raReference: string, + iteration: number + ) { + const dependentPredicates = getDependentPredicates( + inLayerEvent.ra[raReference] + ); + let dependentPredicateSizes: I.Map; + // We treat the base case as a non-recursive pipeline. In that case, the dependent predicates are + // the dependencies of the base case and the cur_deltas. + if (raReference === 'base') { + dependentPredicateSizes = I.Map( + dependentPredicates.map((pred): [string, number] => { + // A base case cannot contain a `prev_delta`, but it can contain a `cur_delta`. + let size = 0; + if (pred.endsWith('#cur_delta')) { + size = this.curDeltaSizes( + event, + pred.slice(0, -'#cur_delta'.length), + iteration + ); + } else { + const hash = event.dependencies[pred]; + size = this.predicateSizes.get(hash)!; + } + return [pred, size]; + }) + ); + } else { + // It's a non-base case in a recursive pipeline. In that case, the dependent predicates are + // only the prev_deltas. + dependentPredicateSizes = I.Map( + dependentPredicates + .flatMap(pred => { + // If it's actually a prev_delta + if (pred.endsWith('#prev_delta')) { + // Return the predicate without the #prev_delta suffix. + return [pred.slice(0, -'#prev_delta'.length)]; + } else { + // Not a recursive delta. Skip it. + return []; + } + }) + .map((prev): [string, number] => { + const size = this.prevDeltaSizes(event, prev, iteration); + return [prev, size]; + }) + ); + } + + const deltaSize = inLayerEvent.deltaSizes[iteration]; + return { dependentPredicateSizes, deltaSize }; + } + + /** + * Compute the metric input for all the events in a SCC that starts with main node `event` + */ + private badnessInputsForRecursiveDelta(event: ComputeRecursive): Map> { + // nameToOrderToBucket : predicate name -> ordering (i.e., standard, order_500000, etc.) -> bucket + const nameToOrderToBucket = new Map>(); + + // Iterate through the SCC and compute the metric inputs + this.iterateSCC(event, (inLayerEvent, run, iteration) => { + const raReference = run.raReference; + const predicateName = inLayerEvent.predicateName; + if (!nameToOrderToBucket.has(predicateName)) { + nameToOrderToBucket.set(predicateName, new Map()); + } + const orderTobucket = nameToOrderToBucket.get(predicateName)!; + if (!orderTobucket.has(raReference)) { + orderTobucket.set(raReference, { + tupleCounts: new Int32Array(0), + resultSize: 0, + dependentPredicateSizes: I.Map() + }); + } + + const { dependentPredicateSizes, deltaSize } = this.badnessInputsForLayer( + event, + inLayerEvent, + raReference, + iteration + ); + + const bucket = orderTobucket.get(raReference)!; + // Pointwise sum the tuple counts + const newTupleCounts = pointwiseSum( + bucket.tupleCounts, + new Int32Array(run.counts), + this.problemReporter + ); + const resultSize = bucket.resultSize + deltaSize; + // Pointwise sum the deltas. + const newDependentPredicateSizes = bucket.dependentPredicateSizes.mergeWith( + (oldSize, newSize) => oldSize + newSize, + dependentPredicateSizes + ); + orderTobucket.set(raReference, { + tupleCounts: newTupleCounts, + resultSize: resultSize, + dependentPredicateSizes: newDependentPredicateSizes + }); + }); + return nameToOrderToBucket; + } +} + +export class JoinOrderScannerProvider implements EvaluationLogScannerProvider { + public createScanner(problemReporter: EvaluationLogProblemReporter): EvaluationLogScanner { + return new JoinOrderScanner(problemReporter, DEFAULT_WARNING_THRESHOLD); + } +} diff --git a/extensions/ql-vscode/src/log-insights/jsonl-reader.ts b/extensions/ql-vscode/src/log-insights/jsonl-reader.ts new file mode 100644 index 000000000..d5414cb2f --- /dev/null +++ b/extensions/ql-vscode/src/log-insights/jsonl-reader.ts @@ -0,0 +1,23 @@ +import * as fs from 'fs-extra'; + +/** + * Read a file consisting of multiple JSON objects. Each object is separated from the previous one + * by a double newline sequence. This is basically a more human-readable form of JSONL. + * + * The current implementation reads the entire text of the document into memory, but in the future + * it will stream the document to improve the performance with large documents. + * + * @param path The path to the file. + * @param handler Callback to be invoked for each top-level JSON object in order. + */ +export async function readJsonlFile(path: string, handler: (value: any) => Promise): Promise { + const logSummary = await fs.readFile(path, 'utf-8'); + + // Remove newline delimiters because summary is in .jsonl format. + const jsonSummaryObjects: string[] = logSummary.split(/\r?\n\r?\n/g); + + for (const obj of jsonSummaryObjects) { + const jsonObj = JSON.parse(obj); + await handler(jsonObj); + } +} diff --git a/extensions/ql-vscode/src/log-insights/log-scanner-service.ts b/extensions/ql-vscode/src/log-insights/log-scanner-service.ts new file mode 100644 index 000000000..b1b41c822 --- /dev/null +++ b/extensions/ql-vscode/src/log-insights/log-scanner-service.ts @@ -0,0 +1,109 @@ +import { Diagnostic, DiagnosticSeverity, languages, Range, Uri } from 'vscode'; +import { DisposableObject } from '../pure/disposable-object'; +import { QueryHistoryManager } from '../query-history'; +import { QueryHistoryInfo } from '../query-results'; +import { EvaluationLogProblemReporter, EvaluationLogScannerSet } from './log-scanner'; +import { PipelineInfo, SummarySymbols } from './summary-parser'; +import * as fs from 'fs-extra'; +import { logger } from '../logging'; + +/** + * Compute the key used to find a predicate in the summary symbols. + * @param name The name of the predicate. + * @param raHash The RA hash of the predicate. + * @returns The key of the predicate, consisting of `name@shortHash`, where `shortHash` is the first + * eight characters of `raHash`. + */ +function predicateSymbolKey(name: string, raHash: string): string { + return `${name}@${raHash.substring(0, 8)}`; +} + +/** + * Implementation of `EvaluationLogProblemReporter` that generates `Diagnostic` objects to display + * in the VS Code "Problems" view. + */ +class ProblemReporter implements EvaluationLogProblemReporter { + public readonly diagnostics: Diagnostic[] = []; + + constructor(private readonly symbols: SummarySymbols | undefined) { + } + + public reportProblem(predicateName: string, raHash: string, iteration: number, message: string): void { + const nameWithHash = predicateSymbolKey(predicateName, raHash); + const predicateSymbol = this.symbols?.predicates[nameWithHash]; + let predicateInfo: PipelineInfo | undefined = undefined; + if (predicateSymbol !== undefined) { + predicateInfo = predicateSymbol.iterations[iteration]; + } + if (predicateInfo !== undefined) { + const range = new Range(predicateInfo.raStartLine, 0, predicateInfo.raEndLine + 1, 0); + this.diagnostics.push(new Diagnostic(range, message, DiagnosticSeverity.Error)); + } + } + + public log(message: string): void { + void logger.log(message); + } +} + +export class LogScannerService extends DisposableObject { + public readonly scanners = new EvaluationLogScannerSet(); + private readonly diagnosticCollection = this.push(languages.createDiagnosticCollection('ql-eval-log')); + private currentItem: QueryHistoryInfo | undefined = undefined; + + constructor(qhm: QueryHistoryManager) { + super(); + + this.push(qhm.onDidChangeCurrentQueryItem(async (item) => { + if (item !== this.currentItem) { + this.currentItem = item; + await this.scanEvalLog(item); + } + })); + + this.push(qhm.onDidCompleteQuery(async (item) => { + if (item === this.currentItem) { + await this.scanEvalLog(item); + } + })); + } + + /** + * Scan the evaluation log for a query, and report any diagnostics. + * + * @param query The query whose log is to be scanned. + */ + public async scanEvalLog( + query: QueryHistoryInfo | undefined + ): Promise { + this.diagnosticCollection.clear(); + + if ((query?.t !== 'local') + || (query.evalLogSummaryLocation === undefined) + || (query.jsonEvalLogSummaryLocation === undefined)) { + return; + } + + const diagnostics = await this.scanLog(query.jsonEvalLogSummaryLocation, query.evalLogSummarySymbolsLocation); + const uri = Uri.file(query.evalLogSummaryLocation); + this.diagnosticCollection.set(uri, diagnostics); + } + + /** + * Scan the evaluator summary log for problems, using the scanners for all registered providers. + * @param jsonSummaryLocation The file path of the JSON summary log. + * @param symbolsLocation The file path of the symbols file for the human-readable log summary. + * @returns An array of `Diagnostic`s representing the problems found by scanners. + */ + private async scanLog(jsonSummaryLocation: string, symbolsLocation: string | undefined): Promise { + let symbols: SummarySymbols | undefined = undefined; + if (symbolsLocation !== undefined) { + symbols = JSON.parse(await fs.readFile(symbolsLocation, { encoding: 'utf-8' })); + } + const problemReporter = new ProblemReporter(symbols); + + await this.scanners.scanLog(jsonSummaryLocation, problemReporter); + + return problemReporter.diagnostics; + } +} diff --git a/extensions/ql-vscode/src/log-insights/log-scanner.ts b/extensions/ql-vscode/src/log-insights/log-scanner.ts new file mode 100644 index 000000000..85969e7cd --- /dev/null +++ b/extensions/ql-vscode/src/log-insights/log-scanner.ts @@ -0,0 +1,103 @@ +import { SummaryEvent } from './log-summary'; +import { readJsonlFile } from './jsonl-reader'; + +/** + * Callback interface used to report diagnostics from a log scanner. + */ +export interface EvaluationLogProblemReporter { + /** + * Report a potential problem detected in the evaluation log. + * + * @param predicateName The mangled name of the predicate with the problem. + * @param raHash The RA hash of the predicate with the problem. + * @param iteration The iteration number with the problem. For a non-recursive predicate, this + * must be zero. + * @param message The problem message. + */ + reportProblem(predicateName: string, raHash: string, iteration: number, message: string): void; + + /** + * Log a message about a problem in the implementation of the scanner. These will typically be + * displayed separate from any problems reported via `reportProblem()`. + */ + log(message: string): void; +} + +/** + * Interface implemented by a log scanner. Instances are created via + * `EvaluationLogScannerProvider.createScanner()`. + */ +export interface EvaluationLogScanner { + /** + * Called for each event in the log summary, in order. The implementation can report problems via + * the `EvaluationLogProblemReporter` interface that was supplied to `createScanner()`. + * @param event The log summary event. + */ + onEvent(event: SummaryEvent): void; + /** + * Called after all events in the log summary have been processed. The implementation can report + * problems via the `EvaluationLogProblemReporter` interface that was supplied to + * `createScanner()`. + */ + onDone(): void; +} + +/** + * A factory for log scanners. When a log is to be scanned, all registered + * `EvaluationLogScannerProviders` will be asked to create a new instance of `EvaluationLogScanner` + * to do the scanning. + */ +export interface EvaluationLogScannerProvider { + /** + * Create a new instance of `EvaluationLogScanner` to scan a single summary log. + * @param problemReporter Callback interface for reporting any problems discovered. + */ + createScanner(problemReporter: EvaluationLogProblemReporter): EvaluationLogScanner; +} + +/** + * Same as VSCode's `Disposable`, but avoids a dependency on VS Code. + */ +export interface Disposable { + dispose(): void; +} + +export class EvaluationLogScannerSet { + private readonly scannerProviders = new Map(); + private nextScannerProviderId = 0; + + /** + * Register a provider that can create instances of `EvaluationLogScanner` to scan evaluation logs + * for problems. + * @param provider The provider. + * @returns A `Disposable` that, when disposed, will unregister the provider. + */ + public registerLogScannerProvider(provider: EvaluationLogScannerProvider): Disposable { + const id = this.nextScannerProviderId; + this.nextScannerProviderId++; + + this.scannerProviders.set(id, provider); + return { + dispose: () => { + this.scannerProviders.delete(id); + } + }; + } + + /** + * Scan the evaluator summary log for problems, using the scanners for all registered providers. + * @param jsonSummaryLocation The file path of the JSON summary log. + * @param problemReporter Callback interface for reporting any problems discovered. + */ + public async scanLog(jsonSummaryLocation: string, problemReporter: EvaluationLogProblemReporter): Promise { + const scanners = [...this.scannerProviders.values()].map(p => p.createScanner(problemReporter)); + + await readJsonlFile(jsonSummaryLocation, async obj => { + scanners.forEach(scanner => { + scanner.onEvent(obj); + }); + }); + + scanners.forEach(scanner => scanner.onDone()); + } +} diff --git a/extensions/ql-vscode/src/log-insights/log-summary.ts b/extensions/ql-vscode/src/log-insights/log-summary.ts new file mode 100644 index 000000000..43b2b14c6 --- /dev/null +++ b/extensions/ql-vscode/src/log-insights/log-summary.ts @@ -0,0 +1,93 @@ +export interface PipelineRun { + raReference: string; + counts: number[]; + duplicationPercentages: number[]; +} + +export interface Ra { + [key: string]: string[]; +} + +export type EvaluationStrategy = + 'COMPUTE_SIMPLE' | + 'COMPUTE_RECURSIVE' | + 'IN_LAYER' | + 'COMPUTED_EXTENSIONAL' | + 'EXTENSIONAL' | + 'SENTINEL_EMPTY' | + 'CACHACA' | + 'CACHE_HIT'; + +interface SummaryEventBase { + evaluationStrategy: EvaluationStrategy; + predicateName: string; + raHash: string; + appearsAs: { [key: string]: { [key: string]: number[] } }; + completionType?: string; +} + +interface ResultEventBase extends SummaryEventBase { + resultSize: number; +} + +export interface ComputeSimple extends ResultEventBase { + evaluationStrategy: 'COMPUTE_SIMPLE'; + ra: Ra; + pipelineRuns?: [PipelineRun]; + queryCausingWork?: string; + dependencies: { [key: string]: string }; +} + +export interface ComputeRecursive extends ResultEventBase { + evaluationStrategy: 'COMPUTE_RECURSIVE'; + deltaSizes: number[]; + ra: Ra; + pipelineRuns: PipelineRun[]; + queryCausingWork?: string; + dependencies: { [key: string]: string }; + predicateIterationMillis: number[]; +} + +export interface InLayer extends ResultEventBase { + evaluationStrategy: 'IN_LAYER'; + deltaSizes: number[]; + ra: Ra; + pipelineRuns: PipelineRun[]; + queryCausingWork?: string; + mainHash: string; + predicateIterationMillis: number[]; +} + +export interface ComputedExtensional extends ResultEventBase { + evaluationStrategy: 'COMPUTED_EXTENSIONAL'; + queryCausingWork?: string; +} + +export interface NonComputedExtensional extends ResultEventBase { + evaluationStrategy: 'EXTENSIONAL'; + queryCausingWork?: string; +} + +export interface SentinelEmpty extends SummaryEventBase { + evaluationStrategy: 'SENTINEL_EMPTY'; + sentinelRaHash: string; +} + +export interface Cachaca extends ResultEventBase { + evaluationStrategy: 'CACHACA'; +} + +export interface CacheHit extends ResultEventBase { + evaluationStrategy: 'CACHE_HIT'; +} + +export type Extensional = ComputedExtensional | NonComputedExtensional; + +export type SummaryEvent = + | ComputeSimple + | ComputeRecursive + | InLayer + | Extensional + | SentinelEmpty + | Cachaca + | CacheHit; diff --git a/extensions/ql-vscode/src/log-insights/summary-language-support.ts b/extensions/ql-vscode/src/log-insights/summary-language-support.ts index 989347c8d..d514ab86a 100644 --- a/extensions/ql-vscode/src/log-insights/summary-language-support.ts +++ b/extensions/ql-vscode/src/log-insights/summary-language-support.ts @@ -35,11 +35,11 @@ export class SummaryLanguageSupport extends DisposableObject { * The last `TextDocument` (with language `ql-summary`) for which we tried to find a sourcemap, or * `undefined` if we have not seen such a document yet. */ - private lastDocument : TextDocument | undefined = undefined; + private lastDocument: TextDocument | undefined = undefined; /** * The sourcemap for `lastDocument`, or `undefined` if there was no such sourcemap or document. */ - private sourceMap : SourceMapConsumer | undefined = undefined; + private sourceMap: SourceMapConsumer | undefined = undefined; constructor() { super(); diff --git a/extensions/ql-vscode/src/log-insights/summary-parser.ts b/extensions/ql-vscode/src/log-insights/summary-parser.ts new file mode 100644 index 000000000..71365e36f --- /dev/null +++ b/extensions/ql-vscode/src/log-insights/summary-parser.ts @@ -0,0 +1,113 @@ +import * as fs from 'fs-extra'; + +/** + * Location information for a single pipeline invocation in the RA. + */ +export interface PipelineInfo { + startLine: number; + raStartLine: number; + raEndLine: number; +} + +/** + * Location information for a single predicate in the RA. + */ +export interface PredicateSymbol { + /** + * `PipelineInfo` for each iteration. A non-recursive predicate will have a single iteration `0`. + */ + iterations: Record; +} + +/** + * Location information for the RA from an evaluation log. Line numbers point into the + * human-readable log summary. + */ +export interface SummarySymbols { + predicates: Record; +} + +// Tuple counts for Expr::Expr::getParent#dispred#f0820431#ff@76d6745o: +const NON_RECURSIVE_TUPLE_COUNT_REGEXP = /^Evaluated relational algebra for predicate (?\S+) with tuple counts:$/; +// Tuple counts for Expr::Expr::getEnclosingStmt#f0820431#bf@923ddwj9 on iteration 0 running pipeline base: +const RECURSIVE_TUPLE_COUNT_REGEXP = /^Evaluated relational algebra for predicate (?\S+) on iteration (?\d+) running pipeline (?\S+) with tuple counts:$/; +const RETURN_REGEXP = /^\s*return /; + +/** + * Parse a human-readable evaluation log summary to find the location of the RA for each pipeline + * run. + * + * TODO: Once we're more certain about the symbol format, we should have the CLI generate this as it + * generates the human-readabe summary to avoid having to rely on regular expression matching of the + * human-readable text. + * + * @param summaryPath The path to the summary file. + * @param symbolsPath The path to the symbols file to generate. + */ +export async function generateSummarySymbolsFile(summaryPath: string, symbolsPath: string): Promise { + const symbols = await generateSummarySymbols(summaryPath); + await fs.writeFile(symbolsPath, JSON.stringify(symbols)); +} + +/** + * Parse a human-readable evaluation log summary to find the location of the RA for each pipeline + * run. + * + * @param fileLocation The path to the summary file. + * @returns Symbol information for the summary file. + */ +async function generateSummarySymbols(summaryPath: string): Promise { + const summary = await fs.promises.readFile(summaryPath, { encoding: 'utf-8' }); + const symbols: SummarySymbols = { + predicates: {} + }; + + const lines = summary.split(/\r?\n/); + let lineNumber = 0; + while (lineNumber < lines.length) { + const startLineNumber = lineNumber; + lineNumber++; + const startLine = lines[startLineNumber]; + const nonRecursiveMatch = startLine.match(NON_RECURSIVE_TUPLE_COUNT_REGEXP); + let predicateName: string | undefined = undefined; + let iteration = 0; + if (nonRecursiveMatch) { + predicateName = nonRecursiveMatch.groups!.predicateName; + } else { + const recursiveMatch = startLine.match(RECURSIVE_TUPLE_COUNT_REGEXP); + if (recursiveMatch?.groups) { + predicateName = recursiveMatch.groups.predicateName; + iteration = parseInt(recursiveMatch.groups.iteration); + } + } + + if (predicateName !== undefined) { + const raStartLine = lineNumber; + let raEndLine: number | undefined = undefined; + while ((lineNumber < lines.length) && (raEndLine === undefined)) { + const raLine = lines[lineNumber]; + const returnMatch = raLine.match(RETURN_REGEXP); + if (returnMatch) { + raEndLine = lineNumber; + } + lineNumber++; + } + if (raEndLine !== undefined) { + let symbol = symbols.predicates[predicateName]; + if (symbol === undefined) { + symbol = { + iterations: {} + }; + symbols.predicates[predicateName] = symbol; + } + symbol.iterations[iteration] = { + startLine: lineNumber, + raStartLine: raStartLine, + raEndLine: raEndLine + }; + } + } + } + + return symbols; +} diff --git a/extensions/ql-vscode/src/pure/log-summary-parser.ts b/extensions/ql-vscode/src/pure/log-summary-parser.ts index c5914b477..21186583f 100644 --- a/extensions/ql-vscode/src/pure/log-summary-parser.ts +++ b/extensions/ql-vscode/src/pure/log-summary-parser.ts @@ -1,3 +1,5 @@ +import { readJsonlFile } from '../log-insights/jsonl-reader'; + // TODO(angelapwen): Only load in necessary information and // location in bytes for this log to save memory. export interface EvalLogData { @@ -11,16 +13,11 @@ export interface EvalLogData { /** * A pure method that parses a string of evaluator log summaries into * an array of EvalLogData objects. - * */ -export function parseViewerData(logSummary: string): EvalLogData[] { - // Remove newline delimiters because summary is in .jsonl format. - const jsonSummaryObjects: string[] = logSummary.split(/\r?\n\r?\n/g); +export async function parseViewerData(jsonSummaryPath: string): Promise { const viewerData: EvalLogData[] = []; - for (const obj of jsonSummaryObjects) { - const jsonObj = JSON.parse(obj); - + await readJsonlFile(jsonSummaryPath, async jsonObj => { // Only convert log items that have an RA and millis field if (jsonObj.ra !== undefined && jsonObj.millis !== undefined) { const newLogData: EvalLogData = { @@ -31,6 +28,7 @@ export function parseViewerData(logSummary: string): EvalLogData[] { }; viewerData.push(newLogData); } - } + }); + return viewerData; } diff --git a/extensions/ql-vscode/src/pure/messages.ts b/extensions/ql-vscode/src/pure/messages.ts index cec4391a5..aeb691f86 100644 --- a/extensions/ql-vscode/src/pure/messages.ts +++ b/extensions/ql-vscode/src/pure/messages.ts @@ -654,7 +654,7 @@ export interface ClearCacheParams { /** * Parameters to start a new structured log */ - export interface StartLogParams { +export interface StartLogParams { /** * The dataset for which we want to start a new structured log */ @@ -668,7 +668,7 @@ export interface ClearCacheParams { /** * Parameters to terminate a structured log */ - export interface EndLogParams { +export interface EndLogParams { /** * The dataset for which we want to terminated the log */ @@ -1074,12 +1074,12 @@ export const compileUpgradeSequence = new rpc.RequestType, StartLogResult, void, void>('evaluation/startLog'); +export const startLog = new rpc.RequestType, StartLogResult, void, void>('evaluation/startLog'); /** * Terminate a structured log in the evaluator. Is a no-op if we aren't logging to the given location */ - export const endLog = new rpc.RequestType, EndLogResult, void, void>('evaluation/endLog'); +export const endLog = new rpc.RequestType, EndLogResult, void, void>('evaluation/endLog'); /** * Clear the cache of a dataset diff --git a/extensions/ql-vscode/src/query-history.ts b/extensions/ql-vscode/src/query-history.ts index 6624c1d8a..3a6a6e6ec 100644 --- a/extensions/ql-vscode/src/query-history.ts +++ b/extensions/ql-vscode/src/query-history.ts @@ -9,6 +9,7 @@ import { ProviderResult, Range, ThemeIcon, + TreeDataProvider, TreeItem, TreeView, Uri, @@ -47,6 +48,7 @@ import { WebviewReveal } from './interface-utils'; import { EvalLogViewer } from './eval-log-viewer'; import EvalLogTreeBuilder from './eval-log-tree-builder'; import { EvalLogData, parseViewerData } from './pure/log-summary-parser'; +import { QueryWithResults } from './run-queries'; /** * query-history.ts @@ -114,7 +116,7 @@ const WORKSPACE_QUERY_HISTORY_FILE = 'workspace-query-history.json'; /** * Tree data provider for the query history view. */ -export class HistoryTreeDataProvider extends DisposableObject { +export class HistoryTreeDataProvider extends DisposableObject implements TreeDataProvider { private _sortOrder = SortOrder.DateAsc; private _onDidChangeTreeData = super.push(new EventEmitter()); @@ -122,6 +124,10 @@ export class HistoryTreeDataProvider extends DisposableObject { readonly onDidChangeTreeData: Event = this ._onDidChangeTreeData.event; + private _onDidChangeCurrentQueryItem = super.push(new EventEmitter()); + + public readonly onDidChangeCurrentQueryItem = this._onDidChangeCurrentQueryItem.event; + private history: QueryHistoryInfo[] = []; private failedIconPath: string; @@ -260,7 +266,10 @@ export class HistoryTreeDataProvider extends DisposableObject { } setCurrentItem(item?: QueryHistoryInfo) { - this.current = item; + if (item !== this.current) { + this.current = item; + this._onDidChangeCurrentQueryItem.fire(item); + } } remove(item: QueryHistoryInfo) { @@ -286,7 +295,7 @@ export class HistoryTreeDataProvider extends DisposableObject { set allHistory(history: QueryHistoryInfo[]) { this.history = history; - this.current = history[0]; + this.setCurrentItem(history[0]); this.refresh(); } @@ -313,6 +322,12 @@ export class QueryHistoryManager extends DisposableObject { queryHistoryScrubber: Disposable | undefined; private queryMetadataStorageLocation; + private readonly _onDidChangeCurrentQueryItem = super.push(new EventEmitter()); + readonly onDidChangeCurrentQueryItem = this._onDidChangeCurrentQueryItem.event; + + private readonly _onDidCompleteQuery = super.push(new EventEmitter()); + readonly onDidCompleteQuery = this._onDidCompleteQuery.event; + constructor( private readonly qs: QueryServerClient, private readonly dbm: DatabaseManager, @@ -345,6 +360,11 @@ export class QueryHistoryManager extends DisposableObject { canSelectMany: true, })); + // Forward any change of current history item from the tree data. + this.push(this.treeDataProvider.onDidChangeCurrentQueryItem((item) => { + this._onDidChangeCurrentQueryItem.fire(item); + })); + // Lazily update the tree view selection due to limitations of TreeView API (see // `updateTreeViewSelectionIfVisible` doc for details) this.push( @@ -537,6 +557,11 @@ export class QueryHistoryManager extends DisposableObject { this.registerToRemoteQueriesEvents(); } + public completeQuery(info: LocalQueryInfo, results: QueryWithResults): void { + info.completeThisQuery(results); + this._onDidCompleteQuery.fire(info); + } + private getCredentials() { return Credentials.initialize(this.ctx); } @@ -926,7 +951,7 @@ export class QueryHistoryManager extends DisposableObject { } // Summary log file doesn't exist. - if (finalSingleItem.evalLogLocation && fs.pathExists(finalSingleItem.evalLogLocation)) { + if (finalSingleItem.evalLogLocation && await fs.pathExists(finalSingleItem.evalLogLocation)) { // If raw log does exist, then the summary log is still being generated. this.warnInProgressEvalLogSummary(); } else { @@ -950,15 +975,14 @@ export class QueryHistoryManager extends DisposableObject { return; } - // TODO(angelapwen): Stream the file in. - void fs.readFile(finalSingleItem.jsonEvalLogSummaryLocation, async (err, buffer) => { - if (err) { - throw new Error(`Could not read evaluator log summary JSON file to generate viewer data at ${finalSingleItem.jsonEvalLogSummaryLocation}.`); - } - const evalLogData: EvalLogData[] = parseViewerData(buffer.toString()); + // TODO(angelapwen): Stream the file in. + try { + const evalLogData: EvalLogData[] = await parseViewerData(finalSingleItem.jsonEvalLogSummaryLocation); const evalLogTreeBuilder = new EvalLogTreeBuilder(finalSingleItem.getQueryName(), evalLogData); this.evalLogViewer.updateRoots(await evalLogTreeBuilder.getRoots()); - }); + } catch (e) { + throw new Error(`Could not read evaluator log summary JSON file to generate viewer data at ${finalSingleItem.jsonEvalLogSummaryLocation}.`); + } } async handleCancel( diff --git a/extensions/ql-vscode/src/query-results.ts b/extensions/ql-vscode/src/query-results.ts index 34dd4f733..536426901 100644 --- a/extensions/ql-vscode/src/query-results.ts +++ b/extensions/ql-vscode/src/query-results.ts @@ -218,6 +218,7 @@ export class LocalQueryInfo { public evalLogLocation: string | undefined; public evalLogSummaryLocation: string | undefined; public jsonEvalLogSummaryLocation: string | undefined; + public evalLogSummarySymbolsLocation: string | undefined; /** * Note that in the {@link slurpQueryHistory} method, we create a FullQueryInfo instance @@ -282,7 +283,7 @@ export class LocalQueryInfo { return !!this.completedQuery; } - completeThisQuery(info: QueryWithResults) { + completeThisQuery(info: QueryWithResults): void { this.completedQuery = new CompletedQueryInfo(info); // dispose of the cancellation token source and also ensure the source is not serialized as JSON diff --git a/extensions/ql-vscode/src/queryserver-client.ts b/extensions/ql-vscode/src/queryserver-client.ts index 372f4dcc0..277b46b2d 100644 --- a/extensions/ql-vscode/src/queryserver-client.ts +++ b/extensions/ql-vscode/src/queryserver-client.ts @@ -271,6 +271,10 @@ export function findJsonQueryEvalLogSummaryFile(resultPath: string): string { return path.join(resultPath, 'evaluator-log.summary.jsonl'); } +export function findQueryEvalLogSummarySymbolsFile(resultPath: string): string { + return path.join(resultPath, 'evaluator-log.summary.symbols.json'); +} + export function findQueryEvalLogEndSummaryFile(resultPath: string): string { return path.join(resultPath, 'evaluator-log-end.summary'); -} \ No newline at end of file +} diff --git a/extensions/ql-vscode/src/run-queries.ts b/extensions/ql-vscode/src/run-queries.ts index 814af7684..916989acb 100644 --- a/extensions/ql-vscode/src/run-queries.ts +++ b/extensions/ql-vscode/src/run-queries.ts @@ -37,6 +37,7 @@ import { ensureMetadataIsComplete } from './query-results'; import { SELECT_QUERY_NAME } from './contextual/locationFinder'; import { DecodedBqrsChunk } from './pure/bqrs-cli-types'; import { getErrorMessage } from './pure/helpers-pure'; +import { generateSummarySymbolsFile } from './log-insights/summary-parser'; /** * run-queries.ts @@ -107,6 +108,10 @@ export class QueryEvaluationInfo { return qsClient.findJsonQueryEvalLogSummaryFile(this.querySaveDir); } + get evalLogSummarySymbolsPath() { + return qsClient.findQueryEvalLogSummarySymbolsFile(this.querySaveDir); + } + get evalLogEndSummaryPath() { return qsClient.findQueryEvalLogEndSummaryFile(this.querySaveDir); } @@ -206,6 +211,8 @@ export class QueryEvaluationInfo { if (config.isCanary()) { // Generate JSON summary for viewer. await qs.cliServer.generateJsonLogSummary(this.evalLogPath, this.jsonEvalLogSummaryPath); queryInfo.jsonEvalLogSummaryLocation = this.jsonEvalLogSummaryPath; + await generateSummarySymbolsFile(this.evalLogSummaryPath, this.evalLogSummarySymbolsPath); + queryInfo.evalLogSummarySymbolsLocation = this.evalLogSummarySymbolsPath; } } else { void showAndLogWarningMessage(`Failed to write structured evaluator log to ${this.evalLogPath}.`); @@ -333,8 +340,8 @@ export class QueryEvaluationInfo { } /** - * Calls the appropriate CLI command to generate a human-readable log summary - * and logs to the Query Server console and query log file. + * Calls the appropriate CLI command to generate a human-readable log summary + * and logs to the Query Server console and query log file. */ displayHumanReadableLogSummary(queryInfo: LocalQueryInfo, qs: qsClient.QueryServerClient): void { queryInfo.evalLogLocation = this.evalLogPath; diff --git a/extensions/ql-vscode/src/vscode-tests/no-workspace/eval-log-tree-builder.test.ts b/extensions/ql-vscode/src/vscode-tests/no-workspace/eval-log-tree-builder.test.ts index d711962c2..7b798e48c 100644 --- a/extensions/ql-vscode/src/vscode-tests/no-workspace/eval-log-tree-builder.test.ts +++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/eval-log-tree-builder.test.ts @@ -2,108 +2,108 @@ import { expect } from 'chai'; import EvalLogTreeBuilder from '../../eval-log-tree-builder'; import { EvalLogData } from '../../pure/log-summary-parser'; -describe('EvalLogTreeBuilder', () => { - it('should build the log tree roots', async () => { - const evalLogDataItems: EvalLogData[] = [ - { - predicateName: 'quick_eval#query#ffffffff', - millis: 1, - resultSize: 596, - ra: { - pipeline: [ - '{1} r1', - '{2} r2', - 'return r2' - ] - }, - } - ]; - - const expectedRoots = [ - { - label: 'test-query.ql', - children: undefined - } - ]; - - const expectedPredicate = [ - { - label: 'quick_eval#query#ffffffff (596 tuples, 1 ms)', - children: undefined, - parent: undefined - }, - ]; - - const expectedRA = [ - { - label: 'Pipeline: pipeline', - children: undefined, - parent: undefined - } - ]; - - const expectedPipelineSteps = [{ - label: '{1} r1', - children: [], - parent: undefined +describe('EvalLogTreeBuilder', () => { + it('should build the log tree roots', async () => { + const evalLogDataItems: EvalLogData[] = [ + { + predicateName: 'quick_eval#query#ffffffff', + millis: 1, + resultSize: 596, + ra: { + pipeline: [ + '{1} r1', + '{2} r2', + 'return r2' + ] }, - { - label: '{2} r2', - children: [], - parent: undefined - }, - { - label: 'return r2', - children: [], - parent: undefined - }]; + } + ]; - const builder = new EvalLogTreeBuilder('test-query.ql', evalLogDataItems); - const roots = await builder.getRoots(); - - // Force children, parent to be undefined for ease of testing. - expect(roots.map( - r => ({ ...r, children: undefined }) - )).to.deep.eq(expectedRoots); + const expectedRoots = [ + { + label: 'test-query.ql', + children: undefined + } + ]; - expect((roots[0].children.map( - pred => ({ ...pred, children: undefined, parent: undefined }) - ))).to.deep.eq(expectedPredicate); + const expectedPredicate = [ + { + label: 'quick_eval#query#ffffffff (596 tuples, 1 ms)', + children: undefined, + parent: undefined + }, + ]; - expect((roots[0].children[0].children.map( - ra => ({ ...ra, children: undefined, parent: undefined }) - ))).to.deep.eq(expectedRA); - - // Pipeline steps' children should be empty so do not force undefined children here. - expect(roots[0].children[0].children[0].children.map( - step => ({ ...step, parent: undefined }) - )).to.deep.eq(expectedPipelineSteps); - }); + const expectedRA = [ + { + label: 'Pipeline: pipeline', + children: undefined, + parent: undefined + } + ]; - it('should build the tree with descriptive message when no data exists', async () => { - // Force children, parent to be undefined for ease of testing. - const expectedRoots = [ - { - label: 'test-query-cached.ql', - children: undefined - } - ]; - const expectedNoPredicates = [ - { - label: 'No predicates evaluated in this query run.', - children: [], // Should be empty so do not force empty here. - parent: undefined - } - ]; - const builder = new EvalLogTreeBuilder('test-query-cached.ql', []); - const roots = await builder.getRoots(); + const expectedPipelineSteps = [{ + label: '{1} r1', + children: [], + parent: undefined + }, + { + label: '{2} r2', + children: [], + parent: undefined + }, + { + label: 'return r2', + children: [], + parent: undefined + }]; - expect(roots.map( - r => ({ ...r, children: undefined }) - )).to.deep.eq(expectedRoots); + const builder = new EvalLogTreeBuilder('test-query.ql', evalLogDataItems); + const roots = await builder.getRoots(); - expect(roots[0].children.map( - noPreds => ({ ...noPreds, parent: undefined }) - )).to.deep.eq(expectedNoPredicates); - }); -}); \ No newline at end of file + // Force children, parent to be undefined for ease of testing. + expect(roots.map( + r => ({ ...r, children: undefined }) + )).to.deep.eq(expectedRoots); + + expect((roots[0].children.map( + pred => ({ ...pred, children: undefined, parent: undefined }) + ))).to.deep.eq(expectedPredicate); + + expect((roots[0].children[0].children.map( + ra => ({ ...ra, children: undefined, parent: undefined }) + ))).to.deep.eq(expectedRA); + + // Pipeline steps' children should be empty so do not force undefined children here. + expect(roots[0].children[0].children[0].children.map( + step => ({ ...step, parent: undefined }) + )).to.deep.eq(expectedPipelineSteps); + }); + + it('should build the tree with descriptive message when no data exists', async () => { + // Force children, parent to be undefined for ease of testing. + const expectedRoots = [ + { + label: 'test-query-cached.ql', + children: undefined + } + ]; + const expectedNoPredicates = [ + { + label: 'No predicates evaluated in this query run.', + children: [], // Should be empty so do not force empty here. + parent: undefined + } + ]; + const builder = new EvalLogTreeBuilder('test-query-cached.ql', []); + const roots = await builder.getRoots(); + + expect(roots.map( + r => ({ ...r, children: undefined }) + )).to.deep.eq(expectedRoots); + + expect(roots[0].children.map( + noPreds => ({ ...noPreds, parent: undefined }) + )).to.deep.eq(expectedNoPredicates); + }); +}); diff --git a/extensions/ql-vscode/test/pure-tests/evaluator-log-summaries/bad-join-order.jsonl b/extensions/ql-vscode/test/pure-tests/evaluator-log-summaries/bad-join-order.jsonl new file mode 100644 index 000000000..8d3660673 --- /dev/null +++ b/extensions/ql-vscode/test/pure-tests/evaluator-log-summaries/bad-join-order.jsonl @@ -0,0 +1,13081 @@ +{ + "summaryLogVersion" : "0.3.0", + "codeqlVersion" : "2.10.1+202208011919plus", + "startTime" : "2022-08-10T21:28:27.673Z" +} + +{ + "completionTime" : "2022-08-10T21:28:27.957Z", + "raHash" : "d090e7q4tnlr6h30omabn66n2da", + "predicateName" : "params", + "appearsAs" : { + "params" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 2, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:489,1-496,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 103, + "resultSize" : 7866 +} + +{ + "completionTime" : "2022-08-10T21:28:27.957Z", + "raHash" : "111495kh3b6m9sku94i8oj4pqr3", + "predicateName" : "localvariables", + "appearsAs" : { + "localvariables" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 2, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:514,1-519,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 103, + "resultSize" : 6212 +} + +{ + "completionTime" : "2022-08-10T21:28:27.957Z", + "raHash" : "2b4839pss7ki8gosmgnk6jcfjt1", + "predicateName" : "globalvariables", + "appearsAs" : { + "globalvariables" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 2, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:507,1-512,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 103, + "resultSize" : 159 +} + +{ + "completionTime" : "2022-08-10T21:28:27.957Z", + "raHash" : "7c37bduotvpfjjrgej2r6r84p4b", + "predicateName" : "membervariables", + "appearsAs" : { + "membervariables" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 2, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:500,1-505,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 103, + "resultSize" : 1412 +} + +{ + "completionTime" : "2022-08-10T21:28:27.957Z", + "raHash" : "7a398429ti3kj9d80pf7drffoh1", + "predicateName" : "stmts", + "appearsAs" : { + "stmts" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1818,1-1822,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 75, + "resultSize" : 46015 +} + +{ + "completionTime" : "2022-08-10T21:28:27.970Z", + "raHash" : "ff49855htg34cr357mjg0pjpnpf", + "predicateName" : "exprconv", + "appearsAs" : { + "exprconv" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1066,1-1069,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 116, + "resultSize" : 107672 +} + +{ + "completionTime" : "2022-08-10T21:28:27.976Z", + "raHash" : "4590572fcfvn8d9ukg7kmiigb24", + "predicateName" : "expr_ancestor", + "appearsAs" : { + "expr_ancestor" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1443,1-1450,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 115 +} + +{ + "completionTime" : "2022-08-10T21:28:27.980Z", + "raHash" : "c10195ctfthoommu9q08d5rci34", + "predicateName" : "usertypes", + "appearsAs" : { + "usertypes" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 1, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:690,1-694,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 7, + "resultSize" : 793 +} + +{ + "completionTime" : "2022-08-10T21:28:27.991Z", + "raHash" : "d39cf8a1icrggbbc4g34qjqsqa1", + "predicateName" : "initialisers", + "appearsAs" : { + "initialisers" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1432,1-1437,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 18, + "resultSize" : 7512 +} + +{ + "completionTime" : "2022-08-10T21:28:28.003Z", + "raHash" : "a427a78knumk074qs3frhkdcsl8", + "predicateName" : "var_def", + "appearsAs" : { + "var_def" : { + "BadAdditionOverflowCheck.ql" : [ 2, 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:444,1-444,39", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 30, + "resultSize" : 13035 +} + +{ + "completionTime" : "2022-08-10T21:28:28.011Z", + "raHash" : "19e663f6klnnoolnln7bm5fsf2a", + "predicateName" : "var_decls", + "appearsAs" : { + "var_decls" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 2, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:436,1-443,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 38, + "resultSize" : 17240 +} + +{ + "completionTime" : "2022-08-10T21:28:28.020Z", + "raHash" : "4993a2gkk04l6oafdrv8j2d47ga", + "predicateName" : "fun_decls", + "appearsAs" : { + "fun_decls" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:397,1-404,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 8, + "resultSize" : 4514 +} + +{ + "completionTime" : "2022-08-10T21:28:28.025Z", + "raHash" : "24a2balph6rbvqhb3m1k7pjpin0", + "predicateName" : "type_decls", + "appearsAs" : { + "type_decls" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:451,1-455,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 829 +} + +{ + "completionTime" : "2022-08-10T21:28:28.028Z", + "raHash" : "75ec32pgvetbmdlamosulu2rjef", + "predicateName" : "builtintypes", + "appearsAs" : { + "builtintypes" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 1, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:596,1-603,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 47 +} + +{ + "completionTime" : "2022-08-10T21:28:28.033Z", + "raHash" : "8dfb6bscm7bke1cl6illlc7u8k4", + "predicateName" : "derivedtypes", + "appearsAs" : { + "derivedtypes" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 1, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:622,1-627,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 5, + "resultSize" : 2349 +} + +{ + "completionTime" : "2022-08-10T21:28:28.041Z", + "raHash" : "97c6277aqmam35sl31temrfofre", + "predicateName" : "ptrtomembers", + "appearsAs" : { + "ptrtomembers" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 1, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:807,1-811,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 8, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.042Z", + "raHash" : "c755fct9r1fc560s7fqd0ts6dp0", + "predicateName" : "Type::PointerToMemberType#class#2e8eb3ef#f", + "appearsAs" : { + "Type::PointerToMemberType#class#2e8eb3ef#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "97c6277aqmam35sl31temrfofre" +} + +{ + "completionTime" : "2022-08-10T21:28:28.048Z", + "raHash" : "79364e1157kbirt0k84e0i0aec8", + "predicateName" : "exprparents", + "appearsAs" : { + "exprparents" : { + "BadAdditionOverflowCheck.ql" : [ 0 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1103,1-1107,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 194, + "resultSize" : 215686 +} + +{ + "completionTime" : "2022-08-10T21:28:28.049Z", + "raHash" : "73563dqdgofcni857o7aprhdgr4", + "predicateName" : "routinetypes", + "appearsAs" : { + "routinetypes" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 1, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:796,1-799,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 1260 +} + +{ + "completionTime" : "2022-08-10T21:28:28.049Z", + "raHash" : "3a01870sqjgo49g3nrlgg2qsjg4", + "predicateName" : "decltypes", + "appearsAs" : { + "decltypes" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 1, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:645,1-670,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.050Z", + "raHash" : "1fd97cs69091peoj31jgk2dl1p7", + "predicateName" : "project#decltypes", + "appearsAs" : { + "project#decltypes" : { + "BadAdditionOverflowCheck.ql" : [ 1, 4, 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "3a01870sqjgo49g3nrlgg2qsjg4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.050Z", + "raHash" : "4dca243j9gkm5tfti53t283af1b", + "predicateName" : "project#decltypes#2", + "appearsAs" : { + "project#decltypes#2" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "3a01870sqjgo49g3nrlgg2qsjg4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.050Z", + "raHash" : "63e0f8t7frfetpoef5aopc8mn8e", + "predicateName" : "Type::Decltype#class#2e8eb3ef#f", + "appearsAs" : { + "Type::Decltype#class#2e8eb3ef#f" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "1fd97cs69091peoj31jgk2dl1p7" +} + +{ + "completionTime" : "2022-08-10T21:28:28.050Z", + "raHash" : "7fbd9dk1qi8sbsdipbn229ca1ae", + "predicateName" : "Type::Decltype::getBaseType#dispred#f0820431#ff", + "appearsAs" : { + "Type::Decltype::getBaseType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "63e0f8t7frfetpoef5aopc8mn8e" +} + +{ + "completionTime" : "2022-08-10T21:28:28.050Z", + "raHash" : "7ea6advk0g0us46c3vohu4ko9q1", + "predicateName" : "Type::Decltype::getBaseType#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Type::Decltype::getBaseType#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "7fbd9dk1qi8sbsdipbn229ca1ae" +} + +{ + "completionTime" : "2022-08-10T21:28:28.074Z", + "raHash" : "56ea56nfg1f2tdlq3h1ierbst3a", + "predicateName" : "exprs", + "appearsAs" : { + "exprs" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1448,1-1452,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 194, + "resultSize" : 324197 +} + +{ + "completionTime" : "2022-08-10T21:28:28.089Z", + "raHash" : "95da6cug8cip2m8k6s57qjd14p4", + "predicateName" : "usertypes_0#antijoin_rhs", + "appearsAs" : { + "usertypes_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:58,3-59,92", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 88, + "resultSize" : 793, + "dependencies" : { + "usertypes" : "c10195ctfthoommu9q08d5rci34" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN usertypes OUTPUT In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 793 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.089Z", + "raHash" : "ea537b18m1251cdp00lp73c4ss1", + "predicateName" : "globalvariables_0#antijoin_rhs", + "appearsAs" : { + "globalvariables_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:535,1-535,69", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 88, + "resultSize" : 159, + "dependencies" : { + "globalvariables" : "2b4839pss7ki8gosmgnk6jcfjt1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN globalvariables OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 159, 159 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.098Z", + "raHash" : "2e3e1ad1ra485cdgeblnafjpie3", + "predicateName" : "usertypes_20#join_rhs", + "appearsAs" : { + "usertypes_20#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 1, 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:113,3-125,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 8, + "resultSize" : 793, + "dependencies" : { + "usertypes" : "c10195ctfthoommu9q08d5rci34" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN usertypes OUTPUT In.2, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 793 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.098Z", + "raHash" : "64953d3ql9fvegp8lv2q4lt4fd0", + "predicateName" : "expr_ancestor_10#join_rhs", + "appearsAs" : { + "expr_ancestor_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 97, + "resultSize" : 115, + "dependencies" : { + "expr_ancestor" : "4590572fcfvn8d9ukg7kmiigb24" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN expr_ancestor OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 115 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.101Z", + "raHash" : "a7bb44o93bk5d64edin5qq128r0", + "predicateName" : "functions", + "appearsAs" : { + "functions" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:357,1-361,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 3803 +} + +{ + "completionTime" : "2022-08-10T21:28:28.104Z", + "raHash" : "6213c7pqpkgs0qduk1tsu11ab8e", + "predicateName" : "@type#f", + "appearsAs" : { + "@type#f" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:937,1-943,19", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 53, + "resultSize" : 4449, + "dependencies" : { + "project#decltypes" : "1fd97cs69091peoj31jgk2dl1p7", + "usertypes" : "c10195ctfthoommu9q08d5rci34", + "routinetypes" : "73563dqdgofcni857o7aprhdgr4", + "ptrtomembers" : "97c6277aqmam35sl31temrfofre", + "derivedtypes" : "8dfb6bscm7bke1cl6illlc7u8k4", + "builtintypes" : "75ec32pgvetbmdlamosulu2rjef" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN usertypes OUTPUT In.0", + "", + " {1} r2 = SCAN routinetypes OUTPUT In.0", + "", + " {1} r3 = r1 UNION r2", + "", + " {1} r4 = project#decltypes UNION r3", + "", + " {1} r5 = SCAN ptrtomembers OUTPUT In.0", + "", + " {1} r6 = SCAN derivedtypes OUTPUT In.0", + "", + " {1} r7 = SCAN builtintypes OUTPUT In.0", + "", + " {1} r8 = r6 UNION r7", + " {1} r9 = r5 UNION r8", + " {1} r10 = r4 UNION r9", + " return r10" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 793, -1, 1260, -1, 2053, -1, 2053, -1, 0, -1, 2349, -1, 47, -1, 2396, 2396, 4449 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 2, -1, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.111Z", + "raHash" : "b48c04c2s0mmnmg7q1fev8k54d8", + "predicateName" : "function_entry_point", + "appearsAs" : { + "function_entry_point" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:363,1-363,80", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 2487 +} + +{ + "completionTime" : "2022-08-10T21:28:28.115Z", + "raHash" : "3b06515o0l7jaur3nki6ggv7c53", + "predicateName" : "stmtparents", + "appearsAs" : { + "stmtparents" : { + "BadAdditionOverflowCheck.ql" : [ 0 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\stmtparents.rele9a518baf14f4322ac243578a8e1391386ff030f6515381300128294551\\old.dbscheme:1929,1-1933,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 13, + "resultSize" : 43528 +} + +{ + "completionTime" : "2022-08-10T21:28:28.116Z", + "raHash" : "d2f6f0vq547an4vgd2l53jm5699", + "predicateName" : "ResolveClass::Cached::isClass#eb2868f4#f", + "appearsAs" : { + "ResolveClass::Cached::isClass#eb2868f4#f" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:113,3-125,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 17, + "resultSize" : 252, + "dependencies" : { + "usertypes_20#join_rhs" : "2e3e1ad1ra485cdgeblnafjpie3" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[1]", + " {1} r2 = JOIN r1 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = CONSTANT(unique int)[2]", + " {1} r4 = JOIN r3 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r5 = CONSTANT(unique int)[3]", + " {1} r6 = JOIN r5 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r7 = r4 UNION r6", + " {1} r8 = r2 UNION r7", + "", + " {1} r9 = CONSTANT(unique int)[6]", + " {1} r10 = JOIN r9 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r11 = CONSTANT(unique int)[10]", + " {1} r12 = JOIN r11 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r13 = r10 UNION r12", + "", + " {1} r14 = CONSTANT(unique int)[11]", + " {1} r15 = JOIN r14 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r16 = CONSTANT(unique int)[12]", + " {1} r17 = JOIN r16 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r18 = r15 UNION r17", + " {1} r19 = r13 UNION r18", + " {1} r20 = r8 UNION r19", + " return r20" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 206, -1, 1, 0, -1, 1, 46, -1, 46, 252, -1, 1, 0, -1, 1, 0, -1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 252 ], + "duplicationPercentages" : [ 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.116Z", + "raHash" : "6793187vdajk31pj0ajr52cu85e", + "predicateName" : "iscall", + "appearsAs" : { + "iscall" : { + "BadAdditionOverflowCheck.ql" : [ 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1155,1-1155,64", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 4, + "resultSize" : 11571 +} + +{ + "completionTime" : "2022-08-10T21:28:28.118Z", + "raHash" : "b11d6bcumifg21befashf33b4g3", + "predicateName" : "ResolveClass::Cached::isClass#eb2868f4#f", + "appearsAs" : { + "ResolveClass::Cached::isClass#eb2868f4#f" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:113,3-125,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 252 +} + +{ + "completionTime" : "2022-08-10T21:28:28.118Z", + "raHash" : "b687f43hut9uaipufkfb5ccnok4", + "predicateName" : "enumconstants", + "appearsAs" : { + "enumconstants" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:526,1-533,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 2325 +} + +{ + "completionTime" : "2022-08-10T21:28:28.119Z", + "raHash" : "aeab1cjdifv15av5ftki3347nhe", + "predicateName" : "@variable#f", + "appearsAs" : { + "@variable#f" : { + "BadAdditionOverflowCheck.ql" : [ 3, 5 ] + }, + "@variable#b" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:535,1-535,69", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 114, + "resultSize" : 15437, + "dependencies" : { + "params" : "d090e7q4tnlr6h30omabn66n2da", + "localvariables" : "111495kh3b6m9sku94i8oj4pqr3", + "globalvariables" : "2b4839pss7ki8gosmgnk6jcfjt1", + "membervariables" : "7c37bduotvpfjjrgej2r6r84p4b" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN params OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + "", + " {1} r3 = SCAN localvariables OUTPUT In.0", + " {1} r4 = STREAM DEDUP r3", + "", + " {1} r5 = r2 UNION r4", + "", + " {1} r6 = SCAN globalvariables OUTPUT In.0", + " {1} r7 = STREAM DEDUP r6", + "", + " {1} r8 = SCAN membervariables OUTPUT In.0", + " {1} r9 = STREAM DEDUP r8", + "", + " {1} r10 = r7 UNION r9", + " {1} r11 = r5 UNION r10", + " return r11" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7866, 7660, -1, 6212, 6212, -1, 13872, -1, 159, 159, -1, 1412, 1406, -1, 1565, 15437 ], + "duplicationPercentages" : [ 1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 6, 6, -1, 6, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.121Z", + "raHash" : "0c06f761am45c978h480cggik2e", + "predicateName" : "folders", + "appearsAs" : { + "folders" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:277,1-280,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 22 +} + +{ + "completionTime" : "2022-08-10T21:28:28.121Z", + "raHash" : "7f5fb8keqhfuljbsrqi6cka5a1f", + "predicateName" : "files", + "appearsAs" : { + "files" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:272,1-275,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 301 +} + +{ + "completionTime" : "2022-08-10T21:28:28.124Z", + "raHash" : "b4d31fmo7rtktfarajhbi807tj5", + "predicateName" : "type_def", + "appearsAs" : { + "type_def" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:456,1-456,41", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 334 +} + +{ + "completionTime" : "2022-08-10T21:28:28.124Z", + "raHash" : "529cf0o8krceqscefq2ru4h0h22", + "predicateName" : "iscall_0#antijoin_rhs", + "appearsAs" : { + "iscall_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:17,3-17,91", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 11571, + "dependencies" : { + "iscall" : "6793187vdajk31pj0ajr52cu85e" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN iscall OUTPUT In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571 ], + "duplicationPercentages" : [ 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.127Z", + "raHash" : "cf4be9rr2lpb6fucbt8bi3ts4de", + "predicateName" : "attribute_arg_name", + "appearsAs" : { + "attribute_arg_name" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:912,1-915,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.127Z", + "raHash" : "47ed22gl7uamt78e000q9ofcnp7", + "predicateName" : "attribute_arg_name_0#antijoin_rhs", + "appearsAs" : { + "attribute_arg_name_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "cf4be9rr2lpb6fucbt8bi3ts4de" +} + +{ + "completionTime" : "2022-08-10T21:28:28.128Z", + "raHash" : "7b1a5169scls3540rn7l8mc7h59", + "predicateName" : "fun_def", + "appearsAs" : { + "fun_def" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:405,1-405,39", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 2486 +} + +{ + "completionTime" : "2022-08-10T21:28:28.134Z", + "raHash" : "f619196et831u782kri8f1e92qc", + "predicateName" : "File::Container::toString#f0820431#ff", + "appearsAs" : { + "File::Container::toString#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + }, + "File::Container::getAbsolutePath#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\File.qll:164,19-164,27", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 12, + "resultSize" : 323, + "dependencies" : { + "files" : "7f5fb8keqhfuljbsrqi6cka5a1f", + "folders" : "0c06f761am45c978h480cggik2e" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = files UNION folders", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 323 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.135Z", + "raHash" : "4f7caba5dsgk1r6entcv25ano4d", + "predicateName" : "@variable#f", + "appearsAs" : { + "@variable#f" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:535,1-535,69", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 45, + "resultSize" : 15437, + "dependencies" : { + "globalvariables_0#antijoin_rhs" : "ea537b18m1251cdp00lp73c4ss1", + "params" : "d090e7q4tnlr6h30omabn66n2da", + "localvariables" : "111495kh3b6m9sku94i8oj4pqr3", + "membervariables" : "7c37bduotvpfjjrgej2r6r84p4b" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN params OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + "", + " {1} r3 = globalvariables_0#antijoin_rhs UNION r2", + "", + " {1} r4 = SCAN localvariables OUTPUT In.0", + " {1} r5 = STREAM DEDUP r4", + "", + " {1} r6 = SCAN membervariables OUTPUT In.0", + " {1} r7 = STREAM DEDUP r6", + "", + " {1} r8 = r5 UNION r7", + " {1} r9 = r3 UNION r8", + " return r9" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7866, 7660, -1, 7819, -1, 6212, 6212, -1, 1412, 1406, -1, 7618, 15437 ], + "duplicationPercentages" : [ 1, 0, -1, 0, -1, 0, 0, -1, 6, 6, -1, 2, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.139Z", + "raHash" : "5397fd5be48t0ikr4h0f4ccf4f4", + "predicateName" : "attribute_args", + "appearsAs" : { + "attribute_args" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:889,1-895,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 5, + "resultSize" : 902 +} + +{ + "completionTime" : "2022-08-10T21:28:28.142Z", + "raHash" : "0ec74f4cf2b3ie74lkqi73h2s44", + "predicateName" : "attribute_arg_value", + "appearsAs" : { + "attribute_arg_value" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:904,1-907,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 902 +} + +{ + "completionTime" : "2022-08-10T21:28:28.144Z", + "raHash" : "784ecebi2of8g6rj1mgiclc06l3", + "predicateName" : "param_decl_bind", + "appearsAs" : { + "param_decl_bind" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:430,1-434,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 16, + "resultSize" : 9233 +} + +{ + "completionTime" : "2022-08-10T21:28:28.144Z", + "raHash" : "3be0580ld116n2jtjpgtodj45v1", + "predicateName" : "attribute_args_10#join_rhs", + "appearsAs" : { + "attribute_args_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 902, + "dependencies" : { + "attribute_args" : "5397fd5be48t0ikr4h0f4ccf4f4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN attribute_args OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 902 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.145Z", + "raHash" : "381468i4ncf462h2to5m7bf3mg3", + "predicateName" : "specialnamequalifyingelements", + "appearsAs" : { + "specialnamequalifyingelements" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1162,1-1165,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 1 +} + +{ + "completionTime" : "2022-08-10T21:28:28.145Z", + "raHash" : "b50f9eclrn7lcuaig2u6g3aha70", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#3", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#3" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 0, + "dependencies" : { + "attribute_args_10#join_rhs" : "3be0580ld116n2jtjpgtodj45v1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[0]", + " {1} r2 = JOIN r1 WITH attribute_args_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.145Z", + "raHash" : "d77fc6ba27gauq3kreenvqgj01d", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#2", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#2" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 0, + "dependencies" : { + "attribute_args_10#join_rhs" : "3be0580ld116n2jtjpgtodj45v1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[3]", + " {1} r2 = JOIN r1 WITH attribute_args_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.146Z", + "raHash" : "39c36b6ne5vccs9no9kbl54pon0", + "predicateName" : "namequalifiers", + "appearsAs" : { + "namequalifiers" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1172,1-1177,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.146Z", + "raHash" : "d6a489c648m2p3ftr9nk05a9abe", + "predicateName" : "fold", + "appearsAs" : { + "fold" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1826,1-1830,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.147Z", + "raHash" : "5ebe7fn38btf3r245ma4k40cnc7", + "predicateName" : "fold_02#join_rhs", + "appearsAs" : { + "fold_02#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "d6a489c648m2p3ftr9nk05a9abe" +} + +{ + "completionTime" : "2022-08-10T21:28:28.147Z", + "raHash" : "8302e4qou22bsu9ja5phauvkk82", + "predicateName" : "fold_20#join_rhs", + "appearsAs" : { + "fold_20#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "d6a489c648m2p3ftr9nk05a9abe" +} + +{ + "completionTime" : "2022-08-10T21:28:28.147Z", + "raHash" : "cff297fj96ukkj18snt62ru1o59", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#6", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#6" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "8302e4qou22bsu9ja5phauvkk82" +} + +{ + "completionTime" : "2022-08-10T21:28:28.148Z", + "raHash" : "444594tcomqqm1eeubunuqiiap0", + "predicateName" : "namespaces", + "appearsAs" : { + "namespaces" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1087,1-1090,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 1 +} + +{ + "completionTime" : "2022-08-10T21:28:28.148Z", + "raHash" : "76251fa7llqs6brv1h2spucduv7", + "predicateName" : "param_decl_bind_0#antijoin_rhs", + "appearsAs" : { + "param_decl_bind_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 9233, + "dependencies" : { + "param_decl_bind" : "784ecebi2of8g6rj1mgiclc06l3" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN param_decl_bind OUTPUT In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 9233 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.151Z", + "raHash" : "2b777ahnpqgcvabqcq3qi6583s7", + "predicateName" : "static_asserts", + "appearsAs" : { + "static_asserts" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:480,1-486,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 1, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.155Z", + "raHash" : "501680ijsq1sagbea2uqpclm871", + "predicateName" : "preprocdirects", + "appearsAs" : { + "preprocdirects" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1968,1-1972,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 4, + "resultSize" : 14765 +} + +{ + "completionTime" : "2022-08-10T21:28:28.156Z", + "raHash" : "308849hf6k3tb7n8r58e6n3m98e", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#shared#1", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared#1" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 3963, + "dependencies" : { + "param_decl_bind_0#antijoin_rhs" : "76251fa7llqs6brv1h2spucduv7", + "var_def" : "a427a78knumk074qs3frhkdcsl8" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = param_decl_bind_0#antijoin_rhs AND NOT var_def(Lhs.0)", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 3963 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.157Z", + "raHash" : "98bf61n5u6ah253pa33022cb9eb", + "predicateName" : "query::isStmtWithInitializer#f0820431#f", + "appearsAs" : { + "query::isStmtWithInitializer#f0820431#f" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\query.ql:13,1-15,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 108, + "resultSize" : 6366, + "dependencies" : { + "stmts" : "7a398429ti3kj9d80pf7drffoh1" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = SELECT stmts ON In.1 = 2 OR In.1 = 11 OR In.1 = 35", + " {1} r2 = SCAN r1 OUTPUT In.0", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 6366, 6366 ], + "duplicationPercentages" : [ 11, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.157Z", + "raHash" : "a91605j57d31u1f53jdg0vp6ngc", + "predicateName" : "lambda_capture", + "appearsAs" : { + "lambda_capture" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1786,1-1794,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.157Z", + "raHash" : "4c8bb9rcbu5pit41jrm08ko2ggc", + "predicateName" : "usings", + "appearsAs" : { + "usings" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:468,1-472,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.158Z", + "raHash" : "d274d2ihgcpe7d09pfv2oepnchc", + "predicateName" : "Namespace::UsingDeclarationEntry#class#a86a25b0#f#antijoin_rhs", + "appearsAs" : { + "Namespace::UsingDeclarationEntry#class#a86a25b0#f#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "4c8bb9rcbu5pit41jrm08ko2ggc" +} + +{ + "completionTime" : "2022-08-10T21:28:28.158Z", + "raHash" : "86d2baa4gvl3ik54gutkn2of561", + "predicateName" : "Namespace::UsingDeclarationEntry#class#a86a25b0#f", + "appearsAs" : { + "Namespace::UsingDeclarationEntry#class#a86a25b0#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "4c8bb9rcbu5pit41jrm08ko2ggc" +} + +{ + "completionTime" : "2022-08-10T21:28:28.158Z", + "raHash" : "2d9db9omefk4dnid4esvdfqgr71", + "predicateName" : "usings_102#join_rhs", + "appearsAs" : { + "usings_102#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "4c8bb9rcbu5pit41jrm08ko2ggc" +} + +{ + "completionTime" : "2022-08-10T21:28:28.158Z", + "raHash" : "bdc64501hni80d8onb6vvo5b33d", + "predicateName" : "Namespace::UsingDeclarationEntry::getDeclaration#dispred#f0820431#ff", + "appearsAs" : { + "Namespace::UsingDeclarationEntry::getDeclaration#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "86d2baa4gvl3ik54gutkn2of561" +} + +{ + "completionTime" : "2022-08-10T21:28:28.158Z", + "raHash" : "ebff81qtem4jlutqeouq5foh2d8", + "predicateName" : "Namespace::UsingDirectiveEntry::getNamespace#dispred#f0820431#ff", + "appearsAs" : { + "Namespace::UsingDirectiveEntry::getNamespace#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "2d9db9omefk4dnid4esvdfqgr71" +} + +{ + "completionTime" : "2022-08-10T21:28:28.167Z", + "raHash" : "4380772qdcpm8epl3n8qbdtp07c", + "predicateName" : "Declaration::DeclarationEntry::isDefinition#dispred#f0820431#f", + "appearsAs" : { + "Declaration::DeclarationEntry::isDefinition#dispred#f0820431#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:375,3-376,38", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 33, + "resultSize" : 15855, + "dependencies" : { + "fun_def" : "7b1a5169scls3540rn7l8mc7h59", + "var_def" : "a427a78knumk074qs3frhkdcsl8", + "type_def" : "b4d31fmo7rtktfarajhbi807tj5" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = var_def UNION type_def", + "", + " {1} r2 = fun_def UNION r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 13369, -1, 15855 ], + "duplicationPercentages" : [ 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.168Z", + "raHash" : "92a2f8hcollo3fb0eu1ufbh8fp7", + "predicateName" : "code_block", + "appearsAs" : { + "code_block" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1789,1-1792,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.168Z", + "raHash" : "9c4b44m0ph92hj9qril4hm58eb6", + "predicateName" : "code_block_0#antijoin_rhs", + "appearsAs" : { + "code_block_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "92a2f8hcollo3fb0eu1ufbh8fp7" +} + +{ + "completionTime" : "2022-08-10T21:28:28.168Z", + "raHash" : "353354ak9qmtgb2pkdm7f9uv7e3", + "predicateName" : "Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff", + "appearsAs" : { + "Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:220,3-237,101", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 46, + "resultSize" : 16895, + "dependencies" : { + "var_decls" : "19e663f6klnnoolnln7bm5fsf2a" + }, + "ra" : { + "pipeline" : [ + " {5} r1 = SELECT var_decls ON In.3 != \"\"", + " {2} r2 = SCAN r1 OUTPUT In.0, In.3", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 17096, 17096 ], + "duplicationPercentages" : [ 7, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.169Z", + "raHash" : "321806gb901anaoamipg3hn9dt2", + "predicateName" : "namespace_decls", + "appearsAs" : { + "namespace_decls" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:461,1-466,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.176Z", + "raHash" : "d61bf7n1gonre7hd42g75rkhc84", + "predicateName" : "type_mentions", + "appearsAs" : { + "type_mentions" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:740,1-746,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 7, + "resultSize" : 13797 +} + +{ + "completionTime" : "2022-08-10T21:28:28.177Z", + "raHash" : "d054f4pe8716at0f0vtceu8iqad", + "predicateName" : "frienddecls", + "appearsAs" : { + "frienddecls" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:998,1-1003,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.188Z", + "raHash" : "28baa7haapfunikslgv7o507ut3", + "predicateName" : "preprocdirects_10#join_rhs", + "appearsAs" : { + "preprocdirects_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Include.qll:8,1-46,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 32, + "resultSize" : 14765, + "dependencies" : { + "preprocdirects" : "501680ijsq1sagbea2uqpclm871" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN preprocdirects OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 14765 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.191Z", + "raHash" : "18e3c2lkfgn912k0p1abcli290b", + "predicateName" : "Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff#antijoin_rhs", + "appearsAs" : { + "Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:287,3-303,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 13, + "resultSize" : 16895, + "dependencies" : { + "var_decls" : "19e663f6klnnoolnln7bm5fsf2a" + }, + "ra" : { + "pipeline" : [ + " {5} r1 = SELECT var_decls ON In.3 != \"\"", + " {1} r2 = SCAN r1 OUTPUT In.0", + " {1} r3 = STREAM DEDUP r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 17096, 17096, 16895 ], + "duplicationPercentages" : [ 7, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.191Z", + "raHash" : "d60daaas71d07nq9hqbk1b2vkh4", + "predicateName" : "exprconv_10#join_rhs", + "appearsAs" : { + "exprconv_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:31,17-31,33", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 190, + "resultSize" : 107672, + "dependencies" : { + "exprconv" : "ff49855htg34cr357mjg0pjpnpf" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN exprconv OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 107672 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.192Z", + "raHash" : "be7e81fg31h0iqfctbj95ig6i2d", + "predicateName" : "Include::Include#class#feab3531#f#antijoin_rhs#1", + "appearsAs" : { + "Include::Include#class#feab3531#f#antijoin_rhs#1" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Include.qll:8,1-46,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 3, + "dependencies" : { + "preprocdirects_10#join_rhs" : "28baa7haapfunikslgv7o507ut3" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[13]", + " {1} r2 = JOIN r1 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 3 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.193Z", + "raHash" : "beecd6738kc8m60pu8t0d11pore", + "predicateName" : "Include::Include#class#feab3531#f#antijoin_rhs", + "appearsAs" : { + "Include::Include#class#feab3531#f#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Include.qll:8,1-46,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 0, + "dependencies" : { + "preprocdirects_10#join_rhs" : "28baa7haapfunikslgv7o507ut3" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[12]", + " {1} r2 = JOIN r1 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.197Z", + "raHash" : "1c114bp9vsmb28scf1v9p1u9r6d", + "predicateName" : "preproctext", + "appearsAs" : { + "preproctext" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:2032,1-2036,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 9, + "resultSize" : 10589 +} + +{ + "completionTime" : "2022-08-10T21:28:28.198Z", + "raHash" : "dadb21ho5uvf9obbobs26ksqg29", + "predicateName" : "attributes", + "appearsAs" : { + "attributes" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:872,1-878,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 5, + "resultSize" : 3270 +} + +{ + "completionTime" : "2022-08-10T21:28:28.202Z", + "raHash" : "fd93fdj9jivr0o8sgd29ue1aova", + "predicateName" : "macroinvocations", + "appearsAs" : { + "macroinvocations" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:312,1-317,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 34, + "resultSize" : 55809 +} + +{ + "completionTime" : "2022-08-10T21:28:28.208Z", + "raHash" : "27699f98g7217nfv55t6sqbefbf", + "predicateName" : "attributes_10#join_rhs", + "appearsAs" : { + "attributes_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 3270, + "dependencies" : { + "attributes" : "dadb21ho5uvf9obbobs26ksqg29" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN attributes OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 3270 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.209Z", + "raHash" : "fe3d9cc3kj3h9f3j44ks89em3e9", + "predicateName" : "Include::Include#class#feab3531#f", + "appearsAs" : { + "Include::Include#class#feab3531#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Include.qll:8,1-46,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 8, + "resultSize" : 1206, + "dependencies" : { + "Include::Include#class#feab3531#f#antijoin_rhs" : "beecd6738kc8m60pu8t0d11pore", + "Include::Include#class#feab3531#f#antijoin_rhs#1" : "be7e81fg31h0iqfctbj95ig6i2d", + "preprocdirects_10#join_rhs" : "28baa7haapfunikslgv7o507ut3" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[6]", + " {1} r2 = JOIN r1 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = Include::Include#class#feab3531#f#antijoin_rhs#1 UNION r2", + "", + " {1} r4 = Include::Include#class#feab3531#f#antijoin_rhs UNION r3", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1203, -1, 1206, -1, 1206 ], + "duplicationPercentages" : [ 0, 0, -1, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.209Z", + "raHash" : "447923iinm6l2kruaksrq3faq39", + "predicateName" : "derivations", + "appearsAs" : { + "derivations" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:963,1-969,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.211Z", + "raHash" : "53f3bfvkvtrloq2kj50bh0oi2gc", + "predicateName" : "Macro::Macro::getBody#dispred#f0820431#ff", + "appearsAs" : { + "Macro::Macro::getBody#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Macro.qll:18,3-22,71", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 13, + "resultSize" : 5201, + "dependencies" : { + "preprocdirects_10#join_rhs" : "28baa7haapfunikslgv7o507ut3", + "preproctext" : "1c114bp9vsmb28scf1v9p1u9r6d" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[7]", + " {1} r2 = JOIN r1 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r3 = JOIN r2 WITH preproctext ON FIRST 1 OUTPUT Lhs.0, Rhs.2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 5201, 5201 ], + "duplicationPercentages" : [ 0, 6, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.220Z", + "raHash" : "3078ad36ujp52jqnbt1g2n5t5dd", + "predicateName" : "Macro::Macro::getHead#dispred#f0820431#ff", + "appearsAs" : { + "Macro::Macro::getHead#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Macro.qll:10,3-14,80", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 10, + "resultSize" : 5201, + "dependencies" : { + "preprocdirects_10#join_rhs" : "28baa7haapfunikslgv7o507ut3", + "preproctext" : "1c114bp9vsmb28scf1v9p1u9r6d" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[7]", + " {1} r2 = JOIN r1 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r3 = JOIN r2 WITH preproctext ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 5201, 5201 ], + "duplicationPercentages" : [ 0, 6, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.221Z", + "raHash" : "4545fafjnspbjqno642udv7it0a", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#1", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#1" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 0, + "dependencies" : { + "attributes_10#join_rhs" : "27699f98g7217nfv55t6sqbefbf" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[4]", + " {1} r2 = JOIN r1 WITH attributes_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.222Z", + "raHash" : "a3a788jger39gvndri8d6q3g8ra", + "predicateName" : "Macro::Macro::getBody#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Macro::Macro::getBody#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 10, + "resultSize" : 5201, + "dependencies" : { + "Macro::Macro::getBody#dispred#f0820431#ff" : "53f3bfvkvtrloq2kj50bh0oi2gc" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Macro::Macro::getBody#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 5201 ], + "duplicationPercentages" : [ 5 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.222Z", + "raHash" : "a154fejk0bt293sdhr9g2jmjjec", + "predicateName" : "diagnostics", + "appearsAs" : { + "diagnostics" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:263,1-270,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.223Z", + "raHash" : "b4ddc7rul83mhlsgo7a5b764qq4", + "predicateName" : "xmlEncoding", + "appearsAs" : { + "xmlEncoding" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:2055,1-2055,68", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.223Z", + "raHash" : "9cca432kbi687s6trkbojfvqigf", + "predicateName" : "XML::XMLParent#cb4732a3#b", + "appearsAs" : { + "XML::XMLParent#cb4732a3#b" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "b4ddc7rul83mhlsgo7a5b764qq4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.223Z", + "raHash" : "377c43fu61ive1afshapc50grk4", + "predicateName" : "XML::XMLFile#class#cb4732a3#f", + "appearsAs" : { + "XML::XMLFile#class#cb4732a3#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "9cca432kbi687s6trkbojfvqigf" +} + +{ + "completionTime" : "2022-08-10T21:28:28.224Z", + "raHash" : "ef427dd6m7f8gupqpreoiuniag2", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#7", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#7" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 441, + "dependencies" : { + "Macro::Macro::getBody#dispred#f0820431#ff_10#join_rhs" : "a3a788jger39gvndri8d6q3g8ra" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique string)[\"\"]", + " {1} r2 = JOIN r1 WITH Macro::Macro::getBody#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 441 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.225Z", + "raHash" : "4020f4d16rf6lcptf7bb3of07r8", + "predicateName" : "specifiers", + "appearsAs" : { + "specifiers" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:852,1-855,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 53 +} + +{ + "completionTime" : "2022-08-10T21:28:28.226Z", + "raHash" : "316d2bvq9gc8l3gu5gqstr5d7l4", + "predicateName" : "files_0#antijoin_rhs", + "appearsAs" : { + "files_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 301, + "dependencies" : { + "files" : "7f5fb8keqhfuljbsrqi6cka5a1f" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN files OUTPUT In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 301 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.226Z", + "raHash" : "bbe9fb5po52vsvate2rmm1of253", + "predicateName" : "namespaces_10#join_rhs", + "appearsAs" : { + "namespaces_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Namespace.qll:34,7-34,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1, + "dependencies" : { + "namespaces" : "444594tcomqqm1eeubunuqiiap0" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN namespaces OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.229Z", + "raHash" : "5aefd6p057qvie5nbj3umh56100", + "predicateName" : "comments", + "appearsAs" : { + "comments" : { + "BadAdditionOverflowCheck.ql" : [ 0, 0, 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\old.dbscheme:1055,1-1059,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 6, + "resultSize" : 14697 +} + +{ + "completionTime" : "2022-08-10T21:28:28.229Z", + "raHash" : "cc41237e8dcp25luvv67lgoqq8e", + "predicateName" : "stmts_10#join_rhs", + "appearsAs" : { + "stmts_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:13,3-17,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 82, + "resultSize" : 46015, + "dependencies" : { + "stmts" : "7a398429ti3kj9d80pf7drffoh1" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN stmts OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 46015 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.231Z", + "raHash" : "bf56137euh0fd2peclmsni20cl0", + "predicateName" : "condition_decl_bind", + "appearsAs" : { + "condition_decl_bind" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1767,1-1770,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.231Z", + "raHash" : "063c5a8sileo3rh1ibl2hfc04k2", + "predicateName" : "Assignment::ConditionDeclExpr::getVariable#dispred#f0820431#ff", + "appearsAs" : { + "Assignment::ConditionDeclExpr::getVariable#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "bf56137euh0fd2peclmsni20cl0" +} + +{ + "completionTime" : "2022-08-10T21:28:28.231Z", + "raHash" : "e5ec44m69hoonl7u2eevrs3db39", + "predicateName" : "project#Assignment::ConditionDeclExpr::getVariable#dispred#f0820431#ff", + "appearsAs" : { + "project#Assignment::ConditionDeclExpr::getVariable#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "063c5a8sileo3rh1ibl2hfc04k2" +} + +{ + "completionTime" : "2022-08-10T21:28:28.231Z", + "raHash" : "d4d64bg1c7m50vocm112khpj3n7", + "predicateName" : "Expr::Expr::getEnclosingStmt#f0820431#bf#join_rhs#1", + "appearsAs" : { + "Expr::Expr::getEnclosingStmt#f0820431#bf#join_rhs#1" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "063c5a8sileo3rh1ibl2hfc04k2" +} + +{ + "completionTime" : "2022-08-10T21:28:28.231Z", + "raHash" : "14c8f7srs7hjdsujsavtbn3hk2f", + "predicateName" : "Namespace::Namespace_not_GlobalNamespace#f#antijoin_rhs", + "appearsAs" : { + "Namespace::Namespace_not_GlobalNamespace#f#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Namespace.qll:34,7-34,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 1, + "dependencies" : { + "namespaces_10#join_rhs" : "bbe9fb5po52vsvate2rmm1of253" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique string)[\"\"]", + " {1} r2 = JOIN r1 WITH namespaces_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.232Z", + "raHash" : "9dde677pk65e919mh1g5an4c15f", + "predicateName" : "mangled_name", + "appearsAs" : { + "mangled_name" : { + "BadAdditionOverflowCheck.ql" : [ 1, 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:709,1-712,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 6, + "resultSize" : 645 +} + +{ + "completionTime" : "2022-08-10T21:28:28.233Z", + "raHash" : "978811c5o0qbdc4pjgtkfiu8t25", + "predicateName" : "m#Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf", + "appearsAs" : { + "m#Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Preprocessor.qll:19,3-19,71", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 22, + "resultSize" : 5388, + "dependencies" : { + "Include::Include#class#feab3531#f" : "fe3d9cc3kj3h9f3j44ks89em3e9", + "preprocdirects_10#join_rhs" : "28baa7haapfunikslgv7o507ut3" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[0]", + " {1} r2 = JOIN r1 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = Include::Include#class#feab3531#f UNION r2", + "", + " {1} r4 = CONSTANT(unique int)[1]", + " {1} r5 = JOIN r4 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r6 = CONSTANT(unique int)[2]", + " {1} r7 = JOIN r6 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r8 = CONSTANT(unique int)[3]", + " {1} r9 = JOIN r8 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r10 = r7 UNION r9", + " {1} r11 = r5 UNION r10", + " {1} r12 = r3 UNION r11", + "", + " {1} r13 = CONSTANT(unique int)[8]", + " {1} r14 = JOIN r13 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r15 = CONSTANT(unique int)[9]", + " {1} r16 = JOIN r15 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r17 = r14 UNION r16", + "", + " {1} r18 = CONSTANT(unique int)[10]", + " {1} r19 = JOIN r18 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r20 = CONSTANT(unique int)[11]", + " {1} r21 = JOIN r20 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r22 = CONSTANT(unique int)[18]", + " {1} r23 = JOIN r22 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r24 = r21 UNION r23", + " {1} r25 = r19 UNION r24", + " {1} r26 = r17 UNION r25", + " {1} r27 = r12 UNION r26", + " return r27" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1670, -1, 2876, -1, 1, 1200, -1, 1, 518, -1, 1, 246, -1, 764, 1964, 4840, -1, 1, 270, -1, 1, 278, -1, 548, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 548, 5388 ], + "duplicationPercentages" : [ 0, 0, -1, 0, -1, 0, 0, -1, 0, 3, -1, 0, 0, -1, 6, 5, 0, -1, 0, 3, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.233Z", + "raHash" : "53bd06glhfc50e4rbbm2igj18f3", + "predicateName" : "Declaration::DeclarationEntry#class#4bfb53be#b", + "appearsAs" : { + "Declaration::DeclarationEntry#class#4bfb53be#b" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:306,1-386,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 110, + "dependencies" : { + "expr_ancestor" : "4590572fcfvn8d9ukg7kmiigb24", + "type_decls" : "24a2balph6rbvqhb3m1k7pjpin0", + "fun_decls" : "4993a2gkk04l6oafdrv8j2d47ga", + "var_decls" : "19e663f6klnnoolnln7bm5fsf2a" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN expr_ancestor OUTPUT In.1", + "", + " {1} r2 = JOIN r1 WITH type_decls ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r3 = JOIN r1 WITH fun_decls ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r4 = JOIN r1 WITH var_decls ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r5 = r3 UNION r4", + " {1} r6 = r2 UNION r5", + " return r6" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 115, -1, 0, -1, 0, -1, 110, -1, 110, 110 ], + "duplicationPercentages" : [ 4, -1, 0, -1, 0, -1, 0, -1, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.233Z", + "raHash" : "043459orchlrqv4sai5fg45irc0", + "predicateName" : "Namespace::Namespace_not_GlobalNamespace#f", + "appearsAs" : { + "Namespace::Namespace_not_GlobalNamespace#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Namespace.qll:34,7-34,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 0, + "dependencies" : { + "namespaces" : "444594tcomqqm1eeubunuqiiap0", + "Namespace::Namespace_not_GlobalNamespace#f#antijoin_rhs" : "14c8f7srs7hjdsujsavtbn3hk2f" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN namespaces OUTPUT In.0", + " {1} r2 = r1 AND NOT Namespace::Namespace_not_GlobalNamespace#f#antijoin_rhs(Lhs.0)", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.234Z", + "raHash" : "4cf88ad62gq66tq7mn9m2c22fke", + "predicateName" : "is_complete", + "appearsAs" : { + "is_complete" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:717,1-717,43", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 242 +} + +{ + "completionTime" : "2022-08-10T21:28:28.234Z", + "raHash" : "a4eb83dro5jr6tesq8fj4jf5nna", + "predicateName" : "Namespace::Namespace::getParentNamespace#dispred#f0820431#ff", + "appearsAs" : { + "Namespace::Namespace::getParentNamespace#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "043459orchlrqv4sai5fg45irc0" +} + +{ + "completionTime" : "2022-08-10T21:28:28.235Z", + "raHash" : "f6bdcf8l83d5f73odfjptu9f7c2", + "predicateName" : "Namespace::Namespace::getParentNamespace#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Namespace::Namespace::getParentNamespace#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "a4eb83dro5jr6tesq8fj4jf5nna" +} + +{ + "completionTime" : "2022-08-10T21:28:28.235Z", + "raHash" : "97a95al8nm122vfpj3mf8jphfm0", + "predicateName" : "Namespace::Namespace::getParentName#dispred#f0820431#ff", + "appearsAs" : { + "Namespace::Namespace::getParentName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "f6bdcf8l83d5f73odfjptu9f7c2" +} + +{ + "completionTime" : "2022-08-10T21:28:28.235Z", + "raHash" : "15041bpiglja4e6e9rge8doti76", + "predicateName" : "project#Namespace::Namespace::getParentName#dispred#f0820431#ff", + "appearsAs" : { + "project#Namespace::Namespace::getParentName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "97a95al8nm122vfpj3mf8jphfm0" +} + +{ + "completionTime" : "2022-08-10T21:28:28.235Z", + "raHash" : "cca32bjvbgqo4s72mljcf1j8t19", + "predicateName" : "Namespace::Namespace::getQualifiedName#f0820431#ff#join_rhs", + "appearsAs" : { + "Namespace::Namespace::getQualifiedName#f0820431#ff#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "15041bpiglja4e6e9rge8doti76" +} + +{ + "completionTime" : "2022-08-10T21:28:28.236Z", + "raHash" : "2541ecufo3fdpvep3bn7frdvigf", + "predicateName" : "mangled_name#nonempty", + "appearsAs" : { + "mangled_name#nonempty" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:709,1-712,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1, + "dependencies" : { + "mangled_name" : "9dde677pk65e919mh1g5an4c15f" + }, + "ra" : { + "pipeline" : [ + " {0} r1 = SCAN mangled_name OUTPUT {}", + " {0} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 645, 1 ], + "duplicationPercentages" : [ 64369, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.237Z", + "raHash" : "3f163d4af7900535i0ep6qcm043", + "predicateName" : "stmt_decl_entry_bind", + "appearsAs" : { + "stmt_decl_entry_bind" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1974,1-1978,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 3, + "resultSize" : 6215 +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "0d4a79svtjl4ht8hft5j1pmuf52", + "predicateName" : "ResolveClass::getTopLevelClassName#eb2868f4#ff#shared", + "appearsAs" : { + "ResolveClass::getTopLevelClassName#eb2868f4#ff#shared" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:3,1-12,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 0, + "dependencies" : { + "mangled_name#nonempty" : "2541ecufo3fdpvep3bn7frdvigf" + }, + "ra" : { + "pipeline" : [ + " {0} r1 = CONSTANT()[]", + " {0} r2 = r1 AND NOT mangled_name#nonempty({})", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "54a246aubgevt7ktq1nlhfgvuo9", + "predicateName" : "ResolveClass::getTopLevelClassName#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::getTopLevelClassName#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "0d4a79svtjl4ht8hft5j1pmuf52" +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "c3a7b0kchi967jkjipc3sb7c164", + "predicateName" : "ResolveClass::existsIncompleteWithName#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::existsIncompleteWithName#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "54a246aubgevt7ktq1nlhfgvuo9" +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "321d82qu38on5klmh6vvdbn5u14", + "predicateName" : "ResolveClass::onlyOneCompleteClassExistsWithName#eb2868f4#f#count_range", + "appearsAs" : { + "ResolveClass::onlyOneCompleteClassExistsWithName#eb2868f4#f#count_range" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "54a246aubgevt7ktq1nlhfgvuo9" +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "87a0ddslbloh74fhdd2tc12bug1", + "predicateName" : "ResolveClass::oldHasCompleteTwin#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::oldHasCompleteTwin#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "c3a7b0kchi967jkjipc3sb7c164" +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "9f2886q55kj5possin0vcojbdr4", + "predicateName" : "ResolveClass::onlyOneCompleteClassExistsWithName#eb2868f4#f#join_rhs", + "appearsAs" : { + "ResolveClass::onlyOneCompleteClassExistsWithName#eb2868f4#f#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "321d82qu38on5klmh6vvdbn5u14" +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "a3f175qa7suog8c888hc4pcq2l2", + "predicateName" : "project#ResolveClass::oldHasCompleteTwin#eb2868f4#ff", + "appearsAs" : { + "project#ResolveClass::oldHasCompleteTwin#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "87a0ddslbloh74fhdd2tc12bug1" +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "232164gmr1u0dvnnhoccrpd14s8", + "predicateName" : "ResolveClass::onlyOneCompleteClassExistsWithName#eb2868f4#f", + "appearsAs" : { + "ResolveClass::onlyOneCompleteClassExistsWithName#eb2868f4#f" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "9f2886q55kj5possin0vcojbdr4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.238Z", + "raHash" : "2ae137injra2t6qc1k2pu7ae62c", + "predicateName" : "ResolveClass::existsCompleteWithName#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::existsCompleteWithName#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "232164gmr1u0dvnnhoccrpd14s8" +} + +{ + "completionTime" : "2022-08-10T21:28:28.239Z", + "raHash" : "0f7c33rvva1q5o73e7rmh846d8d", + "predicateName" : "Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf", + "appearsAs" : { + "Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Preprocessor.qll:19,3-19,71", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 5388, + "dependencies" : { + "m#Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf" : "978811c5o0qbdc4pjgtkfiu8t25", + "preproctext" : "1c114bp9vsmb28scf1v9p1u9r6d" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN m#Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf WITH preproctext ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 5388 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.241Z", + "raHash" : "6fcdc4ofh2j031br94ekahnsji1", + "predicateName" : "Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf_0#antijoin_rhs", + "appearsAs" : { + "Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 5388, + "dependencies" : { + "Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf" : "0f7c33rvva1q5o73e7rmh846d8d" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf OUTPUT In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 5388 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.244Z", + "raHash" : "6b0274766b43hptkbrj5a18g49b", + "predicateName" : "Include::Include::getIncludeText#dispred#f0820431#ff", + "appearsAs" : { + "Include::Include::getIncludeText#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Include.qll:22,3-26,54", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 1206, + "dependencies" : { + "Include::Include#class#feab3531#f" : "fe3d9cc3kj3h9f3j44ks89em3e9", + "Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf" : "0f7c33rvva1q5o73e7rmh846d8d" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Include::Include#class#feab3531#f WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1206 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.245Z", + "raHash" : "e898d66lt2s4g1v7pfsi2c9erpb", + "predicateName" : "stmt_decl_entry_bind_20#join_rhs", + "appearsAs" : { + "stmt_decl_entry_bind_20#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:1993,3-2002,83", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 8, + "resultSize" : 6215, + "dependencies" : { + "stmt_decl_entry_bind" : "3f163d4af7900535i0ep6qcm043" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN stmt_decl_entry_bind OUTPUT In.2, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 6215 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.251Z", + "raHash" : "505e6ea2mhjek37vqvqrs427hbe", + "predicateName" : "Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb", + "appearsAs" : { + "Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:1993,3-2002,83", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 80, + "dependencies" : { + "expr_ancestor" : "4590572fcfvn8d9ukg7kmiigb24", + "Declaration::DeclarationEntry#class#4bfb53be#b" : "53bd06glhfc50e4rbbm2igj18f3", + "stmt_decl_entry_bind_20#join_rhs" : "e898d66lt2s4g1v7pfsi2c9erpb" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN expr_ancestor OUTPUT In.1", + " {1} r2 = JOIN r1 WITH Declaration::DeclarationEntry#class#4bfb53be#b ON FIRST 1 OUTPUT Lhs.0", + " {2} r3 = JOIN r2 WITH stmt_decl_entry_bind_20#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 115, 110, 80 ], + "duplicationPercentages" : [ 4, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.251Z", + "raHash" : "24f6c7258i58t3au89ufllt6ms0", + "predicateName" : "ResolveClass::getClassMangledName#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::getClassMangledName#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:57,1-61,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 12, + "resultSize" : 182, + "dependencies" : { + "mangled_name" : "9dde677pk65e919mh1g5an4c15f", + "ResolveClass::Cached::isClass#eb2868f4#f" : "d2f6f0vq547an4vgd2l53jm5699" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN mangled_name WITH ResolveClass::Cached::isClass#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 182 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.253Z", + "raHash" : "68001b2olgt0tikfpqi95jkjtk7", + "predicateName" : "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs#2", + "appearsAs" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs#2" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 80, + "dependencies" : { + "Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb" : "505e6ea2mhjek37vqvqrs427hbe", + "expr_ancestor_10#join_rhs" : "64953d3ql9fvegp8lv2q4lt4fd0" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb OUTPUT In.1, In.0", + " {2} r2 = JOIN r1 WITH expr_ancestor_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 80, 80 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.255Z", + "raHash" : "e8cb85hfaacsp54kv4ahf3psr78", + "predicateName" : "Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb_1#antijoin_rhs", + "appearsAs" : { + "Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb_1#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 80, + "dependencies" : { + "Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb" : "505e6ea2mhjek37vqvqrs427hbe" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb OUTPUT In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 80 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.256Z", + "raHash" : "159a5ck9l5gc4rkuffddgg6484a", + "predicateName" : "attribute_arg_type", + "appearsAs" : { + "attribute_arg_type" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:908,1-911,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.256Z", + "raHash" : "cbb16c2hhbfieedpmgdmhm535pb", + "predicateName" : "Specifier::AttributeArgument::getValueType#dispred#f0820431#ff", + "appearsAs" : { + "Specifier::AttributeArgument::getValueType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "159a5ck9l5gc4rkuffddgg6484a" +} + +{ + "completionTime" : "2022-08-10T21:28:28.257Z", + "raHash" : "49faa0ae1cr3aftuf4m6qedgrk3", + "predicateName" : "uuidof_bind", + "appearsAs" : { + "uuidof_bind" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1777,1-1780,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.257Z", + "raHash" : "6e3f94vnihep78r66mkkqen5k65", + "predicateName" : "Cast::UuidofOperator::getTypeOperand#dispred#f0820431#ff", + "appearsAs" : { + "Cast::UuidofOperator::getTypeOperand#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "49faa0ae1cr3aftuf4m6qedgrk3" +} + +{ + "completionTime" : "2022-08-10T21:28:28.257Z", + "raHash" : "695362sdf7semslhfvb41o5mfse", + "predicateName" : "project#Cast::UuidofOperator::getTypeOperand#dispred#f0820431#ff", + "appearsAs" : { + "project#Cast::UuidofOperator::getTypeOperand#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "6e3f94vnihep78r66mkkqen5k65" +} + +{ + "completionTime" : "2022-08-10T21:28:28.263Z", + "raHash" : "5bd5003rk4pdjj92bept8iflv86", + "predicateName" : "var_decls_10#join_rhs", + "appearsAs" : { + "var_decls_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveGlobalVariable.qll:1,1-3,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 30, + "resultSize" : 17039, + "dependencies" : { + "var_decls" : "19e663f6klnnoolnln7bm5fsf2a" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN var_decls OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 17240 ], + "duplicationPercentages" : [ 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.265Z", + "raHash" : "54f1df5eanrq6mjkq3tcl99es38", + "predicateName" : "ResolveGlobalVariable::hasDefinition#ac30c42f#f", + "appearsAs" : { + "ResolveGlobalVariable::hasDefinition#ac30c42f#f" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveGlobalVariable.qll:1,1-3,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 132, + "dependencies" : { + "globalvariables_0#antijoin_rhs" : "ea537b18m1251cdp00lp73c4ss1", + "var_decls_10#join_rhs" : "5bd5003rk4pdjj92bept8iflv86", + "var_def" : "a427a78knumk074qs3frhkdcsl8" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN globalvariables_0#antijoin_rhs WITH var_decls_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {1} r2 = JOIN r1 WITH var_def ON FIRST 1 OUTPUT Lhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 173, 132 ], + "duplicationPercentages" : [ 3, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.267Z", + "raHash" : "a340a0hq5pu18lqq2orc5lh2e5b", + "predicateName" : "ResolveGlobalVariable::onlyOneCompleteGlobalVariableExistsWithMangledName#ac30c42f#f#count_range", + "appearsAs" : { + "ResolveGlobalVariable::onlyOneCompleteGlobalVariableExistsWithMangledName#ac30c42f#f#count_range" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveGlobalVariable.qll:5,1-7,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 0, + "dependencies" : { + "ResolveGlobalVariable::hasDefinition#ac30c42f#f" : "54f1df5eanrq6mjkq3tcl99es38", + "mangled_name" : "9dde677pk65e919mh1g5an4c15f" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN ResolveGlobalVariable::hasDefinition#ac30c42f#f WITH mangled_name ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 0 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.267Z", + "raHash" : "e77559gj95512343upkandsesn8", + "predicateName" : "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#count_range", + "appearsAs" : { + "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#count_range" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:71,1-74,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 10, + "resultSize" : 172, + "dependencies" : { + "is_complete" : "4cf88ad62gq66tq7mn9m2c22fke", + "ResolveClass::getClassMangledName#eb2868f4#ff" : "24f6c7258i58t3au89ufllt6ms0" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN is_complete WITH ResolveClass::getClassMangledName#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 172 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.267Z", + "raHash" : "02121fne1onp71p2p2lascvium7", + "predicateName" : "ResolveGlobalVariable::onlyOneCompleteGlobalVariableExistsWithMangledName#ac30c42f#f#join_rhs", + "appearsAs" : { + "ResolveGlobalVariable::onlyOneCompleteGlobalVariableExistsWithMangledName#ac30c42f#f#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "a340a0hq5pu18lqq2orc5lh2e5b" +} + +{ + "completionTime" : "2022-08-10T21:28:28.267Z", + "raHash" : "4a4729rr51n8ulpi560is9gquhe", + "predicateName" : "ResolveGlobalVariable::onlyOneCompleteGlobalVariableExistsWithMangledName#ac30c42f#f", + "appearsAs" : { + "ResolveGlobalVariable::onlyOneCompleteGlobalVariableExistsWithMangledName#ac30c42f#f" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "02121fne1onp71p2p2lascvium7" +} + +{ + "completionTime" : "2022-08-10T21:28:28.267Z", + "raHash" : "cbf0bfrvggeg64bfuj05482uorc", + "predicateName" : "ResolveGlobalVariable::hasTwinWithDefinition#ac30c42f#ff", + "appearsAs" : { + "ResolveGlobalVariable::hasTwinWithDefinition#ac30c42f#ff" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "4a4729rr51n8ulpi560is9gquhe" +} + +{ + "completionTime" : "2022-08-10T21:28:28.267Z", + "raHash" : "a2fd155e1ch0uet213upch29sce", + "predicateName" : "project#ResolveGlobalVariable::hasTwinWithDefinition#ac30c42f#ff", + "appearsAs" : { + "project#ResolveGlobalVariable::hasTwinWithDefinition#ac30c42f#ff" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "cbf0bfrvggeg64bfuj05482uorc" +} + +{ + "completionTime" : "2022-08-10T21:28:28.275Z", + "raHash" : "cf84577uk1kr0arjnjkiqfrlroe", + "predicateName" : "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff", + "appearsAs" : { + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveGlobalVariable.qll:38,3-49,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 8, + "resultSize" : 15437, + "dependencies" : { + "@variable#f" : "4f7caba5dsgk1r6entcv25ano4d", + "project#ResolveGlobalVariable::hasTwinWithDefinition#ac30c42f#ff" : "a2fd155e1ch0uet213upch29sce", + "ResolveGlobalVariable::hasTwinWithDefinition#ac30c42f#ff" : "cbf0bfrvggeg64bfuj05482uorc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = @variable#f AND NOT project#ResolveGlobalVariable::hasTwinWithDefinition#ac30c42f#ff(Lhs.0)", + " {2} r2 = SCAN r1 OUTPUT In.0, In.0", + "", + " {2} r3 = SCAN ResolveGlobalVariable::hasTwinWithDefinition#ac30c42f#ff OUTPUT In.1, In.0", + " {2} r4 = JOIN r3 WITH @variable#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r5 = r2 UNION r4", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 15437, 15437, -1, 0, 0, -1, 15437 ], + "duplicationPercentages" : [ 0, 0, -1, 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.282Z", + "raHash" : "f6ff4eq4hh9l66jo2q6fgp5mck3", + "predicateName" : "values", + "appearsAs" : { + "values" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1377,1-1381,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 24, + "resultSize" : 107781 +} + +{ + "completionTime" : "2022-08-10T21:28:28.284Z", + "raHash" : "da85a8769r62cskd8idv6dtinb2", + "predicateName" : "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff", + "appearsAs" : { + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveGlobalVariable.qll:38,3-49,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 15437 +} + +{ + "completionTime" : "2022-08-10T21:28:28.286Z", + "raHash" : "4b68f8u8413f0cq0kdllnq3rk72", + "predicateName" : "Namespace::Namespace::getQualifiedName#f0820431#ff", + "appearsAs" : { + "Namespace::Namespace::getQualifiedName#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Namespace.qll:62,10-62,26", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_RECURSIVE", + "millis" : 31, + "predicateIterationMillis" : [ 1, 3 ], + "deltaSizes" : [ 1, 0 ], + "resultSize" : 1, + "dependencies" : { + "namespaces" : "444594tcomqqm1eeubunuqiiap0", + "project#Namespace::Namespace::getParentName#dispred#f0820431#ff" : "15041bpiglja4e6e9rge8doti76", + "Namespace::Namespace::getParentNamespace#dispred#f0820431#ff_10#join_rhs" : "f6bdcf8l83d5f73odfjptu9f7c2", + "Namespace::Namespace::getQualifiedName#f0820431#ff#join_rhs" : "cca32bjvbgqo4s72mljcf1j8t19" + }, + "layerSize" : 1, + "ra" : { + "base" : [ + " {2} r1 = namespaces AND NOT project#Namespace::Namespace::getParentName#dispred#f0820431#ff(Lhs.0)", + " return r1" + ], + "standard" : [ + " {2} r1 = JOIN Namespace::Namespace::getQualifiedName#f0820431#ff#prev_delta WITH Namespace::Namespace::getQualifiedName#f0820431#ff#join_rhs ON FIRST 1 OUTPUT Rhs.1, (Lhs.1 ++ \"::\" ++ Rhs.2)", + " {2} r2 = r1 AND NOT Namespace::Namespace::getQualifiedName#f0820431#ff#prev(Lhs.0, Lhs.1)", + " return r2" + ], + "order_500000" : [ + " {2} r1 = JOIN Namespace::Namespace::getQualifiedName#f0820431#ff#prev_delta WITH Namespace::Namespace::getParentNamespace#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r2 = JOIN r1 WITH project#Namespace::Namespace::getParentName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " {2} r3 = JOIN r2 WITH namespaces ON FIRST 1 OUTPUT Lhs.0, (Lhs.1 ++ \"::\" ++ Rhs.1)", + " {2} r4 = r3 AND NOT Namespace::Namespace::getQualifiedName#f0820431#ff#prev(Lhs.0, Lhs.1)", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "base", + "counts" : [ 1 ], + "duplicationPercentages" : [ 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, 0, 0, 0 ], + "duplicationPercentages" : [ 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.288Z", + "raHash" : "d03d3a4c88ofr5ctj9n4i7ra3e4", + "predicateName" : "Namespace::Namespace::getFriendlyName#dispred#f0820431#ff", + "appearsAs" : { + "Namespace::Namespace::getFriendlyName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Namespace.qll:92,3-93,64", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1, + "dependencies" : { + "Namespace::Namespace_not_GlobalNamespace#f" : "043459orchlrqv4sai5fg45irc0", + "Namespace::Namespace::getQualifiedName#f0820431#ff" : "4b68f8u8413f0cq0kdllnq3rk72", + "namespaces_10#join_rhs" : "bbe9fb5po52vsvate2rmm1of253" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Namespace::Namespace_not_GlobalNamespace#f WITH Namespace::Namespace::getQualifiedName#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r2 = CONSTANT(string, unique string)[\"\",\"(global namespace)\"]", + " {2} r3 = JOIN r2 WITH namespaces_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"(global namespace)\"", + "", + " {2} r4 = r1 UNION r3", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 0, -1, 1, 1, -1, 1 ], + "duplicationPercentages" : [ 0, -1, 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.294Z", + "raHash" : "8057edi8viiq0fbb2ut69d46dj9", + "predicateName" : "funbind", + "appearsAs" : { + "funbind" : { + "BadAdditionOverflowCheck.ql" : [ 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1184,1-1187,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 5, + "resultSize" : 12277 +} + +{ + "completionTime" : "2022-08-10T21:28:28.296Z", + "raHash" : "6ddbfbs40ktkq0tbgg3jo0d16na", + "predicateName" : "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#join_rhs", + "appearsAs" : { + "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:71,1-74,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 29, + "resultSize" : 166, + "dependencies" : { + "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#count_range" : "e77559gj95512343upkandsesn8" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = AGGREGATE ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#count_range, ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#count_range ON WITH COUNT OUTPUT In.0, Agg.0", + " {2} r2 = SCAN r1 OUTPUT In.1, In.0", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 166, 166 ], + "duplicationPercentages" : [ 3, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.298Z", + "raHash" : "2a73c1n2oqmj5vtv6a75vfpk675", + "predicateName" : "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f", + "appearsAs" : { + "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:71,1-74,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 160, + "dependencies" : { + "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#join_rhs" : "6ddbfbs40ktkq0tbgg3jo0d16na" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[1]", + " {1} r2 = JOIN r1 WITH ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 160 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.299Z", + "raHash" : "2486303f27joo9g68ndelhdd1j1", + "predicateName" : "ResolveClass::existsCompleteWithMangledName#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::existsCompleteWithMangledName#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:63,1-69,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 160, + "dependencies" : { + "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#count_range" : "e77559gj95512343upkandsesn8", + "ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f" : "2a73c1n2oqmj5vtv6a75vfpk675" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f#count_range WITH ResolveClass::onlyOneCompleteClassExistsWithMangledName#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 160 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.301Z", + "raHash" : "e2f48di291bqfs3semk6idgdah5", + "predicateName" : "locations_expr", + "appearsAs" : { + "locations_expr" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:236,1-251,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 54, + "resultSize" : 151608 +} + +{ + "completionTime" : "2022-08-10T21:28:28.302Z", + "raHash" : "f7c4b0r48rsta8gb5akjv7vbslb", + "predicateName" : "ResolveClass::existsIncompleteWithMangledName#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::existsIncompleteWithMangledName#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:76,1-81,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 10, + "dependencies" : { + "ResolveClass::getClassMangledName#eb2868f4#ff" : "24f6c7258i58t3au89ufllt6ms0", + "is_complete" : "4cf88ad62gq66tq7mn9m2c22fke" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = ResolveClass::getClassMangledName#eb2868f4#ff AND NOT is_complete(Lhs.0)", + " {2} r2 = SCAN r1 OUTPUT In.1, In.0", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 10, 10 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.303Z", + "raHash" : "dcf789h5id6rmfuakkdfasd7ldf", + "predicateName" : "Initializer::Initializer::getDeclaration#dispred#f0820431#ff", + "appearsAs" : { + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3, 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Initializer.qll:42,3-45,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 18, + "resultSize" : 7512, + "dependencies" : { + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "@variable#f" : "aeab1cjdifv15av5ftki3347nhe" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN initialisers OUTPUT In.1, In.0", + " {2} r2 = JOIN r1 WITH ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {3} r3 = SCAN initialisers OUTPUT In.0, In.1, In.1", + " {3} r4 = r3 AND NOT @variable#f(Lhs.2)", + " {2} r5 = SCAN r4 OUTPUT In.0, In.2", + "", + " {2} r6 = r2 UNION r5", + " return r6" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512, 4475, -1, 7512, 3037, 3037, -1, 7512 ], + "duplicationPercentages" : [ 2, 1, -1, 0, 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.305Z", + "raHash" : "fd2927uc5kgg4fgdg23loun2n2a", + "predicateName" : "ResolveClass::hasCompleteTwin#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::hasCompleteTwin#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:83,1-92,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 2, + "dependencies" : { + "ResolveClass::existsCompleteWithMangledName#eb2868f4#ff" : "2486303f27joo9g68ndelhdd1j1", + "ResolveClass::existsIncompleteWithMangledName#eb2868f4#ff" : "f7c4b0r48rsta8gb5akjv7vbslb" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN ResolveClass::existsCompleteWithMangledName#eb2868f4#ff WITH ResolveClass::existsIncompleteWithMangledName#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.305Z", + "raHash" : "7a1066u856ha7tjitscgkbadhf9", + "predicateName" : "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f", + "appearsAs" : { + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveGlobalVariable.qll:51,3-56,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 29, + "resultSize" : 15437, + "dependencies" : { + "@variable#f" : "4f7caba5dsgk1r6entcv25ano4d", + "globalvariables_0#antijoin_rhs" : "ea537b18m1251cdp00lp73c4ss1", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "cf84577uk1kr0arjnjkiqfrlroe" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = @variable#f AND NOT globalvariables_0#antijoin_rhs(Lhs.0)", + "", + " {1} r2 = SCAN ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff OUTPUT In.1", + " {1} r3 = JOIN r2 WITH @variable#f ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r4 = r1 UNION r3", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 15278, -1, 15437, 15437, -1, 30715 ], + "duplicationPercentages" : [ 0, -1, 0, 0, -1, 93 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.306Z", + "raHash" : "3b7d11p4c4e9mvbu14hc5b84t0e", + "predicateName" : "Initializer::Initializer::getDeclaration#dispred#f0820431#ff_0#antijoin_rhs", + "appearsAs" : { + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 7512, + "dependencies" : { + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : "dcf789h5id6rmfuakkdfasd7ldf" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Initializer::Initializer::getDeclaration#dispred#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512, 7512 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.306Z", + "raHash" : "e5b4bcorh0d4gtsdi1d05545s71", + "predicateName" : "project#ResolveClass::hasCompleteTwin#eb2868f4#ff", + "appearsAs" : { + "project#ResolveClass::hasCompleteTwin#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:83,1-92,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 2, + "dependencies" : { + "ResolveClass::hasCompleteTwin#eb2868f4#ff" : "fd2927uc5kgg4fgdg23loun2n2a" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN ResolveClass::hasCompleteTwin#eb2868f4#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2, 2 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.307Z", + "raHash" : "820e54uma8ge48bt57kubqkdag1", + "predicateName" : "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f", + "appearsAs" : { + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : { + "BadAdditionOverflowCheck.ql" : [ 2 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveGlobalVariable.qll:51,3-56,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 1, + "resultSize" : 15437 +} + +{ + "completionTime" : "2022-08-10T21:28:28.309Z", + "raHash" : "27c8c1dcq39mrl2s05gje3qc74c", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#shared#2", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared#2" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 7512, + "dependencies" : { + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : "dcf789h5id6rmfuakkdfasd7ldf" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN initialisers WITH Initializer::Initializer::getDeclaration#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.311Z", + "raHash" : "b2a97emm8g2borqss3q1ithbsf1", + "predicateName" : "ResolveClass::Cached::resolveClass#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:98,3-111,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 793, + "dependencies" : { + "usertypes" : "c10195ctfthoommu9q08d5rci34", + "ResolveClass::hasCompleteTwin#eb2868f4#ff" : "fd2927uc5kgg4fgdg23loun2n2a", + "ResolveClass::oldHasCompleteTwin#eb2868f4#ff" : "87a0ddslbloh74fhdd2tc12bug1", + "project#ResolveClass::hasCompleteTwin#eb2868f4#ff" : "e5b4bcorh0d4gtsdi1d05545s71", + "project#ResolveClass::oldHasCompleteTwin#eb2868f4#ff" : "a3f175qa7suog8c888hc4pcq2l2" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN usertypes WITH ResolveClass::hasCompleteTwin#eb2868f4#ff ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r2 = JOIN usertypes WITH ResolveClass::oldHasCompleteTwin#eb2868f4#ff ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {1} r3 = SCAN usertypes OUTPUT In.0", + " {1} r4 = r3 AND NOT project#ResolveClass::hasCompleteTwin#eb2868f4#ff(Lhs.0)", + " {1} r5 = r4 AND NOT project#ResolveClass::oldHasCompleteTwin#eb2868f4#ff(Lhs.0)", + " {2} r6 = SCAN r5 OUTPUT In.0, In.0", + "", + " {2} r7 = r2 UNION r6", + " {2} r8 = r1 UNION r7", + " return r8" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2, -1, 0, -1, 793, 791, 791, 791, -1, 791, 793 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0, 1, -1, 1, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.316Z", + "raHash" : "071b3ddctqfv392jbrqadrlvta8", + "predicateName" : "project#ResolveClass::Cached::resolveClass#eb2868f4#ff", + "appearsAs" : { + "project#ResolveClass::Cached::resolveClass#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:98,3-111,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 791, + "dependencies" : { + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "b2a97emm8g2borqss3q1ithbsf1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN ResolveClass::Cached::resolveClass#eb2868f4#ff OUTPUT In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 793 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.316Z", + "raHash" : "39d5d2nccctdkfs67nb5ehta6ge", + "predicateName" : "Parameter::Parameter#class#ed81dd8f#f", + "appearsAs" : { + "Parameter::Parameter#class#ed81dd8f#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Parameter.qll:9,1-153,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 6, + "resultSize" : 7660, + "dependencies" : { + "params" : "d090e7q4tnlr6h30omabn66n2da", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN params OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " {1} r3 = JOIN r2 WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.0", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7866, 7660, 7660 ], + "duplicationPercentages" : [ 1, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.317Z", + "raHash" : "6425a8tgaaqfsggujsb60fqkuqe", + "predicateName" : "ResolveClass::Cached::resolveClass#eb2868f4#ff", + "appearsAs" : { + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:98,3-111,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 793 +} + +{ + "completionTime" : "2022-08-10T21:28:28.318Z", + "raHash" : "55d114f4sdqi2stctc8vhkfvuj8", + "predicateName" : "project#Initializer::Initializer::getDeclaration#dispred#f0820431#ff", + "appearsAs" : { + "project#Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Initializer.qll:42,3-45,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 8, + "resultSize" : 6800, + "dependencies" : { + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : "dcf789h5id6rmfuakkdfasd7ldf" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Initializer::Initializer::getDeclaration#dispred#f0820431#ff OUTPUT In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512 ], + "duplicationPercentages" : [ 7 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.325Z", + "raHash" : "e700ffcbm2nvau0qc6991ke8ahb", + "predicateName" : "Parameter::Parameter#class#ed81dd8f#b", + "appearsAs" : { + "Parameter::Parameter#class#ed81dd8f#b" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Parameter.qll:9,1-153,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 0, + "dependencies" : { + "project#Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : "55d114f4sdqi2stctc8vhkfvuj8", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1", + "params" : "d090e7q4tnlr6h30omabn66n2da" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN project#Initializer::Initializer::getDeclaration#dispred#f0820431#ff WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.0", + " {1} r2 = JOIN r1 WITH params ON FIRST 1 OUTPUT Lhs.0", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4475, 0 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.325Z", + "raHash" : "54b3a2mr9cbb6od7v65400c1407", + "predicateName" : "Parameter::Parameter::getFunction#dispred#f0820431#bf", + "appearsAs" : { + "Parameter::Parameter::getFunction#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "e700ffcbm2nvau0qc6991ke8ahb" +} + +{ + "completionTime" : "2022-08-10T21:28:28.325Z", + "raHash" : "a57c8f33nr7iluhu9q40na76305", + "predicateName" : "Enclosing::exprEnclosingElement#c50c5fbf#ff#antijoin_rhs", + "appearsAs" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "e700ffcbm2nvau0qc6991ke8ahb" +} + +{ + "completionTime" : "2022-08-10T21:28:28.329Z", + "raHash" : "9794f2ntc3dscnec46gnipss9g9", + "predicateName" : "Parameter::Parameter::getIndex#dispred#f0820431#ff", + "appearsAs" : { + "Parameter::Parameter::getIndex#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Parameter.qll:121,3-126,67", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 7660, + "dependencies" : { + "params" : "d090e7q4tnlr6h30omabn66n2da", + "Parameter::Parameter#class#ed81dd8f#f" : "39d5d2nccctdkfs67nb5ehta6ge" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN params WITH Parameter::Parameter#class#ed81dd8f#f ON FIRST 1 OUTPUT Lhs.0, Lhs.2", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7866 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.331Z", + "raHash" : "1fc9ac6onv7vaupqcmfcd4cpcb0", + "predicateName" : "ResolveClass::Cached::isType#eb2868f4#f", + "appearsAs" : { + "ResolveClass::Cached::isType#eb2868f4#f" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:127,3-132,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 13, + "resultSize" : 4447, + "dependencies" : { + "@type#f" : "6213c7pqpkgs0qduk1tsu11ab8e", + "ResolveClass::Cached::isClass#eb2868f4#f" : "d2f6f0vq547an4vgd2l53jm5699", + "project#ResolveClass::Cached::resolveClass#eb2868f4#ff" : "071b3ddctqfv392jbrqadrlvta8" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = @type#f AND NOT ResolveClass::Cached::isClass#eb2868f4#f(Lhs.0)", + "", + " {1} r2 = JOIN @type#f WITH project#ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r3 = r1 UNION r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4197, -1, 791, -1, 4988 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 5 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.332Z", + "raHash" : "8b3f22jtvpn0s9e0s4dgoden071", + "predicateName" : "member", + "appearsAs" : { + "member" : { + "BadAdditionOverflowCheck.ql" : [ 1, 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:950,1-954,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 1406 +} + +{ + "completionTime" : "2022-08-10T21:28:28.332Z", + "raHash" : "34c70bu24f3qru86sj48qiih5d9", + "predicateName" : "ResolveClass::Cached::isType#eb2868f4#f", + "appearsAs" : { + "ResolveClass::Cached::isType#eb2868f4#f" : { + "BadAdditionOverflowCheck.ql" : [ 1 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\internal\\ResolveClass.qll:127,3-132,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 4447 +} + +{ + "completionTime" : "2022-08-10T21:28:28.334Z", + "raHash" : "28ea22saqlal1d6bsnrqagq7mo9", + "predicateName" : "sizeof_bind", + "appearsAs" : { + "sizeof_bind" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1784,1-1787,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 742 +} + +{ + "completionTime" : "2022-08-10T21:28:28.334Z", + "raHash" : "139654uu97n1nhv6pvidnh51q27", + "predicateName" : "#select#query#fff", + "appearsAs" : { + "#select#query#fff" : { + "BadAdditionOverflowCheck.ql" : [ 0 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\stmtparents.rele9a518baf14f4322ac243578a8e1391386ff030f6515381300128294551\\query.ql:13,1-17,32", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 176, + "resultSize" : 43528, + "dependencies" : { + "stmtparents" : "3b06515o0l7jaur3nki6ggv7c53", + "query::isStmtWithInitializer#f0820431#f" : "98bf61n5u6ah253pa33022cb9eb" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = stmtparents AND NOT query::isStmtWithInitializer#f0820431#f(Lhs.2)", + "", + " {3} r2 = SCAN stmtparents OUTPUT In.2, In.0, In.1", + " {3} r3 = JOIN r2 WITH query::isStmtWithInitializer#f0820431#f ON FIRST 1 OUTPUT Lhs.1, (Lhs.2 + 1), Lhs.0", + "", + " {3} r4 = r1 UNION r3", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 35067, -1, 43528, 8461, -1, 43528 ], + "duplicationPercentages" : [ 0, -1, 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.335Z", + "raHash" : "b770b3dd00tr01siqj3tgilh4q2", + "predicateName" : "varbind", + "appearsAs" : { + "varbind" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1179,1-1182,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 40, + "resultSize" : 98988 +} + +{ + "completionTime" : "2022-08-10T21:28:28.337Z", + "raHash" : "c28897b38t1afpec2hvnpfsfci5", + "predicateName" : "Type::RoutineType#class#2e8eb3ef#f", + "appearsAs" : { + "Type::RoutineType#class#2e8eb3ef#f" : { + "BadAdditionOverflowCheck.ql" : [ 4, 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:1553,1-1640,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1260, + "dependencies" : { + "routinetypes" : "73563dqdgofcni857o7aprhdgr4", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN routinetypes WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1260 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.338Z", + "raHash" : "1f8231p17fv7mnmfdrhkkrd17bf", + "predicateName" : "#select#query#fff", + "appearsAs" : { + "#select#query#fff" : { + "BadAdditionOverflowCheck.ql" : [ 0 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\stmtparents.rele9a518baf14f4322ac243578a8e1391386ff030f6515381300128294551\\query.ql:13,1-17,32", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 43528 +} + +{ + "completionTime" : "2022-08-10T21:28:28.338Z", + "raHash" : "df7d4cm0530dpn7gltrte6te2b2", + "predicateName" : "Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#bf", + "appearsAs" : { + "Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:335,3-346,42", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 110, + "dependencies" : { + "expr_ancestor" : "4590572fcfvn8d9ukg7kmiigb24", + "fun_decls" : "4993a2gkk04l6oafdrv8j2d47ga", + "type_decls" : "24a2balph6rbvqhb3m1k7pjpin0", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "var_decls" : "19e663f6klnnoolnln7bm5fsf2a", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN expr_ancestor OUTPUT In.1", + "", + " {2} r2 = JOIN r1 WITH fun_decls ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r3 = JOIN r1 WITH type_decls ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r5 = JOIN r4 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r6 = JOIN r1 WITH var_decls ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r7 = JOIN r6 WITH ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r8 = JOIN r7 WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r9 = r5 UNION r8", + " {2} r10 = r2 UNION r9", + " return r10" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 115, -1, 0, -1, 0, 0, 0, -1, 110, 110, 110, -1, 110, 110 ], + "duplicationPercentages" : [ 4, -1, 0, -1, 0, 0, 0, -1, 0, 0, 2, -1, 2, 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.340Z", + "raHash" : "4773123to6rq2m662d9guv6kgp8", + "predicateName" : "Type::DerivedType::getName#dispred#f0820431#ff", + "appearsAs" : { + "Type::DerivedType::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:1072,3-1072,84", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 2349, + "dependencies" : { + "derivedtypes" : "8dfb6bscm7bke1cl6illlc7u8k4", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN derivedtypes WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2349 ], + "duplicationPercentages" : [ 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.340Z", + "raHash" : "67426dr56f0inkn51godckpilca", + "predicateName" : "UserType::UserType#class#f5951597#f", + "appearsAs" : { + "UserType::UserType#class#f5951597#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\UserType.qll:11,1-100,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 791, + "dependencies" : { + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN usertypes_0#antijoin_rhs WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 791 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.341Z", + "raHash" : "7b8a876g23n9dr3ks45vfadgdc1", + "predicateName" : "type_decls_10#join_rhs", + "appearsAs" : { + "type_decls_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\UserType.qll:116,3-119,95", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 829, + "dependencies" : { + "type_decls" : "24a2balph6rbvqhb3m1k7pjpin0" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN type_decls OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 829 ], + "duplicationPercentages" : [ 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.341Z", + "raHash" : "3dfdadperuubb8o68dmb96utja1", + "predicateName" : "UserType::UserType::getName#dispred#f0820431#ff", + "appearsAs" : { + "UserType::UserType::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\UserType.qll:22,3-25,78", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 791, + "dependencies" : { + "usertypes" : "c10195ctfthoommu9q08d5rci34", + "UserType::UserType#class#f5951597#f" : "67426dr56f0inkn51godckpilca" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN usertypes WITH UserType::UserType#class#f5951597#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 791 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.342Z", + "raHash" : "e7f9a01c1msggqhhikklo0pdhr2", + "predicateName" : "Type::BuiltInType::getName#dispred#f0820431#ff", + "appearsAs" : { + "Type::BuiltInType::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:310,3-310,90", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 47, + "dependencies" : { + "builtintypes" : "75ec32pgvetbmdlamosulu2rjef", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN builtintypes WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 47 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.343Z", + "raHash" : "f6e9b02njp6rh9im38j6aidq5fc", + "predicateName" : "Class::Class#bacd9b46#f", + "appearsAs" : { + "Class::Class#bacd9b46#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:34,3-34,47", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 250, + "dependencies" : { + "ResolveClass::Cached::isClass#eb2868f4#f" : "b11d6bcumifg21befashf33b4g3", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN ResolveClass::Cached::isClass#eb2868f4#f WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 250 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.346Z", + "raHash" : "856bd8g3beni7tivlef0l68lcsc", + "predicateName" : "UserType::TypeDeclarationEntry::getType#dispred#f0820431#ff", + "appearsAs" : { + "UserType::TypeDeclarationEntry::getType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\UserType.qll:116,3-119,95", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 829, + "dependencies" : { + "type_decls_10#join_rhs" : "7b8a876g23n9dr3ks45vfadgdc1", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "type_decls" : "24a2balph6rbvqhb3m1k7pjpin0", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN type_decls_10#join_rhs WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r2 = JOIN r1 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {3} r3 = SCAN type_decls OUTPUT In.1, In.0, In.1", + " {3} r4 = JOIN r3 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + " {3} r5 = r4 AND NOT usertypes_0#antijoin_rhs(Lhs.2)", + " {2} r6 = SCAN r5 OUTPUT In.0, In.2", + "", + " {2} r7 = r2 UNION r6", + " return r7" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 829, 829, -1, 829, 827, 0, 0, -1, 829 ], + "duplicationPercentages" : [ 3, 2, -1, 0, 3, 0, 0, -1, 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.346Z", + "raHash" : "ea2afe07afeq5c0qedoi4b2i8ca", + "predicateName" : "NameQualifiers::NameQualifyingElement::getName#dispred#f0820431#ff", + "appearsAs" : { + "NameQualifiers::NameQualifyingElement::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\NameQualifiers.qll:154,3-155,30", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 793, + "dependencies" : { + "UserType::UserType::getName#dispred#f0820431#ff" : "3dfdadperuubb8o68dmb96utja1", + "namespaces" : "444594tcomqqm1eeubunuqiiap0", + "specialnamequalifyingelements" : "381468i4ncf462h2to5m7bf3mg3" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = namespaces UNION specialnamequalifyingelements", + "", + " {2} r2 = UserType::UserType::getName#dispred#f0820431#ff UNION r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2, -1, 793 ], + "duplicationPercentages" : [ 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.353Z", + "raHash" : "b325f9lien7jldmkh4vm7621vf2", + "predicateName" : "Type::RoutineType::getReturnType#dispred#f0820431#ff", + "appearsAs" : { + "Type::RoutineType::getReturnType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:1583,3-1586,91", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 1260, + "dependencies" : { + "routinetypes" : "73563dqdgofcni857o7aprhdgr4", + "Type::RoutineType#class#2e8eb3ef#f" : "c28897b38t1afpec2hvnpfsfci5", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN routinetypes WITH Type::RoutineType#class#2e8eb3ef#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r2 = JOIN r1 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r3 = JOIN r2 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {3} r4 = JOIN routinetypes WITH Type::RoutineType#class#2e8eb3ef#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0, Lhs.1", + " {3} r5 = JOIN r4 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + " {3} r6 = r5 AND NOT usertypes_0#antijoin_rhs(Lhs.2)", + " {2} r7 = SCAN r6 OUTPUT In.0, In.2", + "", + " {2} r8 = r3 UNION r7", + " return r8" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1260, 246, 246, -1, 1260, 1260, 1014, 1014, -1, 1260 ], + "duplicationPercentages" : [ 0, 0, 0, -1, 0, 0, 3, 1, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.353Z", + "raHash" : "eb8ebemc6a7n611tcuppt8sld23", + "predicateName" : "Type::Type::getName#dispred#f0820431#ff", + "appearsAs" : { + "Type::Type::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:17,3-20,30", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 9, + "resultSize" : 4447, + "dependencies" : { + "UserType::UserType::getName#dispred#f0820431#ff" : "3dfdadperuubb8o68dmb96utja1", + "Type::DerivedType::getName#dispred#f0820431#ff" : "4773123to6rq2m662d9guv6kgp8", + "Type::BuiltInType::getName#dispred#f0820431#ff" : "e7f9a01c1msggqhhikklo0pdhr2", + "Type::PointerToMemberType#class#2e8eb3ef#f" : "c755fct9r1fc560s7fqd0ts6dp0", + "Type::RoutineType#class#2e8eb3ef#f" : "c28897b38t1afpec2hvnpfsfci5" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = UserType::UserType::getName#dispred#f0820431#ff UNION Type::DerivedType::getName#dispred#f0820431#ff", + "", + " {2} r2 = SCAN Type::PointerToMemberType#class#2e8eb3ef#f OUTPUT In.0, \"..:: *\"", + "", + " {2} r3 = SCAN Type::RoutineType#class#2e8eb3ef#f OUTPUT In.0, \"..()(..)\"", + "", + " {2} r4 = r2 UNION r3", + "", + " {2} r5 = Type::BuiltInType::getName#dispred#f0820431#ff UNION r4", + " {2} r6 = r1 UNION r5", + " return r6" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 3140, -1, 0, -1, 1260, -1, 1260, -1, 1307, 4447 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 2, -1, 2, -1, 1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.368Z", + "raHash" : "d1b01bjc2t7rp353m3lk73m0948", + "predicateName" : "Cast::SizeofTypeOperator::getTypeOperand#dispred#f0820431#ff", + "appearsAs" : { + "Cast::SizeofTypeOperator::getTypeOperand#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Cast.qll:745,3-746,91", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 14, + "resultSize" : 742, + "dependencies" : { + "sizeof_bind" : "28ea22saqlal1d6bsnrqagq7mo9", + "exprs" : "56ea56nfg1f2tdlq3h1ierbst3a", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = SCAN sizeof_bind OUTPUT In.0, 93, In.1", + " {2} r2 = JOIN r1 WITH exprs ON FIRST 2 OUTPUT Lhs.0, Lhs.2", + "", + " {2} r3 = JOIN r2 WITH sizeof_bind ON FIRST 2 OUTPUT Lhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r5 = JOIN r4 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {3} r6 = JOIN r2 WITH sizeof_bind ON FIRST 2 OUTPUT Lhs.1, Lhs.0, Lhs.1", + " {3} r7 = JOIN r6 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + " {3} r8 = r7 AND NOT usertypes_0#antijoin_rhs(Lhs.2)", + " {2} r9 = SCAN r8 OUTPUT In.0, In.2", + "", + " {2} r10 = r5 UNION r9", + " return r10" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 742, 742, -1, 742, 585, 585, -1, 742, 742, 157, 157, -1, 742 ], + "duplicationPercentages" : [ 4, 0, -1, 0, 0, 0, -1, 0, 0, 0, 3, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.380Z", + "raHash" : "2aefc4brogs8rusuui4tm6f0151", + "predicateName" : "Class::Class::getCanonicalMember#dispred#f0820431#fff", + "appearsAs" : { + "Class::Class::getCanonicalMember#dispred#f0820431#fff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:91,3-99,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 11, + "resultSize" : 1406, + "dependencies" : { + "Class::Class#bacd9b46#f" : "f6e9b02njp6rh9im38j6aidq5fc", + "member" : "8b3f22jtvpn0s9e0s4dgoden071", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4", + "@variable#f" : "aeab1cjdifv15av5ftki3347nhe" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = JOIN Class::Class#bacd9b46#f WITH member ON FIRST 1 OUTPUT Rhs.2, Lhs.0, Rhs.1", + " {3} r2 = JOIN r1 WITH ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Rhs.1", + "", + " {4} r3 = JOIN Class::Class#bacd9b46#f WITH member ON FIRST 1 OUTPUT Lhs.0, Rhs.1, Rhs.2, Rhs.2", + " {4} r4 = r3 AND NOT usertypes_0#antijoin_rhs(Lhs.3)", + " {4} r5 = r4 AND NOT @variable#f(Lhs.3)", + " {3} r6 = SCAN r5 OUTPUT In.0, In.1, In.3", + "", + " {3} r7 = r2 UNION r6", + " return r7" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406, 1406, -1, 1406, 1406, 0, 0, -1, 1406 ], + "duplicationPercentages" : [ 1, 1, -1, 3, 3, 0, 0, -1, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.384Z", + "raHash" : "314c00k0mhdh4m1t6abvddoiv61", + "predicateName" : "Class::Class::getCanonicalMember#dispred#f0820431#fff_201#join_rhs", + "appearsAs" : { + "Class::Class::getCanonicalMember#dispred#f0820431#fff_201#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:101,3-112,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 1406, + "dependencies" : { + "Class::Class::getCanonicalMember#dispred#f0820431#fff" : "2aefc4brogs8rusuui4tm6f0151" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = SCAN Class::Class::getCanonicalMember#dispred#f0820431#fff OUTPUT In.2, In.0, In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.390Z", + "raHash" : "4e3186khqch4qtd1tnvnj98jcpa", + "predicateName" : "function_return_type", + "appearsAs" : { + "function_return_type" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:365,1-365,73", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 5, + "resultSize" : 3817 +} + +{ + "completionTime" : "2022-08-10T21:28:28.398Z", + "raHash" : "10891e0b6kqnofs5lijpa8n6uvb", + "predicateName" : "Declaration::DeclarationEntry::getName#dispred#f0820431#ff", + "appearsAs" : { + "Declaration::DeclarationEntry::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:348,3-349,30", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 44, + "resultSize" : 22226, + "dependencies" : { + "Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff" : "353354ak9qmtgb2pkdm7f9uv7e3", + "fun_decls" : "4993a2gkk04l6oafdrv8j2d47ga", + "UserType::TypeDeclarationEntry::getType#dispred#f0820431#ff" : "856bd8g3beni7tivlef0l68lcsc", + "Type::Type::getName#dispred#f0820431#ff" : "eb8ebemc6a7n611tcuppt8sld23" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN fun_decls OUTPUT In.0, In.3", + "", + " {2} r2 = SCAN UserType::TypeDeclarationEntry::getType#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r3 = JOIN r2 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r4 = r1 UNION r3", + "", + " {2} r5 = Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff UNION r4", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4514, -1, 829, 829, -1, 5343, -1, 22238 ], + "duplicationPercentages" : [ 5, -1, 3, 2, -1, 5, -1, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.402Z", + "raHash" : "bc104abs54s5689em991rl86ek1", + "predicateName" : "Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff", + "appearsAs" : { + "Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:215,3-218,99", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 84, + "resultSize" : 17039, + "dependencies" : { + "var_decls" : "19e663f6klnnoolnln7bm5fsf2a", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN var_decls OUTPUT In.1, In.0", + " {2} r2 = JOIN r1 WITH ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r3 = JOIN r2 WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 17240, 17039, 17039 ], + "duplicationPercentages" : [ 6, 5, 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "fcd39e3da9fuas537fmf6kpikd9", + "predicateName" : "function_instantiation", + "appearsAs" : { + "function_instantiation" : { + "BadAdditionOverflowCheck.ql" : [ 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:749,1-752,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 1, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "3444362gt6kaj6d7p3l8b7qgpn7", + "predicateName" : "m#Declaration::Declaration::getATemplateArgument#dispred#f0820431#bf", + "appearsAs" : { + "m#Declaration::Declaration::getATemplateArgument#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "fcd39e3da9fuas537fmf6kpikd9" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "cc29e4gojo3dg8mvr5h5fpg4gl4", + "predicateName" : "Parameter::Parameter::getFunction#dispred#f0820431#fb", + "appearsAs" : { + "Parameter::Parameter::getFunction#dispred#f0820431#fb" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "fcd39e3da9fuas537fmf6kpikd9" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "7dc912vuo1689kue8n6chljd0ve", + "predicateName" : "Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb", + "appearsAs" : { + "Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "fcd39e3da9fuas537fmf6kpikd9" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "a67580jqq0bbm11g2fe1d422608", + "predicateName" : "project#function_instantiation", + "appearsAs" : { + "project#function_instantiation" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "fcd39e3da9fuas537fmf6kpikd9" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "1bc094p3n9k3o2ht2mpfunnksge", + "predicateName" : "Declaration::Declaration::getTemplateArgumentType#dispred#f0820431#bff", + "appearsAs" : { + "Declaration::Declaration::getTemplateArgumentType#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "3444362gt6kaj6d7p3l8b7qgpn7" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "bd73dfushtnsc4115elieu1bvg5", + "predicateName" : "Declaration::Declaration::getTemplateArgumentValue#dispred#f0820431#bff", + "appearsAs" : { + "Declaration::Declaration::getTemplateArgumentValue#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "3444362gt6kaj6d7p3l8b7qgpn7" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "3225a3tmoiain4arvrq05jvoiv4", + "predicateName" : "Declaration::Declaration::getATemplateArgument#dispred#f0820431#bf", + "appearsAs" : { + "Declaration::Declaration::getATemplateArgument#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "3444362gt6kaj6d7p3l8b7qgpn7" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "42aa0aofantpjj2eg2gvqrmgodb", + "predicateName" : "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff#antijoin_rhs", + "appearsAs" : { + "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "cc29e4gojo3dg8mvr5h5fpg4gl4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "411d2dt3p8d6rdpiv41oqgb04k4", + "predicateName" : "Function::Function::getParameter#dispred#f0820431#bff", + "appearsAs" : { + "Function::Function::getParameter#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "a67580jqq0bbm11g2fe1d422608" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "251b62kds399o4l328hqaa5gto5", + "predicateName" : "project#Declaration::Declaration::getTemplateArgumentValue#dispred#f0820431#bff", + "appearsAs" : { + "project#Declaration::Declaration::getTemplateArgumentValue#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "bd73dfushtnsc4115elieu1bvg5" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "9f46663do434vbf82vr7u5ve2d0", + "predicateName" : "project#Declaration::Declaration::getATemplateArgument#dispred#f0820431#bf", + "appearsAs" : { + "project#Declaration::Declaration::getATemplateArgument#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "3225a3tmoiain4arvrq05jvoiv4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "e3ad2780uektko9hkg6kno1reub", + "predicateName" : "Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb", + "appearsAs" : { + "Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "9f46663do434vbf82vr7u5ve2d0" +} + +{ + "completionTime" : "2022-08-10T21:28:28.404Z", + "raHash" : "e499a9mq61dhg1mgj0v4ov4he23", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#shared#3", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared#3" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 14, + "resultSize" : 7512, + "dependencies" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared#2" : "27c8c1dcq39mrl2s05gje3qc74c", + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : "dcf789h5id6rmfuakkdfasd7ldf" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#shared#2 WITH Initializer::Initializer::getDeclaration#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.405Z", + "raHash" : "2d34b92m5gvjgjeu4u5up5vp6b4", + "predicateName" : "fun_specialized", + "appearsAs" : { + "fun_specialized" : { + "BadAdditionOverflowCheck.ql" : [ 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:406,1-406,47", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.405Z", + "raHash" : "17b7908kt540bk135880fob92a1", + "predicateName" : "Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb#antijoin_rhs", + "appearsAs" : { + "Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "2d34b92m5gvjgjeu4u5up5vp6b4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.405Z", + "raHash" : "7c2ee3fco1jkv0e2av2jia0blqe", + "predicateName" : "Function::Function::isSpecialization#dispred#f0820431#f", + "appearsAs" : { + "Function::Function::isSpecialization#dispred#f0820431#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "2d34b92m5gvjgjeu4u5up5vp6b4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.408Z", + "raHash" : "5c921acmlc3li7ajiat2auo4bsb", + "predicateName" : "fun_decls_10#join_rhs", + "appearsAs" : { + "fun_decls_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Function.qll:225,3-238,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 4502, + "dependencies" : { + "fun_decls" : "4993a2gkk04l6oafdrv8j2d47ga" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN fun_decls OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4514 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.415Z", + "raHash" : "f53113ph3g1l6hc6nckfarniir6", + "predicateName" : "fun_decls_1#join_rhs", + "appearsAs" : { + "fun_decls_1#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Function.qll:225,3-238,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 11, + "resultSize" : 3782, + "dependencies" : { + "fun_decls" : "4993a2gkk04l6oafdrv8j2d47ga" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN fun_decls OUTPUT In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4514 ], + "duplicationPercentages" : [ 19 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.416Z", + "raHash" : "2b365achm0556lu2j5j3unfv1d1", + "predicateName" : "Function::Function::declEntry#dispred#f0820431#fb", + "appearsAs" : { + "Function::Function::declEntry#dispred#f0820431#fb" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Function.qll:240,3-247,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 10, + "resultSize" : 2486, + "dependencies" : { + "fun_def" : "7b1a5169scls3540rn7l8mc7h59", + "fun_decls" : "4993a2gkk04l6oafdrv8j2d47ga", + "Function::Function::isSpecialization#dispred#f0820431#f" : "7c2ee3fco1jkv0e2av2jia0blqe", + "fun_specialized" : "2d34b92m5gvjgjeu4u5up5vp6b4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN fun_def WITH fun_decls ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r2 = r1 AND NOT Function::Function::isSpecialization#dispred#f0820431#f(Lhs.1)", + " {2} r3 = SCAN r2 OUTPUT In.1, In.0", + "", + " {2} r4 = JOIN r1 WITH fun_specialized ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r5 = r3 UNION r4", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2486, -1, 2486, 2486, -1, 0, -1, 2486 ], + "duplicationPercentages" : [ 0, -1, 0, 0, -1, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.425Z", + "raHash" : "0aa1e6dnh37oq8rt0g3vvfk3hb1", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#shared", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 8, + "resultSize" : 6371, + "dependencies" : { + "Declaration::DeclarationEntry::getName#dispred#f0820431#ff" : "10891e0b6kqnofs5lijpa8n6uvb", + "Declaration::DeclarationEntry::isDefinition#dispred#f0820431#f" : "4380772qdcpm8epl3n8qbdtp07c" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Declaration::DeclarationEntry::getName#dispred#f0820431#ff AND NOT Declaration::DeclarationEntry::isDefinition#dispred#f0820431#f(Lhs.0)", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 6371 ], + "duplicationPercentages" : [ 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.427Z", + "raHash" : "1a784emdvon8in5e2km8u1hgam9", + "predicateName" : "Function::Function::getADeclarationEntry#dispred#f0820431#fb", + "appearsAs" : { + "Function::Function::getADeclarationEntry#dispred#f0820431#fb" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Function.qll:225,3-238,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 8, + "resultSize" : 2486, + "dependencies" : { + "Function::Function::declEntry#dispred#f0820431#fb" : "2b365achm0556lu2j5j3unfv1d1", + "fun_def" : "7b1a5169scls3540rn7l8mc7h59", + "fun_decls_1#join_rhs" : "f53113ph3g1l6hc6nckfarniir6", + "function_instantiation" : "fcd39e3da9fuas537fmf6kpikd9", + "fun_decls_10#join_rhs" : "5c921acmlc3li7ajiat2auo4bsb" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Function::Function::declEntry#dispred#f0820431#fb OUTPUT In.1, In.0", + " {2} r2 = JOIN r1 WITH fun_def ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r3 = JOIN r2 WITH fun_decls_1#join_rhs ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r4 = function_instantiation AND NOT fun_decls_1#join_rhs(Lhs.0)", + " {2} r5 = SCAN r4 OUTPUT In.1, In.0", + " {2} r6 = JOIN r5 WITH fun_decls_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r7 = JOIN r6 WITH fun_def ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r8 = r3 UNION r7", + " return r8" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2486, 2486, 2486, -1, 0, 0, 0, 0, -1, 2486 ], + "duplicationPercentages" : [ 0, 0, 0, -1, 0, 0, 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.429Z", + "raHash" : "c27fca86865n3m9ahiu4ai758vd", + "predicateName" : "type_decls_1#join_rhs", + "appearsAs" : { + "type_decls_1#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\UserType.qll:50,33-50,53", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 791, + "dependencies" : { + "type_decls" : "24a2balph6rbvqhb3m1k7pjpin0" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN type_decls OUTPUT In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 829 ], + "duplicationPercentages" : [ 5 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.431Z", + "raHash" : "d7f752hpjaoouf507s2s4hs39ec", + "predicateName" : "stmtparents_20#join_rhs", + "appearsAs" : { + "stmtparents_20#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:7,1-15,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 93, + "resultSize" : 43528, + "dependencies" : { + "#select#query#fff" : "1f8231p17fv7mnmfdrhkkrd17bf" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN #select#query#fff OUTPUT In.2, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 43528 ], + "duplicationPercentages" : [ 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.431Z", + "raHash" : "df0499d4anvs0pfkgjr99absmi6", + "predicateName" : "ResolveClass::Cached::resolveClass#eb2868f4#ff_10#join_rhs", + "appearsAs" : { + "ResolveClass::Cached::resolveClass#eb2868f4#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\UserType.qll:50,33-50,53", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 793, + "dependencies" : { + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN ResolveClass::Cached::resolveClass#eb2868f4#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 793 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.432Z", + "raHash" : "2277b7soiij7vlul6o9sjs4o1la", + "predicateName" : "expr_types", + "appearsAs" : { + "expr_types" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1465,1-1469,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 86, + "resultSize" : 324197 +} + +{ + "completionTime" : "2022-08-10T21:28:28.433Z", + "raHash" : "e123ee3m4un02n2hig8q4nc1fec", + "predicateName" : "class_instantiation", + "appearsAs" : { + "class_instantiation" : { + "BadAdditionOverflowCheck.ql" : [ 1, 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:720,1-723,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.433Z", + "raHash" : "dd41898crdqmgojnduhal12lpta", + "predicateName" : "Class::Class::isConstructedFrom#dispred#f0820431#ff", + "appearsAs" : { + "Class::Class::isConstructedFrom#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "e123ee3m4un02n2hig8q4nc1fec" +} + +{ + "completionTime" : "2022-08-10T21:28:28.433Z", + "raHash" : "020428svo2o9fjskk0c94b94v9e", + "predicateName" : "UserType::UserType::getADeclarationEntry#f0820431#ff#join_rhs", + "appearsAs" : { + "UserType::UserType::getADeclarationEntry#f0820431#ff#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "dd41898crdqmgojnduhal12lpta" +} + +{ + "completionTime" : "2022-08-10T21:28:28.433Z", + "raHash" : "444b250i313nooqe6pb3f2n9gr6", + "predicateName" : "Class::Class::isConstructedFrom#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Class::Class::isConstructedFrom#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "dd41898crdqmgojnduhal12lpta" +} + +{ + "completionTime" : "2022-08-10T21:28:28.442Z", + "raHash" : "d60f1almom96cj84pnniugndbh9", + "predicateName" : "Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Parameter.qll:79,3-96,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 16, + "resultSize" : 17039, + "dependencies" : { + "Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff" : "bc104abs54s5689em991rl86ek1" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 17039 ], + "duplicationPercentages" : [ 5 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.443Z", + "raHash" : "62a793kgm73dje8nsqe459c6j9c", + "predicateName" : "UserType::UserType::getADeclarationEntry#f0820431#ff", + "appearsAs" : { + "UserType::UserType::getADeclarationEntry#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\UserType.qll:50,33-50,53", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_RECURSIVE", + "millis" : 9, + "predicateIterationMillis" : [ 3, 3 ], + "deltaSizes" : [ 829, 0 ], + "resultSize" : 829, + "dependencies" : { + "type_decls_1#join_rhs" : "c27fca86865n3m9ahiu4ai758vd", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "UserType::UserType#class#f5951597#f" : "67426dr56f0inkn51godckpilca", + "ResolveClass::Cached::resolveClass#eb2868f4#ff_10#join_rhs" : "df0499d4anvs0pfkgjr99absmi6", + "type_decls_10#join_rhs" : "7b8a876g23n9dr3ks45vfadgdc1", + "Class::Class::isConstructedFrom#dispred#f0820431#ff_10#join_rhs" : "444b250i313nooqe6pb3f2n9gr6", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4", + "UserType::UserType::getADeclarationEntry#f0820431#ff#join_rhs" : "020428svo2o9fjskk0c94b94v9e" + }, + "layerSize" : 1, + "ra" : { + "base" : [ + " {1} r1 = JOIN type_decls_1#join_rhs WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1", + " {1} r2 = JOIN r1 WITH UserType::UserType#class#f5951597#f ON FIRST 1 OUTPUT Lhs.0", + " {2} r3 = JOIN r2 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH type_decls_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " return r4" + ], + "standard" : [ + " {2} r1 = JOIN UserType::UserType::getADeclarationEntry#f0820431#ff#prev_delta WITH UserType::UserType::getADeclarationEntry#f0820431#ff#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r2 = r1 AND NOT UserType::UserType::getADeclarationEntry#f0820431#ff#prev(Lhs.0, Lhs.1)", + " return r2" + ], + "order_500000" : [ + " {2} r1 = JOIN UserType::UserType::getADeclarationEntry#f0820431#ff#prev_delta WITH Class::Class::isConstructedFrom#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r2 = JOIN r1 WITH UserType::UserType#class#f5951597#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r3 = r2 AND NOT UserType::UserType::getADeclarationEntry#f0820431#ff#prev(Lhs.1, Lhs.0)", + "", + " {2} r4 = r2 AND NOT UserType::UserType::getADeclarationEntry#f0820431#ff#prev(Lhs.1, Lhs.0)", + "", + " {2} r5 = r4 AND NOT usertypes_0#antijoin_rhs(Lhs.1)", + " {2} r6 = SCAN r5 OUTPUT In.1, In.0", + " {2} r7 = JOIN r6 WITH type_decls_1#join_rhs ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r8 = SCAN r4 OUTPUT In.1, In.0", + " {3} r9 = JOIN r8 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1, Lhs.0", + " {2} r10 = JOIN r9 WITH type_decls_1#join_rhs ON FIRST 1 OUTPUT Lhs.1, Lhs.2", + "", + " {2} r11 = r7 UNION r10", + " {2} r12 = MATERIALIZE r11 AS unknown", + "", + " {2} r13 = r3 AND NOT r12(Lhs.0, Lhs.1)", + " {2} r14 = SCAN r13 OUTPUT In.1, In.0", + " return r14" + ] + }, + "pipelineRuns" : [ { + "raReference" : "base", + "counts" : [ 791, 790, 793, 829 ], + "duplicationPercentages" : [ 0, 0, 2, 3 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, -1, -1, 0, 0 ], + "duplicationPercentages" : [ 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, -1, -1, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.445Z", + "raHash" : "23d5663b1sgojtdqgba7klf02t1", + "predicateName" : "Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#ff", + "appearsAs" : { + "Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:335,3-346,42", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 36, + "resultSize" : 22370, + "dependencies" : { + "Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff" : "bc104abs54s5689em991rl86ek1", + "UserType::TypeDeclarationEntry::getType#dispred#f0820431#ff" : "856bd8g3beni7tivlef0l68lcsc", + "UserType::UserType#class#f5951597#f" : "67426dr56f0inkn51godckpilca", + "fun_decls" : "4993a2gkk04l6oafdrv8j2d47ga" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN UserType::TypeDeclarationEntry::getType#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r2 = JOIN r1 WITH UserType::UserType#class#f5951597#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r3 = SCAN fun_decls OUTPUT In.0, In.1", + " {2} r4 = STREAM DEDUP r3", + "", + " {2} r5 = r2 UNION r4", + "", + " {2} r6 = Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff UNION r5", + " return r6" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 829, 829, -1, 4514, 4502, -1, 5331, -1, 22370 ], + "duplicationPercentages" : [ 3, 2, -1, 0, 0, -1, 0, -1, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.448Z", + "raHash" : "c600b20q1ej9im3n5hja4m12og2", + "predicateName" : "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff", + "appearsAs" : { + "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Parameter.qll:79,3-96,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 5, + "resultSize" : 9233, + "dependencies" : { + "Parameter::Parameter#class#ed81dd8f#f" : "39d5d2nccctdkfs67nb5ehta6ge", + "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff#antijoin_rhs" : "42aa0aofantpjj2eg2gvqrmgodb", + "Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff_10#join_rhs" : "d60f1almom96cj84pnniugndbh9", + "Parameter::Parameter::getFunction#dispred#f0820431#fb" : "cc29e4gojo3dg8mvr5h5fpg4gl4", + "function_instantiation" : "fcd39e3da9fuas537fmf6kpikd9", + "Parameter::Parameter::getIndex#dispred#f0820431#ff" : "9794f2ntc3dscnec46gnipss9g9", + "Function::Function::getParameter#dispred#f0820431#bff" : "411d2dt3p8d6rdpiv41oqgb04k4" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = Parameter::Parameter#class#ed81dd8f#f AND NOT Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff#antijoin_rhs(Lhs.0)", + " {2} r2 = JOIN r1 WITH Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r3 = SCAN Parameter::Parameter::getFunction#dispred#f0820431#fb OUTPUT In.1, In.0", + " {2} r4 = JOIN r3 WITH function_instantiation ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " {2} r5 = JOIN r4 WITH Parameter::Parameter#class#ed81dd8f#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " {3} r6 = JOIN r5 WITH Parameter::Parameter::getFunction#dispred#f0820431#fb ON FIRST 1 OUTPUT Rhs.1, Lhs.1, Lhs.0", + " {2} r7 = JOIN r6 WITH function_instantiation ON FIRST 1 OUTPUT Lhs.2, Lhs.1", + " {3} r8 = JOIN r7 WITH Parameter::Parameter::getIndex#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1, Lhs.0", + " {2} r9 = JOIN r8 WITH Function::Function::getParameter#dispred#f0820431#bff ON FIRST 2 OUTPUT Rhs.2, Lhs.2", + " {2} r10 = JOIN r9 WITH Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r11 = r2 UNION r10", + " return r11" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7660, 9233, -1, 0, 0, 0, 0, 0, 0, 0, 0, -1, 9233 ], + "duplicationPercentages" : [ 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, -1, 5 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.456Z", + "raHash" : "3a6465aanlr3228mtc3653a5gcb", + "predicateName" : "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Parameter.qll:75,3-77,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 8, + "resultSize" : 9233, + "dependencies" : { + "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff" : "c600b20q1ej9im3n5hja4m12og2" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 9233 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.462Z", + "raHash" : "3530b97bsqv6mvmi2rtlmksnvvc", + "predicateName" : "exprs_10#join_rhs", + "appearsAs" : { + "exprs_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3, 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Cast.qll:9,1-25,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 388, + "resultSize" : 324197, + "dependencies" : { + "exprs" : "56ea56nfg1f2tdlq3h1ierbst3a" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN exprs OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 324197 ], + "duplicationPercentages" : [ 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.464Z", + "raHash" : "ca6898479uq5l0qqec2n31s03g6", + "predicateName" : "Declaration::Declaration::getDefinition#dispred#f0820431#ff", + "appearsAs" : { + "Declaration::Declaration::getDefinition#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:174,3-178,46", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 21, + "resultSize" : 15855, + "dependencies" : { + "var_def" : "a427a78knumk074qs3frhkdcsl8", + "Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff" : "bc104abs54s5689em991rl86ek1", + "Function::Function::getADeclarationEntry#dispred#f0820431#fb" : "1a784emdvon8in5e2km8u1hgam9", + "fun_def" : "7b1a5169scls3540rn7l8mc7h59", + "UserType::UserType::getADeclarationEntry#f0820431#ff" : "62a793kgm73dje8nsqe459c6j9c", + "type_def" : "b4d31fmo7rtktfarajhbi807tj5" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN var_def WITH Variable::VariableDeclarationEntry::getVariable#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + "", + " {2} r2 = SCAN Function::Function::getADeclarationEntry#dispred#f0820431#fb OUTPUT In.1, In.0", + " {2} r3 = JOIN r2 WITH fun_def ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r4 = SCAN UserType::UserType::getADeclarationEntry#f0820431#ff OUTPUT In.1, In.0", + " {2} r5 = JOIN r4 WITH type_def ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r6 = r3 UNION r5", + " {2} r7 = r1 UNION r6", + " return r7" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 13035, -1, 2486, 2486, -1, 829, 334, -1, 2820, 15855 ], + "duplicationPercentages" : [ 1, -1, 0, 0, -1, 2, 4, -1, 0, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.468Z", + "raHash" : "d7df6ela423lior4flati1vu14a", + "predicateName" : "@access#f#antijoin_rhs", + "appearsAs" : { + "@access#f#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1824,1-1824,38", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 5, + "resultSize" : 12277, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[97]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 12277 ], + "duplicationPercentages" : [ 0, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.468Z", + "raHash" : "cb59ab7ugr3051b3j24ocp200b0", + "predicateName" : "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff", + "appearsAs" : { + "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Parameter.qll:75,3-77,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 11, + "resultSize" : 9089, + "dependencies" : { + "Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff#antijoin_rhs" : "18e3c2lkfgn912k0p1abcli290b", + "Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff_10#join_rhs" : "3a6465aanlr3228mtc3653a5gcb" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff#antijoin_rhs WITH Parameter::Parameter::getAnEffectiveDeclarationEntry#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 9089 ], + "duplicationPercentages" : [ 5 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.472Z", + "raHash" : "5cbde744fr7070u06nt3dijaqk9", + "predicateName" : "project#Declaration::Declaration::getDefinition#dispred#f0820431#ff", + "appearsAs" : { + "project#Declaration::Declaration::getDefinition#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:174,3-178,46", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 15823, + "dependencies" : { + "Declaration::Declaration::getDefinition#dispred#f0820431#ff" : "ca6898479uq5l0qqec2n31s03g6" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Declaration::Declaration::getDefinition#dispred#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 15855, 15823 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.483Z", + "raHash" : "a78c049o4v84k43q6oo2hi128o1", + "predicateName" : "exprconv_1#join_rhs", + "appearsAs" : { + "exprconv_1#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Cast.qll:9,1-25,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 20, + "resultSize" : 107672, + "dependencies" : { + "exprconv" : "ff49855htg34cr357mjg0pjpnpf" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN exprconv OUTPUT In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 107672 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.492Z", + "raHash" : "9f11929rhe4jv95c7mekt8693kd", + "predicateName" : "Call::Call#39248e3c#f", + "appearsAs" : { + "Call::Call#39248e3c#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:25,3-25,77", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 23, + "resultSize" : 11605, + "dependencies" : { + "iscall_0#antijoin_rhs" : "529cf0o8krceqscefq2ru4h0h22", + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[74]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = iscall_0#antijoin_rhs UNION r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 34, -1, 11605 ], + "duplicationPercentages" : [ 0, 0, -1, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.495Z", + "raHash" : "30bc3a41ro9rcbg1bgern4m5k82", + "predicateName" : "valuebind", + "appearsAs" : { + "valuebind" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1389,1-1392,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 32, + "resultSize" : 114499 +} + +{ + "completionTime" : "2022-08-10T21:28:28.499Z", + "raHash" : "c48684no3nchd22a8ib57flacc2", + "predicateName" : "Call::FunctionCall#39248e3c#f", + "appearsAs" : { + "Call::FunctionCall#39248e3c#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:165,3-165,56", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 6, + "resultSize" : 11571, + "dependencies" : { + "iscall_0#antijoin_rhs" : "529cf0o8krceqscefq2ru4h0h22", + "Call::Call#39248e3c#f" : "9f11929rhe4jv95c7mekt8693kd" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN iscall_0#antijoin_rhs WITH Call::Call#39248e3c#f ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571 ], + "duplicationPercentages" : [ 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.507Z", + "raHash" : "f85a2a84krfqmudq6ipu2kj7u89", + "predicateName" : "Call::FunctionCall::getTarget#f0820431#ff", + "appearsAs" : { + "Call::FunctionCall::getTarget#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:263,21-263,30", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 11571, + "dependencies" : { + "Call::FunctionCall#39248e3c#f" : "c48684no3nchd22a8ib57flacc2", + "funbind" : "8057edi8viiq0fbb2ut69d46dj9" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Call::FunctionCall#39248e3c#f WITH funbind ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.513Z", + "raHash" : "4feb95nsgdn2ri8as0h9kcpl573", + "predicateName" : "@access#f", + "appearsAs" : { + "@access#f" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1824,1-1824,38", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 45, + "resultSize" : 111265, + "dependencies" : { + "@access#f#antijoin_rhs" : "d7df6ela423lior4flati1vu14a", + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[84]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = @access#f#antijoin_rhs UNION r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 98988, -1, 111265 ], + "duplicationPercentages" : [ 0, 7, -1, 7 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.519Z", + "raHash" : "c0f2c6ou4b5uk9nudplo06c5kl5", + "predicateName" : "valuebind_10#join_rhs", + "appearsAs" : { + "valuebind_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:123,3-126,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 23, + "resultSize" : 114499, + "dependencies" : { + "valuebind" : "30bc3a41ro9rcbg1bgern4m5k82" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN valuebind OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 114499 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.519Z", + "raHash" : "e5b0c7lg3vibb5n3rudb3dorq06", + "predicateName" : "project#Call::FunctionCall::getTarget#f0820431#ff", + "appearsAs" : { + "project#Call::FunctionCall::getTarget#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:263,21-263,30", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 10, + "resultSize" : 1993, + "dependencies" : { + "Call::FunctionCall::getTarget#f0820431#ff" : "f85a2a84krfqmudq6ipu2kj7u89" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Call::FunctionCall::getTarget#f0820431#ff OUTPUT In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571 ], + "duplicationPercentages" : [ 507 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.520Z", + "raHash" : "25954695ueg607rkjqkji5ggic4", + "predicateName" : "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff#antijoin_rhs", + "appearsAs" : { + "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:325,3-333,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 47, + "resultSize" : 18113, + "dependencies" : { + "Declaration::DeclarationEntry::getName#dispred#f0820431#ff" : "10891e0b6kqnofs5lijpa8n6uvb", + "Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#ff" : "23d5663b1sgojtdqgba7klf02t1", + "project#Declaration::Declaration::getDefinition#dispred#f0820431#ff" : "5cbde744fr7070u06nt3dijaqk9" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = JOIN Declaration::DeclarationEntry::getName#dispred#f0820431#ff WITH Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0, Lhs.1", + " {2} r2 = JOIN r1 WITH project#Declaration::Declaration::getDefinition#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Lhs.2", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 22226, 18113 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.522Z", + "raHash" : "f1c03bljvncq12sqc1ji61bbqje", + "predicateName" : "m#Declaration::Declaration::isMember#dispred#f0820431#b", + "appearsAs" : { + "m#Declaration::Declaration::isMember#dispred#f0820431#b" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:211,3-212,51", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 3399, + "dependencies" : { + "project#Call::FunctionCall::getTarget#f0820431#ff" : "e5b0c7lg3vibb5n3rudb3dorq06", + "membervariables" : "7c37bduotvpfjjrgej2r6r84p4b" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN membervariables OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + "", + " {1} r3 = project#Call::FunctionCall::getTarget#f0820431#ff UNION r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1412, 1406, -1, 3399 ], + "duplicationPercentages" : [ 6, 6, -1, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.524Z", + "raHash" : "f694d012h9nfsq48aptb10di975", + "predicateName" : "variable_instantiation", + "appearsAs" : { + "variable_instantiation" : { + "BadAdditionOverflowCheck.ql" : [ 2, 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:765,1-768,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.524Z", + "raHash" : "5fa20bfie70b9fq0knm989r9u4d", + "predicateName" : "Variable::Variable::isConstructedFrom#dispred#f0820431#ff", + "appearsAs" : { + "Variable::Variable::isConstructedFrom#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "f694d012h9nfsq48aptb10di975" +} + +{ + "completionTime" : "2022-08-10T21:28:28.524Z", + "raHash" : "884e57ubrjst38rmplnd7eafdfc", + "predicateName" : "Variable::Variable::isConstructedFrom#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Variable::Variable::isConstructedFrom#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "5fa20bfie70b9fq0knm989r9u4d" +} + +{ + "completionTime" : "2022-08-10T21:28:28.524Z", + "raHash" : "93c36db1lqpcr5p07djs9v77md7", + "predicateName" : "Variable::TemplateVariable::getAnInstantiation#dispred#f0820431#ff", + "appearsAs" : { + "Variable::TemplateVariable::getAnInstantiation#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "5fa20bfie70b9fq0knm989r9u4d" +} + +{ + "completionTime" : "2022-08-10T21:28:28.524Z", + "raHash" : "c2335a4feh15rmin4qmm1cduhl7", + "predicateName" : "is_variable_template", + "appearsAs" : { + "is_variable_template" : { + "BadAdditionOverflowCheck.ql" : [ 4, 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:764,1-764,52", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 0, + "resultSize" : 0 +} + +{ + "completionTime" : "2022-08-10T21:28:28.528Z", + "raHash" : "0498b4vhp3t1lqtjoiiobngj5s8", + "predicateName" : "Class::Class::getAMember#dispred#f0820431#2#ffb", + "appearsAs" : { + "Class::Class::getAMember#dispred#f0820431#2#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:101,3-112,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 1406, + "dependencies" : { + "Class::Class::getCanonicalMember#dispred#f0820431#fff_201#join_rhs" : "314c00k0mhdh4m1t6abvddoiv61", + "m#Declaration::Declaration::isMember#dispred#f0820431#b" : "f1c03bljvncq12sqc1ji61bbqje", + "Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb" : "7dc912vuo1689kue8n6chljd0ve", + "is_variable_template" : "c2335a4feh15rmin4qmm1cduhl7", + "Variable::Variable::isConstructedFrom#dispred#f0820431#ff_10#join_rhs" : "884e57ubrjst38rmplnd7eafdfc" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = JOIN Class::Class::getCanonicalMember#dispred#f0820431#fff_201#join_rhs WITH m#Declaration::Declaration::isMember#dispred#f0820431#b ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + "", + " {2} r2 = SCAN Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb OUTPUT In.1, In.0", + " {2} r3 = JOIN r2 WITH m#Declaration::Declaration::isMember#dispred#f0820431#b ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {3} r4 = JOIN r3 WITH Class::Class::getCanonicalMember#dispred#f0820431#fff_201#join_rhs ON FIRST 1 OUTPUT Rhs.1, Rhs.2, Lhs.1", + "", + " {3} r5 = JOIN Class::Class::getCanonicalMember#dispred#f0820431#fff_201#join_rhs WITH is_variable_template ON FIRST 1 OUTPUT Lhs.0, Lhs.1, Lhs.2", + " {3} r6 = JOIN r5 WITH Variable::Variable::isConstructedFrom#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1, Lhs.2", + " {3} r7 = JOIN r6 WITH m#Declaration::Declaration::isMember#dispred#f0820431#b ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + "", + " {3} r8 = r4 UNION r7", + " {3} r9 = r1 UNION r8", + " return r9" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 1406 ], + "duplicationPercentages" : [ 1, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.533Z", + "raHash" : "ad6d7aqpnbq0v2eskblafm74v51", + "predicateName" : "project#Class::Class::getAMember#dispred#f0820431#2#ffb", + "appearsAs" : { + "project#Class::Class::getAMember#dispred#f0820431#2#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:101,3-112,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 1406, + "dependencies" : { + "Class::Class::getAMember#dispred#f0820431#2#ffb" : "0498b4vhp3t1lqtjoiiobngj5s8" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Class::Class::getAMember#dispred#f0820431#2#ffb OUTPUT In.2", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406 ], + "duplicationPercentages" : [ 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.535Z", + "raHash" : "9f6509fn9ru5e6tbedv9skgmba8", + "predicateName" : "Declaration::Declaration::isMember#dispred#f0820431#b", + "appearsAs" : { + "Declaration::Declaration::isMember#dispred#f0820431#b" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:211,3-212,51", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1406, + "dependencies" : { + "m#Declaration::Declaration::isMember#dispred#f0820431#b" : "f1c03bljvncq12sqc1ji61bbqje", + "project#Class::Class::getAMember#dispred#f0820431#2#ffb" : "ad6d7aqpnbq0v2eskblafm74v51" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN m#Declaration::Declaration::isMember#dispred#f0820431#b WITH project#Class::Class::getAMember#dispred#f0820431#2#ffb ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406 ], + "duplicationPercentages" : [ 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.537Z", + "raHash" : "bcfbf1d728v9ihajmh8tacbjitc", + "predicateName" : "Variable::MemberVariable#7a968d4e#f", + "appearsAs" : { + "Variable::MemberVariable#7a968d4e#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:531,3-531,39", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1406, + "dependencies" : { + "Declaration::Declaration::isMember#dispred#f0820431#b" : "9f6509fn9ru5e6tbedv9skgmba8", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN Declaration::Declaration::isMember#dispred#f0820431#b WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406 ], + "duplicationPercentages" : [ 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.540Z", + "raHash" : "3040ee401amduqiuf7miko5gmt4", + "predicateName" : "fieldoffsets", + "appearsAs" : { + "fieldoffsets" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1394,1-1398,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 1406 +} + +{ + "completionTime" : "2022-08-10T21:28:28.542Z", + "raHash" : "61418129rsd6dv2t50bart37e00", + "predicateName" : "Field::Field#class#1b3cf47e#f", + "appearsAs" : { + "Field::Field#class#1b3cf47e#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Field.qll:8,1-78,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 1406, + "dependencies" : { + "Variable::MemberVariable#7a968d4e#f" : "bcfbf1d728v9ihajmh8tacbjitc", + "fieldoffsets" : "3040ee401amduqiuf7miko5gmt4" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN Variable::MemberVariable#7a968d4e#f WITH fieldoffsets ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406 ], + "duplicationPercentages" : [ 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.543Z", + "raHash" : "a15b76ljum9c1cp2tkfnomn70e4", + "predicateName" : "Call::DestructorFieldDestruction::getTarget#dispred#f0820431#ff", + "appearsAs" : { + "Call::DestructorFieldDestruction::getTarget#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:656,3-657,83", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 0, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "varbind" : "b770b3dd00tr01siqj3tgilh4q2", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "Field::Field#class#1b3cf47e#f" : "61418129rsd6dv2t50bart37e00" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[206]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r3 = JOIN r2 WITH varbind ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r5 = JOIN r4 WITH Field::Field#class#1b3cf47e#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0, 0, 0, 0 ], + "duplicationPercentages" : [ 0, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.544Z", + "raHash" : "7f608f4rhkk8pnspvoaidp9ldu6", + "predicateName" : "Call::ConstructorFieldInit::getTarget#dispred#f0820431#ff", + "appearsAs" : { + "Call::ConstructorFieldInit::getTarget#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:577,3-578,83", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 0, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "varbind" : "b770b3dd00tr01siqj3tgilh4q2", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "Field::Field#class#1b3cf47e#f" : "61418129rsd6dv2t50bart37e00" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[202]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r3 = JOIN r2 WITH varbind ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r5 = JOIN r4 WITH Field::Field#class#1b3cf47e#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0, 0, 0, 0 ], + "duplicationPercentages" : [ 0, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.546Z", + "raHash" : "0bc7abbb0b18lsmk0k0jr1hvdmb", + "predicateName" : "locations_expr_23450#join_rhs", + "appearsAs" : { + "locations_expr_23450#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Location.qll:155,1-162,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 240, + "resultSize" : 151608, + "dependencies" : { + "locations_expr" : "e2f48di291bqfs3semk6idgdah5" + }, + "ra" : { + "pipeline" : [ + " {5} r1 = SCAN locations_expr OUTPUT In.2, In.3, In.4, In.5, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 151608 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.548Z", + "raHash" : "d5f8c1f1hmeek8bje16bgbp22q6", + "predicateName" : "Variable::MemberVariable::getName#dispred#f0820431#ff", + "appearsAs" : { + "Variable::MemberVariable::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:544,3-544,84", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 1406, + "dependencies" : { + "membervariables" : "7c37bduotvpfjjrgej2r6r84p4b", + "Variable::MemberVariable#7a968d4e#f" : "bcfbf1d728v9ihajmh8tacbjitc" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN membervariables WITH Variable::MemberVariable#7a968d4e#f ON FIRST 1 OUTPUT Lhs.0, Lhs.2", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1412 ], + "duplicationPercentages" : [ 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.552Z", + "raHash" : "267ba2j3vstl4ska8odmg5i1dba", + "predicateName" : "Call::Call#39248e3c#f", + "appearsAs" : { + "Call::Call#39248e3c#f" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:25,3-25,77", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 11605, + "dependencies" : { + "iscall" : "6793187vdajk31pj0ajr52cu85e", + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN iscall OUTPUT In.0", + "", + " {1} r2 = CONSTANT(unique int)[74]", + " {1} r3 = JOIN r2 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r4 = r1 UNION r3", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571, -1, 1, 34, -1, 11605 ], + "duplicationPercentages" : [ 4, -1, 0, 0, -1, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.554Z", + "raHash" : "615b67vahla6to12d7mqk835an9", + "predicateName" : "Cast::AlignofTypeOperator::getTypeOperand#dispred#f0820431#ff", + "appearsAs" : { + "Cast::AlignofTypeOperator::getTypeOperand#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Cast.qll:788,3-789,91", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 0, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "sizeof_bind" : "28ea22saqlal1d6bsnrqagq7mo9", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[94]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r3 = JOIN r2 WITH sizeof_bind ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r4 = JOIN r3 WITH sizeof_bind ON FIRST 2 OUTPUT Lhs.1, Lhs.0", + " {2} r5 = JOIN r4 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r6 = JOIN r5 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {3} r7 = JOIN r3 WITH sizeof_bind ON FIRST 2 OUTPUT Lhs.1, Lhs.0, Lhs.1", + " {3} r8 = JOIN r7 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + " {3} r9 = r8 AND NOT usertypes_0#antijoin_rhs(Lhs.2)", + " {2} r10 = SCAN r9 OUTPUT In.0, In.2", + "", + " {2} r11 = r6 UNION r10", + " return r11" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0 ], + "duplicationPercentages" : [ 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.557Z", + "raHash" : "037922bo4sihit0bn09deleo59b", + "predicateName" : "Call::FunctionCall#39248e3c#f", + "appearsAs" : { + "Call::FunctionCall#39248e3c#f" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:165,3-165,56", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 5, + "resultSize" : 11571, + "dependencies" : { + "iscall" : "6793187vdajk31pj0ajr52cu85e", + "Call::Call#39248e3c#f" : "267ba2j3vstl4ska8odmg5i1dba" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN iscall WITH Call::Call#39248e3c#f ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571 ], + "duplicationPercentages" : [ 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.559Z", + "raHash" : "f067e5emkrkj5da8vn873f3kqpd", + "predicateName" : "Call::FunctionCall::getTarget#f0820431#ff", + "appearsAs" : { + "Call::FunctionCall::getTarget#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "CACHACA", + "resultSize" : 11571 +} + +{ + "completionTime" : "2022-08-10T21:28:28.560Z", + "raHash" : "8eafabk1jjtdfpuii7kfeflq9p5", + "predicateName" : "project#Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff", + "appearsAs" : { + "project#Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Parameter.qll:75,3-77,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 6, + "resultSize" : 7465, + "dependencies" : { + "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff" : "cb59ab7ugr3051b3j24ocp200b0" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 9089, 7465 ], + "duplicationPercentages" : [ 19, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.567Z", + "raHash" : "475e7erp703knn56am79c4ed3c5", + "predicateName" : "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:68,3-69,39", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 6, + "resultSize" : 9089, + "dependencies" : { + "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff" : "cb59ab7ugr3051b3j24ocp200b0" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 9089 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.572Z", + "raHash" : "b23ff24ork1iapti8d3463nckq6", + "predicateName" : "Cast::Conversion#class#1f33e835#b", + "appearsAs" : { + "Cast::Conversion#class#1f33e835#b" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Cast.qll:9,1-25,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 78, + "resultSize" : 107672, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "exprconv_1#join_rhs" : "a78c049o4v84k43q6oo2hi128o1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[3]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r3 = JOIN r2 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r4 = CONSTANT(unique int)[5]", + " {1} r5 = JOIN r4 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r6 = JOIN r5 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r7 = r3 UNION r6", + "", + " {1} r8 = CONSTANT(unique int)[8]", + " {1} r9 = JOIN r8 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r10 = JOIN r9 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r11 = CONSTANT(unique int)[12]", + " {1} r12 = JOIN r11 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r13 = JOIN r12 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r14 = CONSTANT(unique int)[210]", + " {1} r15 = JOIN r14 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r16 = JOIN r15 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r17 = r13 UNION r16", + " {1} r18 = r10 UNION r17", + " {1} r19 = r7 UNION r18", + "", + " {1} r20 = CONSTANT(unique int)[211]", + " {1} r21 = JOIN r20 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r22 = JOIN r21 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r23 = CONSTANT(unique int)[212]", + " {1} r24 = JOIN r23 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r25 = JOIN r24 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r26 = r22 UNION r25", + "", + " {1} r27 = CONSTANT(unique int)[213]", + " {1} r28 = JOIN r27 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r29 = JOIN r28 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r30 = CONSTANT(unique int)[214]", + " {1} r31 = JOIN r30 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r32 = JOIN r31 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r33 = CONSTANT(unique int)[329]", + " {1} r34 = JOIN r33 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r35 = JOIN r34 WITH exprconv_1#join_rhs ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r36 = r32 UNION r35", + " {1} r37 = r29 UNION r36", + " {1} r38 = r26 UNION r37", + " {1} r39 = r19 UNION r38", + " return r39" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0, 0, -1, 1, 0, 0, -1, 0, -1, 1, 3682, 3682, -1, 1, 59459, 59459, -1, 1, 0, 0, -1, 59459, 63141, 63141, -1, 1, 0, 0, -1, 1, 0, 0, -1, 0, -1, 1, 0, 0, -1, 1, 44531, 44531, -1, 1, 0, 0, -1, 44531, 44531, 44531, 107672 ], + "duplicationPercentages" : [ 0, 0, 0, -1, 0, 0, 0, -1, 0, -1, 0, 0, 0, -1, 0, 1, 1, -1, 0, 0, 0, -1, 1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.592Z", + "raHash" : "2891548aljmvbffr00eismcu2ua", + "predicateName" : "Expr::Expr::getValue#dispred#f0820431#bf", + "appearsAs" : { + "Expr::Expr::getValue#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:123,3-126,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 51, + "resultSize" : 38851, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "valuebind_10#join_rhs" : "c0f2c6ou4b5uk9nudplo06c5kl5", + "values" : "f6ff4eq4hh9l66jo2q6fgp5mck3" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[123]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r3 = JOIN r2 WITH valuebind_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH values ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 38851, 38851, 38851 ], + "duplicationPercentages" : [ 0, 5, 0, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.596Z", + "raHash" : "7ff9e4mn9lid2jcetq2rtg51g2a", + "predicateName" : "Expr::Expr::getValue#dispred#f0820431#bf_0#antijoin_rhs", + "appearsAs" : { + "Expr::Expr::getValue#dispred#f0820431#bf_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 38851, + "dependencies" : { + "Expr::Expr::getValue#dispred#f0820431#bf" : "2891548aljmvbffr00eismcu2ua" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Expr::Expr::getValue#dispred#f0820431#bf OUTPUT In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 38851 ], + "duplicationPercentages" : [ 5 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.603Z", + "raHash" : "c7d2da60ir6lc2tt26iq650i259", + "predicateName" : "Assignment::AssignOperation#class#9d5edc7a#f", + "appearsAs" : { + "Assignment::AssignOperation#class#9d5edc7a#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Assignment.qll:50,1-58,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 6, + "resultSize" : 1129, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[53]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = CONSTANT(unique int)[54]", + " {1} r4 = JOIN r3 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r5 = CONSTANT(unique int)[55]", + " {1} r6 = JOIN r5 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r7 = r4 UNION r6", + " {1} r8 = r2 UNION r7", + "", + " {1} r9 = CONSTANT(unique int)[56]", + " {1} r10 = JOIN r9 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r11 = CONSTANT(unique int)[57]", + " {1} r12 = JOIN r11 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r13 = CONSTANT(unique int)[58]", + " {1} r14 = JOIN r13 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r15 = r12 UNION r14", + " {1} r16 = r10 UNION r15", + " {1} r17 = r8 UNION r16", + "", + " {1} r18 = CONSTANT(unique int)[59]", + " {1} r19 = JOIN r18 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r20 = CONSTANT(unique int)[60]", + " {1} r21 = JOIN r20 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r22 = CONSTANT(unique int)[61]", + " {1} r23 = JOIN r22 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r24 = r21 UNION r23", + " {1} r25 = r19 UNION r24", + "", + " {1} r26 = CONSTANT(unique int)[62]", + " {1} r27 = JOIN r26 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r28 = CONSTANT(unique int)[63]", + " {1} r29 = JOIN r28 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r30 = CONSTANT(unique int)[64]", + " {1} r31 = JOIN r30 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r32 = r29 UNION r31", + " {1} r33 = r27 UNION r32", + " {1} r34 = r25 UNION r33", + " {1} r35 = r17 UNION r34", + " return r35" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 222, -1, 1, 138, -1, 1, 20, -1, 158, 380, -1, 1, 5, -1, 1, 0, -1, 1, 15, -1, 15, 20, 400, -1, 1, 24, -1, 1, 172, -1, 1, 256, -1, 428, 452, -1, 1, 54, -1, 1, 145, -1, 1, 78, -1, 223, 277, 729, 1129 ], + "duplicationPercentages" : [ 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 4, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 3, -1, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.604Z", + "raHash" : "c66d3dau0jkcgi1m9jrchjc51f7", + "predicateName" : "Variable::Variable::getName#dispred#f0820431#ff#antijoin_rhs", + "appearsAs" : { + "Variable::Variable::getName#dispred#f0820431#ff#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:68,3-69,39", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 36, + "resultSize" : 6824, + "dependencies" : { + "Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff" : "353354ak9qmtgb2pkdm7f9uv7e3", + "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff_10#join_rhs" : "475e7erp703knn56am79c4ed3c5", + "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff" : "cb59ab7ugr3051b3j24ocp200b0", + "var_def" : "a427a78knumk074qs3frhkdcsl8" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = JOIN Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff WITH Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0, Lhs.1", + " {4} r2 = JOIN r1 WITH Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1, Lhs.2, Lhs.0", + " {3} r3 = JOIN r2 WITH var_def ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.3", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 9089, 12361, 6824 ], + "duplicationPercentages" : [ 0, 0, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.627Z", + "raHash" : "c4f76binsl1psrlucid4idavdq4", + "predicateName" : "Expr::BinaryOperation#class#ef463c5d#f", + "appearsAs" : { + "Expr::BinaryOperation#class#ef463c5d#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:529,1-561,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 65, + "resultSize" : 35571, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[25]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = CONSTANT(unique int)[26]", + " {1} r4 = JOIN r3 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r5 = CONSTANT(unique int)[27]", + " {1} r6 = JOIN r5 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r7 = r4 UNION r6", + " {1} r8 = r2 UNION r7", + "", + " {1} r9 = CONSTANT(unique int)[28]", + " {1} r10 = JOIN r9 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r11 = CONSTANT(unique int)[29]", + " {1} r12 = JOIN r11 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r13 = r10 UNION r12", + "", + " {1} r14 = CONSTANT(unique int)[30]", + " {1} r15 = JOIN r14 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r16 = CONSTANT(unique int)[31]", + " {1} r17 = JOIN r16 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r18 = r15 UNION r17", + " {1} r19 = r13 UNION r18", + " {1} r20 = r8 UNION r19", + "", + " {1} r21 = CONSTANT(unique int)[32]", + " {1} r22 = JOIN r21 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r23 = CONSTANT(unique int)[33]", + " {1} r24 = JOIN r23 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r25 = r22 UNION r24", + "", + " {1} r26 = CONSTANT(unique int)[34]", + " {1} r27 = JOIN r26 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r28 = CONSTANT(unique int)[35]", + " {1} r29 = JOIN r28 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r30 = r27 UNION r29", + " {1} r31 = r25 UNION r30", + "", + " {1} r32 = CONSTANT(unique int)[36]", + " {1} r33 = JOIN r32 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r34 = CONSTANT(unique int)[37]", + " {1} r35 = JOIN r34 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r36 = r33 UNION r35", + "", + " {1} r37 = CONSTANT(unique int)[38]", + " {1} r38 = JOIN r37 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r39 = CONSTANT(unique int)[39]", + " {1} r40 = JOIN r39 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r41 = r38 UNION r40", + " {1} r42 = r36 UNION r41", + " {1} r43 = r31 UNION r42", + " {1} r44 = r20 UNION r43", + "", + " {1} r45 = CONSTANT(unique int)[40]", + " {1} r46 = JOIN r45 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r47 = CONSTANT(unique int)[41]", + " {1} r48 = JOIN r47 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r49 = CONSTANT(unique int)[42]", + " {1} r50 = JOIN r49 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r51 = r48 UNION r50", + " {1} r52 = r46 UNION r51", + "", + " {1} r53 = CONSTANT(unique int)[43]", + " {1} r54 = JOIN r53 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r55 = CONSTANT(unique int)[44]", + " {1} r56 = JOIN r55 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r57 = r54 UNION r56", + "", + " {1} r58 = CONSTANT(unique int)[45]", + " {1} r59 = JOIN r58 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r60 = CONSTANT(unique int)[46]", + " {1} r61 = JOIN r60 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r62 = r59 UNION r61", + " {1} r63 = r57 UNION r62", + " {1} r64 = r52 UNION r63", + "", + " {1} r65 = CONSTANT(unique int)[47]", + " {1} r66 = JOIN r65 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r67 = CONSTANT(unique int)[48]", + " {1} r68 = JOIN r67 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r69 = r66 UNION r68", + "", + " {1} r70 = CONSTANT(unique int)[49]", + " {1} r71 = JOIN r70 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r72 = CONSTANT(unique int)[50]", + " {1} r73 = JOIN r72 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r74 = r71 UNION r73", + " {1} r75 = r69 UNION r74", + "", + " {1} r76 = CONSTANT(unique int)[51]", + " {1} r77 = JOIN r76 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r78 = CONSTANT(unique int)[65]", + " {1} r79 = JOIN r78 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r80 = r77 UNION r79", + "", + " {1} r81 = CONSTANT(unique int)[66]", + " {1} r82 = JOIN r81 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r83 = CONSTANT(unique int)[326]", + " {1} r84 = JOIN r83 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r85 = r82 UNION r84", + " {1} r86 = r80 UNION r85", + " {1} r87 = r75 UNION r86", + " {1} r88 = r64 UNION r87", + " {1} r89 = r44 UNION r88", + " return r89" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 3342, -1, 1, 3540, -1, 1, 877, -1, 4417, 7759, -1, 1, 218, -1, 1, 19, -1, 237, -1, 1, 0, -1, 1, 0, -1, 0, 237, 7996, -1, 1, 0, -1, 1, 0, -1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 1429, -1, 1, 877, -1, 2306, -1, 1, 313, -1, 1, 5868, -1, 6181, 8487, 8487, 16483, -1, 1, 1719, -1, 1, 3607, -1, 1, 3530, -1, 7137, 8856, -1, 1, 150, -1, 1, 4105, -1, 4255, -1, 1, 785, -1, 1, 704, -1, 1489, 5744, 14600, -1, 1, 1079, -1, 1, 520, -1, 1599, -1, 1, 474, -1, 1, 0, -1, 474, 2073, -1, 1, 0, -1, 1, 1623, -1, 1623, -1, 1, 792, -1, 1, 0, -1, 792, 2415, 4488, 19088, 35571 ], + "duplicationPercentages" : [ 0, 3, -1, 0, 0, -1, 0, 1, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 2, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, -1, 0, 1, -1, 0, 1, -1, 6, 2, -1, 0, 0, -1, 0, 1, -1, 1, -1, 0, 0, -1, 0, 0, -1, 2, 5, 2, -1, 0, 6, -1, 0, 0, -1, 5, -1, 0, 3, -1, 0, 0, -1, 3, 4, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 5, -1, 0, 0, -1, 5, 0, 0, 1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.648Z", + "raHash" : "361324qac1tpovtfah7660phno8", + "predicateName" : "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff", + "appearsAs" : { + "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:325,3-333,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 127, + "resultSize" : 22231, + "dependencies" : { + "Declaration::DeclarationEntry::getName#dispred#f0820431#ff" : "10891e0b6kqnofs5lijpa8n6uvb", + "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff#antijoin_rhs" : "25954695ueg607rkjqkji5ggic4", + "Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#ff" : "23d5663b1sgojtdqgba7klf02t1", + "project#Declaration::Declaration::getDefinition#dispred#f0820431#ff" : "5cbde744fr7070u06nt3dijaqk9", + "Declaration::Declaration::getDefinition#dispred#f0820431#ff" : "ca6898479uq5l0qqec2n31s03g6" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Declaration::DeclarationEntry::getName#dispred#f0820431#ff AND NOT Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff#antijoin_rhs(Lhs.0, Lhs.1)", + "", + " {2} r2 = SCAN Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#ff OUTPUT In.1, In.0", + " {1} r3 = JOIN r2 WITH project#Declaration::Declaration::getDefinition#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1", + " {2} r4 = JOIN r3 WITH Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r5 = JOIN r4 WITH Declaration::Declaration::getDefinition#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r6 = JOIN r5 WITH Declaration::DeclarationEntry::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r7 = r1 UNION r6", + " return r7" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4113, -1, 22370, 18118, 18118, 18184, 18184, -1, 22297 ], + "duplicationPercentages" : [ 6, -1, 5, 0, 2, 0, 0, -1, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.653Z", + "raHash" : "1717458ds4b7khs86d8heiraasd", + "predicateName" : "#select#query#fff", + "appearsAs" : { + "#select#query#fff" : { + "BadAdditionOverflowCheck.ql" : [ 0 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\query.ql:17,1-21,32", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 495, + "resultSize" : 215686, + "dependencies" : { + "exprparents" : "79364e1157kbirt0k84e0i0aec8", + "query::isStmtWithInitializer#f0820431#f" : "98bf61n5u6ah253pa33022cb9eb" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = exprparents AND NOT query::isStmtWithInitializer#f0820431#f(Lhs.2)", + "", + " {3} r2 = SCAN exprparents OUTPUT In.2, In.0, In.1", + " {3} r3 = JOIN r2 WITH query::isStmtWithInitializer#f0820431#f ON FIRST 1 OUTPUT Lhs.1, (Lhs.2 + 1), Lhs.0", + "", + " {3} r4 = r1 UNION r3", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 209320, -1, 215686, 6366, -1, 215686 ], + "duplicationPercentages" : [ 1, -1, 0, 4, -1, 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.654Z", + "raHash" : "a84d43mi7q241i6vn9ee7r7jh68", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#4", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#4" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 5, + "resultSize" : 6255, + "dependencies" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared" : "0aa1e6dnh37oq8rt0g3vvfk3hb1", + "Declaration::DeclarationEntry::getName#dispred#f0820431#ff" : "10891e0b6kqnofs5lijpa8n6uvb", + "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff" : "361324qac1tpovtfah7660phno8" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#shared WITH Declaration::DeclarationEntry::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, Rhs.1, Lhs.1", + " {2} r2 = JOIN r1 WITH Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff ON FIRST 2 OUTPUT Lhs.0, Lhs.2", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 6371, 6255 ], + "duplicationPercentages" : [ 0, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.660Z", + "raHash" : "8fb2f93mtv67r1k9oi1o5rghos3", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#5", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#5" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 3703, + "dependencies" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared#1" : "308849hf6k3tb7n8r58e6n3m98e", + "Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff" : "353354ak9qmtgb2pkdm7f9uv7e3", + "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff" : "361324qac1tpovtfah7660phno8" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#shared#1 WITH Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + " {1} r2 = JOIN r1 WITH Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff ON FIRST 2 OUTPUT Lhs.0", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 3819, 3703 ], + "duplicationPercentages" : [ 4, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.663Z", + "raHash" : "5a0c76g3ooo66qcd3nbb1f1pird", + "predicateName" : "Expr::UnaryOperation#class#ef463c5d#f", + "appearsAs" : { + "Expr::UnaryOperation#class#ef463c5d#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:515,1-527,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 35, + "resultSize" : 12864, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[2]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = CONSTANT(unique int)[4]", + " {1} r4 = JOIN r3 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r5 = r2 UNION r4", + "", + " {1} r6 = CONSTANT(unique int)[13]", + " {1} r7 = JOIN r6 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r8 = CONSTANT(unique int)[14]", + " {1} r9 = JOIN r8 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r10 = r7 UNION r9", + " {1} r11 = r5 UNION r10", + "", + " {1} r12 = CONSTANT(unique int)[15]", + " {1} r13 = JOIN r12 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r14 = CONSTANT(unique int)[16]", + " {1} r15 = JOIN r14 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r16 = r13 UNION r15", + "", + " {1} r17 = CONSTANT(unique int)[17]", + " {1} r18 = JOIN r17 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r19 = CONSTANT(unique int)[18]", + " {1} r20 = JOIN r19 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r21 = r18 UNION r20", + " {1} r22 = r16 UNION r21", + " {1} r23 = r11 UNION r22", + "", + " {1} r24 = CONSTANT(unique int)[19]", + " {1} r25 = JOIN r24 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r26 = CONSTANT(unique int)[20]", + " {1} r27 = JOIN r26 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r28 = r25 UNION r27", + "", + " {1} r29 = CONSTANT(unique int)[21]", + " {1} r30 = JOIN r29 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r31 = CONSTANT(unique int)[22]", + " {1} r32 = JOIN r31 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r33 = r30 UNION r32", + " {1} r34 = r28 UNION r33", + "", + " {1} r35 = CONSTANT(unique int)[23]", + " {1} r36 = JOIN r35 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r37 = CONSTANT(unique int)[322]", + " {1} r38 = JOIN r37 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r39 = r36 UNION r38", + "", + " {1} r40 = CONSTANT(unique int)[323]", + " {1} r41 = JOIN r40 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r42 = CONSTANT(unique int)[327]", + " {1} r43 = JOIN r42 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r44 = CONSTANT(unique int)[328]", + " {1} r45 = JOIN r44 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r46 = r43 UNION r45", + " {1} r47 = r41 UNION r46", + " {1} r48 = r39 UNION r47", + " {1} r49 = r34 UNION r48", + " {1} r50 = r23 UNION r49", + " return r50" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 4132, -1, 1, 2122, -1, 6254, -1, 1, 1230, -1, 1, 14, -1, 1244, 7498, -1, 1, 1951, -1, 1, 1654, -1, 3605, -1, 1, 0, -1, 1, 0, -1, 0, 3605, 11103, -1, 1, 0, -1, 1, 1236, -1, 1236, -1, 1, 310, -1, 1, 91, -1, 401, 1637, -1, 1, 124, -1, 1, 0, -1, 124, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 124, 1761, 12864 ], + "duplicationPercentages" : [ 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 1, 0, -1, 0, 2, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 1, -1, 0, 0, -1, 1, 0, -1, 0, 1, -1, 0, 0, -1, 1, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 1, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.664Z", + "raHash" : "60e29eg9c2egvhe5m7ja1nh2o1e", + "predicateName" : "files_10#join_rhs", + "appearsAs" : { + "files_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Location.qll:144,3-144,62", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 301, + "dependencies" : { + "files" : "7f5fb8keqhfuljbsrqi6cka5a1f" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN files OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 301 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.665Z", + "raHash" : "9020ccncme1vn8gftlc348ilbv2", + "predicateName" : "Variable::Variable::getName#dispred#f0820431#ff", + "appearsAs" : { + "Variable::Variable::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:68,3-69,39", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 60, + "resultSize" : 15437, + "dependencies" : { + "Variable::MemberVariable::getName#dispred#f0820431#ff" : "d5f8c1f1hmeek8bje16bgbp22q6", + "localvariables" : "111495kh3b6m9sku94i8oj4pqr3", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1", + "globalvariables" : "2b4839pss7ki8gosmgnk6jcfjt1", + "Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff" : "353354ak9qmtgb2pkdm7f9uv7e3", + "Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff_10#join_rhs" : "475e7erp703knn56am79c4ed3c5", + "var_def" : "a427a78knumk074qs3frhkdcsl8", + "Variable::Variable::getName#dispred#f0820431#ff#antijoin_rhs" : "c66d3dau0jkcgi1m9jrchjc51f7", + "Parameter::Parameter::getIndex#dispred#f0820431#ff" : "9794f2ntc3dscnec46gnipss9g9", + "project#Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff" : "8eafabk1jjtdfpuii7kfeflq9p5" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN localvariables WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.0, Lhs.2", + "", + " {2} r2 = JOIN globalvariables WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.0, Lhs.2", + "", + " {2} r3 = r1 UNION r2", + "", + " {2} r4 = Variable::MemberVariable::getName#dispred#f0820431#ff UNION r3", + "", + " {3} r5 = JOIN Variable::VariableDeclarationEntry::getName#dispred#f0820431#ff WITH Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Lhs.0, Lhs.1, Rhs.1", + "", + " {2} r6 = JOIN r5 WITH var_def ON FIRST 1 OUTPUT Lhs.2, Lhs.1", + "", + " {3} r7 = r5 AND NOT Variable::Variable::getName#dispred#f0820431#ff#antijoin_rhs(Lhs.0, Lhs.1, Lhs.2)", + " {2} r8 = SCAN r7 OUTPUT In.2, In.1", + "", + " {2} r9 = Parameter::Parameter::getIndex#dispred#f0820431#ff AND NOT project#Parameter::Parameter::getANamedDeclarationEntry#dispred#f0820431#ff(Lhs.0)", + " {2} r10 = SCAN r9 OUTPUT In.0, (\"(unnamed parameter \" ++ toString(In.1) ++ \")\")", + "", + " {2} r11 = r8 UNION r10", + " {2} r12 = r6 UNION r11", + " {2} r13 = r4 UNION r12", + " return r13" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 6212, -1, 159, -1, 6371, -1, 7777, -1, 9089, -1, 5270, -1, 2265, 2265, -1, 195, 195, -1, 2460, 7730, 15507 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 2, -1, 0, -1, 0, -1, 3, 2, -1, 0, 0, -1, 4, 4, 7 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.666Z", + "raHash" : "8a184b7flpbqrq1khschbih65cd", + "predicateName" : "project#Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff", + "appearsAs" : { + "project#Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:325,3-333,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 6, + "resultSize" : 22231, + "dependencies" : { + "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff" : "361324qac1tpovtfah7660phno8" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 22231, 22231 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.672Z", + "raHash" : "a42d37dob7favvo6k41oe3k1hre", + "predicateName" : "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs", + "appearsAs" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 68, + "resultSize" : 107672, + "dependencies" : { + "exprconv_10#join_rhs" : "d60daaas71d07nq9hqbk1b2vkh4", + "Cast::Conversion#class#1f33e835#b" : "b23ff24ork1iapti8d3463nckq6" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN exprconv_10#join_rhs WITH Cast::Conversion#class#1f33e835#b ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 107672 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.673Z", + "raHash" : "a33c4en26qbqh4pdg1bb6bjret2", + "predicateName" : "Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff", + "appearsAs" : { + "Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:287,3-303,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 144, + "dependencies" : { + "param_decl_bind" : "784ecebi2of8g6rj1mgiclc06l3", + "Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff#antijoin_rhs" : "18e3c2lkfgn912k0p1abcli290b", + "project#Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff" : "8a184b7flpbqrq1khschbih65cd", + "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff" : "361324qac1tpovtfah7660phno8" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN param_decl_bind OUTPUT In.0, In.1", + " {2} r2 = r1 AND NOT Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff#antijoin_rhs(Lhs.0)", + " {2} r3 = SCAN r2 OUTPUT In.0, replaceAll(replaceAll(replaceAll(replaceAll(replaceAll(replaceAll((toString((In.1 + 1)) ++ \"th\")[\"1th\"->\"1st\"])[\"2th\"->\"2nd\"])[\"3th\"->\"3rd\"])[\"11st\"->\"11th\"])[\"12nd\"->\"12th\"])[\"13rd\"->\"13th\"])", + " {2} r4 = r3 AND NOT project#Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff(Lhs.0)", + " {2} r5 = SCAN r4 OUTPUT In.0, (\"declaration of \" ++ In.1 ++ \" parameter\")", + "", + " {2} r6 = SCAN param_decl_bind OUTPUT In.0, In.1", + " {2} r7 = r6 AND NOT Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff#antijoin_rhs(Lhs.0)", + " {2} r8 = JOIN r7 WITH Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"declaration of \" ++ Rhs.1 ++ \" as anonymous \" ++ replaceAll(replaceAll(replaceAll(replaceAll(replaceAll(replaceAll((toString((Lhs.1 + 1)) ++ \"th\")[\"1th\"->\"1st\"])[\"2th\"->\"2nd\"])[\"3th\"->\"3rd\"])[\"11st\"->\"11th\"])[\"12nd\"->\"12th\"])[\"13rd\"->\"13th\"]) ++ \" parameter\")", + "", + " {2} r9 = r5 UNION r8", + " return r9" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 9233, 144, 144, 139, 139, -1, 9233, 144, 5, -1, 144 ], + "duplicationPercentages" : [ 0, 0, 5, 5, 0, -1, 0, 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.686Z", + "raHash" : "b09bd3sc21dh83kqvf6jm5dauc6", + "predicateName" : "locations_default", + "appearsAs" : { + "locations_default" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:202,1-217,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 21, + "resultSize" : 91336 +} + +{ + "completionTime" : "2022-08-10T21:28:28.686Z", + "raHash" : "3882b6gcd5b9e0niojg8pskda33", + "predicateName" : "project#Call::FunctionCall::getTarget#f0820431#ff", + "appearsAs" : { + "project#Call::FunctionCall::getTarget#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "CACHACA", + "resultSize" : 1993 +} + +{ + "completionTime" : "2022-08-10T21:28:28.686Z", + "raHash" : "31fa93s850tckmjvku3l8k7mko7", + "predicateName" : "MemberFunction::MemberFunction#5d715d12#b", + "appearsAs" : { + "MemberFunction::MemberFunction#5d715d12#b" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\MemberFunction.qll:26,3-26,39", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 0, + "dependencies" : { + "project#Call::FunctionCall::getTarget#f0820431#ff" : "e5b0c7lg3vibb5n3rudb3dorq06", + "Declaration::Declaration::isMember#dispred#f0820431#b" : "9f6509fn9ru5e6tbedv9skgmba8" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN project#Call::FunctionCall::getTarget#f0820431#ff WITH Declaration::Declaration::isMember#dispred#f0820431#b ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 0 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.687Z", + "raHash" : "fc3124kl18bb1s5716r48kdu6fe", + "predicateName" : "locations_stmt", + "appearsAs" : { + "locations_stmt" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:219,1-234,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 14, + "resultSize" : 43691 +} + +{ + "completionTime" : "2022-08-10T21:28:28.687Z", + "raHash" : "84960eeap2d9djg6a9u8vhdhr29", + "predicateName" : "MemberFunction::Constructor#class#5d715d12#b", + "appearsAs" : { + "MemberFunction::Constructor#class#5d715d12#b" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "31fa93s850tckmjvku3l8k7mko7" +} + +{ + "completionTime" : "2022-08-10T21:28:28.687Z", + "raHash" : "3d3878d7e8vfa2nvn9sclslvph9", + "predicateName" : "MemberFunction::Destructor#class#5d715d12#b", + "appearsAs" : { + "MemberFunction::Destructor#class#5d715d12#b" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "31fa93s850tckmjvku3l8k7mko7" +} + +{ + "completionTime" : "2022-08-10T21:28:28.687Z", + "raHash" : "0eec07sttpna47bt6ktbi6ccu69", + "predicateName" : "Call::ConstructorCall#class#39248e3c#f", + "appearsAs" : { + "Call::ConstructorCall#class#39248e3c#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "84960eeap2d9djg6a9u8vhdhr29" +} + +{ + "completionTime" : "2022-08-10T21:28:28.687Z", + "raHash" : "b96bd8ejkpb7a7olf7urf849bna", + "predicateName" : "Call::DestructorCall#class#39248e3c#f", + "appearsAs" : { + "Call::DestructorCall#class#39248e3c#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "3d3878d7e8vfa2nvn9sclslvph9" +} + +{ + "completionTime" : "2022-08-10T21:28:28.691Z", + "raHash" : "f947f0rq2vajjn1hb88l136tpa6", + "predicateName" : "m#Class::Class::getCanonicalMember#dispred#f0820431#ffb", + "appearsAs" : { + "m#Class::Class::getCanonicalMember#dispred#f0820431#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:91,3-99,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 1993, + "dependencies" : { + "project#Call::FunctionCall::getTarget#f0820431#ff" : "3882b6gcd5b9e0niojg8pskda33", + "Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb" : "e3ad2780uektko9hkg6kno1reub" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Function::TemplateFunction::getAnInstantiation#dispred#f0820431#fb OUTPUT In.1, In.0", + " {1} r2 = JOIN r1 WITH project#Call::FunctionCall::getTarget#f0820431#ff ON FIRST 1 OUTPUT Lhs.1", + "", + " {1} r3 = project#Call::FunctionCall::getTarget#f0820431#ff UNION r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 0, 0, -1, 1993 ], + "duplicationPercentages" : [ 0, 0, -1, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.691Z", + "raHash" : "7c75c6rdrqj3nai1vpr5l66v9t2", + "predicateName" : "Declaration::Declaration::getName#dispred#f0820431#ff", + "appearsAs" : { + "Declaration::Declaration::getName#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:112,3-127,30", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 26, + "resultSize" : 22356, + "dependencies" : { + "UserType::UserType::getName#dispred#f0820431#ff" : "3dfdadperuubb8o68dmb96utja1", + "Variable::Variable::getName#dispred#f0820431#ff" : "9020ccncme1vn8gftlc348ilbv2", + "functions" : "a7bb44o93bk5d64edin5qq128r0", + "enumconstants" : "b687f43hut9uaipufkfb5ccnok4", + "frienddecls" : "d054f4pe8716at0f0vtceu8iqad", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "Class::Class#bacd9b46#f" : "f6e9b02njp6rh9im38j6aidq5fc" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = UserType::UserType::getName#dispred#f0820431#ff UNION Variable::Variable::getName#dispred#f0820431#ff", + "", + " {2} r2 = SCAN functions OUTPUT In.0, In.1", + "", + " {2} r3 = SCAN enumconstants OUTPUT In.0, In.4", + "", + " {2} r4 = SCAN frienddecls OUTPUT In.1, In.0", + " {2} r5 = JOIN r4 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r6 = JOIN r5 WITH Class::Class#bacd9b46#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " {2} r7 = JOIN r6 WITH UserType::UserType::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (Rhs.1 ++ \"'s friend\")", + "", + " {2} r8 = r3 UNION r7", + " {2} r9 = r2 UNION r8", + " {2} r10 = r1 UNION r9", + " return r10" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 16228, -1, 3803, -1, 2325, -1, 0, 0, 0, 0, -1, 2325, 6128, 22356 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "6feae7vbhhsp99f73bjpfk7qijc", + "predicateName" : "Class::Class::getCanonicalMember#dispred#f0820431#ffb", + "appearsAs" : { + "Class::Class::getCanonicalMember#dispred#f0820431#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:91,3-99,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 0, + "dependencies" : { + "member" : "8b3f22jtvpn0s9e0s4dgoden071", + "m#Class::Class::getCanonicalMember#dispred#f0820431#ffb" : "f947f0rq2vajjn1hb88l136tpa6", + "ResolveClass::Cached::isClass#eb2868f4#f" : "b11d6bcumifg21befashf33b4g3", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = SCAN member OUTPUT In.2, In.0, In.1", + " {3} r2 = JOIN r1 WITH m#Class::Class::getCanonicalMember#dispred#f0820431#ffb ON FIRST 1 OUTPUT Lhs.1, Lhs.0, Lhs.2", + " {3} r3 = JOIN r2 WITH ResolveClass::Cached::isClass#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1, Lhs.2", + " {3} r4 = JOIN r3 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, Lhs.2, Lhs.1", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406, 0, 0, 0 ], + "duplicationPercentages" : [ 1, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "87e4b104t7rcovc7uei8bosunqa", + "predicateName" : "Class::Class::getCanonicalMember#dispred#f0820431#ffb_201#join_rhs", + "appearsAs" : { + "Class::Class::getCanonicalMember#dispred#f0820431#ffb_201#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "6feae7vbhhsp99f73bjpfk7qijc" +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "704a20usfhca9hdp6dceiucrvk4", + "predicateName" : "Class::Class::getAMember#dispred#f0820431#2#ffb", + "appearsAs" : { + "Class::Class::getAMember#dispred#f0820431#2#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "87e4b104t7rcovc7uei8bosunqa" +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "29e434d976oobclag9e9kv96jjd", + "predicateName" : "project#Class::Class::getAMember#dispred#f0820431#2#ffb", + "appearsAs" : { + "project#Class::Class::getAMember#dispred#f0820431#2#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "704a20usfhca9hdp6dceiucrvk4" +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "0d01cd29npb4ltcgb4rf6kjjqra", + "predicateName" : "MemberFunction::MemberFunction#5d715d12#b", + "appearsAs" : { + "MemberFunction::MemberFunction#5d715d12#b" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "29e434d976oobclag9e9kv96jjd" +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "9c7d64k5rtofmsh8b1g068466s8", + "predicateName" : "MemberFunction::Constructor#class#5d715d12#b", + "appearsAs" : { + "MemberFunction::Constructor#class#5d715d12#b" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "0d01cd29npb4ltcgb4rf6kjjqra" +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "c21437jjivlqsf4lq0fjnl9ca26", + "predicateName" : "MemberFunction::Destructor#class#5d715d12#b", + "appearsAs" : { + "MemberFunction::Destructor#class#5d715d12#b" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "0d01cd29npb4ltcgb4rf6kjjqra" +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "ade51a57uifm7p7tcamihbj7g02", + "predicateName" : "Call::ConstructorCall#class#39248e3c#f", + "appearsAs" : { + "Call::ConstructorCall#class#39248e3c#f" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "9c7d64k5rtofmsh8b1g068466s8" +} + +{ + "completionTime" : "2022-08-10T21:28:28.693Z", + "raHash" : "df07dat89l8qa8f7uem2j9co56f", + "predicateName" : "Call::DestructorCall#class#39248e3c#f", + "appearsAs" : { + "Call::DestructorCall#class#39248e3c#f" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "c21437jjivlqsf4lq0fjnl9ca26" +} + +{ + "completionTime" : "2022-08-10T21:28:28.704Z", + "raHash" : "1df09bupo7ee66hd8ohvvl0rfke", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#max_range", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#max_range" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 12, + "resultSize" : 7512, + "dependencies" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared#3" : "e499a9mq61dhg1mgj0v4ov4he23", + "Declaration::Declaration::getName#dispred#f0820431#ff" : "7c75c6rdrqj3nai1vpr5l66v9t2" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#shared#3 WITH Declaration::Declaration::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.705Z", + "raHash" : "e8d4d846dp19a31eq1rv27ab5g5", + "predicateName" : "Call::FunctionCall::getTarget#dispred#f0820431#ff", + "appearsAs" : { + "Call::FunctionCall::getTarget#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:255,3-263,95", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 18, + "resultSize" : 11571, + "dependencies" : { + "Call::FunctionCall::getTarget#f0820431#ff" : "f85a2a84krfqmudq6ipu2kj7u89", + "Call::ConstructorCall#class#39248e3c#f" : "0eec07sttpna47bt6ktbi6ccu69", + "Call::DestructorCall#class#39248e3c#f" : "b96bd8ejkpb7a7olf7urf849bna", + "MemberFunction::Constructor#class#5d715d12#b" : "84960eeap2d9djg6a9u8vhdhr29", + "MemberFunction::Destructor#class#5d715d12#b" : "3d3878d7e8vfa2nvn9sclslvph9" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Call::FunctionCall::getTarget#f0820431#ff AND NOT Call::ConstructorCall#class#39248e3c#f(Lhs.0)", + " {2} r2 = r1 AND NOT Call::DestructorCall#class#39248e3c#f(Lhs.0)", + "", + " {2} r3 = SCAN Call::FunctionCall::getTarget#f0820431#ff OUTPUT In.1, In.0", + "", + " {2} r4 = JOIN r3 WITH MemberFunction::Constructor#class#5d715d12#b ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r5 = JOIN r4 WITH Call::ConstructorCall#class#39248e3c#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r6 = JOIN r3 WITH MemberFunction::Destructor#class#5d715d12#b ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r7 = JOIN r6 WITH Call::DestructorCall#class#39248e3c#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r8 = r5 UNION r7", + " {2} r9 = r2 UNION r8", + " return r9" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571, 11571, -1, 11571, -1, 0, 0, -1, 0, 0, -1, 0, 11571 ], + "duplicationPercentages" : [ 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.707Z", + "raHash" : "c5f4afvmrcjddpv13ee094gq2a0", + "predicateName" : "Call::FunctionCall::getTarget#dispred#f0820431#ff", + "appearsAs" : { + "Call::FunctionCall::getTarget#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:255,3-263,95", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 14, + "resultSize" : 11571, + "dependencies" : { + "Call::FunctionCall::getTarget#f0820431#ff" : "f067e5emkrkj5da8vn873f3kqpd", + "Call::ConstructorCall#class#39248e3c#f" : "ade51a57uifm7p7tcamihbj7g02", + "Call::DestructorCall#class#39248e3c#f" : "df07dat89l8qa8f7uem2j9co56f", + "MemberFunction::Constructor#class#5d715d12#b" : "9c7d64k5rtofmsh8b1g068466s8", + "MemberFunction::Destructor#class#5d715d12#b" : "c21437jjivlqsf4lq0fjnl9ca26" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Call::FunctionCall::getTarget#f0820431#ff AND NOT Call::ConstructorCall#class#39248e3c#f(Lhs.0)", + " {2} r2 = r1 AND NOT Call::DestructorCall#class#39248e3c#f(Lhs.0)", + "", + " {2} r3 = SCAN Call::FunctionCall::getTarget#f0820431#ff OUTPUT In.1, In.0", + "", + " {2} r4 = JOIN r3 WITH MemberFunction::Constructor#class#5d715d12#b ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r5 = JOIN r4 WITH Call::ConstructorCall#class#39248e3c#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r6 = JOIN r3 WITH MemberFunction::Destructor#class#5d715d12#b ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r7 = JOIN r6 WITH Call::DestructorCall#class#39248e3c#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r8 = r5 UNION r7", + " {2} r9 = r2 UNION r8", + " return r9" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571, 11571, -1, 11571, -1, 0, 0, -1, 0, 0, -1, 0, 11571 ], + "duplicationPercentages" : [ 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.710Z", + "raHash" : "357af4vm1crmtl701s0ep0422v9", + "predicateName" : "project#Call::FunctionCall::getTarget#dispred#f0820431#ff", + "appearsAs" : { + "project#Call::FunctionCall::getTarget#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:255,3-263,95", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 5, + "resultSize" : 11571, + "dependencies" : { + "Call::FunctionCall::getTarget#dispred#f0820431#ff" : "e8d4d846dp19a31eq1rv27ab5g5" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Call::FunctionCall::getTarget#dispred#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571, 11571 ], + "duplicationPercentages" : [ 4, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.715Z", + "raHash" : "9023ecvvpdea7mk4fksi1080kgc", + "predicateName" : "Access::Access#8878f617#f", + "appearsAs" : { + "Access::Access#8878f617#f" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:17,3-17,91", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 169, + "resultSize" : 99694, + "dependencies" : { + "@access#f" : "4feb95nsgdn2ri8as0h9kcpl573", + "iscall_0#antijoin_rhs" : "529cf0o8krceqscefq2ru4h0h22", + "@access#f#antijoin_rhs" : "d7df6ela423lior4flati1vu14a" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = @access#f AND NOT iscall_0#antijoin_rhs(Lhs.0)", + "", + " {1} r2 = @access#f AND NOT @access#f#antijoin_rhs(Lhs.0)", + "", + " {1} r3 = r1 UNION r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 99694, -1, 98988, -1, 198682 ], + "duplicationPercentages" : [ 7, -1, 7, -1, 112 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.715Z", + "raHash" : "c04edck1e6ps6e2njri9ig4qa89", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#max_term", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#max_term" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 10, + "resultSize" : 7512, + "dependencies" : { + "Element::ElementBase::toString#dispred#f0820431#ff#shared#3" : "e499a9mq61dhg1mgj0v4ov4he23", + "Declaration::Declaration::getName#dispred#f0820431#ff" : "7c75c6rdrqj3nai1vpr5l66v9t2" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#shared#3 WITH Declaration::Declaration::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1, Rhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.719Z", + "raHash" : "177860qn18ruruq5js662948lt4", + "predicateName" : "Access::FunctionAccess#class#8878f617#f", + "appearsAs" : { + "Access::FunctionAccess#class#8878f617#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:343,1-377,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 706, + "dependencies" : { + "@access#f#antijoin_rhs" : "d7df6ela423lior4flati1vu14a", + "Access::Access#8878f617#f" : "9023ecvvpdea7mk4fksi1080kgc", + "iscall_0#antijoin_rhs" : "529cf0o8krceqscefq2ru4h0h22" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN @access#f#antijoin_rhs WITH Access::Access#8878f617#f ON FIRST 1 OUTPUT Lhs.0", + " {1} r2 = r1 AND NOT iscall_0#antijoin_rhs(Lhs.0)", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 706, 706 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.721Z", + "raHash" : "8adbef33nsct1qpanrmao8g8q90", + "predicateName" : "Access::FunctionAccess::getTarget#dispred#f0820431#ff", + "appearsAs" : { + "Access::FunctionAccess::getTarget#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:368,3-369,95", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 706, + "dependencies" : { + "Access::FunctionAccess#class#8878f617#f" : "177860qn18ruruq5js662948lt4", + "funbind" : "8057edi8viiq0fbb2ut69d46dj9" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Access::FunctionAccess#class#8878f617#f WITH funbind ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 706 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.722Z", + "raHash" : "8494f6llfo6bg6jo8ct14r27s16", + "predicateName" : "Access::FunctionAccess::getTarget#dispred#f0820431#ff_0#antijoin_rhs", + "appearsAs" : { + "Access::FunctionAccess::getTarget#dispred#f0820431#ff_0#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 706, + "dependencies" : { + "Access::FunctionAccess::getTarget#dispred#f0820431#ff" : "8adbef33nsct1qpanrmao8g8q90" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Access::FunctionAccess::getTarget#dispred#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 706, 706 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.742Z", + "raHash" : "ee038856qvvv8j0hq5a3ukvanb6", + "predicateName" : "Expr::Operation::getOperator#dispred#f0820431#ff", + "appearsAs" : { + "Expr::Operation::getOperator#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:508,3-509,34", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 138, + "resultSize" : 48018, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = CONSTANT(int, unique string)[2,\"&\"]", + " {2} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"&\"", + "", + " {2} r3 = CONSTANT(int, unique string)[4,\"*\"]", + " {2} r4 = JOIN r3 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"*\"", + "", + " {2} r5 = CONSTANT(int, unique string)[13,\"-\"]", + " {2} r6 = JOIN r5 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"-\"", + "", + " {2} r7 = r4 UNION r6", + " {2} r8 = r2 UNION r7", + "", + " {2} r9 = CONSTANT(int, unique string)[14,\"+\"]", + " {2} r10 = JOIN r9 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"+\"", + "", + " {2} r11 = CONSTANT(int, unique string)[15,\"~\"]", + " {2} r12 = JOIN r11 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"~\"", + "", + " {2} r13 = r10 UNION r12", + "", + " {2} r14 = CONSTANT(int, unique string)[16,\"!\"]", + " {2} r15 = JOIN r14 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"!\"", + "", + " {2} r16 = CONSTANT(int, unique string)[17,\"~\"]", + " {2} r17 = JOIN r16 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"~\"", + "", + " {2} r18 = r15 UNION r17", + " {2} r19 = r13 UNION r18", + " {2} r20 = r8 UNION r19", + "", + " {2} r21 = CONSTANT(int, unique string)[25,\"+\"]", + " {2} r22 = JOIN r21 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"+\"", + "", + " {2} r23 = CONSTANT(int, unique string)[26,\"-\"]", + " {2} r24 = JOIN r23 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"-\"", + "", + " {2} r25 = CONSTANT(int, unique string)[27,\"*\"]", + " {2} r26 = JOIN r25 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"*\"", + "", + " {2} r27 = r24 UNION r26", + " {2} r28 = r22 UNION r27", + "", + " {2} r29 = CONSTANT(int, unique string)[28,\"/\"]", + " {2} r30 = JOIN r29 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"/\"", + "", + " {2} r31 = CONSTANT(int, unique string)[29,\"%\"]", + " {2} r32 = JOIN r31 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"%\"", + "", + " {2} r33 = r30 UNION r32", + "", + " {2} r34 = CONSTANT(int, unique string)[30,\"*\"]", + " {2} r35 = JOIN r34 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"*\"", + "", + " {2} r36 = CONSTANT(int, unique string)[31,\"/\"]", + " {2} r37 = JOIN r36 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"/\"", + "", + " {2} r38 = r35 UNION r37", + " {2} r39 = r33 UNION r38", + " {2} r40 = r28 UNION r39", + " {2} r41 = r20 UNION r40", + "", + " {2} r42 = CONSTANT(int, unique string)[32,\"+\"]", + " {2} r43 = JOIN r42 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"+\"", + "", + " {2} r44 = CONSTANT(int, unique string)[33,\"+\"]", + " {2} r45 = JOIN r44 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"+\"", + "", + " {2} r46 = CONSTANT(int, unique string)[34,\"-\"]", + " {2} r47 = JOIN r46 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"-\"", + "", + " {2} r48 = r45 UNION r47", + " {2} r49 = r43 UNION r48", + "", + " {2} r50 = CONSTANT(int, unique string)[35,\"-\"]", + " {2} r51 = JOIN r50 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"-\"", + "", + " {2} r52 = CONSTANT(int, unique string)[36,\"+\"]", + " {2} r53 = JOIN r52 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"+\"", + "", + " {2} r54 = r51 UNION r53", + "", + " {2} r55 = CONSTANT(int, unique string)[37,\"-\"]", + " {2} r56 = JOIN r55 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"-\"", + "", + " {2} r57 = CONSTANT(int, unique string)[38,\"-\"]", + " {2} r58 = JOIN r57 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"-\"", + "", + " {2} r59 = r56 UNION r58", + " {2} r60 = r54 UNION r59", + " {2} r61 = r49 UNION r60", + "", + " {2} r62 = CONSTANT(int, unique string)[41,\"&\"]", + " {2} r63 = JOIN r62 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"&\"", + "", + " {2} r64 = CONSTANT(int, unique string)[42,\"|\"]", + " {2} r65 = JOIN r64 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"|\"", + "", + " {2} r66 = CONSTANT(int, unique string)[43,\"^\"]", + " {2} r67 = JOIN r66 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"^\"", + "", + " {2} r68 = r65 UNION r67", + " {2} r69 = r63 UNION r68", + "", + " {2} r70 = CONSTANT(int, unique string)[46,\">\"]", + " {2} r71 = JOIN r70 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \">\"", + "", + " {2} r72 = CONSTANT(int, unique string)[47,\"<\"]", + " {2} r73 = JOIN r72 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"<\"", + "", + " {2} r74 = r71 UNION r73", + "", + " {2} r75 = CONSTANT(int, unique string)[22,\"++\"]", + " {2} r76 = JOIN r75 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"++\"", + "", + " {2} r77 = CONSTANT(int, unique string)[23,\"--\"]", + " {2} r78 = JOIN r77 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"--\"", + "", + " {2} r79 = r76 UNION r78", + " {2} r80 = r74 UNION r79", + " {2} r81 = r69 UNION r80", + " {2} r82 = r61 UNION r81", + " {2} r83 = r41 UNION r82", + "", + " {2} r84 = CONSTANT(int, unique string)[39,\"<<\"]", + " {2} r85 = JOIN r84 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"<<\"", + "", + " {2} r86 = CONSTANT(int, unique string)[40,\">>\"]", + " {2} r87 = JOIN r86 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \">>\"", + "", + " {2} r88 = CONSTANT(int, unique string)[44,\"==\"]", + " {2} r89 = JOIN r88 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"==\"", + "", + " {2} r90 = r87 UNION r89", + " {2} r91 = r85 UNION r90", + "", + " {2} r92 = CONSTANT(int, unique string)[45,\"!=\"]", + " {2} r93 = JOIN r92 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"!=\"", + "", + " {2} r94 = CONSTANT(int, unique string)[48,\">=\"]", + " {2} r95 = JOIN r94 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \">=\"", + "", + " {2} r96 = r93 UNION r95", + "", + " {2} r97 = CONSTANT(int, unique string)[49,\"<=\"]", + " {2} r98 = JOIN r97 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"<=\"", + "", + " {2} r99 = CONSTANT(int, unique string)[50,\"?\"]", + " {2} r105 = JOIN r104 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \">?\"", + "", + " {2} r106 = CONSTANT(int, unique string)[53,\"+=\"]", + " {2} r107 = JOIN r106 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"+=\"", + "", + " {2} r108 = CONSTANT(int, unique string)[54,\"-=\"]", + " {2} r109 = JOIN r108 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"-=\"", + "", + " {2} r110 = r107 UNION r109", + " {2} r111 = r105 UNION r110", + "", + " {2} r112 = CONSTANT(int, unique string)[55,\"*=\"]", + " {2} r113 = JOIN r112 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"*=\"", + "", + " {2} r114 = CONSTANT(int, unique string)[56,\"/=\"]", + " {2} r115 = JOIN r114 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"/=\"", + "", + " {2} r116 = r113 UNION r115", + "", + " {2} r117 = CONSTANT(int, unique string)[57,\"%=\"]", + " {2} r118 = JOIN r117 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"%=\"", + "", + " {2} r119 = CONSTANT(int, unique string)[60,\"&=\"]", + " {2} r120 = JOIN r119 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"&=\"", + "", + " {2} r121 = r118 UNION r120", + " {2} r122 = r116 UNION r121", + " {2} r123 = r111 UNION r122", + " {2} r124 = r103 UNION r123", + "", + " {2} r125 = CONSTANT(int, unique string)[61,\"|=\"]", + " {2} r126 = JOIN r125 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"|=\"", + "", + " {2} r127 = CONSTANT(int, unique string)[62,\"^=\"]", + " {2} r128 = JOIN r127 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"^=\"", + "", + " {2} r129 = CONSTANT(int, unique string)[63,\"+=\"]", + " {2} r130 = JOIN r129 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"+=\"", + "", + " {2} r131 = r128 UNION r130", + " {2} r132 = r126 UNION r131", + "", + " {2} r133 = CONSTANT(int, unique string)[64,\"-=\"]", + " {2} r134 = JOIN r133 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"-=\"", + "", + " {2} r135 = CONSTANT(int, unique string)[65,\"&&\"]", + " {2} r136 = JOIN r135 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"&&\"", + "", + " {2} r137 = r134 UNION r136", + "", + " {2} r138 = CONSTANT(int, unique string)[66,\"||\"]", + " {2} r139 = JOIN r138 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"||\"", + "", + " {2} r140 = CONSTANT(int, unique string)[58,\"<<=\"]", + " {2} r141 = JOIN r140 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"<<=\"", + "", + " {2} r142 = r139 UNION r141", + " {2} r143 = r137 UNION r142", + " {2} r144 = r132 UNION r143", + "", + " {2} r145 = CONSTANT(int, unique string)[59,\">>=\"]", + " {2} r146 = JOIN r145 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \">>=\"", + "", + " {2} r147 = CONSTANT(int, unique string)[326,\"<=>\"]", + " {2} r148 = JOIN r147 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"<=>\"", + "", + " {2} r149 = r146 UNION r148", + "", + " {2} r150 = CONSTANT(int, unique string)[18,\"__real\"]", + " {2} r151 = JOIN r150 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__real\"", + "", + " {2} r152 = CONSTANT(int, unique string)[19,\"__imag\"]", + " {2} r153 = JOIN r152 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__imag\"", + "", + " {2} r154 = r151 UNION r153", + " {2} r155 = r149 UNION r154", + "", + " {2} r156 = CONSTANT(int, unique string)[327,\"co_await\"]", + " {2} r157 = JOIN r156 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"co_await\"", + "", + " {2} r158 = CONSTANT(int, unique string)[328,\"co_yield\"]", + " {2} r159 = JOIN r158 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"co_yield\"", + "", + " {2} r160 = r157 UNION r159", + "", + " {2} r161 = CONSTANT(int, unique string)[323,\"(vector fill)\"]", + " {2} r162 = JOIN r161 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"(vector fill)\"", + "", + " {2} r163 = CONSTANT(int, unique string)[322,\"__builtin_addressof\"]", + " {2} r164 = JOIN r163 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_addressof\"", + "", + " {2} r165 = r162 UNION r164", + " {2} r166 = r160 UNION r165", + " {2} r167 = r155 UNION r166", + " {2} r168 = r144 UNION r167", + " {2} r169 = r124 UNION r168", + " {2} r170 = r83 UNION r169", + " return r170" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 4132, -1, 1, 2122, -1, 1, 1230, -1, 3352, 7484, -1, 1, 14, -1, 1, 1951, -1, 1965, -1, 1, 1654, -1, 1, 0, -1, 1654, 3619, 11103, -1, 1, 3342, -1, 1, 3540, -1, 1, 877, -1, 4417, 7759, -1, 1, 218, -1, 1, 19, -1, 237, -1, 1, 0, -1, 1, 0, -1, 0, 237, 7996, 19099, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 0, -1, 1, 1429, -1, 1429, -1, 1, 877, -1, 1, 313, -1, 1190, 2619, 2619, -1, 1, 3607, -1, 1, 3530, -1, 1, 150, -1, 3680, 7287, -1, 1, 704, -1, 1, 1079, -1, 1783, -1, 1, 91, -1, 1, 124, -1, 215, 1998, 9285, 11904, 31003, -1, 1, 5868, -1, 1, 1719, -1, 1, 4105, -1, 5824, 11692, -1, 1, 785, -1, 1, 520, -1, 1305, -1, 1, 474, -1, 1, 0, -1, 474, 1779, 13471, -1, 1, 0, -1, 1, 222, -1, 1, 138, -1, 360, 360, -1, 1, 20, -1, 1, 5, -1, 25, -1, 1, 0, -1, 1, 172, -1, 172, 197, 557, 14028, -1, 1, 256, -1, 1, 54, -1, 1, 145, -1, 199, 455, -1, 1, 78, -1, 1, 1623, -1, 1701, -1, 1, 792, -1, 1, 15, -1, 807, 2508, 2963, -1, 1, 24, -1, 1, 0, -1, 24, -1, 1, 0, -1, 1, 0, -1, 0, 24, -1, 1, 0, -1, 1, 0, -1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 24, 2987, 17015, 48018 ], + "duplicationPercentages" : [ 0, 0, -1, 0, 3, -1, 0, 4, -1, 2, 1, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 2, -1, 0, 1, -1, 1, 0, -1, 0, 0, -1, 0, 5, -1, 1, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 7, -1, 0, 0, -1, 2, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, -1, 0, -1, 0, 4, -1, 0, 3, -1, 0, 1, 0, 0, 0, -1, 0, 2, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 2, -1, 0, 2, -1, 0, 0, -1, 2, 6, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 1, -1, 1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 2, -1, 0, 0, -1, 0, 3, -1, 4, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 8, -1, 0, 0, -1, 8, -1, 0, 0, -1, 0, 0, -1, 0, 8, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 8, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.742Z", + "raHash" : "ceeef7apms3r48e6dnrgl38pl14", + "predicateName" : "Access::VariableAccess#8878f617#f#shared", + "appearsAs" : { + "Access::VariableAccess#8878f617#f#shared" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:71,3-73,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 26, + "resultSize" : 98988, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "Access::Access#8878f617#f" : "9023ecvvpdea7mk4fksi1080kgc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[84]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r3 = JOIN r2 WITH Access::Access#8878f617#f ON FIRST 1 OUTPUT Lhs.0", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 98988, 98988 ], + "duplicationPercentages" : [ 0, 7, 7 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.749Z", + "raHash" : "4178c1esvkmi0g23ntp2ouj1rp5", + "predicateName" : "#select#query#fff", + "appearsAs" : { + "#select#query#fff" : { + "BadAdditionOverflowCheck.ql" : [ 0 ] + } + }, + "position" : "C:\\Users\\dabartol\\AppData\\Local\\Temp\\exprparents.rele9a518baf14f4322ac243578a8e1391386ff030f5711433667813069844\\query.ql:17,1-21,32", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 215686 +} + +{ + "completionTime" : "2022-08-10T21:28:28.750Z", + "raHash" : "ea4ab1lijdb7t4upt2042dj08ne", + "predicateName" : "m#Expr::Expr::getChild#dispred#f0820431#bff", + "appearsAs" : { + "m#Expr::Expr::getChild#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:16,3-17,93", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1115, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[93]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = CONSTANT(unique int)[94]", + " {1} r4 = JOIN r3 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r5 = CONSTANT(unique int)[132]", + " {1} r6 = JOIN r5 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r7 = r4 UNION r6", + " {1} r8 = r2 UNION r7", + " return r8" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1115, -1, 1, 0, -1, 1, 0, -1, 0, 1115 ], + "duplicationPercentages" : [ 0, 1, -1, 0, 0, -1, 0, 0, -1, 0, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.752Z", + "raHash" : "2e0896tc694efpi63ro75505lld", + "predicateName" : "m#Stmt::Stmt::getChild#dispred#f0820431#bff", + "appearsAs" : { + "m#Stmt::Stmt::getChild#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:13,3-17,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1650, + "dependencies" : { + "stmts_10#join_rhs" : "cc41237e8dcp25luvv67lgoqq8e" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[10]", + " {1} r2 = JOIN r1 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = CONSTANT(unique int)[16]", + " {1} r4 = JOIN r3 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r5 = r2 UNION r4", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1650, -1, 1, 0, -1, 1650 ], + "duplicationPercentages" : [ 0, 4, -1, 0, 0, -1, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.757Z", + "raHash" : "2ad5a3d3qiinsaohskpjaukpt18", + "predicateName" : "varbind_10#join_rhs", + "appearsAs" : { + "varbind_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:159,1-180,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 40, + "resultSize" : 98988, + "dependencies" : { + "varbind" : "b770b3dd00tr01siqj3tgilh4q2" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN varbind OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 98988 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.757Z", + "raHash" : "09ba37hdbvn6mrcg0v2v4u0l6u5", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#join_rhs", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 41, + "resultSize" : 7512, + "dependencies" : { + "Element::ElementBase::toString#dispred#f0820431#ff#max_range" : "1df09bupo7ee66hd8ohvvl0rfke", + "Element::ElementBase::toString#dispred#f0820431#ff#max_term" : "c04edck1e6ps6e2njri9ig4qa89" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = AGGREGATE Element::ElementBase::toString#dispred#f0820431#ff#max_range, Element::ElementBase::toString#dispred#f0820431#ff#max_term ON In.2 WITH MAX<0 ASC> OUTPUT In.0, Agg.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.789Z", + "raHash" : "6d5520630p5b5u45b23gi9u7f92", + "predicateName" : "Location::Location::fullLocationInfo#dispred#f0820431#ffffff", + "appearsAs" : { + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Location.qll:43,3-57,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 102, + "resultSize" : 286635, + "dependencies" : { + "locations_expr" : "e2f48di291bqfs3semk6idgdah5", + "locations_stmt" : "fc3124kl18bb1s5716r48kdu6fe", + "locations_default" : "b09bd3sc21dh83kqvf6jm5dauc6" + }, + "ra" : { + "pipeline" : [ + " {6} r1 = locations_stmt UNION locations_default", + "", + " {6} r2 = locations_expr UNION r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 135027, -1, 286635 ], + "duplicationPercentages" : [ 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.871Z", + "raHash" : "0efe9f74fl6nespncqphuoe7c18", + "predicateName" : "Access::VariableAccess#8878f617#f#antijoin_rhs", + "appearsAs" : { + "Access::VariableAccess#8878f617#f#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:71,3-73,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 128, + "resultSize" : 11864, + "dependencies" : { + "Access::VariableAccess#8878f617#f#shared" : "ceeef7apms3r48e6dnrgl38pl14", + "varbind" : "b770b3dd00tr01siqj3tgilh4q2", + "enumconstants" : "b687f43hut9uaipufkfb5ccnok4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Access::VariableAccess#8878f617#f#shared WITH varbind ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {1} r2 = JOIN r1 WITH enumconstants ON FIRST 1 OUTPUT Lhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 98988, 11864 ], + "duplicationPercentages" : [ 0, 5 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.875Z", + "raHash" : "254712uhiqai314msm7i8u9ilt7", + "predicateName" : "Expr::Expr::getChild#dispred#f0820431#bff", + "appearsAs" : { + "Expr::Expr::getChild#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:16,3-17,93", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 124, + "resultSize" : 373, + "dependencies" : { + "#select#query#fff" : "4178c1esvkmi0g23ntp2ouj1rp5", + "m#Expr::Expr::getChild#dispred#f0820431#bff" : "ea4ab1lijdb7t4upt2042dj08ne" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = SCAN #select#query#fff OUTPUT In.2, In.0, In.1", + " {3} r2 = JOIN r1 WITH m#Expr::Expr::getChild#dispred#f0820431#bff ON FIRST 1 OUTPUT Lhs.0, Lhs.2, Lhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 215686, 373 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.877Z", + "raHash" : "78c7f1v0e0qc2ihhi4blgpg0319", + "predicateName" : "Expr::Expr::getChild#dispred#f0820431#bff_10#join_rhs", + "appearsAs" : { + "Expr::Expr::getChild#dispred#f0820431#bff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:16,3-17,93", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 373, + "dependencies" : { + "Expr::Expr::getChild#dispred#f0820431#bff" : "254712uhiqai314msm7i8u9ilt7" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Expr::Expr::getChild#dispred#f0820431#bff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 373 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.877Z", + "raHash" : "d47667og0o89m3jgvvltqv7mj17", + "predicateName" : "Expr::Expr::getChild#dispred#f0820431#bff_02#count_range", + "appearsAs" : { + "Expr::Expr::getChild#dispred#f0820431#bff_02#count_range" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:1241,3-1242,53", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 373, + "dependencies" : { + "Expr::Expr::getChild#dispred#f0820431#bff" : "254712uhiqai314msm7i8u9ilt7" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Expr::Expr::getChild#dispred#f0820431#bff OUTPUT In.0, In.2", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 373 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.877Z", + "raHash" : "6c7824ks7qhqs1lnio52lbmd9ca", + "predicateName" : "Access::VariableAccess#8878f617#f", + "appearsAs" : { + "Access::VariableAccess#8878f617#f" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:71,3-73,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 5, + "resultSize" : 87124, + "dependencies" : { + "Access::VariableAccess#8878f617#f#shared" : "ceeef7apms3r48e6dnrgl38pl14", + "Access::VariableAccess#8878f617#f#antijoin_rhs" : "0efe9f74fl6nespncqphuoe7c18" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = Access::VariableAccess#8878f617#f#shared AND NOT Access::VariableAccess#8878f617#f#antijoin_rhs(Lhs.0)", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 87124 ], + "duplicationPercentages" : [ 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.877Z", + "raHash" : "d840783qk8c487j51clealt4oe0", + "predicateName" : "project#Expr::Expr::getChild#dispred#f0820431#bff#2", + "appearsAs" : { + "project#Expr::Expr::getChild#dispred#f0820431#bff#2" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:16,3-17,93", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 373, + "dependencies" : { + "Expr::Expr::getChild#dispred#f0820431#bff_10#join_rhs" : "78c7f1v0e0qc2ihhi4blgpg0319" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[0]", + " {1} r2 = JOIN r1 WITH Expr::Expr::getChild#dispred#f0820431#bff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 373 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.878Z", + "raHash" : "92831612lu6i3cfcdkrn19fkmga", + "predicateName" : "Expr::FoldExpr::isUnaryFold#dispred#f0820431#f#join_rhs", + "appearsAs" : { + "Expr::FoldExpr::isUnaryFold#dispred#f0820431#f#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:1241,3-1242,53", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 373, + "dependencies" : { + "Expr::Expr::getChild#dispred#f0820431#bff_02#count_range" : "d47667og0o89m3jgvvltqv7mj17" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = AGGREGATE Expr::Expr::getChild#dispred#f0820431#bff_02#count_range, Expr::Expr::getChild#dispred#f0820431#bff_02#count_range ON WITH COUNT OUTPUT In.0, Agg.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 373 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.880Z", + "raHash" : "c20d69aqet0d752bshconkqpse6", + "predicateName" : "Expr::FoldExpr::isUnaryFold#dispred#f0820431#f", + "appearsAs" : { + "Expr::FoldExpr::isUnaryFold#dispred#f0820431#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:1241,3-1242,53", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 0, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "Expr::FoldExpr::isUnaryFold#dispred#f0820431#f#join_rhs" : "92831612lu6i3cfcdkrn19fkmga" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[132]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r3 = JOIN r2 WITH Expr::FoldExpr::isUnaryFold#dispred#f0820431#f#join_rhs ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + " {2} r4 = SELECT r3 ON In.1 = 1", + " {1} r5 = SCAN r4 OUTPUT In.0", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0, 0, 0, 0 ], + "duplicationPercentages" : [ 0, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.902Z", + "raHash" : "4b4a07g94mu3p5loat8ja2np9d4", + "predicateName" : "Access::FieldAccess#class#8878f617#f", + "appearsAs" : { + "Access::FieldAccess#class#8878f617#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:159,1-180,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 25, + "resultSize" : 30745, + "dependencies" : { + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "Field::Field#class#1b3cf47e#f" : "61418129rsd6dv2t50bart37e00", + "varbind_10#join_rhs" : "2ad5a3d3qiinsaohskpjaukpt18", + "Access::VariableAccess#8878f617#f" : "6c7824ks7qhqs1lnio52lbmd9ca" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff OUTPUT In.1, In.0", + " {1} r2 = JOIN r1 WITH Field::Field#class#1b3cf47e#f ON FIRST 1 OUTPUT Lhs.1", + " {1} r3 = JOIN r2 WITH varbind_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r4 = JOIN r3 WITH Access::VariableAccess#8878f617#f ON FIRST 1 OUTPUT Lhs.0", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 15437, 1406, 30745, 30745 ], + "duplicationPercentages" : [ 0, 6, 3, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.907Z", + "raHash" : "14aff5sbhpvcv1sp16on7p4hj3c", + "predicateName" : "Stmt::Stmt::getChild#dispred#f0820431#bff", + "appearsAs" : { + "Stmt::Stmt::getChild#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:13,3-17,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 155, + "resultSize" : 1476, + "dependencies" : { + "#select#query#fff" : "4178c1esvkmi0g23ntp2ouj1rp5", + "m#Stmt::Stmt::getChild#dispred#f0820431#bff" : "2e0896tc694efpi63ro75505lld" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = SCAN #select#query#fff OUTPUT In.2, In.0, In.1", + " {3} r2 = JOIN r1 WITH m#Stmt::Stmt::getChild#dispred#f0820431#bff ON FIRST 1 OUTPUT Lhs.0, Lhs.2, Lhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 215686, 1476 ], + "duplicationPercentages" : [ 0, 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.909Z", + "raHash" : "c399196eu4dbmsntvo9puk0fhl0", + "predicateName" : "Stmt::Stmt::getChild#dispred#f0820431#bff_10#join_rhs", + "appearsAs" : { + "Stmt::Stmt::getChild#dispred#f0820431#bff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:13,3-17,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1476, + "dependencies" : { + "Stmt::Stmt::getChild#dispred#f0820431#bff" : "14aff5sbhpvcv1sp16on7p4hj3c" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Stmt::Stmt::getChild#dispred#f0820431#bff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1476 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.910Z", + "raHash" : "cc7752qqcgt16ld00fta2vvejob", + "predicateName" : "project#Stmt::Stmt::getChild#dispred#f0820431#bff#2", + "appearsAs" : { + "project#Stmt::Stmt::getChild#dispred#f0820431#bff#2" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:13,3-17,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 0, + "dependencies" : { + "Stmt::Stmt::getChild#dispred#f0820431#bff_10#join_rhs" : "c399196eu4dbmsntvo9puk0fhl0" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[1]", + " {1} r2 = JOIN r1 WITH Stmt::Stmt::getChild#dispred#f0820431#bff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.911Z", + "raHash" : "21d0ea27p4dhgb2vgpc1ilmb1ie", + "predicateName" : "project#Stmt::Stmt::getChild#dispred#f0820431#bff", + "appearsAs" : { + "project#Stmt::Stmt::getChild#dispred#f0820431#bff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:13,3-17,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1476, + "dependencies" : { + "Stmt::Stmt::getChild#dispred#f0820431#bff_10#join_rhs" : "c399196eu4dbmsntvo9puk0fhl0" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[0]", + " {1} r2 = JOIN r1 WITH Stmt::Stmt::getChild#dispred#f0820431#bff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1476 ], + "duplicationPercentages" : [ 0, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.913Z", + "raHash" : "49cab1qqt2maglgf6fjb6p6ls25", + "predicateName" : "Stmt::DefaultCase#class#af82e98b#f#antijoin_rhs", + "appearsAs" : { + "Stmt::DefaultCase#class#af82e98b#f#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:1474,1-1496,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 1476, + "dependencies" : { + "stmts_10#join_rhs" : "cc41237e8dcp25luvv67lgoqq8e", + "stmts" : "7a398429ti3kj9d80pf7drffoh1", + "project#Stmt::Stmt::getChild#dispred#f0820431#bff" : "21d0ea27p4dhgb2vgpc1ilmb1ie" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[10]", + " {2} r2 = JOIN r1 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, 10", + " {1} r3 = JOIN r2 WITH stmts ON FIRST 2 OUTPUT Lhs.0", + " {1} r4 = JOIN r3 WITH project#Stmt::Stmt::getChild#dispred#f0820431#bff ON FIRST 1 OUTPUT Lhs.0", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1650, 1650, 1476 ], + "duplicationPercentages" : [ 0, 0, 4, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.914Z", + "raHash" : "4e633c23bjs3d5ulii21tdha386", + "predicateName" : "Stmt::DefaultCase#class#af82e98b#f", + "appearsAs" : { + "Stmt::DefaultCase#class#af82e98b#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\stmts\\Stmt.qll:1474,1-1496,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 174, + "dependencies" : { + "stmts_10#join_rhs" : "cc41237e8dcp25luvv67lgoqq8e", + "Stmt::DefaultCase#class#af82e98b#f#antijoin_rhs" : "49cab1qqt2maglgf6fjb6p6ls25" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[10]", + " {1} r2 = JOIN r1 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r3 = r2 AND NOT Stmt::DefaultCase#class#af82e98b#f#antijoin_rhs(Lhs.0)", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1650, 174 ], + "duplicationPercentages" : [ 0, 4, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.954Z", + "raHash" : "b87812ldcv59610pagsgpencl54", + "predicateName" : "Expr::Expr::getParent#dispred#f0820431#ff", + "appearsAs" : { + "Expr::Expr::getParent#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + }, + "Expr::Expr::getParent#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:58,3-59,92", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 203, + "resultSize" : 215686, + "dependencies" : { + "#select#query#fff" : "4178c1esvkmi0g23ntp2ouj1rp5", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4", + "@variable#f" : "aeab1cjdifv15av5ftki3347nhe" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN #select#query#fff OUTPUT In.0, In.2", + " {2} r2 = r1 AND NOT usertypes_0#antijoin_rhs(Lhs.1)", + " {2} r3 = r2 AND NOT @variable#f(Lhs.1)", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 215686, 215686, 215686 ], + "duplicationPercentages" : [ 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.957Z", + "raHash" : "3f8cc8fgb85vh2vri36q5j6auo7", + "predicateName" : "Location::Location::fullLocationInfo#dispred#f0820431#ffffff_10#join_rhs", + "appearsAs" : { + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Location.qll:144,3-144,62", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 116, + "resultSize" : 286635, + "dependencies" : { + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff" : "6d5520630p5b5u45b23gi9u7f92" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Location::Location::fullLocationInfo#dispred#f0820431#ffffff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 286635 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.959Z", + "raHash" : "9b36f9o8fkl4fi2hmekj3fbrbbe", + "predicateName" : "Location::UnknownLocation#bd5c7591#b", + "appearsAs" : { + "Location::UnknownLocation#bd5c7591#b" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Location.qll:144,3-144,62", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 3, + "dependencies" : { + "files_10#join_rhs" : "60e29eg9c2egvhe5m7ja1nh2o1e", + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff_10#join_rhs" : "3f8cc8fgb85vh2vri36q5j6auo7" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique string)[\"\"]", + " {1} r2 = JOIN r1 WITH files_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r3 = JOIN r2 WITH Location::Location::fullLocationInfo#dispred#f0820431#ffffff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1, 3 ], + "duplicationPercentages" : [ 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.962Z", + "raHash" : "6f4f59bj9vut7sp2en8khtmpopc", + "predicateName" : "Location::UnknownExprLocation#class#bd5c7591#f", + "appearsAs" : { + "Location::UnknownExprLocation#class#bd5c7591#f" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Location.qll:155,1-162,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 1, + "dependencies" : { + "locations_expr_23450#join_rhs" : "0bc7abbb0b18lsmk0k0jr1hvdmb", + "Location::UnknownLocation#bd5c7591#b" : "9b36f9o8fkl4fi2hmekj3fbrbbe" + }, + "ra" : { + "pipeline" : [ + " {4} r1 = CONSTANT(unique int, int, int, int)[0,0,0,0]", + " {1} r2 = JOIN r1 WITH locations_expr_23450#join_rhs ON FIRST 4 OUTPUT Rhs.4", + " {1} r3 = JOIN r2 WITH Location::UnknownLocation#bd5c7591#b ON FIRST 1 OUTPUT Lhs.0", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 1, 1 ], + "duplicationPercentages" : [ 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.981Z", + "raHash" : "b11fae0m1nhm2vpfd3c7kopqcm4", + "predicateName" : "Access::VariableAccess::getTarget#f0820431#ff", + "appearsAs" : { + "Access::VariableAccess::getTarget#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5, 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:76,21-76,30", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 104, + "resultSize" : 87124, + "dependencies" : { + "varbind" : "b770b3dd00tr01siqj3tgilh4q2", + "Access::VariableAccess#8878f617#f" : "6c7824ks7qhqs1lnio52lbmd9ca", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN varbind WITH Access::VariableAccess#8878f617#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r2 = JOIN r1 WITH ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r3 = JOIN r2 WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 87124, 87124, 87124 ], + "duplicationPercentages" : [ 2, 2, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:28.995Z", + "raHash" : "f0b06f8fk4mv0b88tk0v2ilm9sb", + "predicateName" : "m#Expr::Expr::getEnclosingStmt#f0820431#bf", + "appearsAs" : { + "m#Expr::Expr::getEnclosingStmt#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:31,17-31,33", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_RECURSIVE", + "millis" : 18, + "predicateIterationMillis" : [ 1, 5, 3 ], + "deltaSizes" : [ 7512, 7512, 0 ], + "resultSize" : 15024, + "dependencies" : { + "project#Assignment::ConditionDeclExpr::getVariable#dispred#f0820431#ff" : "e5ec44m69hoonl7u2eevrs3db39", + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "Expr::Expr::getParent#dispred#f0820431#ff" : "b87812ldcv59610pagsgpencl54", + "exprconv_10#join_rhs" : "d60daaas71d07nq9hqbk1b2vkh4" + }, + "layerSize" : 1, + "ra" : { + "base" : [ + " {1} r1 = SCAN initialisers OUTPUT In.2", + "", + " {1} r2 = project#Assignment::ConditionDeclExpr::getVariable#dispred#f0820431#ff UNION r1", + " return r2" + ], + "standard" : [ + " {1} r1 = JOIN m#Expr::Expr::getEnclosingStmt#f0820431#bf#prev_delta WITH Expr::Expr::getParent#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r2 = JOIN m#Expr::Expr::getEnclosingStmt#f0820431#bf#prev_delta WITH exprconv_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = r1 UNION r2", + " {1} r4 = r3 AND NOT m#Expr::Expr::getEnclosingStmt#f0820431#bf#prev(Lhs.0)", + " return r4" + ], + "order_500000" : [ + " {1} r1 = JOIN m#Expr::Expr::getEnclosingStmt#f0820431#bf#prev_delta WITH Expr::Expr::getParent#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r2 = JOIN m#Expr::Expr::getEnclosingStmt#f0820431#bf#prev_delta WITH exprconv_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r3 = r1 UNION r2", + " {1} r4 = r3 AND NOT m#Expr::Expr::getEnclosingStmt#f0820431#bf#prev(Lhs.0)", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "base", + "counts" : [ 7512, -1, 7512 ], + "duplicationPercentages" : [ 0, -1, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 7512, -1, 0, -1, 7512, 7512 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.002Z", + "raHash" : "5e72e4gnhp6v4p0ro0e6ukqf0c9", + "predicateName" : "stmts_0#join_rhs", + "appearsAs" : { + "stmts_0#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:31,17-31,33", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 46015, + "dependencies" : { + "stmts" : "7a398429ti3kj9d80pf7drffoh1" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN stmts OUTPUT In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 46015 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.002Z", + "raHash" : "2e683dkvgehta6f7mr5g9q5vjn9", + "predicateName" : "Expr::Expr::getEnclosingStmt#f0820431#bf#join_rhs", + "appearsAs" : { + "Expr::Expr::getEnclosingStmt#f0820431#bf#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:31,17-31,33", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 7512, + "dependencies" : { + "Expr::Expr::getParent#dispred#f0820431#ff" : "b87812ldcv59610pagsgpencl54", + "m#Expr::Expr::getEnclosingStmt#f0820431#bf" : "f0b06f8fk4mv0b88tk0v2ilm9sb" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Expr::Expr::getParent#dispred#f0820431#ff WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.003Z", + "raHash" : "b1dd32c4c01vqhlm1s502565fj1", + "predicateName" : "stmt_decl_bind", + "appearsAs" : { + "stmt_decl_bind" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:1968,1-1972,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 5, + "resultSize" : 6215 +} + +{ + "completionTime" : "2022-08-10T21:28:29.006Z", + "raHash" : "a15139aoc237p3gs6eg8k2fbgp4", + "predicateName" : "stmt_decl_bind_20#join_rhs", + "appearsAs" : { + "stmt_decl_bind_20#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:31,17-31,33", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 6215, + "dependencies" : { + "stmt_decl_bind" : "b1dd32c4c01vqhlm1s502565fj1" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN stmt_decl_bind OUTPUT In.2, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 6215 ], + "duplicationPercentages" : [ 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.009Z", + "raHash" : "e87e08dq84ded1posds1f3lqvf8", + "predicateName" : "Variable::Variable::getInitializer#dispred#f0820431#fb", + "appearsAs" : { + "Variable::Variable::getInitializer#dispred#f0820431#fb" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:40,3-41,66", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 11, + "resultSize" : 4475, + "dependencies" : { + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "m#Expr::Expr::getEnclosingStmt#f0820431#bf" : "f0b06f8fk4mv0b88tk0v2ilm9sb", + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : "dcf789h5id6rmfuakkdfasd7ldf", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN initialisers OUTPUT In.2, In.0", + " {1} r2 = JOIN r1 WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.1", + " {2} r3 = JOIN r2 WITH Initializer::Initializer::getDeclaration#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512, 7512, 7512, 4475 ], + "duplicationPercentages" : [ 0, 0, 2, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.014Z", + "raHash" : "b8501c3sag5ljm62qp6tbv6qp59", + "predicateName" : "Variable::LocalVariable#class#7a968d4e#b", + "appearsAs" : { + "Variable::LocalVariable#class#7a968d4e#b" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Variable.qll:374,1-402,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 4363, + "dependencies" : { + "localvariables" : "111495kh3b6m9sku94i8oj4pqr3", + "Variable::Variable::getInitializer#dispred#f0820431#fb" : "e87e08dq84ded1posds1f3lqvf8", + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "m#Expr::Expr::getEnclosingStmt#f0820431#bf" : "f0b06f8fk4mv0b88tk0v2ilm9sb" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN localvariables OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " {2} r3 = JOIN r2 WITH Variable::Variable::getInitializer#dispred#f0820431#fb ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH initialisers ON FIRST 1 OUTPUT Rhs.2, Lhs.1", + " {1} r5 = JOIN r4 WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.1", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 6212, 6212, 4363, 4363, 4363 ], + "duplicationPercentages" : [ 0, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.021Z", + "raHash" : "1a7d5d6ra506jog8p2a089jpd4d", + "predicateName" : "Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + }, + "Expr::Expr::getParent#dispred#f0820431#bf_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:31,17-31,33", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 46, + "resultSize" : 215686, + "dependencies" : { + "Expr::Expr::getParent#dispred#f0820431#ff" : "b87812ldcv59610pagsgpencl54" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Expr::Expr::getParent#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 215686 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.039Z", + "raHash" : "575a28aqc1cl1507249fk98cfh7", + "predicateName" : "Expr::Expr::getEnclosingStmt#f0820431#bf", + "appearsAs" : { + "Expr::Expr::getEnclosingStmt#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:31,17-31,33", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_RECURSIVE", + "millis" : 17, + "predicateIterationMillis" : [ 11, 5 ], + "deltaSizes" : [ 4363, 0 ], + "resultSize" : 4363, + "dependencies" : { + "stmts_0#join_rhs" : "5e72e4gnhp6v4p0ro0e6ukqf0c9", + "Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs" : "1a7d5d6ra506jog8p2a089jpd4d", + "m#Expr::Expr::getEnclosingStmt#f0820431#bf" : "f0b06f8fk4mv0b88tk0v2ilm9sb", + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "Variable::LocalVariable#class#7a968d4e#b" : "b8501c3sag5ljm62qp6tbv6qp59", + "stmt_decl_bind_20#join_rhs" : "a15139aoc237p3gs6eg8k2fbgp4", + "stmts" : "7a398429ti3kj9d80pf7drffoh1", + "Variable::Variable::getInitializer#dispred#f0820431#fb" : "e87e08dq84ded1posds1f3lqvf8", + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "exprconv" : "ff49855htg34cr357mjg0pjpnpf", + "Assignment::ConditionDeclExpr::getVariable#dispred#f0820431#ff" : "063c5a8sileo3rh1ibl2hfc04k2", + "Expr::Expr::getEnclosingStmt#f0820431#bf#join_rhs" : "2e683dkvgehta6f7mr5g9q5vjn9", + "Expr::Expr::getEnclosingStmt#f0820431#bf#join_rhs#1" : "d4d64bg1c7m50vocm112khpj3n7" + }, + "layerSize" : 1, + "ra" : { + "base" : [ + " {2} r1 = JOIN stmts_0#join_rhs WITH Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r2 = JOIN r1 WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r3 = SCAN ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff OUTPUT In.1, In.0", + " {2} r4 = JOIN r3 WITH Variable::LocalVariable#class#7a968d4e#b ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r5 = JOIN r4 WITH stmt_decl_bind_20#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r6 = JOIN r5 WITH stmts ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r7 = JOIN r6 WITH Variable::Variable::getInitializer#dispred#f0820431#fb ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r8 = JOIN r7 WITH initialisers ON FIRST 1 OUTPUT Rhs.2, Lhs.1", + " {2} r9 = JOIN r8 WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r10 = r2 UNION r9", + " return r10" + ], + "standard" : [ + " {2} r1 = JOIN Expr::Expr::getEnclosingStmt#f0820431#bf#prev_delta WITH Expr::Expr::getEnclosingStmt#f0820431#bf#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " {2} r2 = JOIN r1 WITH stmts ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r3 = JOIN Expr::Expr::getEnclosingStmt#f0820431#bf#prev_delta WITH Expr::Expr::getEnclosingStmt#f0820431#bf#join_rhs#1 ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " {2} r4 = JOIN r3 WITH stmts ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r5 = SCAN Expr::Expr::getEnclosingStmt#f0820431#bf#prev_delta OUTPUT In.1, In.0", + " {2} r6 = JOIN r5 WITH stmts_0#join_rhs ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r7 = JOIN r6 WITH exprconv ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r8 = JOIN r7 WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r9 = r4 UNION r8", + " {2} r10 = r2 UNION r9", + " {2} r11 = r10 AND NOT Expr::Expr::getEnclosingStmt#f0820431#bf#prev(Lhs.0, Lhs.1)", + " return r11" + ], + "order_500000" : [ + " {2} r1 = SCAN Expr::Expr::getEnclosingStmt#f0820431#bf#prev_delta OUTPUT In.1, In.0", + " {2} r2 = JOIN r1 WITH stmts ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r3 = JOIN r2 WITH Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r4 = JOIN r3 WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r5 = JOIN r2 WITH exprconv ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r6 = JOIN r5 WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r7 = JOIN r2 WITH Assignment::ConditionDeclExpr::getVariable#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r8 = JOIN r7 WITH Variable::LocalVariable#class#7a968d4e#b ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " {2} r9 = JOIN r8 WITH Variable::Variable::getInitializer#dispred#f0820431#fb ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r10 = JOIN r9 WITH initialisers ON FIRST 1 OUTPUT Rhs.2, Lhs.1", + " {2} r11 = JOIN r10 WITH m#Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r12 = r6 UNION r11", + " {2} r13 = r4 UNION r12", + " {2} r14 = r13 AND NOT Expr::Expr::getEnclosingStmt#f0820431#bf#prev(Lhs.1, Lhs.0)", + " {2} r15 = SCAN r14 OUTPUT In.1, In.0", + " return r15" + ] + }, + "pipelineRuns" : [ { + "raReference" : "base", + "counts" : [ 28260, 0, -1, 15437, 4363, 4363, 4363, 4363, 4363, 4363, -1, 4363 ], + "duplicationPercentages" : [ 1, 0, -1, 0, 2, 0, 1, 0, 0, 0, -1, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 4363, 4363, -1, 6560, 0, -1, 2035, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0 ], + "duplicationPercentages" : [ 3, 0, -1, 1, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.044Z", + "raHash" : "8454ef6sh0k2r1c98bp3q18s44d", + "predicateName" : "Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff", + "appearsAs" : { + "Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Initializer.qll:53,3-53,82", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 4363, + "dependencies" : { + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "Expr::Expr::getEnclosingStmt#f0820431#bf" : "575a28aqc1cl1507249fk98cfh7" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN initialisers OUTPUT In.2, In.0", + " {2} r2 = JOIN r1 WITH Expr::Expr::getEnclosingStmt#f0820431#bf ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512, 4363 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.046Z", + "raHash" : "9aa1710n2hg2bq6707q1hr9opk5", + "predicateName" : "Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 4363, + "dependencies" : { + "Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff" : "8454ef6sh0k2r1c98bp3q18s44d" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4363 ], + "duplicationPercentages" : [ 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.047Z", + "raHash" : "3bc6ff96avek03b0hrogu7o3553", + "predicateName" : "project#Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff", + "appearsAs" : { + "project#Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Initializer.qll:53,3-53,82", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 4363, + "dependencies" : { + "Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff" : "8454ef6sh0k2r1c98bp3q18s44d" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4363, 4363 ], + "duplicationPercentages" : [ 1, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.051Z", + "raHash" : "0c8d97g3049hsqgr0t0prcrh8f8", + "predicateName" : "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs#1", + "appearsAs" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs#1" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 7, + "resultSize" : 4363, + "dependencies" : { + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff" : "8454ef6sh0k2r1c98bp3q18s44d" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN initialisers WITH Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.2", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4363 ], + "duplicationPercentages" : [ 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.052Z", + "raHash" : "4f2d2flhaf8532adgdehs6lonuf", + "predicateName" : "Enclosing::exprEnclosingElement#c50c5fbf#ff#shared", + "appearsAs" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff#shared" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 3149, + "dependencies" : { + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "project#Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff" : "3bc6ff96avek03b0hrogu7o3553" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN initialisers OUTPUT In.0, In.2", + " {2} r2 = r1 AND NOT project#Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff(Lhs.0)", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 7512, 3149 ], + "duplicationPercentages" : [ 0, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.100Z", + "raHash" : "eb9339l8tcoa3lnjiv3sbecff77", + "predicateName" : "Expr::Expr::getExprLocationOverride#f0820431#ff#join_rhs", + "appearsAs" : { + "Expr::Expr::getExprLocationOverride#f0820431#ff#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:73,20-73,43", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 125, + "resultSize" : 6617, + "dependencies" : { + "exprs" : "56ea56nfg1f2tdlq3h1ierbst3a", + "Location::UnknownExprLocation#class#bd5c7591#f" : "6f4f59bj9vut7sp2en8khtmpopc", + "Expr::Expr::getParent#dispred#f0820431#bf" : "b87812ldcv59610pagsgpencl54" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN exprs OUTPUT In.2, In.0", + " {1} r2 = JOIN r1 WITH Location::UnknownExprLocation#class#bd5c7591#f ON FIRST 1 OUTPUT Lhs.1", + " {2} r3 = JOIN r2 WITH Expr::Expr::getParent#dispred#f0820431#bf ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 324197, 6617, 6617 ], + "duplicationPercentages" : [ 0, 0, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.107Z", + "raHash" : "978dcfcsotu251da1rb1t4ivgl9", + "predicateName" : "Expr::Expr::getExprLocationOverride#f0820431#ff", + "appearsAs" : { + "Expr::Expr::getExprLocationOverride#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:73,20-73,43", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_RECURSIVE", + "millis" : 6, + "predicateIterationMillis" : [ 3, 1, 1, 0 ], + "deltaSizes" : [ 3462, 571, 6, 0 ], + "resultSize" : 4039, + "dependencies" : { + "Expr::Expr::getExprLocationOverride#f0820431#ff#join_rhs" : "eb9339l8tcoa3lnjiv3sbecff77", + "exprs" : "56ea56nfg1f2tdlq3h1ierbst3a", + "Location::UnknownLocation#bd5c7591#b" : "9b36f9o8fkl4fi2hmekj3fbrbbe", + "Expr::Expr::getParent#dispred#f0820431#bf_10#join_rhs" : "1a7d5d6ra506jog8p2a089jpd4d", + "Location::UnknownExprLocation#class#bd5c7591#f" : "6f4f59bj9vut7sp2en8khtmpopc" + }, + "layerSize" : 1, + "ra" : { + "base" : [ + " {2} r1 = JOIN Expr::Expr::getExprLocationOverride#f0820431#ff#join_rhs WITH exprs ON FIRST 1 OUTPUT Lhs.1, Rhs.2", + " {2} r2 = r1 AND NOT Location::UnknownLocation#bd5c7591#b(Lhs.1)", + " return r2" + ], + "standard" : [ + " {2} r1 = JOIN Expr::Expr::getExprLocationOverride#f0820431#ff#prev_delta WITH Expr::Expr::getExprLocationOverride#f0820431#ff#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r2 = r1 AND NOT Expr::Expr::getExprLocationOverride#f0820431#ff#prev(Lhs.0, Lhs.1)", + " return r2" + ], + "order_317" : [ + " {2} r1 = JOIN Expr::Expr::getExprLocationOverride#f0820431#ff#prev_delta WITH Expr::Expr::getParent#dispred#f0820431#bf_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " {2} r2 = r1 AND NOT Expr::Expr::getExprLocationOverride#f0820431#ff#prev(Lhs.1, Lhs.0)", + " {2} r3 = SCAN r2 OUTPUT In.1, In.0", + " {3} r4 = JOIN r3 WITH exprs ON FIRST 1 OUTPUT Rhs.2, Lhs.1, Lhs.0", + " {2} r5 = JOIN r4 WITH Location::UnknownExprLocation#class#bd5c7591#f ON FIRST 1 OUTPUT Lhs.2, Lhs.1", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "base", + "counts" : [ 4039, 3462 ], + "duplicationPercentages" : [ 1, 0 ] + }, { + "raReference" : "standard", + "counts" : [ 571, 571 ], + "duplicationPercentages" : [ 3, 3 ] + }, { + "raReference" : "standard", + "counts" : [ 6, 6 ], + "duplicationPercentages" : [ 0, 0 ] + }, { + "raReference" : "order_317", + "counts" : [ 0, 0, 0, 0, 0 ], + "duplicationPercentages" : [ 0, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.110Z", + "raHash" : "a36325or20dbpc2932t03tdsk4d", + "predicateName" : "project#Expr::Expr::getExprLocationOverride#f0820431#ff", + "appearsAs" : { + "project#Expr::Expr::getExprLocationOverride#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:73,20-73,43", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 4039, + "dependencies" : { + "Expr::Expr::getExprLocationOverride#f0820431#ff" : "978dcfcsotu251da1rb1t4ivgl9" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Expr::Expr::getExprLocationOverride#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4039, 4039 ], + "duplicationPercentages" : [ 1, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.132Z", + "raHash" : "94c3a9eh7irma0p01pv6r76f0g3", + "predicateName" : "Access::Access::getTarget#dispred#f0820431#ff", + "appearsAs" : { + "Access::Access::getTarget#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:19,3-20,37", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 149, + "resultSize" : 98988, + "dependencies" : { + "Access::VariableAccess::getTarget#f0820431#ff" : "b11fae0m1nhm2vpfd3c7kopqcm4", + "Access::FieldAccess#class#8878f617#f" : "4b4a07g94mu3p5loat8ja2np9d4", + "Field::Field#class#1b3cf47e#f" : "61418129rsd6dv2t50bart37e00", + "enumconstants" : "b687f43hut9uaipufkfb5ccnok4", + "varbind_10#join_rhs" : "2ad5a3d3qiinsaohskpjaukpt18", + "Access::Access#8878f617#f" : "9023ecvvpdea7mk4fksi1080kgc", + "varbind" : "b770b3dd00tr01siqj3tgilh4q2" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Access::VariableAccess::getTarget#f0820431#ff AND NOT Access::FieldAccess#class#8878f617#f(Lhs.0)", + "", + " {2} r2 = SCAN Access::VariableAccess::getTarget#f0820431#ff OUTPUT In.1, In.0", + " {2} r3 = JOIN r2 WITH Field::Field#class#1b3cf47e#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH Access::FieldAccess#class#8878f617#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {1} r5 = SCAN enumconstants OUTPUT In.0", + " {2} r6 = JOIN r5 WITH varbind_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r7 = JOIN r6 WITH Access::Access#8878f617#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + " {3} r8 = JOIN r7 WITH varbind ON FIRST 1 OUTPUT Rhs.1, Lhs.1, Lhs.0", + " {2} r9 = JOIN r8 WITH enumconstants ON FIRST 1 OUTPUT Lhs.2, Lhs.1", + "", + " {2} r10 = r4 UNION r9", + " {2} r11 = r1 UNION r10", + " return r11" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 56379, -1, 87124, 30745, 30745, -1, 2325, 11864, 11864, 11864, 11864, -1, 42609, 98988 ], + "duplicationPercentages" : [ 0, -1, 2, 4, 4, -1, 0, 1, 1, 6, 1, -1, 1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.162Z", + "raHash" : "041df63fgpb7j4ofhusq62n1gl2", + "predicateName" : "Expr::Expr::getLocation#dispred#f0820431#ff", + "appearsAs" : { + "Expr::Expr::getLocation#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:61,3-67,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 52, + "resultSize" : 324197, + "dependencies" : { + "Expr::Expr::getExprLocationOverride#f0820431#ff" : "978dcfcsotu251da1rb1t4ivgl9", + "exprs" : "56ea56nfg1f2tdlq3h1ierbst3a", + "project#Expr::Expr::getExprLocationOverride#f0820431#ff" : "a36325or20dbpc2932t03tdsk4d" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN exprs OUTPUT In.0, In.2", + " {2} r2 = r1 AND NOT project#Expr::Expr::getExprLocationOverride#f0820431#ff(Lhs.0)", + "", + " {2} r3 = Expr::Expr::getExprLocationOverride#f0820431#ff UNION r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 324197, 320158, -1, 324197 ], + "duplicationPercentages" : [ 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.169Z", + "raHash" : "d0d06dqe96t5etn4om3i3giqahc", + "predicateName" : "Access::Access::getTarget#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Access::Access::getTarget#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 35, + "resultSize" : 98988, + "dependencies" : { + "Access::Access::getTarget#dispred#f0820431#ff" : "94c3a9eh7irma0p01pv6r76f0g3" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Access::Access::getTarget#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 98988 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.191Z", + "raHash" : "19535911mdou7hg6sn2ptfta050", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 57, + "resultSize" : 87124, + "dependencies" : { + "Access::VariableAccess#8878f617#f" : "6c7824ks7qhqs1lnio52lbmd9ca", + "Access::Access::getTarget#dispred#f0820431#ff" : "94c3a9eh7irma0p01pv6r76f0g3", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Access::VariableAccess#8878f617#f WITH Access::Access::getTarget#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {1} r2 = JOIN r1 WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 87124, 87124 ], + "duplicationPercentages" : [ 2, 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.246Z", + "raHash" : "6860a8b89m36f4jr2l8jne7t9p4", + "predicateName" : "Expr::Expr::getLocation#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Expr::Expr::getLocation#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 44, + "resultSize" : 324197, + "dependencies" : { + "Expr::Expr::getLocation#dispred#f0820431#ff" : "041df63fgpb7j4ofhusq62n1gl2" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Expr::Expr::getLocation#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 324197 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.253Z", + "raHash" : "886634bqhnmvsa25bgll315i24f", + "predicateName" : "Expr::Expr::getType#f0820431#ff", + "appearsAs" : { + "Expr::Expr::getType#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:103,8-103,15", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 820, + "resultSize" : 324197, + "dependencies" : { + "expr_types" : "2277b7soiij7vlul6o9sjs4o1la", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN expr_types OUTPUT In.1, In.0", + " {2} r2 = JOIN r1 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r3 = JOIN r2 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {3} r4 = SCAN expr_types OUTPUT In.1, In.0, In.1", + " {3} r5 = JOIN r4 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + " {3} r6 = r5 AND NOT usertypes_0#antijoin_rhs(Lhs.2)", + " {2} r7 = SCAN r6 OUTPUT In.0, In.2", + "", + " {2} r8 = r3 UNION r7", + " return r8" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 324197, 93396, 93396, -1, 324197, 324197, 230801, 230801, -1, 324197 ], + "duplicationPercentages" : [ 7, 1, 3, -1, 0, 0, 1, 0, -1, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.277Z", + "raHash" : "b9c1182vjr3e0736juh4m6hbo07", + "predicateName" : "Type::DerivedType#class#2e8eb3ef#f", + "appearsAs" : { + "Type::DerivedType#class#2e8eb3ef#f" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:1058,1-1089,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 2349, + "dependencies" : { + "derivedtypes" : "8dfb6bscm7bke1cl6illlc7u8k4", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN derivedtypes WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2349 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.277Z", + "raHash" : "8133d8m907hv222h0anift35l99", + "predicateName" : "TypedefType::TypedefType#class#2045b2ea#f", + "appearsAs" : { + "TypedefType::TypedefType#class#2045b2ea#f" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\TypedefType.qll:8,1-51,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 454, + "dependencies" : { + "usertypes_20#join_rhs" : "2e3e1ad1ra485cdgeblnafjpie3", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[5]", + " {1} r2 = JOIN r1 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r3 = JOIN r2 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r4 = CONSTANT(unique int)[14]", + " {1} r5 = JOIN r4 WITH usertypes_20#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r6 = JOIN r5 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0", + "", + " {1} r7 = r3 UNION r6", + " return r7" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 454, 454, -1, 1, 0, 0, -1, 454 ], + "duplicationPercentages" : [ 0, 1, 1, -1, 0, 0, 0, -1, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.278Z", + "raHash" : "2824beqfldtpvbcln1lv0i82g32", + "predicateName" : "Type::Type_not_Decltype_DerivedType_TypedefType#f", + "appearsAs" : { + "Type::Type_not_Decltype_DerivedType_TypedefType#f" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:14,7-14,11", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1644, + "dependencies" : { + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "Type::Decltype#class#2e8eb3ef#f" : "63e0f8t7frfetpoef5aopc8mn8e", + "Type::DerivedType#class#2e8eb3ef#f" : "b9c1182vjr3e0736juh4m6hbo07", + "TypedefType::TypedefType#class#2045b2ea#f" : "8133d8m907hv222h0anift35l99" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = ResolveClass::Cached::isType#eb2868f4#f AND NOT Type::Decltype#class#2e8eb3ef#f(Lhs.0)", + " {1} r2 = r1 AND NOT Type::DerivedType#class#2e8eb3ef#f(Lhs.0)", + " {1} r3 = r2 AND NOT TypedefType::TypedefType#class#2045b2ea#f(Lhs.0)", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 4447, 2098, 1644 ], + "duplicationPercentages" : [ 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.282Z", + "raHash" : "f909e739mec42s4p2ii1sn5orec", + "predicateName" : "typedefbase", + "appearsAs" : { + "typedefbase" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmlecode.cpp.dbscheme:640,1-643,3", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "EXTENSIONAL", + "millis" : 2, + "resultSize" : 454 +} + +{ + "completionTime" : "2022-08-10T21:28:29.283Z", + "raHash" : "abfc6bk25taqc51rjhr6rrp1kab", + "predicateName" : "Type::DerivedType::getBaseType#dispred#f0820431#ff", + "appearsAs" : { + "Type::DerivedType::getBaseType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:1074,3-1080,95", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 2349, + "dependencies" : { + "derivedtypes" : "8dfb6bscm7bke1cl6illlc7u8k4", + "Type::DerivedType#class#2e8eb3ef#f" : "b9c1182vjr3e0736juh4m6hbo07", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN derivedtypes OUTPUT In.0, In.3", + "", + " {2} r2 = JOIN r1 WITH Type::DerivedType#class#2e8eb3ef#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r3 = JOIN r2 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r4 = JOIN r3 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {3} r5 = JOIN r1 WITH Type::DerivedType#class#2e8eb3ef#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0, Lhs.1", + " {3} r6 = JOIN r5 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + " {3} r7 = r6 AND NOT usertypes_0#antijoin_rhs(Lhs.2)", + " {2} r8 = SCAN r7 OUTPUT In.0, In.2", + "", + " {2} r9 = r4 UNION r8", + " return r9" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2349, -1, 2349, 533, 533, -1, 2349, 2347, 1816, 1816, -1, 2349 ], + "duplicationPercentages" : [ 0, -1, 0, 0, 0, -1, 0, 1, 0, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.284Z", + "raHash" : "db2a292ejtna0c844frehukvgab", + "predicateName" : "TypedefType::TypedefType::getBaseType#dispred#f0820431#ff", + "appearsAs" : { + "TypedefType::TypedefType::getBaseType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\TypedefType.qll:21,3-24,88", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 454, + "dependencies" : { + "typedefbase" : "f909e739mec42s4p2ii1sn5orec", + "TypedefType::TypedefType#class#2045b2ea#f" : "8133d8m907hv222h0anift35l99", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN typedefbase WITH TypedefType::TypedefType#class#2045b2ea#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r2 = JOIN r1 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r3 = JOIN r2 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {3} r4 = JOIN typedefbase WITH TypedefType::TypedefType#class#2045b2ea#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0, Lhs.1", + " {3} r5 = JOIN r4 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.0", + " {3} r6 = r5 AND NOT usertypes_0#antijoin_rhs(Lhs.2)", + " {2} r7 = SCAN r6 OUTPUT In.0, In.2", + "", + " {2} r8 = r3 UNION r7", + " return r8" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 454, 321, 321, -1, 454, 454, 133, 133, -1, 454 ], + "duplicationPercentages" : [ 0, 0, 2, -1, 1, 2, 1, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.284Z", + "raHash" : "358bd51ijrrq5cgr5r3k71lqti5", + "predicateName" : "Type::DerivedType::getBaseType#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Type::DerivedType::getBaseType#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:285,3-289,37", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 2349, + "dependencies" : { + "Type::DerivedType::getBaseType#dispred#f0820431#ff" : "abfc6bk25taqc51rjhr6rrp1kab" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Type::DerivedType::getBaseType#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 2349 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.285Z", + "raHash" : "a6c653skbqq85bse9qq2h21hso5", + "predicateName" : "TypedefType::TypedefType::getBaseType#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "TypedefType::TypedefType::getBaseType#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:285,3-289,37", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 454, + "dependencies" : { + "TypedefType::TypedefType::getBaseType#dispred#f0820431#ff" : "db2a292ejtna0c844frehukvgab" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN TypedefType::TypedefType::getBaseType#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 454 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.302Z", + "raHash" : "da2866f8dijb0303nddciekf6g9", + "predicateName" : "Type::Type::stripType#dispred#f0820431#ff", + "appearsAs" : { + "Type::Type::stripType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Type.qll:285,3-289,37", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_RECURSIVE", + "millis" : 16, + "predicateIterationMillis" : [ 0, 1, 2, 2, 2, 2, 1 ], + "deltaSizes" : [ 1644, 1988, 438, 213, 155, 9, 0 ], + "resultSize" : 4447, + "dependencies" : { + "Type::Type_not_Decltype_DerivedType_TypedefType#f" : "2824beqfldtpvbcln1lv0i82g32", + "Type::Decltype::getBaseType#dispred#f0820431#ff_10#join_rhs" : "7ea6advk0g0us46c3vohu4ko9q1", + "TypedefType::TypedefType::getBaseType#dispred#f0820431#ff_10#join_rhs" : "a6c653skbqq85bse9qq2h21hso5", + "Type::DerivedType::getBaseType#dispred#f0820431#ff_10#join_rhs" : "358bd51ijrrq5cgr5r3k71lqti5" + }, + "layerSize" : 1, + "ra" : { + "base" : [ + " {2} r1 = SCAN Type::Type_not_Decltype_DerivedType_TypedefType#f OUTPUT In.0, In.0", + " return r1" + ], + "standard" : [ + " {2} r1 = JOIN Type::Type::stripType#dispred#f0820431#ff#prev_delta WITH Type::Decltype::getBaseType#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r2 = JOIN Type::Type::stripType#dispred#f0820431#ff#prev_delta WITH TypedefType::TypedefType::getBaseType#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r3 = JOIN Type::Type::stripType#dispred#f0820431#ff#prev_delta WITH Type::DerivedType::getBaseType#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r4 = r2 UNION r3", + " {2} r5 = r1 UNION r4", + " {2} r6 = r5 AND NOT Type::Type::stripType#dispred#f0820431#ff#prev(Lhs.0, Lhs.1)", + " return r6" + ], + "order_500000" : [ + " {2} r1 = JOIN Type::Type::stripType#dispred#f0820431#ff#prev_delta WITH Type::Decltype::getBaseType#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r2 = JOIN Type::Type::stripType#dispred#f0820431#ff#prev_delta WITH TypedefType::TypedefType::getBaseType#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r3 = JOIN Type::Type::stripType#dispred#f0820431#ff#prev_delta WITH Type::DerivedType::getBaseType#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r4 = r2 UNION r3", + " {2} r5 = r1 UNION r4", + " {2} r6 = r5 AND NOT Type::Type::stripType#dispred#f0820431#ff#prev(Lhs.1, Lhs.0)", + " {2} r7 = SCAN r6 OUTPUT In.1, In.0", + " return r7" + ] + }, + "pipelineRuns" : [ { + "raReference" : "base", + "counts" : [ 1644 ], + "duplicationPercentages" : [ 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 284, -1, 1704, -1, 1988, 1988, 1988, 1988 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, 0, 4 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 115, -1, 323, -1, 438, 438, 438, 438 ], + "duplicationPercentages" : [ 0, -1, 2, -1, 0, -1, 0, 0, 0, 1 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 53, -1, 160, -1, 213, 213, 213, 213 ], + "duplicationPercentages" : [ 0, -1, 1, -1, 0, -1, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 1, -1, 154, -1, 155, 155, 155, 155 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 1, 1, 1, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 1, -1, 8, -1, 9, 9, 9, 9 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, -1, 0, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.313Z", + "raHash" : "02405a7t7a5dsaieqdu8qrjjfk3", + "predicateName" : "Call::FunctionCall::getTargetType#dispred#f0820431#ff", + "appearsAs" : { + "Call::FunctionCall::getTargetType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Call.qll:220,3-225,69", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 10, + "resultSize" : 11571, + "dependencies" : { + "Call::FunctionCall#39248e3c#f" : "037922bo4sihit0bn09deleo59b", + "Expr::Expr::getType#f0820431#ff" : "886634bqhnmvsa25bgll315i24f", + "Type::Type::stripType#dispred#f0820431#ff" : "da2866f8dijb0303nddciekf6g9" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN Call::FunctionCall#39248e3c#f WITH Expr::Expr::getType#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r2 = JOIN r1 WITH Type::Type::stripType#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571, 11571 ], + "duplicationPercentages" : [ 2, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.323Z", + "raHash" : "affd1dvur1cmoda5lnbst5hkmq4", + "predicateName" : "m#Function::Function::getType#dispred#f0820431#bf#antijoin_rhs", + "appearsAs" : { + "m#Function::Function::getType#dispred#f0820431#bf#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Function.qll:168,3-169,93", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 9, + "resultSize" : 11571, + "dependencies" : { + "Call::FunctionCall::getTarget#dispred#f0820431#ff" : "c5f4afvmrcjddpv13ee094gq2a0", + "Call::FunctionCall::getTargetType#dispred#f0820431#ff" : "02405a7t7a5dsaieqdu8qrjjfk3", + "Type::RoutineType#class#2e8eb3ef#f" : "c28897b38t1afpec2hvnpfsfci5" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = JOIN Call::FunctionCall::getTarget#dispred#f0820431#ff WITH Call::FunctionCall::getTargetType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0, Lhs.1", + " {2} r2 = JOIN r1 WITH Type::RoutineType#class#2e8eb3ef#f ON FIRST 1 OUTPUT Lhs.1, Lhs.2", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 11571, 11571 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.326Z", + "raHash" : "4df8399q0hgqealbhpffeapqcqc", + "predicateName" : "m#Function::Function::getType#dispred#f0820431#bf#shared", + "appearsAs" : { + "m#Function::Function::getType#dispred#f0820431#bf#shared" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Function.qll:168,3-169,93", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 3, + "resultSize" : 0, + "dependencies" : { + "Call::FunctionCall::getTarget#dispred#f0820431#ff" : "c5f4afvmrcjddpv13ee094gq2a0", + "m#Function::Function::getType#dispred#f0820431#bf#antijoin_rhs" : "affd1dvur1cmoda5lnbst5hkmq4" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Call::FunctionCall::getTarget#dispred#f0820431#ff AND NOT m#Function::Function::getType#dispred#f0820431#bf#antijoin_rhs(Lhs.0, Lhs.1)", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 0 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.326Z", + "raHash" : "703da8kequl1cpdigf8v2kmj9d9", + "predicateName" : "m#Function::Function::getType#dispred#f0820431#bf", + "appearsAs" : { + "m#Function::Function::getType#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "4df8399q0hgqealbhpffeapqcqc" +} + +{ + "completionTime" : "2022-08-10T21:28:29.326Z", + "raHash" : "fb9d12mimts9qt3rcd2dc9ussoc", + "predicateName" : "Function::Function::getType#dispred#f0820431#bf", + "appearsAs" : { + "Function::Function::getType#dispred#f0820431#bf" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "evaluationStrategy" : "SENTINEL_EMPTY", + "sentinelRaHash" : "703da8kequl1cpdigf8v2kmj9d9" +} + +{ + "completionTime" : "2022-08-10T21:28:29.353Z", + "raHash" : "14d9670i5smssh3t5k6ueet9eg5", + "predicateName" : "Location::Location::fullLocationInfo#dispred#f0820431#ffffff_20#join_rhs", + "appearsAs" : { + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff_20#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 78, + "resultSize" : 286635, + "dependencies" : { + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff" : "6d5520630p5b5u45b23gi9u7f92" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Location::Location::fullLocationInfo#dispred#f0820431#ffffff OUTPUT In.2, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 286635 ], + "duplicationPercentages" : [ 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.356Z", + "raHash" : "6f0453459sc89dlagr7amfkvcce", + "predicateName" : "m#Class::Class::getCanonicalMember#dispred#f0820431#ffb", + "appearsAs" : { + "m#Class::Class::getCanonicalMember#dispred#f0820431#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:91,3-99,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1406, + "dependencies" : { + "membervariables" : "7c37bduotvpfjjrgej2r6r84p4b", + "Variable::TemplateVariable::getAnInstantiation#dispred#f0820431#ff" : "93c36db1lqpcr5p07djs9v77md7" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN membervariables OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + "", + " {2} r3 = SCAN Variable::TemplateVariable::getAnInstantiation#dispred#f0820431#ff OUTPUT In.1, In.0", + " {1} r4 = JOIN r3 WITH membervariables ON FIRST 1 OUTPUT Lhs.1", + "", + " {1} r5 = r2 UNION r4", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1412, 1406, -1, 0, 0, -1, 1406 ], + "duplicationPercentages" : [ 6, 6, -1, 0, 0, -1, 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.357Z", + "raHash" : "ed09e9ne4dsnr59ff38m8844a8c", + "predicateName" : "member_201#join_rhs", + "appearsAs" : { + "member_201#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:91,3-99,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1406, + "dependencies" : { + "member" : "8b3f22jtvpn0s9e0s4dgoden071" + }, + "ra" : { + "pipeline" : [ + " {3} r1 = SCAN member OUTPUT In.2, In.0, In.1", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.360Z", + "raHash" : "71e31fg0m2m83ss1mhfoea3ndd8", + "predicateName" : "Class::Class::getCanonicalMember#dispred#f0820431#ffb", + "appearsAs" : { + "Class::Class::getCanonicalMember#dispred#f0820431#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Class.qll:91,3-99,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 2, + "resultSize" : 1406, + "dependencies" : { + "ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff" : "da85a8769r62cskd8idv6dtinb2", + "m#Class::Class::getCanonicalMember#dispred#f0820431#ffb" : "6f0453459sc89dlagr7amfkvcce", + "member_201#join_rhs" : "ed09e9ne4dsnr59ff38m8844a8c", + "ResolveClass::Cached::isClass#eb2868f4#f" : "b11d6bcumifg21befashf33b4g3", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN ResolveGlobalVariable::Cached::resolveGlobalVariable#ac30c42f#ff OUTPUT In.1, In.0", + " {2} r2 = JOIN r1 WITH m#Class::Class::getCanonicalMember#dispred#f0820431#ffb ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {3} r3 = JOIN r2 WITH member_201#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1, Rhs.2", + " {3} r4 = JOIN r3 WITH ResolveClass::Cached::isClass#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1, Lhs.2", + " {3} r5 = JOIN r4 WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, Lhs.2, Lhs.1", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 15437, 1406, 1406, 1406, 1406 ], + "duplicationPercentages" : [ 0, 3, 6, 6, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.361Z", + "raHash" : "c0c64a91j0cp39tm570dftl1443", + "predicateName" : "project#Class::Class::getCanonicalMember#dispred#f0820431#ffb", + "appearsAs" : { + "project#Class::Class::getCanonicalMember#dispred#f0820431#ffb" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "evaluationStrategy" : "CACHACA", + "resultSize" : 1406 +} + +{ + "completionTime" : "2022-08-10T21:28:29.362Z", + "raHash" : "af0cf734sr9op66q1be4l0v548d", + "predicateName" : "Declaration::Declaration::isMember#dispred#f0820431#b", + "appearsAs" : { + "Declaration::Declaration::isMember#dispred#f0820431#b" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:211,3-212,51", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1406, + "dependencies" : { + "membervariables" : "7c37bduotvpfjjrgej2r6r84p4b", + "project#Class::Class::getCanonicalMember#dispred#f0820431#ffb" : "c0c64a91j0cp39tm570dftl1443", + "Variable::TemplateVariable::getAnInstantiation#dispred#f0820431#ff" : "93c36db1lqpcr5p07djs9v77md7" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN membervariables OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " {1} r3 = JOIN r2 WITH project#Class::Class::getCanonicalMember#dispred#f0820431#ffb ON FIRST 1 OUTPUT Lhs.0", + "", + " {2} r4 = SCAN Variable::TemplateVariable::getAnInstantiation#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r5 = JOIN r4 WITH membervariables ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {1} r6 = JOIN r5 WITH project#Class::Class::getCanonicalMember#dispred#f0820431#ffb ON FIRST 1 OUTPUT Lhs.1", + "", + " {1} r7 = r3 UNION r6", + " return r7" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1412, 1406, 1406, -1, 0, 0, 0, -1, 1406 ], + "duplicationPercentages" : [ 6, 6, 6, -1, 0, 0, 0, -1, 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.363Z", + "raHash" : "a403773kahm05ioedma7bpo3q45", + "predicateName" : "Field::Field#class#1b3cf47e#f", + "appearsAs" : { + "Field::Field#class#1b3cf47e#f" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Field.qll:8,1-78,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 1406, + "dependencies" : { + "Declaration::Declaration::isMember#dispred#f0820431#b" : "af0cf734sr9op66q1be4l0v548d", + "ResolveGlobalVariable::Cached::isVariable#ac30c42f#f" : "820e54uma8ge48bt57kubqkdag1", + "fieldoffsets" : "3040ee401amduqiuf7miko5gmt4" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = JOIN Declaration::Declaration::isMember#dispred#f0820431#b WITH ResolveGlobalVariable::Cached::isVariable#ac30c42f#f ON FIRST 1 OUTPUT Lhs.0", + " {1} r2 = JOIN r1 WITH fieldoffsets ON FIRST 1 OUTPUT Lhs.0", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1406, 1406 ], + "duplicationPercentages" : [ 6, 6 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.364Z", + "raHash" : "54ac48g5loptqat736je6vhaudb", + "predicateName" : "Access::FieldAccess#class#8878f617#f", + "appearsAs" : { + "Access::FieldAccess#class#8878f617#f" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "evaluationStrategy" : "CACHACA", + "resultSize" : 30745 +} + +{ + "completionTime" : "2022-08-10T21:28:29.370Z", + "raHash" : "3ea9494hepef6v35m3ma8o67t23", + "predicateName" : "Expr::Expr::getType#dispred#f0820431#ff", + "appearsAs" : { + "Expr::Expr::getType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:95,3-103,86", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 43, + "resultSize" : 324197, + "dependencies" : { + "Expr::Expr::getType#f0820431#ff" : "886634bqhnmvsa25bgll315i24f", + "Call::FunctionCall#39248e3c#f" : "037922bo4sihit0bn09deleo59b", + "m#Function::Function::getType#dispred#f0820431#bf#shared" : "4df8399q0hgqealbhpffeapqcqc", + "Function::Function::getType#dispred#f0820431#bf" : "fb9d12mimts9qt3rcd2dc9ussoc", + "Call::FunctionCall::getTargetType#dispred#f0820431#ff" : "02405a7t7a5dsaieqdu8qrjjfk3", + "Type::RoutineType#class#2e8eb3ef#f" : "c28897b38t1afpec2hvnpfsfci5", + "Type::RoutineType::getReturnType#dispred#f0820431#ff" : "b325f9lien7jldmkh4vm7621vf2" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Expr::Expr::getType#f0820431#ff AND NOT Call::FunctionCall#39248e3c#f(Lhs.0)", + "", + " {2} r2 = SCAN m#Function::Function::getType#dispred#f0820431#bf#shared OUTPUT In.1, In.0", + " {2} r3 = JOIN r2 WITH Function::Function::getType#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r4 = SCAN Call::FunctionCall::getTargetType#dispred#f0820431#ff OUTPUT In.1, In.0", + " {1} r5 = JOIN r4 WITH Type::RoutineType#class#2e8eb3ef#f ON FIRST 1 OUTPUT Lhs.1", + " {2} r6 = JOIN r5 WITH Call::FunctionCall::getTargetType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r7 = JOIN r6 WITH Type::RoutineType::getReturnType#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r8 = r3 UNION r7", + " {2} r9 = r1 UNION r8", + " return r9" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 312626, -1, 0, 0, -1, 11571, 11571, 11571, 11571, -1, 11571, 324197 ], + "duplicationPercentages" : [ 2, -1, 0, 0, -1, 0, 4, 0, 0, -1, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.411Z", + "raHash" : "6dc90aqk5vku7a2fpgr2jkjm4j0", + "predicateName" : "Access::Access::getTarget#dispred#f0820431#ff", + "appearsAs" : { + "Access::Access::getTarget#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Access.qll:19,3-20,37", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 47, + "resultSize" : 87124, + "dependencies" : { + "Access::VariableAccess::getTarget#f0820431#ff" : "b11fae0m1nhm2vpfd3c7kopqcm4", + "Access::FieldAccess#class#8878f617#f" : "54ac48g5loptqat736je6vhaudb", + "Field::Field#class#1b3cf47e#f" : "a403773kahm05ioedma7bpo3q45" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Access::VariableAccess::getTarget#f0820431#ff AND NOT Access::FieldAccess#class#8878f617#f(Lhs.0)", + "", + " {2} r2 = SCAN Access::VariableAccess::getTarget#f0820431#ff OUTPUT In.1, In.0", + " {2} r3 = JOIN r2 WITH Field::Field#class#1b3cf47e#f ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + " {2} r4 = JOIN r3 WITH Access::FieldAccess#class#8878f617#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r5 = r1 UNION r4", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 56379, -1, 87124, 30745, 30745, -1, 87124 ], + "duplicationPercentages" : [ 0, -1, 2, 4, 4, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.419Z", + "raHash" : "1ae02f23rs78s3gvpb2jmrne8m8", + "predicateName" : "Expr::Expr::getType#dispred#f0820431#ff", + "appearsAs" : { + "Expr::Expr::getType#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 4 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:95,3-103,86", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 324197 +} + +{ + "completionTime" : "2022-08-10T21:28:29.420Z", + "raHash" : "862b07qfrf3m6moglteimpc1710", + "predicateName" : "builtintypes_02#join_rhs", + "appearsAs" : { + "builtintypes_02#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:1174,1-1186,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 0, + "resultSize" : 47, + "dependencies" : { + "builtintypes" : "75ec32pgvetbmdlamosulu2rjef" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN builtintypes OUTPUT In.0, In.2", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 47 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.421Z", + "raHash" : "1c2060s53er0h6k102em1iioq44", + "predicateName" : "Lambda::Closure#class#ea6054ce#f", + "appearsAs" : { + "Lambda::Closure#class#ea6054ce#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Lambda.qll:70,1-94,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 0, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "Expr::Expr::getType#dispred#f0820431#ff" : "1ae02f23rs78s3gvpb2jmrne8m8", + "Class::Class#bacd9b46#f" : "f6e9b02njp6rh9im38j6aidq5fc" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[215]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {1} r3 = JOIN r2 WITH Expr::Expr::getType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1", + " {1} r4 = JOIN r3 WITH Class::Class#bacd9b46#f ON FIRST 1 OUTPUT Lhs.0", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.421Z", + "raHash" : "7576becg99af7cng39cod5ibqpd", + "predicateName" : "Expr::ReThrowExpr#class#ef463c5d#f", + "appearsAs" : { + "Expr::ReThrowExpr#class#ef463c5d#f" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:1174,1-1186,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 1, + "resultSize" : 0, + "dependencies" : { + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "Expr::Expr::getType#dispred#f0820431#ff" : "1ae02f23rs78s3gvpb2jmrne8m8", + "builtintypes_02#join_rhs" : "862b07qfrf3m6moglteimpc1710" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = CONSTANT(unique int)[89]", + " {1} r2 = JOIN r1 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {3} r3 = JOIN r2 WITH Expr::Expr::getType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, 3, Lhs.0", + " {1} r4 = JOIN r3 WITH builtintypes_02#join_rhs ON FIRST 2 OUTPUT Lhs.2", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.425Z", + "raHash" : "4c332bkfos27hgbf9tsroa7vel9", + "predicateName" : "Declaration::Declaration::getDescription#dispred#f0820431#ff", + "appearsAs" : { + "Declaration::Declaration::getDescription#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Declaration.qll:105,3-108,54", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 4, + "resultSize" : 22356, + "dependencies" : { + "Declaration::Declaration::getName#dispred#f0820431#ff" : "7c75c6rdrqj3nai1vpr5l66v9t2", + "Lambda::Closure#class#ea6054ce#f" : "1c2060s53er0h6k102em1iioq44" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Declaration::Declaration::getName#dispred#f0820431#ff AND NOT Lambda::Closure#class#ea6054ce#f(Lhs.0)", + "", + " {2} r2 = SCAN Lambda::Closure#class#ea6054ce#f OUTPUT In.0, \"decltype([...](...){...})\"", + "", + " {2} r3 = r1 UNION r2", + " return r3" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 22356, -1, 0, -1, 22356 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.437Z", + "raHash" : "dcb7b0m1btie36sq0vskchcvepa", + "predicateName" : "Access::Access::getTarget#dispred#f0820431#ff_10#join_rhs", + "appearsAs" : { + "Access::Access::getTarget#dispred#f0820431#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 24, + "resultSize" : 87124, + "dependencies" : { + "Access::Access::getTarget#dispred#f0820431#ff" : "6dc90aqk5vku7a2fpgr2jkjm4j0" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Access::Access::getTarget#dispred#f0820431#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 87124 ], + "duplicationPercentages" : [ 2 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.631Z", + "raHash" : "7cc60xtoigvl1lheqqa12d8fmi4", + "predicateName" : "Enclosing::stmtEnclosingElement#c50c5fbf#ff", + "appearsAs" : { + "Enclosing::stmtEnclosingElement#c50c5fbf#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:7,1-15,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_RECURSIVE", + "millis" : 577, + "predicateIterationMillis" : [ 1, 14, 5, 5, 5, 5, 4, 4, 6, 3, 4, 5, 3, 2, 1, 4, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1 ], + "deltaSizes" : [ 2487, 13165, 4072, 6273, 5173, 3625, 3055, 2250, 1821, 1226, 1057, 681, 353, 273, 202, 135, 86, 41, 21, 4, 3, 2, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + "resultSize" : 46015, + "dependencies" : { + "function_entry_point" : "b48c04c2s0mmnmg7q1fev8k54d8", + "stmtparents_20#join_rhs" : "d7f752hpjaoouf507s2s4hs39ec", + "functions" : "a7bb44o93bk5d64edin5qq128r0", + "Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs" : "1a7d5d6ra506jog8p2a089jpd4d", + "Enclosing::exprEnclosingElement#c50c5fbf#ff#shared" : "4f2d2flhaf8532adgdehs6lonuf", + "Enclosing::exprEnclosingElement#c50c5fbf#ff#antijoin_rhs" : "a57c8f33nr7iluhu9q40na76305", + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff" : "dcf789h5id6rmfuakkdfasd7ldf", + "Parameter::Parameter::getFunction#dispred#f0820431#bf" : "54b3a2mr9cbb6od7v65400c1407", + "expr_ancestor" : "4590572fcfvn8d9ukg7kmiigb24", + "Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb_1#antijoin_rhs" : "e8cb85hfaacsp54kv4ahf3psr78", + "Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#bf" : "df7d4cm0530dpn7gltrte6te2b2", + "expr_ancestor_10#join_rhs" : "64953d3ql9fvegp8lv2q4lt4fd0", + "Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb" : "505e6ea2mhjek37vqvqrs427hbe", + "exprconv" : "ff49855htg34cr357mjg0pjpnpf", + "Cast::Conversion#class#1f33e835#b" : "b23ff24ork1iapti8d3463nckq6", + "Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff_10#join_rhs" : "9aa1710n2hg2bq6707q1hr9opk5", + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs#2" : "68001b2olgt0tikfpqi95jkjtk7", + "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs#1" : "0c8d97g3049hsqgr0t0prcrh8f8", + "Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs" : "a42d37dob7favvo6k41oe3k1hre" + }, + "layerSize" : 2, + "ra" : { + "base" : [ + " {2} r1 = SCAN function_entry_point OUTPUT In.1, In.0", + " return r1" + ], + "standard" : [ + " {2} r1 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH stmtparents_20#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r2 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#prev_delta WITH stmtparents_20#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r3 = r1 UNION r2", + " {2} r4 = r3 AND NOT Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev(Lhs.0, Lhs.1)", + " return r4" + ], + "order_500000" : [ + " {2} r1 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH stmtparents_20#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r2 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#prev_delta WITH stmtparents_20#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r3 = r1 UNION r2", + " {2} r4 = r3 AND NOT Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev(Lhs.1, Lhs.0)", + " {2} r5 = SCAN r4 OUTPUT In.1, In.0", + " return r5" + ] + }, + "pipelineRuns" : [ { + "raReference" : "base", + "counts" : [ 2487 ], + "duplicationPercentages" : [ 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 13165, -1, 0, -1, 13165, 13165, 13165 ], + "duplicationPercentages" : [ 2, -1, 0, -1, 2, 2, 6 ] + }, { + "raReference" : "order_500000", + "counts" : [ 4072, -1, 0, -1, 4072, 4072, 4072 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 1 ] + }, { + "raReference" : "order_500000", + "counts" : [ 6273, -1, 0, -1, 6273, 6273, 6273 ], + "duplicationPercentages" : [ 2, -1, 0, -1, 2, 2, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 5172, -1, 1, -1, 5173, 5173, 5173 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 4 ] + }, { + "raReference" : "order_500000", + "counts" : [ 3625, -1, 0, -1, 3625, 3625, 3625 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 3053, -1, 2, -1, 3055, 3055, 3055 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 2250, -1, 0, -1, 2250, 2250, 2250 ], + "duplicationPercentages" : [ 5, -1, 0, -1, 5, 5, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 1821, -1, 0, -1, 1821, 1821, 1821 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 1226, -1, 0, -1, 1226, 1226, 1226 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 1057, -1, 0, -1, 1057, 1057, 1057 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 681, -1, 0, -1, 681, 681, 681 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 353, -1, 0, -1, 353, 353, 353 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 273, -1, 0, -1, 273, 273, 273 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 202, -1, 0, -1, 202, 202, 202 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 135, -1, 0, -1, 135, 135, 135 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 5 ] + }, { + "raReference" : "order_500000", + "counts" : [ 86, -1, 0, -1, 86, 86, 86 ], + "duplicationPercentages" : [ 5, -1, 0, -1, 5, 5, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 41, -1, 0, -1, 41, 41, 41 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 6 ] + }, { + "raReference" : "order_500000", + "counts" : [ 21, -1, 0, -1, 21, 21, 21 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 4, -1, 0, -1, 4, 4, 4 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 3, -1, 0, -1, 3, 3, 3 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 2, -1, 0, -1, 2, 2, 2 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 10, -1, 0, -1, 10, 10, 10 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 11 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.631Z", + "raHash" : "7cc60wtoigvl1lheqqa12d8fmi4", + "predicateName" : "Enclosing::exprEnclosingElement#c50c5fbf#ff", + "appearsAs" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "IN_LAYER", + "predicateIterationMillis" : [ 5, 4, 12, 19, 28, 25, 24, 17, 23, 21, 18, 16, 18, 10, 8, 12, 7, 8, 4, 4, 4, 2, 2, 3, 1, 2, 1, 2, 1, 3, 1, 1 ], + "deltaSizes" : [ 3184, 3271, 14718, 26207, 30980, 34117, 34060, 31345, 28047, 23856, 20663, 17059, 13919, 10742, 8288, 6373, 4823, 3413, 2451, 1642, 1059, 595, 342, 223, 145, 103, 65, 32, 20, 11, 1, 0 ], + "resultSize" : 321754, + "mainHash" : "7cc60xtoigvl1lheqqa12d8fmi4", + "ra" : { + "base" : [ + " {2} r1 = JOIN functions WITH Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + "", + " {2} r2 = Enclosing::exprEnclosingElement#c50c5fbf#ff#shared AND NOT Enclosing::exprEnclosingElement#c50c5fbf#ff#antijoin_rhs(Lhs.0, Lhs.1)", + " {2} r3 = JOIN r2 WITH Initializer::Initializer::getDeclaration#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r4 = r1 UNION r3", + "", + " {2} r5 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#antijoin_rhs WITH Initializer::Initializer::getDeclaration#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r6 = JOIN r5 WITH Parameter::Parameter::getFunction#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r7 = expr_ancestor AND NOT Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb_1#antijoin_rhs(Lhs.1)", + " {2} r8 = SCAN r7 OUTPUT In.1, In.0", + " {2} r9 = JOIN r8 WITH Declaration::DeclarationEntry::getDeclaration#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r10 = r6 UNION r9", + " {2} r11 = r4 UNION r10", + " return r11" + ], + "standard" : [ + " {2} r1 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r2 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs#2 ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r3 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH expr_ancestor_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r4 = r2 UNION r3", + " {2} r5 = r1 UNION r4", + "", + " {2} r6 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs#1 ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r7 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#prev_delta WITH Enclosing::exprEnclosingElement#c50c5fbf#ff#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r8 = r6 UNION r7", + "", + " {2} r9 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#prev_delta WITH Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r10 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#prev_delta WITH expr_ancestor_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {2} r11 = r9 UNION r10", + " {2} r12 = r8 UNION r11", + " {2} r13 = r5 UNION r12", + " {2} r14 = r13 AND NOT Enclosing::exprEnclosingElement#c50c5fbf#ff#prev(Lhs.0, Lhs.1)", + " return r14" + ], + "order_500000" : [ + " {2} r1 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r2 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH expr_ancestor_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r3 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#prev_delta WITH Expr::Expr::getParent#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r4 = r2 UNION r3", + " {2} r5 = r1 UNION r4", + "", + " {2} r6 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#prev_delta WITH expr_ancestor_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r7 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH Stmt::DeclStmt::getADeclarationEntry#dispred#f0820431#fb ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r8 = JOIN r7 WITH expr_ancestor_10#join_rhs ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r9 = r6 UNION r8", + "", + " {2} r10 = JOIN Enclosing::exprEnclosingElement#c50c5fbf#ff#prev_delta WITH exprconv ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r11 = JOIN r10 WITH Cast::Conversion#class#1f33e835#b ON FIRST 1 OUTPUT Lhs.1, Lhs.0", + "", + " {2} r12 = JOIN Enclosing::stmtEnclosingElement#c50c5fbf#ff#prev_delta WITH Initializer::Initializer::getEnclosingStmt#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {2} r13 = JOIN r12 WITH initialisers ON FIRST 1 OUTPUT Lhs.1, Rhs.2", + "", + " {2} r14 = r11 UNION r13", + " {2} r15 = r9 UNION r14", + " {2} r16 = r5 UNION r15", + " {2} r17 = r16 AND NOT Enclosing::exprEnclosingElement#c50c5fbf#ff#prev(Lhs.1, Lhs.0)", + " {2} r18 = SCAN r17 OUTPUT In.1, In.0", + " return r18" + ] + }, + "pipelineRuns" : [ { + "raReference" : "base", + "counts" : [ 0, -1, 3149, 3149, -1, 3149, -1, 0, 0, -1, 35, 35, 35, -1, 35, 3184 ], + "duplicationPercentages" : [ 0, -1, 1, 0, -1, 0, -1, 0, 0, -1, 1, 0, 1, -1, 1, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 3138, -1, 3138, 3138, -1, 0, -1, 0, 0, -1, 0, -1, 133, 133, -1, 0, 0, -1, 133, 133, 3271, 3271, 3271 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 1 ] + }, { + "raReference" : "order_500000", + "counts" : [ 8765, -1, 0, -1, 1589, -1, 1589, 10354, -1, 0, -1, 54, 54, -1, 54, -1, 2124, 2124, -1, 2186, 2186, -1, 4310, 4364, 14718, 14718, 14718 ], + "duplicationPercentages" : [ 2, -1, 0, -1, 3, -1, 3, 2, -1, 0, -1, 1, 0, -1, 0, -1, 1, 0, -1, 0, 6, -1, 5, 5, 5, 5, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 2013, -1, 0, -1, 19950, -1, 19950, 21963, -1, 0, -1, 2, 2, -1, 2, -1, 4146, 4146, -1, 96, 96, -1, 4242, 4244, 26207, 26207, 26207 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 1, -1, 1, 2, -1, 0, -1, 0, 0, -1, 0, -1, 4, 0, -1, 0, 2, -1, 0, 0, 2, 2, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 4573, -1, 0, -1, 17908, -1, 17908, 22481, -1, 0, -1, 10, 10, -1, 10, -1, 7631, 7631, -1, 858, 858, -1, 8489, 8499, 30980, 30980, 30980 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 1, -1, 1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 5, 2, -1, 0, 0, -1, 3, 3, 1, 1, 1 ] + }, { + "raReference" : "order_500000", + "counts" : [ 3273, -1, 0, -1, 21293, -1, 21293, 24566, -1, 0, -1, 1, 1, -1, 1, -1, 9366, 9366, -1, 184, 184, -1, 9550, 9551, 34117, 34117, 34117 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 1, -1, 1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 1, -1, 1, 1, 0, 0, 3 ] + }, { + "raReference" : "order_500000", + "counts" : [ 2438, -1, 0, -1, 20194, -1, 20194, 22632, -1, 0, -1, 2, 2, -1, 2, -1, 11095, 11095, -1, 331, 331, -1, 11426, 11428, 34060, 34060, 34060 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 1, -1, 0, 0, 1, 1, 1 ] + }, { + "raReference" : "order_500000", + "counts" : [ 2054, -1, 0, -1, 18109, -1, 18109, 20163, -1, 0, -1, 1, 1, -1, 1, -1, 11036, 11036, -1, 145, 145, -1, 11181, 11182, 31345, 31345, 31345 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 2, -1, 0, 2, -1, 1, 1, 1, 1, 4 ] + }, { + "raReference" : "order_500000", + "counts" : [ 1433, -1, 0, -1, 15682, -1, 15682, 17115, -1, 0, -1, 4, 4, -1, 4, -1, 10775, 10775, -1, 153, 153, -1, 10928, 10932, 28047, 28047, 28047 ], + "duplicationPercentages" : [ 5, -1, 0, -1, 4, -1, 4, 4, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 2, 3, -1, 0, 0, 3, 3, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 1152, -1, 0, -1, 13030, -1, 13030, 14182, -1, 0, -1, 4, 4, -1, 4, -1, 9546, 9546, -1, 124, 124, -1, 9670, 9674, 23856, 23856, 23856 ], + "duplicationPercentages" : [ 2, -1, 0, -1, 3, -1, 3, 4, -1, 0, -1, 0, 0, -1, 0, -1, 0, 4, -1, 2, 3, -1, 4, 4, 11, 11, 5 ] + }, { + "raReference" : "order_500000", + "counts" : [ 754, -1, 0, -1, 11072, -1, 11072, 11826, -1, 0, -1, 0, 0, -1, 0, -1, 8743, 8743, -1, 94, 94, -1, 8837, 8837, 20663, 20663, 20663 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 1, -1, 0, -1, 0, 0, -1, 0, -1, 0, 2, -1, 2, 0, -1, 1, 1, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 681, -1, 0, -1, 8997, -1, 8997, 9678, -1, 0, -1, 1, 1, -1, 1, -1, 7329, 7329, -1, 51, 51, -1, 7380, 7381, 17059, 17059, 17059 ], + "duplicationPercentages" : [ 2, -1, 0, -1, 4, -1, 4, 4, -1, 0, -1, 0, 0, -1, 0, -1, 2, 0, -1, 0, 0, -1, 0, 0, 3, 3, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 410, -1, 0, -1, 7187, -1, 7187, 7597, -1, 0, -1, 1, 1, -1, 1, -1, 6254, 6254, -1, 67, 67, -1, 6321, 6322, 13919, 13919, 13919 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 5, 0, -1, 0, 5, -1, 0, 0, 0, 0, 1 ] + }, { + "raReference" : "order_500000", + "counts" : [ 220, -1, 0, -1, 5536, -1, 5536, 5756, -1, 0, -1, 0, 0, -1, 0, -1, 4967, 4967, -1, 19, 19, -1, 4986, 4986, 10742, 10742, 10742 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 1, -1, 1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 177, -1, 0, -1, 4122, -1, 4122, 4299, -1, 0, -1, 0, 0, -1, 0, -1, 3965, 3965, -1, 24, 24, -1, 3989, 3989, 8288, 8288, 8288 ], + "duplicationPercentages" : [ 8, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 2, -1, 8, 0, -1, 3, 3, 1, 1, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 118, -1, 0, -1, 3157, -1, 3157, 3275, -1, 0, -1, 0, 0, -1, 0, -1, 3084, 3084, -1, 14, 14, -1, 3098, 3098, 6373, 6373, 6373 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 2, -1, 2, 2, -1, 0, -1, 0, 0, -1, 0, -1, 0, 1, -1, 0, 7, -1, 1, 1, 2, 2, 3 ] + }, { + "raReference" : "order_500000", + "counts" : [ 97, -1, 0, -1, 2336, -1, 2336, 2433, -1, 0, -1, 0, 0, -1, 0, -1, 2385, 2385, -1, 5, 5, -1, 2390, 2390, 4823, 4823, 4823 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 52, -1, 0, -1, 1797, -1, 1797, 1849, -1, 0, -1, 0, 0, -1, 0, -1, 1559, 1559, -1, 5, 5, -1, 1564, 1564, 3413, 3413, 3413 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 1, -1, 1, 2, -1, 0, -1, 0, 0, -1, 0, -1, 4, 0, -1, 0, 0, -1, 0, 0, 3, 3, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 24, -1, 0, -1, 1268, -1, 1268, 1292, -1, 0, -1, 0, 0, -1, 0, -1, 1156, 1156, -1, 3, 3, -1, 1159, 1159, 2451, 2451, 2451 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 1, -1, 1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 15, -1, 0, -1, 850, -1, 850, 865, -1, 0, -1, 0, 0, -1, 0, -1, 776, 776, -1, 1, 1, -1, 777, 777, 1642, 1642, 1642 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 3 ] + }, { + "raReference" : "order_500000", + "counts" : [ 2, -1, 0, -1, 580, -1, 580, 582, -1, 0, -1, 0, 0, -1, 0, -1, 476, 476, -1, 1, 1, -1, 477, 477, 1059, 1059, 1059 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 2, -1, 0, 0, -1, 2, 2, 2, 2, 1 ] + }, { + "raReference" : "order_500000", + "counts" : [ 3, -1, 0, -1, 308, -1, 308, 311, -1, 0, -1, 0, 0, -1, 0, -1, 284, 284, -1, 0, 0, -1, 284, 284, 595, 595, 595 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 2, -1, 2, 3, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 190, -1, 190, 190, -1, 0, -1, 0, 0, -1, 0, -1, 152, 152, -1, 0, 0, -1, 152, 152, 342, 342, 342 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 2, -1, 2, 2, -1, 0, -1, 0, 0, -1, 0, -1, 0, 3, -1, 0, 0, -1, 3, 3, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 6, -1, 0, -1, 125, -1, 125, 131, -1, 0, -1, 0, 0, -1, 0, -1, 90, 90, -1, 2, 2, -1, 92, 92, 223, 223, 223 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 93, -1, 93, 93, -1, 0, -1, 0, 0, -1, 0, -1, 52, 52, -1, 0, 0, -1, 52, 52, 145, 145, 145 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 3 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 64, -1, 64, 64, -1, 0, -1, 0, 0, -1, 0, -1, 39, 39, -1, 0, 0, -1, 39, 39, 103, 103, 103 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 3, 3, -1, 0, 0, -1, 3, 3, 1, 1, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 38, -1, 38, 38, -1, 0, -1, 0, 0, -1, 0, -1, 27, 27, -1, 0, 0, -1, 27, 27, 65, 65, 65 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 16, -1, 16, 16, -1, 0, -1, 0, 0, -1, 0, -1, 16, 16, -1, 0, 0, -1, 16, 16, 32, 32, 32 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 6, 0, -1, 0, 0, -1, 0, 0, 2, 2, 2 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 11, -1, 11, 11, -1, 0, -1, 0, 0, -1, 0, -1, 9, 9, -1, 0, 0, -1, 9, 9, 20, 20, 20 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 5, -1, 5, 5, -1, 0, -1, 0, 0, -1, 0, -1, 6, 6, -1, 0, 0, -1, 6, 6, 11, 11, 11 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 1, -1, 1, 1, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 1, 1, 1 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + }, { + "raReference" : "order_500000", + "counts" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.649Z", + "raHash" : "fd1337kifdpgvg9q03mekjie7d0", + "predicateName" : "Enclosing::exprEnclosingElement#c50c5fbf#ff", + "appearsAs" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:17,1-63,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 321754 +} + +{ + "completionTime" : "2022-08-10T21:28:29.649Z", + "raHash" : "e7653cb4j2r0o7urf9q56gk2vrd", + "predicateName" : "Enclosing::stmtEnclosingElement#c50c5fbf#ff", + "appearsAs" : { + "Enclosing::stmtEnclosingElement#c50c5fbf#ff" : { + "BadAdditionOverflowCheck.ql" : [ 3 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Enclosing.qll:7,1-15,2", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 0, + "resultSize" : 46015 +} + +{ + "completionTime" : "2022-08-10T21:28:29.688Z", + "raHash" : "e3bec7911anup42u55r5fnu6q3a", + "predicateName" : "Enclosing::exprEnclosingElement#c50c5fbf#ff_10#join_rhs", + "appearsAs" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff_10#join_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:25,3-26,74", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 38, + "resultSize" : 321754, + "dependencies" : { + "Enclosing::exprEnclosingElement#c50c5fbf#ff" : "fd1337kifdpgvg9q03mekjie7d0" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Enclosing::exprEnclosingElement#c50c5fbf#ff OUTPUT In.1, In.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 321754 ], + "duplicationPercentages" : [ 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:29.755Z", + "raHash" : "a416d2f4hjco4oha1vjcfqculq5", + "predicateName" : "Expr::Expr::getEnclosingFunction#dispred#f0820431#ff", + "appearsAs" : { + "Expr::Expr::getEnclosingFunction#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\exprs\\Expr.qll:25,3-26,74", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 67, + "resultSize" : 304526, + "dependencies" : { + "functions" : "a7bb44o93bk5d64edin5qq128r0", + "Enclosing::exprEnclosingElement#c50c5fbf#ff_10#join_rhs" : "e3bec7911anup42u55r5fnu6q3a" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN functions WITH Enclosing::exprEnclosingElement#c50c5fbf#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 304526 ], + "duplicationPercentages" : [ 4 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:30.005Z", + "raHash" : "55ddfc21rhjqi8lf8rhkpfl1dg8", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 575, + "resultSize" : 529724, + "dependencies" : { + "Type::DerivedType::getName#dispred#f0820431#ff" : "4773123to6rq2m662d9guv6kgp8", + "Type::BuiltInType::getName#dispred#f0820431#ff" : "e7f9a01c1msggqhhikklo0pdhr2", + "Declaration::Declaration::getDescription#dispred#f0820431#ff" : "4c332bkfos27hgbf9tsroa7vel9", + "Namespace::Namespace::getFriendlyName#dispred#f0820431#ff" : "d03d3a4c88ofr5ctj9n4i7ra3e4", + "File::Container::toString#f0820431#ff" : "f619196et831u782kri8f1e92qc", + "files_0#antijoin_rhs" : "316d2bvq9gc8l3gu5gqstr5d7l4", + "Type::PointerToMemberType#class#2e8eb3ef#f" : "c755fct9r1fc560s7fqd0ts6dp0", + "specifiers" : "4020f4d16rf6lcptf7bb3of07r8", + "Type::RoutineType#class#2e8eb3ef#f" : "c28897b38t1afpec2hvnpfsfci5", + "param_decl_bind_0#antijoin_rhs" : "76251fa7llqs6brv1h2spucduv7", + "Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff" : "a33c4en26qbqh4pdg1bb6bjret2", + "Stmt::DefaultCase#class#af82e98b#f" : "4e633c23bjs3d5ulii21tdha386", + "comments" : "5aefd6p057qvie5nbj3umh56100", + "XML::XMLFile#class#cb4732a3#f" : "377c43fu61ive1afshapc50grk4", + "files" : "7f5fb8keqhfuljbsrqi6cka5a1f", + "Expr::UnaryOperation#class#ef463c5d#f" : "5a0c76g3ooo66qcd3nbb1f1pird", + "Expr::Operation::getOperator#dispred#f0820431#ff" : "ee038856qvvv8j0hq5a3ukvanb6", + "diagnostics" : "a154fejk0bt293sdhr9g2jmjjec", + "stmts_10#join_rhs" : "cc41237e8dcp25luvv67lgoqq8e", + "exprs_10#join_rhs" : "3530b97bsqv6mvmi2rtlmksnvvc", + "Include::Include#class#feab3531#f#antijoin_rhs" : "beecd6738kc8m60pu8t0d11pore", + "Include::Include::getIncludeText#dispred#f0820431#ff" : "6b0274766b43hptkbrj5a18g49b", + "Expr::ReThrowExpr#class#ef463c5d#f" : "7576becg99af7cng39cod5ibqpd", + "project#decltypes" : "1fd97cs69091peoj31jgk2dl1p7", + "ResolveClass::Cached::isType#eb2868f4#f" : "34c70bu24f3qru86sj48qiih5d9", + "preprocdirects_10#join_rhs" : "28baa7haapfunikslgv7o507ut3", + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs" : "19535911mdou7hg6sn2ptfta050", + "Access::Access::getTarget#dispred#f0820431#ff" : "94c3a9eh7irma0p01pv6r76f0g3", + "Variable::Variable::getName#dispred#f0820431#ff" : "9020ccncme1vn8gftlc348ilbv2", + "code_block" : "92a2f8hcollo3fb0eu1ufbh8fp7", + "Assignment::AssignOperation#class#9d5edc7a#f" : "c7d2da60ir6lc2tt26iq650i259", + "Expr::BinaryOperation#class#ef463c5d#f" : "c4f76binsl1psrlucid4idavdq4", + "Namespace::UsingDeclarationEntry::getDeclaration#dispred#f0820431#ff" : "bdc64501hni80d8onb6vvo5b33d", + "Include::Include#class#feab3531#f#antijoin_rhs#1" : "be7e81fg31h0iqfctbj95ig6i2d", + "attributes" : "dadb21ho5uvf9obbobs26ksqg29", + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#1" : "4545fafjnspbjqno642udv7it0a", + "specialnamequalifyingelements" : "381468i4ncf462h2to5m7bf3mg3", + "Access::FunctionAccess#class#8878f617#f" : "177860qn18ruruq5js662948lt4", + "Access::FunctionAccess::getTarget#dispred#f0820431#ff_0#antijoin_rhs" : "8494f6llfo6bg6jo8ct14r27s16", + "Access::VariableAccess#8878f617#f" : "6c7824ks7qhqs1lnio52lbmd9ca", + "Macro::Macro::getHead#dispred#f0820431#ff" : "3078ad36ujp52jqnbt1g2n5t5dd", + "Macro::Macro::getBody#dispred#f0820431#ff" : "53f3bfvkvtrloq2kj50bh0oi2gc", + "derivations" : "447923iinm6l2kruaksrq3faq39", + "enumconstants" : "b687f43hut9uaipufkfb5ccnok4", + "Access::Access::getTarget#dispred#f0820431#ff_10#join_rhs" : "d0d06dqe96t5etn4om3i3giqahc", + "attributes_10#join_rhs" : "27699f98g7217nfv55t6sqbefbf", + "Element::ElementBase::toString#dispred#f0820431#ff#shared#2" : "27c8c1dcq39mrl2s05gje3qc74c", + "Element::ElementBase::toString#dispred#f0820431#ff#join_rhs" : "09ba37hdbvn6mrcg0v2v4u0l6u5", + "Cast::SizeofTypeOperator::getTypeOperand#dispred#f0820431#ff" : "d1b01bjc2t7rp353m3lk73m0948", + "Type::Type::getName#dispred#f0820431#ff" : "eb8ebemc6a7n611tcuppt8sld23", + "Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf" : "0f7c33rvva1q5o73e7rmh846d8d", + "type_mentions" : "d61bf7n1gonre7hd42g75rkhc84", + "attribute_args_10#join_rhs" : "3be0580ld116n2jtjpgtodj45v1", + "Cast::AlignofTypeOperator::getTypeOperand#dispred#f0820431#ff" : "615b67vahla6to12d7mqk835an9", + "Access::FunctionAccess::getTarget#dispred#f0820431#ff" : "8adbef33nsct1qpanrmao8g8q90", + "functions" : "a7bb44o93bk5d64edin5qq128r0", + "namespace_decls" : "321806gb901anaoamipg3hn9dt2", + "macroinvocations" : "fd93fdj9jivr0o8sgd29ue1aova", + "code_block_0#antijoin_rhs" : "9c4b44m0ph92hj9qril4hm58eb6", + "Expr::Expr::getValue#dispred#f0820431#bf" : "2891548aljmvbffr00eismcu2ua", + "Namespace::UsingDirectiveEntry::getNamespace#dispred#f0820431#ff" : "ebff81qtem4jlutqeouq5foh2d8", + "lambda_capture" : "a91605j57d31u1f53jdg0vp6ngc", + "Variable::MemberVariable::getName#dispred#f0820431#ff" : "d5f8c1f1hmeek8bje16bgbp22q6", + "Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf_0#antijoin_rhs" : "6fcdc4ofh2j031br94ekahnsji1", + "Call::FunctionCall#39248e3c#f" : "c48684no3nchd22a8ib57flacc2", + "project#Call::FunctionCall::getTarget#dispred#f0820431#ff" : "357af4vm1crmtl701s0ep0422v9", + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#7" : "ef427dd6m7f8gupqpreoiuniag2", + "Expr::Expr::getType#dispred#f0820431#ff" : "1ae02f23rs78s3gvpb2jmrne8m8", + "project#Cast::UuidofOperator::getTypeOperand#dispred#f0820431#ff" : "695362sdf7semslhfvb41o5mfse", + "Call::FunctionCall::getTarget#dispred#f0820431#ff" : "e8d4d846dp19a31eq1rv27ab5g5", + "initialisers" : "d39cf8a1icrggbbc4g34qjqsqa1", + "Initializer::Initializer::getDeclaration#dispred#f0820431#ff_0#antijoin_rhs" : "3b7d11p4c4e9mvbu14hc5b84t0e", + "Call::ConstructorFieldInit::getTarget#dispred#f0820431#ff" : "7f608f4rhkk8pnspvoaidp9ldu6", + "project#Expr::Expr::getChild#dispred#f0820431#bff#2" : "d840783qk8c487j51clealt4oe0", + "Call::Call#39248e3c#f" : "9f11929rhe4jv95c7mekt8693kd", + "static_asserts" : "2b777ahnpqgcvabqcq3qi6583s7", + "Call::DestructorFieldDestruction::getTarget#dispred#f0820431#ff" : "a15b76ljum9c1cp2tkfnomn70e4", + "Expr::Expr::getValue#dispred#f0820431#bf_0#antijoin_rhs" : "7ff9e4mn9lid2jcetq2rtg51g2a", + "Cast::UuidofOperator::getTypeOperand#dispred#f0820431#ff" : "6e3f94vnihep78r66mkkqen5k65", + "project#Stmt::Stmt::getChild#dispred#f0820431#bff#2" : "cc7752qqcgt16ld00fta2vvejob", + "fold" : "d6a489c648m2p3ftr9nk05a9abe", + "Expr::FoldExpr::isUnaryFold#dispred#f0820431#f" : "c20d69aqet0d752bshconkqpse6", + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#6" : "cff297fj96ukkj18snt62ru1o59", + "fold_02#join_rhs" : "5ebe7fn38btf3r245ma4k40cnc7", + "namequalifiers" : "39c36b6ne5vccs9no9kbl54pon0", + "ResolveClass::Cached::resolveClass#eb2868f4#ff" : "6425a8tgaaqfsggujsb60fqkuqe", + "usertypes_0#antijoin_rhs" : "95da6cug8cip2m8k6s57qjd14p4", + "NameQualifiers::NameQualifyingElement::getName#dispred#f0820431#ff" : "ea2afe07afeq5c0qedoi4b2i8ca", + "Element::ElementBase::toString#dispred#f0820431#ff#shared#1" : "308849hf6k3tb7n8r58e6n3m98e", + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#5" : "8fb2f93mtv67r1k9oi1o5rghos3", + "var_decls" : "19e663f6klnnoolnln7bm5fsf2a", + "Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff" : "361324qac1tpovtfah7660phno8", + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#2" : "d77fc6ba27gauq3kreenvqgj01d", + "Specifier::AttributeArgument::getValueType#dispred#f0820431#ff" : "cbb16c2hhbfieedpmgdmhm535pb", + "attribute_arg_value" : "0ec74f4cf2b3ie74lkqi73h2s44", + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#3" : "b50f9eclrn7lcuaig2u6g3aha70", + "attribute_arg_name_0#antijoin_rhs" : "47ed22gl7uamt78e000q9ofcnp7", + "var_def" : "a427a78knumk074qs3frhkdcsl8", + "param_decl_bind" : "784ecebi2of8g6rj1mgiclc06l3", + "attribute_arg_name" : "cf4be9rr2lpb6fucbt8bi3ts4de", + "Declaration::DeclarationEntry::isDefinition#dispred#f0820431#f" : "4380772qdcpm8epl3n8qbdtp07c", + "Declaration::DeclarationEntry::getName#dispred#f0820431#ff" : "10891e0b6kqnofs5lijpa8n6uvb", + "Element::ElementBase::toString#dispred#f0820431#ff#shared" : "0aa1e6dnh37oq8rt0g3vvfk3hb1", + "Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#4" : "a84d43mi7q241i6vn9ee7r7jh68" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = Type::BuiltInType::getName#dispred#f0820431#ff UNION Declaration::Declaration::getDescription#dispred#f0820431#ff", + "", + " {2} r2 = Type::DerivedType::getName#dispred#f0820431#ff UNION r1", + "", + " {2} r3 = File::Container::toString#f0820431#ff AND NOT files_0#antijoin_rhs(Lhs.0)", + "", + " {2} r4 = SCAN Type::PointerToMemberType#class#2e8eb3ef#f OUTPUT In.0, \"..:: *\"", + "", + " {2} r5 = r3 UNION r4", + "", + " {2} r6 = Namespace::Namespace::getFriendlyName#dispred#f0820431#ff UNION r5", + " {2} r7 = r2 UNION r6", + "", + " {2} r8 = SCAN Type::RoutineType#class#2e8eb3ef#f OUTPUT In.0, \"..()(..)\"", + "", + " {2} r9 = JOIN param_decl_bind_0#antijoin_rhs WITH Variable::ParameterDeclarationEntry::getAnonymousParameterDescription#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r10 = r8 UNION r9", + "", + " {2} r11 = specifiers UNION r10", + "", + " {2} r12 = SCAN Stmt::DefaultCase#class#af82e98b#f OUTPUT In.0, \"default: \"", + "", + " {2} r13 = SCAN comments OUTPUT In.0, In.1", + "", + " {2} r14 = JOIN XML::XMLFile#class#cb4732a3#f WITH files ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r15 = r13 UNION r14", + " {2} r16 = r12 UNION r15", + " {2} r17 = r11 UNION r16", + " {2} r18 = r7 UNION r17", + "", + " {2} r19 = JOIN Expr::UnaryOperation#class#ef463c5d#f WITH Expr::Operation::getOperator#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (Rhs.1 ++ \" ...\")", + "", + " {2} r20 = SCAN diagnostics OUTPUT In.0, In.3", + "", + " {2} r21 = CONSTANT(int, unique string)[26,\";\"]", + " {2} r22 = JOIN r21 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \";\"", + "", + " {2} r23 = r20 UNION r22", + " {2} r24 = r19 UNION r23", + "", + " {1} r25 = files_0#antijoin_rhs AND NOT XML::XMLFile#class#cb4732a3#f(Lhs.0)", + " {2} r26 = JOIN r25 WITH File::Container::toString#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r27 = CONSTANT(int, unique string)[87,\"new\"]", + " {2} r28 = JOIN r27 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"new\"", + "", + " {2} r29 = JOIN Include::Include#class#feab3531#f#antijoin_rhs WITH Include::Include::getIncludeText#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"#import \" ++ Rhs.1)", + "", + " {2} r30 = r28 UNION r29", + " {2} r31 = r26 UNION r30", + " {2} r32 = r24 UNION r31", + "", + " {2} r33 = SCAN Expr::ReThrowExpr#class#ef463c5d#f OUTPUT In.0, \"re-throw exception \"", + "", + " {2} r34 = CONSTANT(int, unique string)[85,\"this\"]", + " {2} r35 = JOIN r34 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"this\"", + "", + " {2} r36 = JOIN project#decltypes WITH ResolveClass::Cached::isType#eb2868f4#f ON FIRST 1 OUTPUT Lhs.0, \"decltype(...)\"", + "", + " {2} r37 = r35 UNION r36", + " {2} r38 = r33 UNION r37", + "", + " {2} r39 = CONSTANT(int, unique string)[127,\"{...}\"]", + " {2} r40 = JOIN r39 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"{...}\"", + "", + " {2} r41 = CONSTANT(int, unique string)[4,\"#else\"]", + " {2} r42 = JOIN r41 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"#else\"", + "", + " {2} r43 = r40 UNION r42", + "", + " {2} r44 = CONSTANT(int, unique string)[12,\"(...)\"]", + " {2} r45 = JOIN r44 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"(...)\"", + "", + " {2} r46 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs WITH Access::Access::getTarget#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r47 = JOIN r46 WITH Variable::Variable::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r48 = r45 UNION r47", + " {2} r49 = r43 UNION r48", + " {2} r50 = r38 UNION r49", + " {2} r51 = r32 UNION r50", + " {2} r52 = r18 UNION r51", + "", + " {2} r53 = SCAN code_block OUTPUT In.0, \"^ { ... }\"", + "", + " {2} r54 = CONSTANT(unique int, unique string)[20,\"... ++\"]", + " {2} r55 = JOIN r54 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"... ++\"", + "", + " {2} r56 = CONSTANT(unique int, unique string)[21,\"... --\"]", + " {2} r57 = JOIN r56 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"... --\"", + "", + " {2} r58 = r55 UNION r57", + " {2} r59 = r53 UNION r58", + "", + " {2} r60 = CONSTANT(int, unique string)[88,\"delete\"]", + " {2} r61 = JOIN r60 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"delete\"", + "", + " {2} r62 = CONSTANT(int, unique string)[129,\"new[]\"]", + " {2} r63 = JOIN r62 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"new[]\"", + "", + " {2} r64 = CONSTANT(int, unique string)[5,\"#endif\"]", + " {2} r65 = JOIN r64 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"#endif\"", + "", + " {2} r66 = r63 UNION r65", + " {2} r67 = r61 UNION r66", + " {2} r68 = r59 UNION r67", + "", + " {2} r69 = CONSTANT(int, unique string)[28,\"break;\"]", + " {2} r70 = JOIN r69 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"break;\"", + "", + " {2} r71 = CONSTANT(int, unique string)[91,\"({...})\"]", + " {2} r72 = JOIN r71 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"({...})\"", + "", + " {2} r73 = CONSTANT(int, unique string)[217,\"__noop\"]", + " {2} r74 = JOIN r73 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__noop\"", + "", + " {2} r75 = r72 UNION r74", + " {2} r76 = r70 UNION r75", + "", + " {2} r77 = CONSTANT(int, unique string)[7,\"{ ... }\"]", + " {2} r78 = JOIN r77 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"{ ... }\"", + "", + " {2} r79 = JOIN Assignment::AssignOperation#class#9d5edc7a#f WITH Expr::Operation::getOperator#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"... \" ++ Rhs.1 ++ \" ...\")", + "", + " {2} r80 = JOIN Expr::BinaryOperation#class#ef463c5d#f WITH Expr::Operation::getOperator#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"... \" ++ Rhs.1 ++ \" ...\")", + "", + " {2} r81 = r79 UNION r80", + " {2} r82 = r78 UNION r81", + " {2} r83 = r76 UNION r82", + " {2} r84 = r68 UNION r83", + "", + " {2} r85 = SCAN Namespace::UsingDeclarationEntry::getDeclaration#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r86 = JOIN r85 WITH Declaration::Declaration::getDescription#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"using \" ++ Rhs.1)", + "", + " {2} r87 = CONSTANT(int, unique string)[116,\"__is_pod\"]", + " {2} r88 = JOIN r87 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_pod\"", + "", + " {2} r89 = CONSTANT(int, unique string)[1,\"ExprStmt\"]", + " {2} r90 = JOIN r89 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"ExprStmt\"", + "", + " {2} r91 = r88 UNION r90", + " {2} r92 = r86 UNION r91", + "", + " {2} r93 = CONSTANT(int, unique string)[4,\"goto ...\"]", + " {2} r94 = JOIN r93 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"goto ...\"", + "", + " {2} r95 = CONSTANT(int, unique string)[115,\"__is_enum\"]", + " {2} r96 = JOIN r95 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_enum\"", + "", + " {2} r97 = CONSTANT(int, unique string)[128,\"delete[]\"]", + " {2} r98 = JOIN r97 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"delete[]\"", + "", + " {2} r99 = r96 UNION r98", + " {2} r100 = r94 UNION r99", + " {2} r101 = r92 UNION r100", + "", + " {2} r102 = CONSTANT(int, unique string)[27,\"continue;\"]", + " {2} r103 = JOIN r102 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"continue;\"", + "", + " {2} r104 = CONSTANT(int, unique string)[33,\"\"]", + " {2} r105 = JOIN r104 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"\"", + "", + " {2} r106 = CONSTANT(int, unique string)[52,\"... = ...\"]", + " {2} r107 = JOIN r106 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"... = ...\"", + "", + " {2} r108 = r105 UNION r107", + " {2} r109 = r103 UNION r108", + "", + " {2} r110 = CONSTANT(int, unique string)[67,\"... , ...\"]", + " {2} r111 = JOIN r110 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"... , ...\"", + "", + " {2} r112 = JOIN Include::Include#class#feab3531#f#antijoin_rhs#1 WITH Include::Include::getIncludeText#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"#include_next \" ++ Rhs.1)", + "", + " {2} r113 = r111 UNION r112", + "", + " {2} r114 = SCAN attributes OUTPUT In.0, In.2", + " {2} r115 = r114 AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#1(Lhs.0)", + " {2} r116 = r115 UNION specialnamequalifyingelements", + " {2} r117 = r113 UNION r116", + " {2} r118 = r109 UNION r117", + " {2} r119 = r101 UNION r118", + " {2} r120 = r84 UNION r119", + " {2} r121 = r52 UNION r120", + "", + " {2} r122 = CONSTANT(int, unique string)[92,\"typeid ...\"]", + " {2} r123 = JOIN r122 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"typeid ...\"", + "", + " {2} r124 = CONSTANT(int, unique string)[101,\"__has_copy\"]", + " {2} r125 = JOIN r124 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_copy\"", + "", + " {2} r126 = CONSTANT(int, unique string)[112,\"__is_class\"]", + " {2} r127 = JOIN r126 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_class\"", + "", + " {2} r128 = r125 UNION r127", + " {2} r129 = r123 UNION r128", + "", + " {2} r130 = CONSTANT(int, unique string)[114,\"__is_empty\"]", + " {2} r131 = JOIN r130 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_empty\"", + "", + " {2} r132 = CONSTANT(int, unique string)[118,\"__is_union\"]", + " {2} r133 = JOIN r132 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_union\"", + "", + " {2} r134 = CONSTANT(int, unique string)[5,\"label ...:\"]", + " {2} r135 = JOIN r134 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"label ...:\"", + "", + " {2} r136 = r133 UNION r135", + " {2} r137 = r131 UNION r136", + " {2} r138 = r129 UNION r137", + "", + " {2} r139 = CONSTANT(int, unique string)[6,\"return ...\"]", + " {2} r140 = JOIN r139 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"return ...\"", + "", + " {1} r141 = Access::FunctionAccess#class#8878f617#f AND NOT Access::FunctionAccess::getTarget#dispred#f0820431#ff_0#antijoin_rhs(Lhs.0)", + " {2} r142 = SCAN r141 OUTPUT In.0, \"function access\"", + "", + " {1} r143 = Access::VariableAccess#8878f617#f AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs(Lhs.0)", + " {2} r144 = SCAN r143 OUTPUT In.0, \"variable access\"", + "", + " {2} r145 = r142 UNION r144", + " {2} r146 = r140 UNION r145", + "", + " {3} r147 = SCAN Macro::Macro::getHead#dispred#f0820431#ff OUTPUT In.0, \"\", In.1", + " {2} r148 = JOIN r147 WITH Macro::Macro::getBody#dispred#f0820431#ff ON FIRST 2 OUTPUT Lhs.0, (\"#define \" ++ Lhs.2)", + "", + " {2} r149 = SCAN derivations OUTPUT In.0, \"derivation\"", + "", + " {2} r150 = CONSTANT(int, unique string)[120,\"__INTADDR__\"]", + " {2} r151 = JOIN r150 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__INTADDR__\"", + "", + " {2} r152 = r149 UNION r151", + " {2} r153 = r148 UNION r152", + " {2} r154 = r146 UNION r153", + " {2} r155 = r138 UNION r154", + "", + " {2} r156 = CONSTANT(int, unique string)[317,\"__is_final\"]", + " {2} r157 = JOIN r156 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_final\"", + "", + " {2} r158 = CONSTANT(int, unique string)[15,\"try { ... }\"]", + " {2} r159 = JOIN r158 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"try { ... }\"", + "", + " {2} r160 = CONSTANT(int, unique string)[17,\"declaration\"]", + " {2} r161 = JOIN r160 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"declaration\"", + "", + " {2} r162 = r159 UNION r161", + " {2} r163 = r157 UNION r162", + "", + " {2} r164 = JOIN enumconstants WITH Access::Access::getTarget#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.4", + "", + " {2} r165 = CONSTANT(int, unique string)[100,\"__has_assign\"]", + " {2} r166 = JOIN r165 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_assign\"", + "", + " {2} r167 = CONSTANT(int, unique string)[111,\"__is_base_of\"]", + " {2} r168 = JOIN r167 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_base_of\"", + "", + " {2} r169 = r166 UNION r168", + " {2} r170 = r164 UNION r169", + " {2} r171 = r163 UNION r170", + "", + " {2} r172 = CONSTANT(int, unique string)[314,\"__is_sealed\"]", + " {2} r173 = JOIN r172 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_sealed\"", + "", + " {2} r174 = CONSTANT(int, unique string)[1,\"\"]", + " {2} r175 = JOIN r174 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"\"", + "", + " {2} r176 = CONSTANT(int, unique string)[4,\"alignas(...)\"]", + " {2} r177 = JOIN r176 WITH attributes_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"alignas(...)\"", + "", + " {2} r178 = r175 UNION r177", + " {2} r179 = r173 UNION r178", + "", + " {2} r180 = CONSTANT(int, unique string)[8,\"do (...) ...\"]", + " {2} r181 = JOIN r180 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"do (...) ...\"", + "", + " {2} r182 = CONSTANT(int, unique string)[110,\"__is_abstract\"]", + " {2} r183 = JOIN r182 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_abstract\"", + "", + " {2} r184 = r181 UNION r183", + "", + " {2} r185 = CONSTANT(int, unique string)[216,\"param access\"]", + " {2} r186 = JOIN r185 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"param access\"", + "", + " {2} r187 = CONSTANT(int, unique string)[2,\"if (...) ... \"]", + " {2} r188 = JOIN r187 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"if (...) ... \"", + "", + " {2} r189 = r186 UNION r188", + " {2} r190 = r184 UNION r189", + " {2} r191 = r179 UNION r190", + " {2} r192 = r171 UNION r191", + " {2} r193 = r155 UNION r192", + "", + " {2} r194 = CONSTANT(int, unique string)[11,\"__assume(...)\"]", + " {2} r195 = JOIN r194 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__assume(...)\"", + "", + " {2} r196 = CONSTANT(int, unique string)[13,\"asm statement\"]", + " {2} r197 = JOIN r196 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"asm statement\"", + "", + " {2} r198 = CONSTANT(int, unique string)[37,\"co_return ...\"]", + " {2} r199 = JOIN r198 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"co_return ...\"", + "", + " {2} r200 = r197 UNION r199", + " {2} r201 = r195 UNION r200", + "", + " {2} r202 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#shared#2 WITH Element::ElementBase::toString#dispred#f0820431#ff#join_rhs ON FIRST 1 OUTPUT Lhs.0, (\"initializer for \" ++ Rhs.1)", + "", + " {2} r203 = SCAN Cast::SizeofTypeOperator::getTypeOperand#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r204 = JOIN r203 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"sizeof(\" ++ Rhs.1 ++ \")\")", + "", + " {1} r205 = CONSTANT(unique int)[0]", + " {1} r206 = JOIN r205 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r207 = JOIN r206 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#if \" ++ Rhs.1)", + "", + " {2} r208 = r204 UNION r207", + " {2} r209 = r202 UNION r208", + " {2} r210 = r201 UNION r209", + "", + " {2} r211 = SCAN type_mentions OUTPUT In.0, \"type mention\"", + "", + " {2} r212 = CONSTANT(int, unique string)[95,\"sizeof...(...)\"]", + " {2} r213 = JOIN r212 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"sizeof...(...)\"", + "", + " {2} r214 = CONSTANT(int, unique string)[310,\"__is_delegate\"]", + " {2} r215 = JOIN r214 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_delegate\"", + "", + " {2} r216 = r213 UNION r215", + " {2} r217 = r211 UNION r216", + "", + " {2} r218 = CONSTANT(int, unique string)[319,\"noexcept(...)\"]", + " {2} r219 = JOIN r218 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"noexcept(...)\"", + "", + " {2} r220 = CONSTANT(int, unique string)[0,\"empty argument\"]", + " {2} r221 = JOIN r220 WITH attribute_args_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"empty argument\"", + "", + " {2} r222 = CONSTANT(int, unique string)[3,\"(reference to)\"]", + " {2} r223 = JOIN r222 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"(reference to)\"", + "", + " {2} r224 = r221 UNION r223", + " {2} r225 = r219 UNION r224", + " {2} r226 = r217 UNION r225", + " {2} r227 = r210 UNION r226", + "", + " {2} r228 = SCAN Cast::AlignofTypeOperator::getTypeOperand#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r229 = JOIN r228 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"alignof(\" ++ Rhs.1 ++ \")\")", + "", + " {2} r230 = JOIN Access::FunctionAccess#class#8878f617#f WITH Access::FunctionAccess::getTarget#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r231 = JOIN r230 WITH functions ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r232 = CONSTANT(int, unique string)[312,\"__is_ref_array\"]", + " {2} r233 = JOIN r232 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_ref_array\"", + "", + " {2} r234 = r231 UNION r233", + " {2} r235 = r229 UNION r234", + "", + " {2} r236 = CONSTANT(int, unique string)[313,\"__is_ref_class\"]", + " {2} r237 = JOIN r236 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_ref_class\"", + "", + " {2} r238 = CONSTANT(int, unique string)[331,\"__is_aggregate\"]", + " {2} r239 = JOIN r238 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_aggregate\"", + "", + " {2} r240 = CONSTANT(int, unique string)[3,\"while (...) ...\"]", + " {2} r241 = JOIN r240 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"while (...) ...\"", + "", + " {2} r242 = r239 UNION r241", + " {2} r243 = r237 UNION r242", + " {2} r244 = r235 UNION r243", + "", + " {2} r245 = CONSTANT(int, unique string)[19,\"VLA declaration\"]", + " {2} r246 = JOIN r245 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"VLA declaration\"", + "", + " {2} r247 = CONSTANT(int, unique string)[24,\"... ? ... : ...\"]", + " {2} r248 = JOIN r247 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"... ? ... : ...\"", + "", + " {2} r249 = CONSTANT(int, unique string)[68,\"access to array\"]", + " {2} r250 = JOIN r249 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"access to array\"", + "", + " {2} r251 = r248 UNION r250", + " {2} r252 = r246 UNION r251", + "", + " {1} r253 = CONSTANT(unique int)[3]", + " {1} r254 = JOIN r253 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r255 = JOIN r254 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#elif \" ++ Rhs.1)", + "", + " {1} r256 = CONSTANT(unique int)[9]", + " {1} r257 = JOIN r256 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r258 = JOIN r257 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#line \" ++ Rhs.1)", + "", + " {2} r259 = r255 UNION r258", + "", + " {2} r260 = CONSTANT(int, unique string)[80,\"__builtin_va_arg\"]", + " {2} r261 = JOIN r260 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_va_arg\"", + "", + " {2} r262 = CONSTANT(int, unique string)[81,\"__builtin_va_end\"]", + " {2} r263 = JOIN r262 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_va_end\"", + "", + " {2} r264 = r261 UNION r263", + " {2} r265 = r259 UNION r264", + " {2} r266 = r252 UNION r265", + " {2} r267 = r244 UNION r266", + " {2} r268 = r227 UNION r267", + " {2} r269 = r193 UNION r268", + " {2} r270 = r121 UNION r269", + "", + " {2} r271 = CONSTANT(int, unique string)[90,\"(condition decl)\"]", + " {2} r272 = JOIN r271 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"(condition decl)\"", + "", + " {2} r273 = CONSTANT(int, unique string)[117,\"__is_polymorphic\"]", + " {2} r274 = JOIN r273 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_polymorphic\"", + "", + " {2} r275 = CONSTANT(int, unique string)[215,\"[...](...){...}\"]", + " {2} r276 = JOIN r275 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"[...](...){...}\"", + "", + " {2} r277 = r274 UNION r276", + " {2} r278 = r272 UNION r277", + "", + " {2} r279 = CONSTANT(int, unique string)[309,\"__has_finalizer\"]", + " {2} r280 = JOIN r279 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_finalizer\"", + "", + " {2} r281 = CONSTANT(int, unique string)[330,\"__is_assignable\"]", + " {2} r282 = JOIN r281 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_assignable\"", + "", + " {2} r283 = CONSTANT(int, unique string)[29,\"for(...:...) ...\"]", + " {2} r284 = JOIN r283 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"for(...:...) ...\"", + "", + " {2} r285 = r282 UNION r284", + " {2} r286 = r280 UNION r285", + " {2} r287 = r278 UNION r286", + "", + " {2} r288 = SCAN namespace_decls OUTPUT In.1, In.0", + " {2} r289 = JOIN r288 WITH Namespace::Namespace::getFriendlyName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r290 = SCAN macroinvocations OUTPUT In.1, In.0", + " {2} r291 = JOIN r290 WITH Macro::Macro::getHead#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {1} r292 = CONSTANT(unique int)[1]", + " {1} r293 = JOIN r292 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r294 = JOIN r293 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#ifdef \" ++ Rhs.1)", + "", + " {2} r295 = r291 UNION r294", + " {2} r296 = r289 UNION r295", + "", + " {1} r297 = CONSTANT(unique int)[8]", + " {1} r298 = JOIN r297 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r299 = JOIN r298 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#undef \" ++ Rhs.1)", + "", + " {1} r300 = CONSTANT(unique int)[10]", + " {1} r301 = JOIN r300 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r302 = JOIN r301 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#error \" ++ Rhs.1)", + "", + " {1} r303 = CONSTANT(unique int)[123]", + " {1} r304 = JOIN r303 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r305 = r304 AND NOT code_block_0#antijoin_rhs(Lhs.0)", + " {2} r306 = JOIN r305 WITH Expr::Expr::getValue#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, Rhs.1", + "", + " {2} r307 = r302 UNION r306", + " {2} r308 = r299 UNION r307", + " {2} r309 = r296 UNION r308", + " {2} r310 = r287 UNION r309", + "", + " {2} r311 = CONSTANT(int, unique string)[82,\"__builtin_va_copy\"]", + " {2} r312 = JOIN r311 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_va_copy\"", + "", + " {2} r313 = CONSTANT(int, unique string)[316,\"__is_value_class\"]", + " {2} r314 = JOIN r313 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_value_class\"", + "", + " {2} r315 = CONSTANT(int, unique string)[329,\"temporary object\"]", + " {2} r316 = JOIN r315 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"temporary object\"", + "", + " {2} r317 = r314 UNION r316", + " {2} r318 = r312 UNION r317", + "", + " {2} r319 = CONSTANT(int, unique string)[11,\"switch (...) ... \"]", + " {2} r320 = JOIN r319 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"switch (...) ... \"", + "", + " {2} r321 = CONSTANT(int, unique string)[25,\"computed goto ...\"]", + " {2} r322 = JOIN r321 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"computed goto ...\"", + "", + " {2} r323 = SCAN Namespace::UsingDirectiveEntry::getNamespace#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r324 = JOIN r323 WITH Namespace::Namespace::getFriendlyName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"using namespace \" ++ Rhs.1)", + "", + " {2} r325 = r322 UNION r324", + " {2} r326 = r320 UNION r325", + " {2} r327 = r318 UNION r326", + "", + " {2} r328 = SCAN lambda_capture OUTPUT In.3, In.0", + " {2} r329 = JOIN r328 WITH Variable::MemberVariable::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {1} r330 = CONSTANT(unique int)[2]", + " {1} r331 = JOIN r330 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r332 = JOIN r331 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#ifndef \" ++ Rhs.1)", + "", + " {1} r333 = CONSTANT(unique int)[11]", + " {1} r334 = JOIN r333 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r335 = r334 AND NOT Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf_0#antijoin_rhs(Lhs.0)", + " {2} r336 = SCAN r335 OUTPUT In.0, \"#pragma\"", + "", + " {2} r337 = r332 UNION r336", + " {2} r338 = r329 UNION r337", + "", + " {2} r339 = JOIN r334 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#pragma \" ++ Rhs.1)", + "", + " {2} r340 = Include::Include::getIncludeText#dispred#f0820431#ff AND NOT Include::Include#class#feab3531#f#antijoin_rhs(Lhs.0)", + " {2} r341 = r340 AND NOT Include::Include#class#feab3531#f#antijoin_rhs#1(Lhs.0)", + " {2} r342 = SCAN r341 OUTPUT In.0, (\"#include \" ++ In.1)", + "", + " {2} r343 = r339 UNION r342", + "", + " {2} r344 = CONSTANT(int, unique string)[99,\"__builtin_offsetof\"]", + " {2} r345 = JOIN r344 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_offsetof\"", + "", + " {2} r346 = CONSTANT(int, unique string)[104,\"__has_nothrow_copy\"]", + " {2} r347 = JOIN r346 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_nothrow_copy\"", + "", + " {2} r348 = r345 UNION r347", + " {2} r349 = r343 UNION r348", + " {2} r350 = r338 UNION r349", + " {2} r351 = r327 UNION r350", + " {2} r352 = r310 UNION r351", + "", + " {2} r353 = CONSTANT(int, unique string)[107,\"__has_trivial_copy\"]", + " {2} r354 = JOIN r353 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_trivial_copy\"", + "", + " {2} r355 = CONSTANT(int, unique string)[295,\"__is_destructible\"]", + " {2} r356 = JOIN r355 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_destructible\"", + "", + " {2} r357 = CONSTANT(int, unique string)[303,\"__is_literal_type\"]", + " {2} r358 = JOIN r357 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_literal_type\"", + "", + " {2} r359 = r356 UNION r358", + " {2} r360 = r354 UNION r359", + "", + " {2} r361 = CONSTANT(int, unique string)[325,\"__builtin_complex\"]", + " {2} r362 = JOIN r361 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_complex\"", + "", + " {2} r363 = CONSTANT(int, unique string)[334,\"__builtin_shuffle\"]", + " {2} r364 = JOIN r363 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_shuffle\"", + "", + " {2} r365 = CONSTANT(int, unique string)[18,\"VLA dimension size\"]", + " {2} r366 = JOIN r365 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"VLA dimension size\"", + "", + " {2} r367 = r364 UNION r366", + " {2} r368 = r362 UNION r367", + " {2} r369 = r360 UNION r368", + "", + " {2} r370 = CONSTANT(int, unique string)[79,\"__builtin_va_start\"]", + " {2} r371 = JOIN r370 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_va_start\"", + "", + " {1} r372 = Call::FunctionCall#39248e3c#f AND NOT project#Call::FunctionCall::getTarget#dispred#f0820431#ff(Lhs.0)", + " {2} r373 = SCAN r372 OUTPUT In.0, \"call to unknown function\"", + "", + " {1} r374 = CONSTANT(unique int)[18]", + " {1} r375 = JOIN r374 WITH preprocdirects_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r376 = JOIN r375 WITH Preprocessor::PreprocessorDirective::getHead#dispred#f0820431#bf ON FIRST 1 OUTPUT Lhs.0, (\"#warning \" ++ Rhs.1)", + "", + " {2} r377 = r373 UNION r376", + " {2} r378 = r371 UNION r377", + "", + " {2} r379 = CONSTANT(int, unique string)[113,\"__is_convertible_to\"]", + " {2} r380 = JOIN r379 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_convertible_to\"", + "", + " {2} r381 = CONSTANT(int, unique string)[307,\"__is_constructible\"]", + " {2} r382 = JOIN r381 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_constructible\"", + "", + " {2} r383 = CONSTANT(int, unique string)[333,\"__builtin_bit_cast\"]", + " {2} r384 = JOIN r383 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_bit_cast\"", + "", + " {2} r385 = r382 UNION r384", + " {2} r386 = r380 UNION r385", + " {2} r387 = r378 UNION r386", + " {2} r388 = r369 UNION r387", + "", + " {2} r389 = Macro::Macro::getHead#dispred#f0820431#ff AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#7(Lhs.0)", + " {2} r390 = JOIN r389 WITH Macro::Macro::getBody#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"#define \" ++ Lhs.1 ++ \" \" ++ Rhs.1)", + "", + " {1} r391 = CONSTANT(unique int)[98]", + " {1} r392 = JOIN r391 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r393 = JOIN r392 WITH Expr::Expr::getType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r394 = JOIN r393 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r395 = CONSTANT(int, unique string)[102,\"__has_nothrow_assign\"]", + " {2} r396 = JOIN r395 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_nothrow_assign\"", + "", + " {2} r397 = r394 UNION r396", + " {2} r398 = r390 UNION r397", + "", + " {2} r399 = CONSTANT(int, unique string)[105,\"__has_trivial_assign\"]", + " {2} r400 = JOIN r399 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_trivial_assign\"", + "", + " {2} r401 = CONSTANT(int, unique string)[9,\"for(...;...;...) ...\"]", + " {2} r402 = JOIN r401 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"for(...;...;...) ...\"", + "", + " {1} r403 = CONSTANT(unique int)[124]", + " {1} r404 = JOIN r403 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + "", + " {1} r405 = r404 AND NOT project#Cast::UuidofOperator::getTypeOperand#dispred#f0820431#ff(Lhs.0)", + " {2} r406 = SCAN r405 OUTPUT In.0, \"__uuidof(0)\"", + "", + " {2} r407 = r402 UNION r406", + " {2} r408 = r400 UNION r407", + " {2} r409 = r398 UNION r408", + "", + " {2} r410 = CONSTANT(int, unique string)[108,\"__has_user_destructor\"]", + " {2} r411 = JOIN r410 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_user_destructor\"", + "", + " {2} r412 = CONSTANT(int, unique string)[301,\"__is_standard_layout\"]", + " {2} r413 = JOIN r412 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_standard_layout\"", + "", + " {2} r414 = CONSTANT(int, unique string)[311,\"__is_interface_class\"]", + " {2} r415 = JOIN r414 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_interface_class\"", + "", + " {2} r416 = r413 UNION r415", + " {2} r417 = r411 UNION r416", + "", + " {2} r418 = CONSTANT(int, unique string)[96,\"(statement expression)\"]", + " {2} r419 = JOIN r418 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"(statement expression)\"", + "", + " {2} r420 = CONSTANT(int, unique string)[321,\"__builtin_choose_expr\"]", + " {2} r421 = JOIN r420 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_choose_expr\"", + "", + " {2} r422 = r419 UNION r421", + "", + " {2} r423 = CONSTANT(int, unique string)[5,\"(reference dereference)\"]", + " {2} r424 = JOIN r423 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"(reference dereference)\"", + "", + " {2} r425 = CONSTANT(int, unique string)[35,\"if constexpr (...) ... \"]", + " {2} r426 = JOIN r425 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"if constexpr (...) ... \"", + "", + " {2} r427 = r424 UNION r426", + " {2} r428 = r422 UNION r427", + " {2} r429 = r417 UNION r428", + " {2} r430 = r409 UNION r429", + " {2} r431 = r388 UNION r430", + " {2} r432 = r352 UNION r431", + "", + " {2} r433 = CONSTANT(int, unique string)[109,\"__has_virtual_destructor\"]", + " {2} r434 = JOIN r433 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_virtual_destructor\"", + "", + " {2} r435 = CONSTANT(int, unique string)[122,\"__has_trivial_destructor\"]", + " {2} r436 = JOIN r435 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_trivial_destructor\"", + "", + " {2} r437 = CONSTANT(int, unique string)[299,\"__is_nothrow_assignable\"]", + " {2} r438 = JOIN r437 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_nothrow_assignable\"", + "", + " {2} r439 = r436 UNION r438", + " {2} r440 = r434 UNION r439", + "", + " {2} r441 = CONSTANT(int, unique string)[302,\"__is_trivially_copyable\"]", + " {2} r442 = JOIN r441 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_trivially_copyable\"", + "", + " {2} r443 = CONSTANT(int, unique string)[315,\"__is_simple_value_class\"]", + " {2} r444 = JOIN r443 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_simple_value_class\"", + "", + " {2} r445 = CONSTANT(int, unique string)[320,\"__builtin_shufflevector\"]", + " {2} r446 = JOIN r445 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_shufflevector\"", + "", + " {2} r447 = r444 UNION r446", + " {2} r448 = r442 UNION r447", + " {2} r449 = r440 UNION r448", + "", + " {2} r450 = CONSTANT(int, unique string)[324,\"__builtin_convertvector\"]", + " {2} r451 = JOIN r450 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_convertvector\"", + "", + " {2} r452 = CONSTANT(int, unique string)[89,\"throw ...\"]", + " {2} r453 = JOIN r452 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT \"throw ...\", Rhs.1", + " {2} r454 = r453 AND NOT Expr::ReThrowExpr#class#ef463c5d#f(Lhs.1)", + " {2} r455 = SCAN r454 OUTPUT In.1, \"throw ...\"", + "", + " {2} r456 = CONSTANT(int, unique string)[10,\"case ...:\"]", + " {2} r457 = JOIN r456 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT \"case ...:\", Rhs.1", + " {2} r458 = r457 AND NOT Stmt::DefaultCase#class#af82e98b#f(Lhs.1)", + " {2} r459 = SCAN r458 OUTPUT In.1, \"case ...:\"", + "", + " {2} r460 = r455 UNION r459", + " {2} r461 = r451 UNION r460", + "", + " {2} r462 = CONSTANT(int, unique string)[103,\"__has_nothrow_constructor\"]", + " {2} r463 = JOIN r462 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_nothrow_constructor\"", + "", + " {2} r464 = CONSTANT(int, unique string)[106,\"__has_trivial_constructor\"]", + " {2} r465 = JOIN r464 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_trivial_constructor\"", + "", + " {2} r466 = CONSTANT(int, unique string)[9,\"(vacuous destructor call)\"]", + " {2} r467 = JOIN r466 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"(vacuous destructor call)\"", + "", + " {2} r468 = r465 UNION r467", + " {2} r469 = r463 UNION r468", + " {2} r470 = r461 UNION r469", + " {2} r471 = r449 UNION r470", + "", + " {2} r472 = JOIN Call::FunctionCall#39248e3c#f WITH Call::FunctionCall::getTarget#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r473 = JOIN r472 WITH functions ON FIRST 1 OUTPUT Lhs.1, (\"call to \" ++ Rhs.1)", + "", + " {2} r474 = CONSTANT(int, unique string)[296,\"__is_nothrow_destructible\"]", + " {2} r475 = JOIN r474 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_nothrow_destructible\"", + "", + " {2} r476 = CONSTANT(int, unique string)[298,\"__is_trivially_assignable\"]", + " {2} r477 = JOIN r476 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_trivially_assignable\"", + "", + " {2} r478 = r475 UNION r477", + " {2} r479 = r473 UNION r478", + "", + " {2} r480 = CONSTANT(int, unique string)[305,\"__has_trivial_move_assign\"]", + " {2} r481 = JOIN r480 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_trivial_move_assign\"", + "", + " {2} r482 = CONSTANT(int, unique string)[306,\"__has_nothrow_move_assign\"]", + " {2} r483 = JOIN r482 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_nothrow_move_assign\"", + "", + " {1} r484 = SCAN initialisers OUTPUT In.0", + " {1} r485 = r484 AND NOT Initializer::Initializer::getDeclaration#dispred#f0820431#ff_0#antijoin_rhs(Lhs.0)", + " {2} r486 = SCAN r485 OUTPUT In.0, \"initializer\"", + "", + " {2} r487 = r483 UNION r486", + " {2} r488 = r481 UNION r487", + " {2} r489 = r479 UNION r488", + "", + " {2} r490 = SCAN Call::ConstructorFieldInit::getTarget#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r491 = JOIN r490 WITH Variable::MemberVariable::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"constructor init of field \" ++ Rhs.1)", + "", + " {2} r492 = CONSTANT(int, unique string)[93,\"sizeof()\"]", + " {2} r493 = JOIN r492 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"sizeof()\"", + " {2} r494 = JOIN r493 WITH project#Expr::Expr::getChild#dispred#f0820431#bff#2 ON FIRST 1 OUTPUT Lhs.0, \"sizeof()\"", + "", + " {2} r495 = CONSTANT(int, unique string)[308,\"__is_nothrow_constructible\"]", + " {2} r496 = JOIN r495 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_nothrow_constructible\"", + "", + " {2} r497 = r494 UNION r496", + " {2} r498 = r491 UNION r497", + "", + " {2} r499 = CONSTANT(int, unique string)[8,\"array to pointer conversion\"]", + " {2} r500 = JOIN r499 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"array to pointer conversion\"", + "", + " {2} r501 = CONSTANT(int, unique string)[94,\"alignof()\"]", + " {2} r502 = JOIN r501 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"alignof()\"", + " {2} r503 = JOIN r502 WITH project#Expr::Expr::getChild#dispred#f0820431#bff#2 ON FIRST 1 OUTPUT Lhs.0, \"alignof()\"", + "", + " {2} r504 = r500 UNION r503", + "", + " {2} r505 = CONSTANT(int, unique string)[119,\"__builtin_types_compatible_p\"]", + " {2} r506 = JOIN r505 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__builtin_types_compatible_p\"", + "", + " {2} r507 = CONSTANT(int, unique string)[297,\"__is_trivially_destructible\"]", + " {2} r508 = JOIN r507 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_trivially_destructible\"", + "", + " {2} r509 = r506 UNION r508", + " {2} r510 = r504 UNION r509", + " {2} r511 = r498 UNION r510", + " {2} r512 = r489 UNION r511", + " {2} r513 = r471 UNION r512", + "", + " {2} r514 = CONSTANT(int, unique string)[294,\"__is_trivially_constructible\"]", + " {2} r515 = JOIN r514 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__is_trivially_constructible\"", + "", + " {2} r516 = CONSTANT(int, unique string)[74,\"call to expression\"]", + " {2} r517 = JOIN r516 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"call to expression\"", + " {2} r518 = JOIN r517 WITH Call::Call#39248e3c#f ON FIRST 1 OUTPUT Lhs.0, \"call to expression\"", + "", + " {2} r519 = CONSTANT(int, unique string)[304,\"__has_trivial_move_constructor\"]", + " {2} r520 = JOIN r519 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_trivial_move_constructor\"", + "", + " {2} r521 = r518 UNION r520", + " {2} r522 = r515 UNION r521", + "", + " {2} r523 = SCAN static_asserts OUTPUT In.0, (\"static_assert(..., \\\"\" ++ In.2 ++ \"\\\")\")", + "", + " {2} r524 = SCAN Call::DestructorFieldDestruction::getTarget#dispred#f0820431#ff OUTPUT In.1, In.0", + " {2} r525 = JOIN r524 WITH Variable::MemberVariable::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"destructor field destruction of \" ++ Rhs.1)", + "", + " {1} r526 = CONSTANT(unique int)[214]", + " {1} r527 = JOIN r526 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r528 = JOIN r527 WITH Expr::Expr::getType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r529 = JOIN r528 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"(\" ++ Rhs.1 ++ \")...\")", + "", + " {2} r530 = r525 UNION r529", + " {2} r531 = r523 UNION r530", + " {2} r532 = r522 UNION r531", + "", + " {1} r533 = r304 AND NOT code_block_0#antijoin_rhs(Lhs.0)", + " {1} r534 = r533 AND NOT Expr::Expr::getValue#dispred#f0820431#bf_0#antijoin_rhs(Lhs.0)", + " {2} r535 = SCAN r534 OUTPUT In.0, \"Unknown literal\"", + "", + " {2} r536 = CONSTANT(int, unique string)[332,\"__has_unique_object_representations\"]", + " {2} r537 = JOIN r536 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__has_unique_object_representations\"", + "", + " {2} r538 = JOIN r404 WITH Cast::UuidofOperator::getTypeOperand#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r539 = JOIN r538 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"__uuidof(\" ++ Rhs.1 ++ \")\")", + "", + " {2} r540 = r537 UNION r539", + " {2} r541 = r535 UNION r540", + "", + " {1} r542 = CONSTANT(unique int)[212]", + " {1} r543 = JOIN r542 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r544 = JOIN r543 WITH Expr::Expr::getType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r545 = JOIN r544 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"const_cast<\" ++ Rhs.1 ++ \">...\")", + "", + " {1} r546 = CONSTANT(unique int)[210]", + " {1} r547 = JOIN r546 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r548 = JOIN r547 WITH Expr::Expr::getType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r549 = JOIN r548 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"static_cast<\" ++ Rhs.1 ++ \">...\")", + "", + " {2} r550 = r545 UNION r549", + "", + " {1} r551 = CONSTANT(unique int)[213]", + " {1} r552 = JOIN r551 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r553 = JOIN r552 WITH Expr::Expr::getType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r554 = JOIN r553 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"dynamic_cast<\" ++ Rhs.1 ++ \">...\")", + "", + " {2} r555 = CONSTANT(int, unique string)[16,\"__try { ... } __finally { ... }\"]", + " {2} r556 = JOIN r555 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT \"__try { ... } __finally { ... }\", Rhs.1", + " {2} r557 = r556 AND NOT project#Stmt::Stmt::getChild#dispred#f0820431#bff#2(Lhs.1)", + " {2} r558 = SCAN r557 OUTPUT In.1, \"__try { ... } __finally { ... }\"", + "", + " {2} r559 = r554 UNION r558", + " {2} r560 = r550 UNION r559", + " {2} r561 = r541 UNION r560", + " {2} r562 = r532 UNION r561", + "", + " {2} r563 = SCAN fold OUTPUT In.0, In.1", + " {2} r564 = STREAM DEDUP r563", + "", + " {2} r565 = JOIN r564 WITH Expr::FoldExpr::isUnaryFold#dispred#f0820431#f ON FIRST 1 OUTPUT Lhs.0, Lhs.1", + "", + " {2} r566 = JOIN r565 WITH fold ON FIRST 2 OUTPUT Lhs.0, Lhs.1", + " {2} r567 = r566 AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#6(Lhs.0)", + " {2} r568 = SCAN r567 OUTPUT In.0, (\"( pack \" ++ In.1 ++ \" ... )\")", + "", + " {3} r569 = JOIN r565 WITH fold ON FIRST 2 OUTPUT Lhs.0, true, Lhs.1", + " {2} r570 = JOIN r569 WITH fold_02#join_rhs ON FIRST 2 OUTPUT Lhs.0, (\"( ... \" ++ Lhs.2 ++ \" pack )\")", + "", + " {1} r571 = CONSTANT(unique int)[211]", + " {1} r572 = JOIN r571 WITH exprs_10#join_rhs ON FIRST 1 OUTPUT Rhs.1", + " {2} r573 = JOIN r572 WITH Expr::Expr::getType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r574 = JOIN r573 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (\"reinterpret_cast<\" ++ Rhs.1 ++ \">...\")", + "", + " {2} r575 = r570 UNION r574", + " {2} r576 = r568 UNION r575", + "", + " {2} r577 = CONSTANT(int, unique string)[16,\"__try { ... } __except( ... ) { ... }\"]", + " {2} r578 = JOIN r577 WITH stmts_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, \"__try { ... } __except( ... ) { ... }\"", + " {2} r579 = JOIN r578 WITH project#Stmt::Stmt::getChild#dispred#f0820431#bff#2 ON FIRST 1 OUTPUT Lhs.0, \"__try { ... } __except( ... ) { ... }\"", + "", + " {2} r580 = r564 AND NOT Expr::FoldExpr::isUnaryFold#dispred#f0820431#f(Lhs.0)", + "", + " {2} r581 = JOIN r580 WITH fold ON FIRST 2 OUTPUT Lhs.0, Lhs.1", + " {2} r582 = r581 AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#6(Lhs.0)", + " {2} r583 = SCAN r582 OUTPUT In.0, (\"( pack \" ++ In.1 ++ \" ... \" ++ In.1 ++ \" init )\")", + "", + " {3} r584 = JOIN r580 WITH fold ON FIRST 2 OUTPUT Lhs.0, true, Lhs.1", + " {2} r585 = JOIN r584 WITH fold_02#join_rhs ON FIRST 2 OUTPUT Lhs.0, (\"( init \" ++ Lhs.2 ++ \" ... \" ++ Lhs.2 ++ \" pack )\")", + "", + " {2} r586 = r583 UNION r585", + " {2} r587 = r579 UNION r586", + " {2} r588 = r576 UNION r587", + "", + " {2} r589 = SCAN namequalifiers OUTPUT In.2, In.0", + " {2} r590 = JOIN r589 WITH ResolveClass::Cached::resolveClass#eb2868f4#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + "", + " {3} r591 = SCAN namequalifiers OUTPUT In.0, In.2, In.2", + " {3} r592 = r591 AND NOT usertypes_0#antijoin_rhs(Lhs.2)", + " {2} r593 = SCAN r592 OUTPUT In.2, In.0", + "", + " {2} r594 = r590 UNION r593", + " {2} r595 = JOIN r594 WITH NameQualifiers::NameQualifyingElement::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, (Rhs.1 ++ \"::\")", + "", + " {1} r596 = Element::ElementBase::toString#dispred#f0820431#ff#shared#1 AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#5(Lhs.0)", + " {5} r597 = JOIN r596 WITH var_decls ON FIRST 1 OUTPUT Lhs.0, Rhs.1, Rhs.2, Rhs.3, Rhs.4", + " {5} r598 = SELECT r597 ON In.3 != \"\"", + " {2} r599 = JOIN r598 WITH Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"declaration of \" ++ Rhs.1 ++ \" as \" ++ Lhs.3)", + "", + " {2} r600 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#2 WITH Specifier::AttributeArgument::getValueType#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0", + " {2} r601 = JOIN r600 WITH Type::Type::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1", + "", + " {2} r602 = attribute_arg_value AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#2(Lhs.0)", + "", + " {2} r603 = r601 UNION r602", + " {2} r604 = r603 AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#3(Lhs.0)", + " {2} r605 = r604 AND NOT attribute_arg_name_0#antijoin_rhs(Lhs.0)", + " {2} r606 = SCAN r605 OUTPUT In.0, (\"\" ++ In.1)", + "", + " {2} r607 = r599 UNION r606", + " {2} r608 = r595 UNION r607", + "", + " {1} r609 = JOIN var_def WITH param_decl_bind ON FIRST 1 OUTPUT Lhs.0", + " {5} r610 = JOIN r609 WITH var_decls ON FIRST 1 OUTPUT Lhs.0, Rhs.1, Rhs.2, Rhs.3, Rhs.4", + " {5} r611 = SELECT r610 ON In.3 != \"\"", + " {2} r612 = SCAN r611 OUTPUT In.0, (\"definition of \" ++ In.3)", + "", + " {5} r613 = JOIN Element::ElementBase::toString#dispred#f0820431#ff#shared#1 WITH var_decls ON FIRST 1 OUTPUT Lhs.0, Rhs.1, Rhs.2, Rhs.3, Rhs.4", + " {5} r614 = SELECT r613 ON In.3 != \"\"", + " {2} r615 = SCAN r614 OUTPUT In.0, In.3", + " {6} r616 = JOIN r615 WITH var_decls ON FIRST 1 OUTPUT Lhs.0, Lhs.1, Rhs.1, Rhs.2, Rhs.3, Rhs.4", + " {6} r617 = SELECT r616 ON In.4 != \"\"", + " {3} r618 = SCAN r617 OUTPUT In.0, In.4, In.1", + " {2} r619 = JOIN r618 WITH Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff ON FIRST 2 OUTPUT Lhs.0, (\"declaration of \" ++ Lhs.2)", + "", + " {2} r620 = r612 UNION r619", + "", + " {2} r621 = attribute_arg_value AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#2(Lhs.0)", + "", + " {2} r622 = r601 UNION r621", + " {2} r623 = r622 AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#3(Lhs.0)", + " {2} r624 = JOIN r623 WITH attribute_arg_name ON FIRST 1 OUTPUT Lhs.0, ((Rhs.1 ++ \"=\") ++ Lhs.1)", + "", + " {2} r625 = JOIN Declaration::DeclarationEntry::isDefinition#dispred#f0820431#f WITH Declaration::DeclarationEntry::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"definition of \" ++ Rhs.1)", + "", + " {1} r626 = JOIN Declaration::DeclarationEntry::getName#dispred#f0820431#ff WITH Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff ON FIRST 2 OUTPUT Lhs.0", + " {1} r627 = r626 AND NOT Declaration::DeclarationEntry::isDefinition#dispred#f0820431#f(Lhs.0)", + " {2} r628 = JOIN r627 WITH Declaration::DeclarationEntry::getName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"declaration of \" ++ Rhs.1)", + "", + " {2} r629 = Element::ElementBase::toString#dispred#f0820431#ff#shared AND NOT Element::ElementBase::toString#dispred#f0820431#ff#antijoin_rhs#4(Lhs.0, Lhs.1)", + " {2} r630 = JOIN r629 WITH Declaration::DeclarationEntry::getCanonicalName#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, (\"declaration of \" ++ Rhs.1 ++ \" as \" ++ Lhs.1)", + "", + " {2} r631 = r628 UNION r630", + " {2} r632 = r625 UNION r631", + " {2} r633 = r632 AND NOT param_decl_bind_0#antijoin_rhs(Lhs.0)", + "", + " {2} r634 = r624 UNION r633", + " {2} r635 = r620 UNION r634", + " {2} r636 = r608 UNION r635", + " {2} r637 = r588 UNION r636", + " {2} r638 = r562 UNION r637", + " {2} r639 = r513 UNION r638", + " {2} r640 = r432 UNION r639", + " {2} r641 = r270 UNION r640", + " return r641" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 22403, -1, 24752, -1, 22, -1, 0, -1, 22, -1, 23, 24775, -1, 1260, -1, 144, -1, 1404, -1, 1457, -1, 174, -1, 14697, -1, 0, -1, 14697, 14871, 16328, 41103, -1, 11318, -1, 0, -1, 1, 593, -1, 593, 11911, -1, 301, 301, -1, 1, 0, -1, 0, -1, 0, 301, 12212, -1, 0, -1, 1, 0, -1, 0, -1, 0, 0, -1, 1, 368, -1, 1, 788, -1, 1156, -1, 1, 59459, -1, 87124, 87124, -1, 146583, 147739, 147739, 159951, 201054, -1, 0, -1, 1, 1236, -1, 1, 310, -1, 1546, 1546, -1, 1, 0, -1, 1, 0, -1, 1, 3388, -1, 3388, 3388, 4934, -1, 1, 1001, -1, 1, 0, -1, 1, 0, -1, 0, 1001, -1, 1, 8545, -1, 1129, -1, 35571, -1, 36700, 45245, 46246, 51180, -1, 0, 0, -1, 1, 0, -1, 1, 16060, -1, 16060, 16060, -1, 1, 287, -1, 1, 0, -1, 1, 0, -1, 0, 287, 16347, -1, 1, 135, -1, 1, 0, -1, 1, 8683, -1, 8683, 8818, -1, 1, 755, -1, 3, -1, 758, -1, 3270, 3270, 3271, 4029, 12847, 29194, 80374, 281428, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 0, -1, 1, 0, -1, 1, 472, -1, 472, 472, 472, -1, 1, 4166, -1, 0, 0, -1, 0, 0, -1, 0, 4166, -1, 5201, 441, -1, 0, -1, 1, 0, -1, 0, 441, 4607, 5079, -1, 1, 0, -1, 1, 0, -1, 1, 5742, -1, 5742, 5742, -1, 11864, -1, 1, 0, -1, 1, 0, -1, 0, 11864, 17606, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 128, -1, 1, 0, -1, 128, -1, 1, 0, -1, 1, 6173, -1, 6173, 6301, 6301, 23907, 28986, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 7512, -1, 742, 742, -1, 1, 1670, 1670, -1, 2412, 9924, 9924, -1, 13797, -1, 1, 0, -1, 1, 0, -1, 0, 13797, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 13797, 23721, -1, 0, 0, -1, 706, 706, -1, 1, 0, -1, 706, 706, -1, 1, 0, -1, 1, 0, -1, 1, 348, -1, 348, 348, 1054, -1, 1, 0, -1, 1, 1090, -1, 1, 3643, -1, 4733, 4733, -1, 1, 246, 246, -1, 1, 278, 278, -1, 524, -1, 1, 16, -1, 1, 14, -1, 30, 554, 5287, 6341, 30062, 59048, 340476, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 0, -1, 0, 0, -1, 55809, 55809, -1, 1, 1200, 1200, -1, 57009, 57009, -1, 1, 270, 270, -1, 1, 0, 0, -1, 1, 38851, -1, 38851, 38851, -1, 38851, 39121, 96130, 96130, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 193, -1, 1, 0, -1, 0, 0, -1, 0, 193, 193, -1, 0, 0, -1, 1, 518, 518, -1, 1, 0, -1, 0, 0, -1, 518, 518, -1, 0, -1, 1206, 1203, 1203, -1, 1203, -1, 1, 555, -1, 1, 0, -1, 555, 1758, 2276, 2469, 98599, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 0, -1, 1, 14, -1, 0, 0, -1, 1, 0, 0, -1, 0, 14, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 14, 14, -1, 4760, 4760, -1, 1, 555, 555, 555, -1, 1, 0, -1, 555, 5315, -1, 1, 0, -1, 1, 522, -1, 1, 0, -1, 0, 0, -1, 522, 522, 5837, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 3, -1, 1, 0, -1, 3, -1, 1, 0, -1, 1, 0, -1, 0, 3, 3, 5840, 5854, 104453, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 0, -1, 1, 0, -1, 1, 0, 0, 0, -1, 1, 1650, 1476, 1476, -1, 1476, 1476, -1, 1, 0, -1, 1, 0, -1, 1, 0, -1, 0, 0, 1476, 1476, -1, 11571, 11571, -1, 1, 0, -1, 1, 0, -1, 0, 11571, -1, 1, 0, -1, 1, 0, -1, 7512, 0, 0, -1, 0, 0, 11571, -1, 0, 0, -1, 1, 1115, 373, -1, 1, 0, -1, 373, 373, -1, 1, 3682, -1, 1, 0, 0, -1, 3682, -1, 1, 0, -1, 1, 0, -1, 0, 3682, 4055, 15626, 17102, -1, 1, 0, -1, 1, 34, 34, -1, 1, 0, -1, 34, 34, -1, 0, -1, 0, 0, -1, 1, 44531, 44531, 44531, -1, 44531, 44531, 44565, -1, 38851, 0, 0, -1, 1, 0, -1, 0, 0, -1, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 0, 0, 0, 44565, -1, 0, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, -1, 1, 0, 0, 0, -1, 0, 0, -1, 1, 0, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 260, 262, 118, 118, -1, 0, 0, -1, 902, -1, 902, 902, 902, 902, -1, 1020, 1020, -1, 5270, 5270, 5270, 5270, -1, 4164, 4020, 4020, 4022, 4022, 4022, 3704, -1, 8974, -1, 902, -1, 902, 902, 0, -1, 15855, -1, 22110, 6255, 6255, -1, 116, 116, -1, 6371, 22226, 13137, -1, 13137, 22111, 23131, 23131, 67696, 84798, 189251, 529727 ], + "duplicationPercentages" : [ 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 2, -1, 2, -1, 0, -1, 1, -1, 2, -1, 0, -1, 2, -1, 0, -1, 2, 2, 1, 0, -1, 1, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, 1, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 2, -1, 0, -1, 0, 2, -1, 2, 0, -1, 0, 0, 0, 0, 0, -1, 0, -1, 0, 0, -1, 0, 2, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 2, -1, 0, 5, -1, 0, 0, -1, 0, 0, -1, 0, 5, -1, 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, -1, 2, 2, 2, 2, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, -1, 1, 1, 1, -1, 0, 1, -1, 0, 0, -1, 0, 0, -1, 0, 1, -1, 0, 2, -1, 0, -1, 0, 0, -1, 0, 2, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 10, -1, 0, 0, -1, 0, 0, -1, 0, 10, 2, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, -1, 0, 0, -1, 1, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 1, 3, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 4, -1, 0, 0, -1, 0, 0, 0, -1, 0, 3, 3, -1, 5, -1, 0, 0, -1, 0, 0, -1, 0, 5, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 5, 4, -1, 0, 0, -1, 2, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 1, -1, 0, 2, -1, 4, 4, -1, 0, 0, 1, -1, 0, 0, 1, -1, 2, -1, 0, 0, -1, 0, 0, -1, 0, 1, 3, 3, 7, 4, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 2, 2, -1, 0, 0, 0, -1, 2, 2, -1, 0, 3, 3, -1, 0, 0, 0, -1, 0, 5, -1, 5, 3, -1, 3, 4, 2, 2, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 3, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 2, 2, 2, -1, 2, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 1, -1, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, -1, 0, 0, -1, 0, 0, -1, 1, 1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 1, 0, 1, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 2, 4, 4, -1, 4, 4, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 4, 4, -1, 0, 4, -1, 0, 0, -1, 0, 0, -1, 0, 4, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 4, -1, 0, 0, -1, 0, 5, 3, -1, 0, 0, -1, 3, 3, -1, 0, 0, -1, 0, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, 4, 4, -1, 4, 4, 4, -1, 5, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 4, -1, 0, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, 0, 0, -1, 2, 2, -1, 0, 0, 0, 0, -1, 4, 4, 10, 0, 0, 10, 3, -1, 0, -1, 0, -1, 0, 0, 0, -1, 4, -1, 0, 0, 4, -1, 1, 0, -1, 4, 0, 3, -1, 3, 0, 0, 0, 3, 2, 5, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:28:30.261Z", + "raHash" : "966812g6968j8ja8hlgihop4k30", + "predicateName" : "Element::ElementBase::toString#dispred#f0820431#ff", + "appearsAs" : { + "Element::ElementBase::toString#dispred#f0820431#ff" : { + "BadAdditionOverflowCheck.ql" : [ 5 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTED_EXTENSIONAL", + "millis" : 182, + "resultSize" : 529724 +} + +{ + "completionTime" : "2022-08-10T21:30:58.130Z", + "raHash" : "1bb43c97jpmuh8r2v0f9hktim63", + "predicateName" : "#select#ff", + "appearsAs" : { + "#select#ff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 148341, + "resultSize" : 139364, + "dependencies" : { + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff" : "6d5520630p5b5u45b23gi9u7f92", + "Expr::Expr::getLocation#dispred#f0820431#ff_10#join_rhs" : "6860a8b89m36f4jr2l8jne7t9p4", + "Access::Access::getTarget#dispred#f0820431#ff" : "6dc90aqk5vku7a2fpgr2jkjm4j0", + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff_20#join_rhs" : "14d9670i5smssh3t5k6ueet9eg5", + "Access::Access::getTarget#dispred#f0820431#ff_10#join_rhs" : "dcb7b0m1btie36sq0vskchcvepa", + "Expr::Expr::getLocation#dispred#f0820431#ff" : "041df63fgpb7j4ofhusq62n1gl2", + "Expr::Expr::getEnclosingFunction#dispred#f0820431#ff" : "a416d2f4hjco4oha1vjcfqculq5" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN Location::Location::fullLocationInfo#dispred#f0820431#ffffff OUTPUT In.0, In.2", + " {2} r2 = JOIN r1 WITH Expr::Expr::getLocation#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.1", + " {3} r3 = JOIN r2 WITH Access::Access::getTarget#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Lhs.0, Rhs.1", + " {3} r4 = JOIN r3 WITH Location::Location::fullLocationInfo#dispred#f0820431#ffffff_20#join_rhs ON FIRST 1 OUTPUT Lhs.2, Lhs.1, Rhs.1", + " {3} r5 = JOIN r4 WITH Access::Access::getTarget#dispred#f0820431#ff_10#join_rhs ON FIRST 1 OUTPUT Rhs.1, Lhs.2, Lhs.1", + " {2} r6 = JOIN r5 WITH Expr::Expr::getLocation#dispred#f0820431#ff ON FIRST 2 OUTPUT Lhs.0, Lhs.2", + " {3} r7 = JOIN r6 WITH Expr::Expr::getEnclosingFunction#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1, Lhs.0", + " {2} r8 = JOIN r7 WITH Expr::Expr::getEnclosingFunction#dispred#f0820431#ff ON FIRST 2 OUTPUT Lhs.2, Lhs.0", + " return r8" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 286635, 324197, 87124, 13435037, 1608611830, 144186, 144074, 139364 ], + "duplicationPercentages" : [ 0, 1, 5, 8, 0, 0, 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:30:58.167Z", + "raHash" : "c34c60l5v5n6e0kb43kpbks9189", + "predicateName" : "#select#query#ffffffffffffff#shared", + "appearsAs" : { + "#select#query#ffffffffffffff#shared" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 31, + "resultSize" : 139364, + "dependencies" : { + "#select#ff" : "1bb43c97jpmuh8r2v0f9hktim63", + "Expr::Expr::getLocation#dispred#f0820431#ff" : "041df63fgpb7j4ofhusq62n1gl2" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = SCAN #select#ff OUTPUT In.1, In.0", + " {3} r2 = JOIN r1 WITH Expr::Expr::getLocation#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.1, Lhs.0", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 139364, 139364 ], + "duplicationPercentages" : [ 0, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:30:58.192Z", + "raHash" : "246dd4utksn7p319ea3ma05jum7", + "predicateName" : "Location::Location::hasLocationInfo#dispred#f0820431#ffffff", + "appearsAs" : { + "Location::Location::hasLocationInfo#dispred#f0820431#ffffff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Location.qll:59,3-72,4", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 56, + "resultSize" : 286635, + "dependencies" : { + "Location::Location::fullLocationInfo#dispred#f0820431#ffffff" : "6d5520630p5b5u45b23gi9u7f92", + "File::Container::getAbsolutePath#dispred#f0820431#ff" : "f619196et831u782kri8f1e92qc" + }, + "ra" : { + "pipeline" : [ + " {6} r1 = SCAN Location::Location::fullLocationInfo#dispred#f0820431#ffffff OUTPUT In.1, In.0, In.2, In.3, In.4, In.5", + " {6} r2 = JOIN r1 WITH File::Container::getAbsolutePath#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Rhs.1, Lhs.2, Lhs.3, Lhs.4, Lhs.5", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 286635, 286635 ], + "duplicationPercentages" : [ 0, 3 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:30:58.225Z", + "raHash" : "09604dm1dl4vjtqslai4h80ttt7", + "predicateName" : "#select#query#ffffffffffffff#antijoin_rhs", + "appearsAs" : { + "#select#query#ffffffffffffff#antijoin_rhs" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 20, + "resultSize" : 139364, + "dependencies" : { + "#select#query#ffffffffffffff#shared" : "c34c60l5v5n6e0kb43kpbks9189", + "Location::Location::hasLocationInfo#dispred#f0820431#ffffff" : "246dd4utksn7p319ea3ma05jum7" + }, + "ra" : { + "pipeline" : [ + " {2} r1 = JOIN #select#query#ffffffffffffff#shared WITH Location::Location::hasLocationInfo#dispred#f0820431#ffffff ON FIRST 1 OUTPUT Lhs.1, Lhs.2", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 139364 ], + "duplicationPercentages" : [ 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:30:58.265Z", + "raHash" : "617c2b8gf1lq60g0h6uh3rbc4mf", + "predicateName" : "#select#query#ffffffffffffff#shared#1", + "appearsAs" : { + "#select#query#ffffffffffffff#shared#1" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 34, + "resultSize" : 139364, + "dependencies" : { + "#select#query#ffffffffffffff#shared" : "c34c60l5v5n6e0kb43kpbks9189", + "Location::Location::hasLocationInfo#dispred#f0820431#ffffff" : "246dd4utksn7p319ea3ma05jum7", + "#select#ff" : "1bb43c97jpmuh8r2v0f9hktim63", + "#select#query#ffffffffffffff#antijoin_rhs" : "09604dm1dl4vjtqslai4h80ttt7" + }, + "ra" : { + "pipeline" : [ + " {7} r1 = JOIN #select#query#ffffffffffffff#shared WITH Location::Location::hasLocationInfo#dispred#f0820431#ffffff ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Rhs.1, Rhs.2, Rhs.3, Rhs.4, Rhs.5", + "", + " {2} r2 = #select#ff AND NOT #select#query#ffffffffffffff#antijoin_rhs(Lhs.0, Lhs.1)", + " {7} r3 = SCAN r2 OUTPUT In.0, In.1, \"\", 0, 0, 0, 0", + "", + " {7} r4 = r1 UNION r3", + " return r4" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 139364, -1, 0, 0, -1, 139364 ], + "duplicationPercentages" : [ 1, -1, 0, 0, -1, 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:30:58.297Z", + "raHash" : "f5b2143i1p87oiuhqo54q1r5eb1", + "predicateName" : "project#Element::ElementBase::toString#dispred#f0820431", + "appearsAs" : { + "project#Element::ElementBase::toString#dispred#f0820431" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\lib\\semmle\\code\\cpp\\Element.qll:58,3-60,31", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 23, + "resultSize" : 529724, + "dependencies" : { + "Element::ElementBase::toString#dispred#f0820431#ff" : "966812g6968j8ja8hlgihop4k30" + }, + "ra" : { + "pipeline" : [ + " {1} r1 = SCAN Element::ElementBase::toString#dispred#f0820431#ff OUTPUT In.0", + " {1} r2 = STREAM DEDUP r1", + " return r2" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 529724, 529724 ], + "duplicationPercentages" : [ 0, 0 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:30:58.298Z", + "raHash" : "3569bdpdntnfsp6fsjuu87ng0v5", + "predicateName" : "#select#query#ffffffffffffff#shared#2", + "appearsAs" : { + "#select#query#ffffffffffffff#shared#2" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 24, + "resultSize" : 139364, + "dependencies" : { + "#select#query#ffffffffffffff#shared#1" : "617c2b8gf1lq60g0h6uh3rbc4mf", + "Expr::Expr::getLocation#dispred#f0820431#ff" : "041df63fgpb7j4ofhusq62n1gl2" + }, + "ra" : { + "pipeline" : [ + " {8} r1 = JOIN #select#query#ffffffffffffff#shared#1 WITH Expr::Expr::getLocation#dispred#f0820431#ff ON FIRST 1 OUTPUT Rhs.1, Lhs.0, Lhs.1, Lhs.2, Lhs.3, Lhs.4, Lhs.5, Lhs.6", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 139364 ], + "duplicationPercentages" : [ 7 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:30:58.332Z", + "raHash" : "4cf8f287shdssv36q142q5p6gib", + "predicateName" : "#select#query#ffffffffffffff#antijoin_rhs#1", + "appearsAs" : { + "#select#query#ffffffffffffff#antijoin_rhs#1" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 20, + "resultSize" : 139364, + "dependencies" : { + "#select#query#ffffffffffffff#shared#2" : "3569bdpdntnfsp6fsjuu87ng0v5", + "Location::Location::hasLocationInfo#dispred#f0820431#ffffff" : "246dd4utksn7p319ea3ma05jum7" + }, + "ra" : { + "pipeline" : [ + " {7} r1 = JOIN #select#query#ffffffffffffff#shared#2 WITH Location::Location::hasLocationInfo#dispred#f0820431#ffffff ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.3, Lhs.4, Lhs.5, Lhs.6, Lhs.7", + " return r1" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 139364 ], + "duplicationPercentages" : [ 1 ] + } ] +} + +{ + "completionTime" : "2022-08-10T21:30:58.484Z", + "raHash" : "ece30ao6rensnka4ndi0hdg6nj8", + "predicateName" : "#select#query#ffffffffffffff", + "appearsAs" : { + "#select#query#ffffffffffffff" : { + "BadAdditionOverflowCheck.ql" : [ 6 ] + } + }, + "position" : "C:\\Src\\Work\\perf-debugging\\semmle-code\\ql\\cpp\\ql\\src\\Likely Bugs\\Arithmetic\\BadAdditionOverflowCheck.ql:21,1-26,16", + "queryCausingWork" : "BadAdditionOverflowCheck.ql", + "evaluationStrategy" : "COMPUTE_SIMPLE", + "millis" : 139, + "resultSize" : 139364, + "dependencies" : { + "#select#query#ffffffffffffff#shared#2" : "3569bdpdntnfsp6fsjuu87ng0v5", + "Location::Location::hasLocationInfo#dispred#f0820431#ffffff" : "246dd4utksn7p319ea3ma05jum7", + "#select#query#ffffffffffffff#shared#1" : "617c2b8gf1lq60g0h6uh3rbc4mf", + "#select#query#ffffffffffffff#antijoin_rhs#1" : "4cf8f287shdssv36q142q5p6gib", + "Element::ElementBase::toString#dispred#f0820431#ff" : "966812g6968j8ja8hlgihop4k30", + "project#Element::ElementBase::toString#dispred#f0820431" : "f5b2143i1p87oiuhqo54q1r5eb1" + }, + "ra" : { + "pipeline" : [ + " {12} r1 = JOIN #select#query#ffffffffffffff#shared#2 WITH Location::Location::hasLocationInfo#dispred#f0820431#ffffff ON FIRST 1 OUTPUT Lhs.1, Lhs.2, Lhs.3, Lhs.4, Lhs.5, Lhs.6, Lhs.7, Rhs.1, Rhs.2, Rhs.3, Rhs.4, Rhs.5", + "", + " {7} r2 = #select#query#ffffffffffffff#shared#1 AND NOT #select#query#ffffffffffffff#antijoin_rhs#1(Lhs.0, Lhs.1, Lhs.2, Lhs.3, Lhs.4, Lhs.5, Lhs.6)", + " {12} r3 = SCAN r2 OUTPUT In.0, In.1, In.2, In.3, In.4, In.5, In.6, \"\", 0, 0, 0, 0", + "", + " {12} r4 = r1 UNION r3", + "", + " {13} r5 = JOIN r4 WITH Element::ElementBase::toString#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Lhs.0, Lhs.2, Lhs.3, Lhs.4, Lhs.5, Lhs.6, Lhs.7, Lhs.8, Lhs.9, Lhs.10, Lhs.11, Rhs.1", + "", + " {12} r6 = r4 AND NOT project#Element::ElementBase::toString#dispred#f0820431(Lhs.0)", + " {13} r7 = SCAN r6 OUTPUT In.1, In.0, In.2, In.3, In.4, In.5, In.6, In.7, In.8, In.9, In.10, In.11, \"(no string representation)\"", + "", + " {13} r8 = r5 UNION r7", + " {14} r9 = JOIN r8 WITH Element::ElementBase::toString#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.1, Lhs.12, Lhs.7, Lhs.8, Lhs.9, Lhs.10, Lhs.11, Lhs.0, Rhs.1, Lhs.2, Lhs.3, Lhs.4, Lhs.5, Lhs.6", + "", + " {13} r10 = JOIN r4 WITH Element::ElementBase::toString#dispred#f0820431#ff ON FIRST 1 OUTPUT Lhs.0, Lhs.1, Lhs.2, Lhs.3, Lhs.4, Lhs.5, Lhs.6, Lhs.7, Lhs.8, Lhs.9, Lhs.10, Lhs.11, Rhs.1", + "", + " {7} r11 = #select#query#ffffffffffffff#shared#1 AND NOT #select#query#ffffffffffffff#antijoin_rhs#1(Lhs.0, Lhs.1, Lhs.2, Lhs.3, Lhs.4, Lhs.5, Lhs.6)", + " {12} r12 = SCAN r11 OUTPUT In.0, In.1, In.2, In.3, In.4, In.5, In.6, \"\", 0, 0, 0, 0", + "", + " {12} r13 = r1 UNION r12", + " {12} r14 = r13 AND NOT project#Element::ElementBase::toString#dispred#f0820431(Lhs.0)", + " {13} r15 = SCAN r14 OUTPUT In.0, In.1, In.2, In.3, In.4, In.5, In.6, In.7, In.8, In.9, In.10, In.11, \"(no string representation)\"", + "", + " {13} r16 = r10 UNION r15", + " {13} r17 = r16 AND NOT project#Element::ElementBase::toString#dispred#f0820431(Lhs.1)", + " {14} r18 = SCAN r17 OUTPUT In.0, In.12, In.7, In.8, In.9, In.10, In.11, In.1, \"(no string representation)\", In.2, In.3, In.4, In.5, In.6", + "", + " {14} r19 = r9 UNION r18", + " return r19" + ] + }, + "pipelineRuns" : [ { + "raReference" : "pipeline", + "counts" : [ 139364, -1, 0, 0, -1, 139364, -1, 139364, -1, 0, 0, -1, 139364, 139364, -1, 139364, -1, 0, 0, -1, 139364, 0, 0, -1, 139364, 0, 0, -1, 139364 ], + "duplicationPercentages" : [ 0, -1, 0, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 2, -1, 0, 0, -1, 0, 0, 0, -1, 2, 0, 0, -1, 0 ] + } ] +} \ No newline at end of file diff --git a/extensions/ql-vscode/test/pure-tests/log-scanner.test.ts b/extensions/ql-vscode/test/pure-tests/log-scanner.test.ts new file mode 100644 index 000000000..db0e79f0f --- /dev/null +++ b/extensions/ql-vscode/test/pure-tests/log-scanner.test.ts @@ -0,0 +1,45 @@ +import { expect } from 'chai'; +import 'mocha'; +import { EvaluationLogProblemReporter, EvaluationLogScannerSet } from '../../src/log-insights/log-scanner'; +import { JoinOrderScannerProvider } from '../../src/log-insights/join-order'; +import * as path from 'path'; + +interface TestProblem { + predicateName: string; + raHash: string; + iteration: number; + message: string; +} + +class TestProblemReporter implements EvaluationLogProblemReporter { + public readonly problems: TestProblem[] = []; + + public reportProblem(predicateName: string, raHash: string, iteration: number, message: string): void { + this.problems.push({ + predicateName, + raHash, + iteration, + message + }); + } + + public log(message: string): void { + console.log(message); + } +} + +describe('log scanners', function() { + it('should detect bad join orders', async function() { + const scanners = new EvaluationLogScannerSet(); + scanners.registerLogScannerProvider(new JoinOrderScannerProvider()); + const summaryPath = path.join(__dirname, 'evaluator-log-summaries/bad-join-order.jsonl'); + const problemReporter = new TestProblemReporter(); + await scanners.scanLog(summaryPath, problemReporter); + + expect(problemReporter.problems.length).to.equal(1); + expect(problemReporter.problems[0].predicateName).to.equal('#select#ff'); + expect(problemReporter.problems[0].raHash).to.equal('1bb43c97jpmuh8r2v0f9hktim63'); + expect(problemReporter.problems[0].iteration).to.equal(0); + expect(problemReporter.problems[0].message).to.equal('Relation \'#select#ff\' has an inefficient join order. Its join order metric is 4961.83, which is larger than the threshold of 50.00.'); + }); +}); diff --git a/extensions/ql-vscode/test/pure-tests/log-summary-parser.test.ts b/extensions/ql-vscode/test/pure-tests/log-summary-parser.test.ts index f157120a8..c89def167 100644 --- a/extensions/ql-vscode/test/pure-tests/log-summary-parser.test.ts +++ b/extensions/ql-vscode/test/pure-tests/log-summary-parser.test.ts @@ -1,5 +1,4 @@ import { expect } from 'chai'; -import * as fs from 'fs-extra'; import * as path from 'path'; import 'mocha'; @@ -8,8 +7,8 @@ import { parseViewerData } from '../../src/pure/log-summary-parser'; describe('Evaluator log summary tests', async function() { describe('for a valid summary text', async function() { it('should return only valid EvalLogData objects', async function() { - const validSummaryText = await fs.readFile(path.join(__dirname, 'evaluator-log-summaries/valid-summary.jsonl'), 'utf8'); - const logDataItems = parseViewerData(validSummaryText.toString()); + const validSummaryPath = path.join(__dirname, 'evaluator-log-summaries/valid-summary.jsonl'); + const logDataItems = await parseViewerData(validSummaryPath); expect(logDataItems).to.not.be.undefined; expect(logDataItems.length).to.eq(3); for (const item of logDataItems) { @@ -27,14 +26,14 @@ describe('Evaluator log summary tests', async function() { }); it('should not parse a summary header object', async function() { - const invalidHeaderText = await fs.readFile(path.join(__dirname, 'evaluator-log-summaries/invalid-header.jsonl'), 'utf8'); - const logDataItems = parseViewerData(invalidHeaderText); + const invalidHeaderPath = path.join(__dirname, 'evaluator-log-summaries/invalid-header.jsonl'); + const logDataItems = await parseViewerData(invalidHeaderPath); expect(logDataItems.length).to.eq(0); }); it('should not parse a log event missing RA or millis fields', async function() { - const invalidSummaryText = await fs.readFile(path.join(__dirname, 'evaluator-log-summaries/invalid-summary.jsonl'), 'utf8'); - const logDataItems = parseViewerData(invalidSummaryText); + const invalidSummaryPath = path.join(__dirname, 'evaluator-log-summaries/invalid-summary.jsonl'); + const logDataItems = await parseViewerData(invalidSummaryPath); expect(logDataItems.length).to.eq(0); }); });