378 lines
10 KiB
C++
378 lines
10 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
// This program is used by the DMD xpcshell test. It is run under DMD and
|
|
// produces some output. The xpcshell test then post-processes and checks this
|
|
// output.
|
|
//
|
|
// Note that this file does not have "Test" or "test" in its name, because that
|
|
// will cause the build system to not record breakpad symbols for it, which
|
|
// will stop the post-processing (which includes stack fixing) from working
|
|
// correctly.
|
|
|
|
// This is required on some systems such as Fedora to allow
|
|
// building with -O0 together with --warnings-as-errors due to
|
|
// a check in /usr/include/features.h
|
|
#undef _FORTIFY_SOURCE
|
|
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/JSONWriter.h"
|
|
#include "mozilla/Sprintf.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "DMD.h"
|
|
|
|
using mozilla::MakeUnique;
|
|
using namespace mozilla::dmd;
|
|
|
|
MOZ_RUNINIT DMDFuncs::Singleton DMDFuncs::sSingleton;
|
|
|
|
class FpWriteFunc final : public mozilla::JSONWriteFunc {
|
|
public:
|
|
explicit FpWriteFunc(const char* aFilename) {
|
|
mFp = fopen(aFilename, "w");
|
|
if (!mFp) {
|
|
fprintf(stderr, "SmokeDMD: can't create %s file: %s\n", aFilename,
|
|
strerror(errno));
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
~FpWriteFunc() { fclose(mFp); }
|
|
|
|
void Write(const mozilla::Span<const char>& aStr) final {
|
|
for (const char c : aStr) {
|
|
fputc(c, mFp);
|
|
}
|
|
}
|
|
|
|
private:
|
|
FILE* mFp;
|
|
};
|
|
|
|
// This stops otherwise-unused variables from being optimized away.
|
|
static void UseItOrLoseIt(void* aPtr, int aSeven) {
|
|
char buf[64];
|
|
int n = SprintfLiteral(buf, "%p\n", aPtr);
|
|
if (n == 20 + aSeven) {
|
|
fprintf(stderr, "well, that is surprising");
|
|
}
|
|
}
|
|
|
|
// This function checks that heap blocks that have the same stack trace but
|
|
// different (or no) reporters get aggregated separately.
|
|
void Foo(int aSeven) {
|
|
char* a[6];
|
|
for (int i = 0; i < aSeven - 1; i++) {
|
|
a[i] = (char*)malloc(128 - 16 * i);
|
|
UseItOrLoseIt(a[i], aSeven);
|
|
}
|
|
|
|
// Oddly, some versions of clang will cause identical stack traces to be
|
|
// generated for adjacent calls to Report(), which breaks the test. Inserting
|
|
// the UseItOrLoseIt() calls in between is enough to prevent this.
|
|
|
|
Report(a[2]); // reported
|
|
|
|
UseItOrLoseIt(a[2], aSeven);
|
|
|
|
for (int i = 0; i < aSeven - 5; i++) {
|
|
Report(a[i]); // reported
|
|
UseItOrLoseIt(a[i], aSeven);
|
|
}
|
|
|
|
UseItOrLoseIt(a[2], aSeven);
|
|
|
|
Report(a[3]); // reported
|
|
|
|
// a[4], a[5] unreported
|
|
}
|
|
|
|
void TestEmpty(const char* aTestName, const char* aMode) {
|
|
char filename[128];
|
|
SprintfLiteral(filename, "complete-%s-%s.json", aTestName, aMode);
|
|
auto f = MakeUnique<FpWriteFunc>(filename);
|
|
|
|
char options[128];
|
|
SprintfLiteral(options, "--mode=%s --stacks=full", aMode);
|
|
ResetEverything(options);
|
|
|
|
// Zero for everything.
|
|
Analyze(std::move(f));
|
|
}
|
|
|
|
void TestFull(const char* aTestName, int aNum, const char* aMode, int aSeven) {
|
|
char filename[128];
|
|
SprintfLiteral(filename, "complete-%s%d-%s.json", aTestName, aNum, aMode);
|
|
auto f = MakeUnique<FpWriteFunc>(filename);
|
|
|
|
// The --show-dump-stats=yes is there just to give that option some basic
|
|
// testing, e.g. ensure it doesn't crash. It's hard to test much beyond that.
|
|
char options[128];
|
|
SprintfLiteral(options, "--mode=%s --stacks=full --show-dump-stats=yes",
|
|
aMode);
|
|
ResetEverything(options);
|
|
|
|
// Analyze 1: 1 freed, 9 out of 10 unreported.
|
|
// Analyze 2: still present and unreported.
|
|
int i;
|
|
char* a = nullptr;
|
|
for (i = 0; i < aSeven + 3; i++) {
|
|
a = (char*)malloc(100);
|
|
UseItOrLoseIt(a, aSeven);
|
|
}
|
|
free(a);
|
|
|
|
// A no-op.
|
|
free(nullptr);
|
|
|
|
// Note: 16 bytes is the smallest requested size that gives consistent
|
|
// behaviour across all platforms with jemalloc.
|
|
// Analyze 1: reported.
|
|
// Analyze 2: thrice-reported.
|
|
char* a2 = (char*)malloc(16);
|
|
Report(a2);
|
|
|
|
// Analyze 1: reported.
|
|
// Analyze 2: reportedness carries over, due to ReportOnAlloc.
|
|
char* b = (char*)malloc(10);
|
|
ReportOnAlloc(b);
|
|
|
|
// ReportOnAlloc, then freed.
|
|
// Analyze 1: freed, irrelevant.
|
|
// Analyze 2: freed, irrelevant.
|
|
char* b2 = (char*)malloc(16);
|
|
ReportOnAlloc(b2);
|
|
free(b2);
|
|
|
|
// Analyze 1: reported 4 times.
|
|
// Analyze 2: freed, irrelevant.
|
|
char* c = (char*)calloc(10, 3);
|
|
Report(c);
|
|
for (int i = 0; i < aSeven - 4; i++) {
|
|
Report(c);
|
|
}
|
|
|
|
// Analyze 1: ignored.
|
|
// Analyze 2: irrelevant.
|
|
Report((void*)(intptr_t)i);
|
|
|
|
// jemalloc rounds this up to 8192.
|
|
// Analyze 1: reported.
|
|
// Analyze 2: freed.
|
|
char* e = (char*)malloc(4096);
|
|
e = (char*)realloc(e, 7169);
|
|
Report(e);
|
|
|
|
// First realloc is like malloc; second realloc is shrinking.
|
|
// Analyze 1: reported.
|
|
// Analyze 2: re-reported.
|
|
char* e2 = (char*)realloc(nullptr, 1024);
|
|
e2 = (char*)realloc(e2, 512);
|
|
Report(e2);
|
|
|
|
// First realloc is like malloc; second realloc creates a min-sized block.
|
|
// XXX: on Windows, second realloc frees the block.
|
|
// Analyze 1: reported.
|
|
// Analyze 2: freed, irrelevant.
|
|
char* e3 = (char*)realloc(nullptr, 1023);
|
|
// e3 = (char*) realloc(e3, 0);
|
|
MOZ_ASSERT(e3);
|
|
Report(e3);
|
|
|
|
// Analyze 1: freed, irrelevant.
|
|
// Analyze 2: freed, irrelevant.
|
|
char* f1 = (char*)malloc(64);
|
|
UseItOrLoseIt(f1, aSeven);
|
|
free(f1);
|
|
|
|
// Analyze 1: ignored.
|
|
// Analyze 2: irrelevant.
|
|
Report((void*)(intptr_t)0x0);
|
|
|
|
// Analyze 1: mixture of reported and unreported.
|
|
// Analyze 2: all unreported.
|
|
Foo(aSeven);
|
|
|
|
// Analyze 1: twice-reported.
|
|
// Analyze 2: twice-reported.
|
|
char* g1 = (char*)malloc(77);
|
|
ReportOnAlloc(g1);
|
|
ReportOnAlloc(g1);
|
|
|
|
// Analyze 1: mixture of reported and unreported.
|
|
// Analyze 2: all unreported.
|
|
// Nb: this Foo() call is deliberately not adjacent to the previous one. See
|
|
// the comment about adjacent calls in Foo() for more details.
|
|
Foo(aSeven);
|
|
|
|
// Analyze 1: twice-reported.
|
|
// Analyze 2: once-reported.
|
|
char* g2 = (char*)malloc(78);
|
|
Report(g2);
|
|
ReportOnAlloc(g2);
|
|
|
|
// Analyze 1: twice-reported.
|
|
// Analyze 2: once-reported.
|
|
char* g3 = (char*)malloc(79);
|
|
ReportOnAlloc(g3);
|
|
Report(g3);
|
|
|
|
// All the odd-ball ones.
|
|
// Analyze 1: all unreported.
|
|
// Analyze 2: all freed, irrelevant.
|
|
// XXX: no memalign on Mac
|
|
// void* w = memalign(64, 65); // rounds up to 128
|
|
// UseItOrLoseIt(w, aSeven);
|
|
|
|
// XXX: posix_memalign doesn't work on B2G
|
|
// void* x;
|
|
// posix_memalign(&y, 128, 129); // rounds up to 256
|
|
// UseItOrLoseIt(x, aSeven);
|
|
|
|
// XXX: valloc doesn't work on Windows.
|
|
// void* y = valloc(1); // rounds up to 4096
|
|
// UseItOrLoseIt(y, aSeven);
|
|
|
|
// XXX: C11 only
|
|
// void* z = aligned_alloc(64, 256);
|
|
// UseItOrLoseIt(z, aSeven);
|
|
|
|
if (aNum == 1) {
|
|
// Analyze 1.
|
|
Analyze(std::move(f));
|
|
}
|
|
|
|
ClearReports();
|
|
|
|
//---------
|
|
|
|
Report(a2);
|
|
Report(a2);
|
|
free(c);
|
|
free(e);
|
|
Report(e2);
|
|
free(e3);
|
|
// free(w);
|
|
// free(x);
|
|
// free(y);
|
|
// free(z);
|
|
|
|
// Do some allocations that will only show up in cumulative mode.
|
|
for (int i = 0; i < 100; i++) {
|
|
void* v = malloc(128);
|
|
UseItOrLoseIt(v, aSeven);
|
|
free(v);
|
|
}
|
|
|
|
if (aNum == 2) {
|
|
// Analyze 2.
|
|
Analyze(std::move(f));
|
|
}
|
|
}
|
|
|
|
void TestPartial(const char* aTestName, const char* aMode, int aSeven) {
|
|
char filename[128];
|
|
SprintfLiteral(filename, "complete-%s-%s.json", aTestName, aMode);
|
|
auto f = MakeUnique<FpWriteFunc>(filename);
|
|
|
|
char options[128];
|
|
SprintfLiteral(options, "--mode=%s", aMode);
|
|
ResetEverything(options);
|
|
|
|
int kTenThousand = aSeven + 9993;
|
|
char* s;
|
|
|
|
// The output of this function is deterministic but it relies on the
|
|
// probability and seeds given to the FastBernoulliTrial instance in
|
|
// ResetBernoulli(). If they change, the output will change too.
|
|
|
|
// Expected fraction with stacks: (1 - (1 - 0.003) ** 16) = 0.0469.
|
|
// So we expect about 0.0469 * 10000 == 469.
|
|
// We actually get 511.
|
|
for (int i = 0; i < kTenThousand; i++) {
|
|
s = (char*)malloc(16);
|
|
UseItOrLoseIt(s, aSeven);
|
|
}
|
|
|
|
// Expected fraction with stacks: (1 - (1 - 0.003) ** 128) = 0.3193.
|
|
// So we expect about 0.3193 * 10000 == 3193.
|
|
// We actually get 3136.
|
|
for (int i = 0; i < kTenThousand; i++) {
|
|
s = (char*)malloc(128);
|
|
UseItOrLoseIt(s, aSeven);
|
|
}
|
|
|
|
// Expected fraction with stacks: (1 - (1 - 0.003) ** 1024) = 0.9539.
|
|
// So we expect about 0.9539 * 10000 == 9539.
|
|
// We actually get 9531.
|
|
for (int i = 0; i < kTenThousand; i++) {
|
|
s = (char*)malloc(1024);
|
|
UseItOrLoseIt(s, aSeven);
|
|
}
|
|
|
|
Analyze(std::move(f));
|
|
}
|
|
|
|
void TestScan(int aSeven) {
|
|
auto f = MakeUnique<FpWriteFunc>("basic-scan.json");
|
|
|
|
ResetEverything("--mode=scan");
|
|
|
|
uintptr_t* p = (uintptr_t*)malloc(6 * sizeof(uintptr_t));
|
|
UseItOrLoseIt(p, aSeven);
|
|
|
|
// Hard-coded values checked by scan-test.py
|
|
p[0] = 0x123; // outside a block, small value
|
|
p[1] = 0x0; // null
|
|
p[2] = (uintptr_t)((uint8_t*)p - 1); // pointer outside a block, but nearby
|
|
p[3] = (uintptr_t)p; // pointer to start of a block
|
|
p[4] = (uintptr_t)((uint8_t*)p + 1); // pointer into a block
|
|
p[5] = 0x0; // trailing null
|
|
|
|
Analyze(std::move(f));
|
|
}
|
|
|
|
void RunTests() {
|
|
// This test relies on the compiler not doing various optimizations, such as
|
|
// eliding unused malloc() calls or unrolling loops with fixed iteration
|
|
// counts. So we compile it with -O0 (or equivalent), which probably prevents
|
|
// that. We also use the following variable for various loop iteration
|
|
// counts, just in case compilers might unroll very small loops even with
|
|
// -O0.
|
|
int seven = 7;
|
|
|
|
// Make sure that DMD is actually running; it is initialized on the first
|
|
// allocation.
|
|
int* x = (int*)malloc(100);
|
|
UseItOrLoseIt(x, seven);
|
|
MOZ_RELEASE_ASSERT(IsRunning());
|
|
|
|
// Please keep this in sync with run_test in test_dmd.js.
|
|
|
|
TestEmpty("empty", "live");
|
|
TestEmpty("empty", "dark-matter");
|
|
TestEmpty("empty", "cumulative");
|
|
|
|
TestFull("full", 1, "live", seven);
|
|
TestFull("full", 1, "dark-matter", seven);
|
|
|
|
TestFull("full", 2, "dark-matter", seven);
|
|
TestFull("full", 2, "cumulative", seven);
|
|
|
|
TestPartial("partial", "live", seven);
|
|
|
|
TestScan(seven);
|
|
}
|
|
|
|
int main() {
|
|
RunTests();
|
|
|
|
return 0;
|
|
}
|