mirror of
https://github.com/compiler-explorer/compiler-explorer.git
synced 2025-12-27 07:04:04 -05:00
fd3dd917f5
Port to vitest. Port everything to typescript. Remove chai, mocha and chai-as-promised. Adds some docs.
341 lines
13 KiB
TypeScript
341 lines
13 KiB
TypeScript
// Copyright (c) 2018, Compiler Explorer Authors
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
import {describe, expect, it} from 'vitest';
|
|
|
|
import {unwrap} from '../lib/assert.js';
|
|
import {BaseCompiler} from '../lib/base-compiler.js';
|
|
import {CompilationEnvironment} from '../lib/compilation-env.js';
|
|
import {CppDemangler, Win32Demangler} from '../lib/demangler/index.js';
|
|
import {PrefixTree} from '../lib/demangler/prefix-tree.js';
|
|
import * as exec from '../lib/exec.js';
|
|
import * as properties from '../lib/properties.js';
|
|
import {SymbolStore} from '../lib/symbol-store.js';
|
|
import * as utils from '../lib/utils.js';
|
|
|
|
import {fs, makeFakeCompilerInfo, path, resolvePathFromTestRoot} from './utils.js';
|
|
|
|
const cppfiltpath = 'c++filt';
|
|
|
|
class DummyCompiler extends BaseCompiler {
|
|
constructor() {
|
|
const env = {
|
|
ceProps: properties.fakeProps({}),
|
|
compilerProps: () => {},
|
|
} as unknown as CompilationEnvironment;
|
|
|
|
// using c++ as the compiler needs at least one language
|
|
const compiler = makeFakeCompilerInfo({lang: 'c++'});
|
|
|
|
super(compiler, env);
|
|
}
|
|
override exec(command, args, options) {
|
|
return exec.execute(command, args, options);
|
|
}
|
|
}
|
|
|
|
class DummyCppDemangler extends CppDemangler {
|
|
public override collectLabels = super.collectLabels;
|
|
}
|
|
|
|
class DummyWin32Demangler extends Win32Demangler {
|
|
public override collectLabels = super.collectLabels;
|
|
}
|
|
|
|
const catchCppfiltNonexistence = err => {
|
|
if (!err.message.startsWith('spawn c++filt')) {
|
|
throw err;
|
|
}
|
|
};
|
|
|
|
describe('Basic demangling', () => {
|
|
it('One line of asm', () => {
|
|
const result = {
|
|
asm: [{text: 'Hello, World!'}],
|
|
};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
return Promise.all([
|
|
demangler.process(result).then(output => {
|
|
expect(output.asm[0].text).toEqual('Hello, World!');
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it('One label and some asm', () => {
|
|
const result = {asm: [{text: '_Z6squarei:'}, {text: ' ret'}]};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
return Promise.all([
|
|
demangler
|
|
.process(result)
|
|
.then(output => {
|
|
expect(output.asm[0].text).toEqual('square(int):');
|
|
expect(output.asm[1].text).toEqual(' ret');
|
|
})
|
|
.catch(catchCppfiltNonexistence),
|
|
]);
|
|
});
|
|
|
|
it('One label and use of a label', () => {
|
|
const result = {asm: [{text: '_Z6squarei:'}, {text: ' mov eax, $_Z6squarei'}]};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
return Promise.all([
|
|
demangler
|
|
.process(result)
|
|
.then(output => {
|
|
expect(output.asm[0].text).toEqual('square(int):');
|
|
expect(output.asm[1].text).toEqual(' mov eax, $square(int)');
|
|
})
|
|
.catch(catchCppfiltNonexistence),
|
|
]);
|
|
});
|
|
|
|
it('Two destructors', () => {
|
|
const result = {
|
|
asm: [
|
|
{text: '_ZN6NormalD0Ev:'},
|
|
{text: ' callq _ZdlPv'},
|
|
{text: '_Z7caller1v:'},
|
|
{text: ' rep ret'},
|
|
{text: '_Z7caller2P6Normal:'},
|
|
{text: ' cmp rax, OFFSET FLAT:_ZN6NormalD0Ev'},
|
|
{text: ' jmp _ZdlPvm'},
|
|
{text: '_ZN6NormalD2Ev:'},
|
|
{text: ' rep ret'},
|
|
],
|
|
};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
return demangler
|
|
.process(result)
|
|
.then(output => {
|
|
expect(output.asm[0].text).toEqual('Normal::~Normal() [deleting destructor]:');
|
|
expect(output.asm[1].text).toEqual(' callq operator delete(void*)');
|
|
expect(output.asm[6].text).toEqual(' jmp operator delete(void*, unsigned long)');
|
|
})
|
|
.catch(catchCppfiltNonexistence);
|
|
});
|
|
|
|
it('Should ignore comments (CL)', () => {
|
|
const result = {asm: [{text: ' call ??3@YAXPEAX_K@Z ; operator delete'}]};
|
|
|
|
const demangler = new DummyWin32Demangler(cppfiltpath, new DummyCompiler());
|
|
demangler.result = result;
|
|
demangler.symbolstore = new SymbolStore();
|
|
demangler.collectLabels();
|
|
|
|
const output = demangler.win32RawSymbols;
|
|
expect(unwrap(output)).toEqual(['??3@YAXPEAX_K@Z']);
|
|
});
|
|
|
|
it('Should ignore comments (CPP)', () => {
|
|
const result = {asm: [{text: ' call hello ; operator delete'}]};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
demangler.result = result;
|
|
demangler.symbolstore = new SymbolStore();
|
|
demangler.collectLabels();
|
|
|
|
const output = demangler.othersymbols.listSymbols();
|
|
expect(output).toEqual(['hello']);
|
|
});
|
|
|
|
it('Should also support ARM branch instructions', () => {
|
|
const result = {asm: [{text: ' bl _ZN3FooC1Ev'}]};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
demangler.result = result;
|
|
demangler.symbolstore = new SymbolStore();
|
|
demangler.collectLabels();
|
|
|
|
const output = demangler.othersymbols.listSymbols();
|
|
expect(output).toEqual(['_ZN3FooC1Ev']);
|
|
});
|
|
|
|
it('Should NOT handle undecorated labels', () => {
|
|
const result = {asm: [{text: '$LN3@caller2:'}]};
|
|
|
|
const demangler = new DummyWin32Demangler(cppfiltpath, new DummyCompiler());
|
|
demangler.result = result;
|
|
demangler.symbolstore = new SymbolStore();
|
|
demangler.collectLabels();
|
|
|
|
const output = demangler.win32RawSymbols;
|
|
expect(output).toEqual([]);
|
|
});
|
|
|
|
it('Should ignore comments after jmps', () => {
|
|
const result = {asm: [{text: ' jmp _Z1fP6mytype # TAILCALL'}]};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
demangler.result = result;
|
|
demangler.symbolstore = new SymbolStore();
|
|
demangler.collectLabels();
|
|
|
|
const output = demangler.othersymbols.listSymbols();
|
|
expect(output).toEqual(['_Z1fP6mytype']);
|
|
});
|
|
|
|
it('Should still work with normal jmps', () => {
|
|
const result = {asm: [{text: ' jmp _Z1fP6mytype'}]};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
demangler.result = result;
|
|
demangler.symbolstore = new SymbolStore();
|
|
demangler.collectLabels();
|
|
|
|
const output = demangler.othersymbols.listSymbols();
|
|
expect(output).toEqual(['_Z1fP6mytype']);
|
|
});
|
|
|
|
it('Should support CUDA PTX', () => {
|
|
const result = {
|
|
asm: [
|
|
{text: ' .visible .entry _Z6squarePii('},
|
|
{text: ' .param .u64 _Z6squarePii_param_0,'},
|
|
{text: ' ld.param.u64 %rd1, [_Z6squarePii_param_0];'},
|
|
{text: ' .func (.param .b32 func_retval0) _Z4cubePii('},
|
|
{text: '.global .attribute(.managed) .align 4 .b8 _ZN2ns9mymanagedE[16];'},
|
|
{text: '.global .texref _ZN2ns6texRefE;'},
|
|
{text: '.const .align 8 .u64 _ZN2ns5mystrE = generic($str);'},
|
|
],
|
|
};
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
return Promise.all([
|
|
demangler
|
|
.process(result)
|
|
.then(output => {
|
|
expect(output.asm[0].text).toEqual(' .visible .entry square(int*, int)(');
|
|
expect(output.asm[1].text).toEqual(' .param .u64 square(int*, int)_param_0,');
|
|
expect(output.asm[2].text).toEqual(' ld.param.u64 %rd1, [square(int*, int)_param_0];');
|
|
expect(output.asm[3].text).toEqual(' .func (.param .b32 func_retval0) cube(int*, int)(');
|
|
expect(output.asm[4].text).toEqual('.global .attribute(.managed) .align 4 .b8 ns::mymanaged[16];');
|
|
expect(output.asm[5].text).toEqual('.global .texref ns::texRef;');
|
|
expect(output.asm[6].text).toEqual('.const .align 8 .u64 ns::mystr = generic($str);');
|
|
})
|
|
.catch(catchCppfiltNonexistence),
|
|
]);
|
|
});
|
|
});
|
|
|
|
async function readResultFile(filename: string) {
|
|
const data = await fs.readFile(filename);
|
|
const asm = utils.splitLines(data.toString()).map(line => {
|
|
return {text: line};
|
|
});
|
|
|
|
return {asm};
|
|
}
|
|
|
|
async function DoDemangleTest(filename: string) {
|
|
const resultIn = await readResultFile(filename);
|
|
const resultOut = await readResultFile(filename + '.demangle');
|
|
|
|
const demangler = new DummyCppDemangler(cppfiltpath, new DummyCompiler(), ['-n']);
|
|
|
|
await expect(demangler.process(resultIn)).resolves.toEqual(resultOut);
|
|
}
|
|
|
|
if (process.platform === 'linux') {
|
|
describe('File demangling', () => {
|
|
const testcasespath = resolvePathFromTestRoot('demangle-cases');
|
|
|
|
/*
|
|
* NB: this readdir must *NOT* be async
|
|
*
|
|
* Mocha calls the function passed to `describe` synchronously
|
|
* and expects the test suite to be fully configured upon return.
|
|
*
|
|
* If you pass an async function to describe and setup test cases
|
|
* after an await there is no guarantee they will be found, and
|
|
* if they are they will not end up in the expected suite.
|
|
*/
|
|
const files = fs.readdirSync(testcasespath);
|
|
|
|
for (const filename of files) {
|
|
if (filename.endsWith('.asm')) {
|
|
it(filename, async () => {
|
|
await DoDemangleTest(path.join(testcasespath, filename));
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
describe('Demangler prefix tree', () => {
|
|
const replacements = new PrefixTree([]);
|
|
replacements.add('a', 'short_a');
|
|
replacements.add('aa', 'long_a');
|
|
replacements.add('aa_shouldnotmatch', 'ERROR');
|
|
it('should replace a short match', () => {
|
|
expect(replacements.replaceAll('a')).toEqual('short_a');
|
|
});
|
|
it('should replace using the longest match', () => {
|
|
expect(replacements.replaceAll('aa')).toEqual('long_a');
|
|
});
|
|
it('should replace using both', () => {
|
|
expect(replacements.replaceAll('aaa')).toEqual('long_ashort_a');
|
|
});
|
|
it('should replace using both', () => {
|
|
expect(replacements.replaceAll('a aa a aa')).toEqual('short_a long_a short_a long_a');
|
|
});
|
|
it('should work with empty replacements', () => {
|
|
expect(new PrefixTree([]).replaceAll('Testing 123')).toEqual('Testing 123');
|
|
});
|
|
it('should leave unmatching text alone', () => {
|
|
expect(replacements.replaceAll('Some text with none of the first letter of the ordered letter list')).toEqual(
|
|
'Some text with none of the first letter of the ordered letter list',
|
|
);
|
|
});
|
|
it('should handle a mixture', () => {
|
|
expect(replacements.replaceAll('Everyone loves an aardvark')).toEqual(
|
|
'Everyone loves short_an long_ardvshort_ark',
|
|
);
|
|
});
|
|
it('should find exact matches', () => {
|
|
expect(unwrap(replacements.findExact('a'))).toEqual('short_a');
|
|
expect(unwrap(replacements.findExact('aa'))).toEqual('long_a');
|
|
expect(unwrap(replacements.findExact('aa_shouldnotmatch'))).toEqual('ERROR');
|
|
});
|
|
it('should find not find mismatches', () => {
|
|
expect(replacements.findExact('aaa')).toBeNull();
|
|
expect(replacements.findExact(' aa')).toBeNull();
|
|
expect(replacements.findExact(' a')).toBeNull();
|
|
expect(replacements.findExact('Oh noes')).toBeNull();
|
|
expect(replacements.findExact('')).toBeNull();
|
|
});
|
|
});
|