Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-15 06:15:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

merge mozilla-central to autoland to fix spidermonkey bustage. r=merge a=merge

Browse Source
This commit is contained in:
Sebastian Hengst 2016-09-07 18:51:09 +02:00
commit 1855efaca1
17 changed files with 0 additions and 628 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
browser/app/moz.build
View File

@ -33,9 +33,6 @@ USE_LIBS += [
'mozglue',
]
if CONFIG['LIBFUZZER']:
USE_LIBS += [ 'fuzzer' ]
if CONFIG['_MSC_VER']:
# Always enter a Windows program through wmain, whether or not we're
# a console application.

24
browser/app/nsBrowserApp.cpp
View File

@ -129,10 +129,6 @@ XRE_GetProcessTypeType XRE_GetProcessType;
XRE_SetProcessTypeType XRE_SetProcessType;
XRE_InitChildProcessType XRE_InitChildProcess;
XRE_EnableSameExecutableForContentProcType XRE_EnableSameExecutableForContentProc;
#ifdef LIBFUZZER
XRE_LibFuzzerSetMainType XRE_LibFuzzerSetMain;
XRE_LibFuzzerGetFuncsType XRE_LibFuzzerGetFuncs;
#endif
static const nsDynamicFunctionLoad kXULFuncs[] = {
{ "XRE_GetFileFromPath", (NSFuncPtr*) &XRE_GetFileFromPath },
@ -147,24 +143,9 @@ static const nsDynamicFunctionLoad kXULFuncs[] = {
{ "XRE_SetProcessType", (NSFuncPtr*) &XRE_SetProcessType },
{ "XRE_InitChildProcess", (NSFuncPtr*) &XRE_InitChildProcess },
{ "XRE_EnableSameExecutableForContentProc", (NSFuncPtr*) &XRE_EnableSameExecutableForContentProc },
#ifdef LIBFUZZER
{ "XRE_LibFuzzerSetMain", (NSFuncPtr*) &XRE_LibFuzzerSetMain },
{ "XRE_LibFuzzerGetFuncs", (NSFuncPtr*) &XRE_LibFuzzerGetFuncs },
#endif
{ nullptr, nullptr }
};
#ifdef LIBFUZZER
int libfuzzer_main(int argc, char **argv);
/* This wrapper is used by the libFuzzer main to call into libxul */
void libFuzzerGetFuncs(const char* moduleName, LibFuzzerInitFunc* initFunc,
LibFuzzerTestingFunc* testingFunc) {
return XRE_LibFuzzerGetFuncs(moduleName, initFunc, testingFunc);
}
#endif
static int do_main(int argc, char* argv[], char* envp[], nsIFile *xreDirectory)
{
nsCOMPtr<nsIFile> appini;
@ -275,11 +256,6 @@ static int do_main(int argc, char* argv[], char* envp[], nsIFile *xreDirectory)
appData.sandboxBrokerServices = brokerServices;
#endif
#ifdef LIBFUZZER
if (getenv("LIBFUZZER"))
XRE_LibFuzzerSetMain(argc, argv, libfuzzer_main);
#endif
return XRE_main(argc, argv, &appData, mainFlags);
}

1
moz.build
View File

@ -57,7 +57,6 @@ DIRS += [
'memory',
'mfbt',
'mozglue',
'tools/fuzzing',
]
if not CONFIG['JS_STANDALONE']:

12
toolkit/moz.configure
View File

@ -764,15 +764,3 @@ def skia_includes(skia, skia_gpu):
return includes
set_config('SKIA_INCLUDES', skia_includes)
# Support various fuzzing options
# ==============================================================
option('--enable-libfuzzer', help='Enable libfuzzer support')
@depends('--enable-libfuzzer')
def enable_libfuzzer(value):
if value:
return True
set_config('LIBFUZZER', enable_libfuzzer)
set_define('LIBFUZZER', enable_libfuzzer)

19
toolkit/xre/nsAppRunner.cpp
View File

@ -258,18 +258,6 @@ nsString gAbsoluteArgv0Path;
extern "C" MFBT_API bool IsSignalHandlingBroken();
#endif
#ifdef LIBFUZZER
#include "LibFuzzerRunner.h"
namespace mozilla {
LibFuzzerRunner* libFuzzerRunner = 0;
} // namespace mozilla
extern "C" MOZ_EXPORT void XRE_LibFuzzerSetMain(int argc, char** argv, LibFuzzerMain main) {
mozilla::libFuzzerRunner->setParams(argc, argv, main);
}
#endif
namespace mozilla {
int (*RunGTest)() = 0;
} // namespace mozilla
@ -3654,13 +3642,6 @@ XREMain::XRE_mainStartup(bool* aExitFlag)
return 1;
#endif /* MOZ_WIDGET_GTK */
#ifdef LIBFUZZER
if (PR_GetEnv("LIBFUZZER")) {
*aExitFlag = true;
return mozilla::libFuzzerRunner->Run();
}
#endif
if (PR_GetEnv("MOZ_RUN_GTEST")) {
int result;
#ifdef XP_WIN

37
tools/fuzzing/libfuzzer/FuzzerCustomMain.cpp
View File

@ -1,37 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* * 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/. */
#include <cstdlib>
#include "FuzzerInterface.h"
#include "FuzzerInternal.h"
#include "harness/LibFuzzerRegistry.h"
/* This is a wrapper defined in browser/app/nsBrowserApp.cpp,
* encapsulating the XRE_ equivalent defined in libxul */
extern void libFuzzerGetFuncs(const char*, LibFuzzerInitFunc*,
LibFuzzerTestingFunc*);
int libfuzzer_main(int argc, char **argv) {
LibFuzzerInitFunc initFunc = nullptr;
LibFuzzerTestingFunc testingFunc = nullptr;
libFuzzerGetFuncs(getenv("LIBFUZZER"), &initFunc, &testingFunc);
if (initFunc) {
int ret = initFunc(&argc, &argv);
if (ret) {
fprintf(stderr, "LibFuzzer: Error: Initialize callback failed\n");
return ret;
}
}
if (!testingFunc) {
fprintf(stderr, "LibFuzzer: Error: No testing callback found\n");
return 1;
}
return fuzzer::FuzzerDriver(&argc, &argv, testingFunc);
}

12
tools/fuzzing/libfuzzer/Makefile.in
View File

@ -1,12 +0,0 @@
# 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/.
include $(topsrcdir)/config/rules.mk
# According to the LLVM docs, LibFuzzer isn't supposed to be built with any
# sanitizer flags and in fact, building it with ASan coverage currently causes
# Clang 3.9+ to crash, so we filter out all sanitizer-related flags here.
CXXFLAGS := $(filter-out -fsanitize%,$(CXXFLAGS))
CFLAGS := $(filter-out -fsanitize%,$(CFLAGS))
LDFLAGS := $(filter-out -fsanitize%,$(LDFLAGS))

7
tools/fuzzing/libfuzzer/clone_libfuzzer.sh
View File

@ -1,7 +0,0 @@
#!/bin/sh
mkdir tmp/
git clone --no-checkout --depth 1 https://chromium.googlesource.com/chromium/llvm-project/llvm/lib/Fuzzer tmp/
mv tmp/.git .
rm -Rf tmp
git reset --hard HEAD

32
tools/fuzzing/libfuzzer/harness/LibFuzzerRegistry.cpp
View File

@ -1,32 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* * 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/. */
#include "LibFuzzerRegistry.h"
extern "C" {
void MOZ_EXPORT XRE_LibFuzzerGetFuncs(const char* moduleName, LibFuzzerInitFunc* initFunc, LibFuzzerTestingFunc* testingFunc) {
std::string moduleNameStr(moduleName);
mozilla::LibFuzzerFunctions funcs = mozilla::LibFuzzerRegistry::getInstance().getModuleFunctions(moduleNameStr);
*initFunc = funcs.first;
*testingFunc = funcs.second;
}
}
namespace mozilla {
LibFuzzerRegistry& LibFuzzerRegistry::getInstance() {
static LibFuzzerRegistry instance;
return instance;
}
void LibFuzzerRegistry::registerModule(std::string moduleName, LibFuzzerInitFunc initFunc, LibFuzzerTestingFunc testingFunc) {
moduleMap.insert(std::pair<std::string, LibFuzzerFunctions>(moduleName,LibFuzzerFunctions(initFunc, testingFunc)));
}
LibFuzzerFunctions LibFuzzerRegistry::getModuleFunctions(std::string& moduleName) {
return moduleMap[moduleName];
}
} // namespace mozilla

41
tools/fuzzing/libfuzzer/harness/LibFuzzerRegistry.h
View File

@ -1,41 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* * 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/. */
#ifndef _LibFuzzerRegistry_h__
#define _LibFuzzerRegistry_h__
#include <cstdint>
#include <map>
#include <string>
#include <utility>
#include "mozilla/Attributes.h"
typedef int(*LibFuzzerMain)(int, char**);
typedef int(*LibFuzzerInitFunc)(int*, char***);
typedef int(*LibFuzzerTestingFunc)(const uint8_t*, size_t);
namespace mozilla {
typedef std::pair<LibFuzzerInitFunc, LibFuzzerTestingFunc> LibFuzzerFunctions;
class LibFuzzerRegistry {
public:
MOZ_EXPORT static LibFuzzerRegistry& getInstance();
MOZ_EXPORT void registerModule(std::string moduleName, LibFuzzerInitFunc initFunc, LibFuzzerTestingFunc testingFunc);
MOZ_EXPORT LibFuzzerFunctions getModuleFunctions(std::string& moduleName);
LibFuzzerRegistry(LibFuzzerRegistry const&) = delete;
void operator=(LibFuzzerRegistry const&) = delete;
private:
LibFuzzerRegistry() {};
std::map<std::string, LibFuzzerFunctions> moduleMap;
};
} // namespace mozilla
#endif // _LibFuzzerRegistry_h__

38
tools/fuzzing/libfuzzer/harness/LibFuzzerRunner.cpp
View File

@ -1,38 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* * 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/. */
#include "LibFuzzerRunner.h"
#include "mozilla/Attributes.h"
#include "prenv.h"
#include "LibFuzzerTestHarness.h"
namespace mozilla {
// We use a static var 'libFuzzerRunner' defined in nsAppRunner.cpp.
// libFuzzerRunner is initialized to nullptr but if LibFuzzer (this file)
// is linked in then libFuzzerRunner will be set here indicating that
// we want to call into LibFuzzer's main.
class _InitLibFuzzer {
public:
_InitLibFuzzer() {
libFuzzerRunner = new LibFuzzerRunner();
}
} InitLibFuzzer;
int LibFuzzerRunner::Run() {
ScopedXPCOM xpcom("LibFuzzer");
return mFuzzerMain(mArgc, mArgv);
}
typedef int(*LibFuzzerMain)(int, char**);
void LibFuzzerRunner::setParams(int argc, char** argv, LibFuzzerMain main) {
mArgc = argc;
mArgv = argv;
mFuzzerMain = main;
}
} // namespace mozilla

23
tools/fuzzing/libfuzzer/harness/LibFuzzerRunner.h
View File

@ -1,23 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* * 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/. */
namespace mozilla {
typedef int(*LibFuzzerMain)(int, char**);
class LibFuzzerRunner {
public:
int Run();
void setParams(int argc, char** argv, LibFuzzerMain main);
private:
int mArgc;
char** mArgv;
LibFuzzerMain mFuzzerMain;
};
extern LibFuzzerRunner* libFuzzerRunner;
} // namespace mozilla

312
tools/fuzzing/libfuzzer/harness/LibFuzzerTestHarness.h
View File

@ -1,312 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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/. */
/*
* Test harness for XPCOM objects, providing a scoped XPCOM initializer,
* nsCOMPtr, nsRefPtr, do_CreateInstance, do_GetService, ns(Auto|C|)String,
* and stdio.h/stdlib.h.
*/
#ifndef LibFuzzerTestHarness_h__
#define LibFuzzerTestHarness_h__
#include "mozilla/ArrayUtils.h"
#include "prenv.h"
#include "nsComponentManagerUtils.h"
#include "nsServiceManagerUtils.h"
#include "nsCOMPtr.h"
#include "nsAutoPtr.h"
#include "nsStringGlue.h"
#include "nsAppDirectoryServiceDefs.h"
#include "nsDirectoryServiceDefs.h"
#include "nsDirectoryServiceUtils.h"
#include "nsIDirectoryService.h"
#include "nsIFile.h"
#include "nsIProperties.h"
#include "nsIObserverService.h"
#include "nsXULAppAPI.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
namespace {
static uint32_t gFailCount = 0;
/**
* Prints the given failure message and arguments using printf, prepending
* "TEST-UNEXPECTED-FAIL " for the benefit of the test harness and
* appending "\n" to eliminate having to type it at each call site.
*/
void fail(const char* msg, ...)
{
va_list ap;
printf("TEST-UNEXPECTED-FAIL | ");
va_start(ap, msg);
vprintf(msg, ap);
va_end(ap);
putchar('\n');
++gFailCount;
}
/**
* Prints the given success message and arguments using printf, prepending
* "TEST-PASS " for the benefit of the test harness and
* appending "\n" to eliminate having to type it at each call site.
*/
void passed(const char* msg, ...)
{
va_list ap;
printf("TEST-PASS | ");
va_start(ap, msg);
vprintf(msg, ap);
va_end(ap);
putchar('\n');
}
//-----------------------------------------------------------------------------
class ScopedLogging
{
public:
ScopedLogging()
{
NS_LogInit();
}
~ScopedLogging()
{
NS_LogTerm();
}
};
static class ScopedXPCOM : public nsIDirectoryServiceProvider2
{
public:
NS_DECL_ISUPPORTS
explicit ScopedXPCOM(const char* testName,
nsIDirectoryServiceProvider *dirSvcProvider = nullptr)
: mDirSvcProvider(dirSvcProvider)
{
mTestName = testName;
printf("Running %s tests...\n", mTestName);
nsresult rv = NS_InitXPCOM2(&mServMgr, nullptr, this);
if (NS_FAILED(rv))
{
fail("NS_InitXPCOM2 returned failure code 0x%x", rv);
mServMgr = nullptr;
return;
}
}
~ScopedXPCOM()
{
// If we created a profile directory, we need to remove it.
if (mProfD) {
nsCOMPtr<nsIObserverService> os =
do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
MOZ_ASSERT(os);
if (os) {
MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-change-net-teardown", nullptr));
MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-change-teardown", nullptr));
MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-before-change", nullptr));
MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-before-change-qm", nullptr));
MOZ_ALWAYS_SUCCEEDS(os->NotifyObservers(nullptr, "profile-before-change-telemetry", nullptr));
}
if (NS_FAILED(mProfD->Remove(true))) {
NS_WARNING("Problem removing profile directory");
}
mProfD = nullptr;
}
if (mServMgr)
{
NS_RELEASE(mServMgr);
nsresult rv = NS_ShutdownXPCOM(nullptr);
if (NS_FAILED(rv))
{
fail("XPCOM shutdown failed with code 0x%x", rv);
exit(1);
}
}
printf("Finished running %s tests.\n", mTestName);
}
bool failed()
{
return mServMgr == nullptr;
}
already_AddRefed<nsIFile> GetProfileDirectory()
{
if (mProfD) {
nsCOMPtr<nsIFile> copy = mProfD;
return copy.forget();
}
// Create a unique temporary folder to use for this test.
// Note that runcppunittests.py will run tests with a temp
// directory as the cwd, so just put something under that.
nsCOMPtr<nsIFile> profD;
nsresult rv = NS_GetSpecialDirectory(NS_OS_CURRENT_PROCESS_DIR,
getter_AddRefs(profD));
NS_ENSURE_SUCCESS(rv, nullptr);
rv = profD->Append(NS_LITERAL_STRING("cpp-unit-profd"));
NS_ENSURE_SUCCESS(rv, nullptr);
rv = profD->CreateUnique(nsIFile::DIRECTORY_TYPE, 0755);
NS_ENSURE_SUCCESS(rv, nullptr);
mProfD = profD;
return profD.forget();
}
already_AddRefed<nsIFile> GetGREDirectory()
{
if (mGRED) {
nsCOMPtr<nsIFile> copy = mGRED;
return copy.forget();
}
char* env = PR_GetEnv("MOZ_XRE_DIR");
nsCOMPtr<nsIFile> greD;
if (env) {
NS_NewLocalFile(NS_ConvertUTF8toUTF16(env), false,
getter_AddRefs(greD));
}
mGRED = greD;
return greD.forget();
}
already_AddRefed<nsIFile> GetGREBinDirectory()
{
if (mGREBinD) {
nsCOMPtr<nsIFile> copy = mGREBinD;
return copy.forget();
}
nsCOMPtr<nsIFile> greD = GetGREDirectory();
if (!greD) {
return greD.forget();
}
greD->Clone(getter_AddRefs(mGREBinD));
#ifdef XP_MACOSX
nsAutoCString leafName;
mGREBinD->GetNativeLeafName(leafName);
if (leafName.Equals("Resources")) {
mGREBinD->SetNativeLeafName(NS_LITERAL_CSTRING("MacOS"));
}
#endif
nsCOMPtr<nsIFile> copy = mGREBinD;
return copy.forget();
}
////////////////////////////////////////////////////////////////////////////
//// nsIDirectoryServiceProvider
NS_IMETHODIMP GetFile(const char *aProperty, bool *_persistent,
nsIFile **_result) override
{
// If we were supplied a directory service provider, ask it first.
if (mDirSvcProvider &&
NS_SUCCEEDED(mDirSvcProvider->GetFile(aProperty, _persistent,
_result))) {
return NS_OK;
}
// Otherwise, the test harness provides some directories automatically.
if (0 == strcmp(aProperty, NS_APP_USER_PROFILE_50_DIR) ||
0 == strcmp(aProperty, NS_APP_USER_PROFILE_LOCAL_50_DIR) ||
0 == strcmp(aProperty, NS_APP_PROFILE_LOCAL_DIR_STARTUP)) {
nsCOMPtr<nsIFile> profD = GetProfileDirectory();
NS_ENSURE_TRUE(profD, NS_ERROR_FAILURE);
nsCOMPtr<nsIFile> clone;
nsresult rv = profD->Clone(getter_AddRefs(clone));
NS_ENSURE_SUCCESS(rv, rv);
*_persistent = true;
clone.forget(_result);
return NS_OK;
} else if (0 == strcmp(aProperty, NS_GRE_DIR)) {
nsCOMPtr<nsIFile> greD = GetGREDirectory();
NS_ENSURE_TRUE(greD, NS_ERROR_FAILURE);
*_persistent = true;
greD.forget(_result);
return NS_OK;
} else if (0 == strcmp(aProperty, NS_GRE_BIN_DIR)) {
nsCOMPtr<nsIFile> greBinD = GetGREBinDirectory();
NS_ENSURE_TRUE(greBinD, NS_ERROR_FAILURE);
*_persistent = true;
greBinD.forget(_result);
return NS_OK;
}
return NS_ERROR_FAILURE;
}
////////////////////////////////////////////////////////////////////////////
//// nsIDirectoryServiceProvider2
NS_IMETHODIMP GetFiles(const char *aProperty, nsISimpleEnumerator **_enum) override
{
// If we were supplied a directory service provider, ask it first.
nsCOMPtr<nsIDirectoryServiceProvider2> provider =
do_QueryInterface(mDirSvcProvider);
if (provider && NS_SUCCEEDED(provider->GetFiles(aProperty, _enum))) {
return NS_OK;
}
return NS_ERROR_FAILURE;
}
private:
const char* mTestName;
nsIServiceManager* mServMgr;
nsCOMPtr<nsIDirectoryServiceProvider> mDirSvcProvider;
nsCOMPtr<nsIFile> mProfD;
nsCOMPtr<nsIFile> mGRED;
nsCOMPtr<nsIFile> mGREBinD;
};
NS_IMPL_QUERY_INTERFACE(
ScopedXPCOM,
nsIDirectoryServiceProvider,
nsIDirectoryServiceProvider2
)
NS_IMETHODIMP_(MozExternalRefCountType)
ScopedXPCOM::AddRef()
{
return 2;
}
NS_IMETHODIMP_(MozExternalRefCountType)
ScopedXPCOM::Release()
{
return 1;
}
} // namespace
#endif // LibFuzzerTestHarness_h__

19
tools/fuzzing/libfuzzer/harness/moz.build
View File

@ -1,19 +0,0 @@
# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
# vim: set filetype=python:
# 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/.
Library('fuzzer-runner')
SOURCES += [
'LibFuzzerRegistry.cpp',
'LibFuzzerRunner.cpp',
]
EXPORTS += [
'LibFuzzerRegistry.h',
'LibFuzzerRunner.h',
]
FINAL_LIBRARY = "xul"

26
tools/fuzzing/libfuzzer/moz.build
View File

@ -1,26 +0,0 @@
# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
# vim: set filetype=python:
# 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/.
Library('fuzzer')
DIRS += [
'harness',
]
SOURCES += [
'FuzzerCrossOver.cpp',
'FuzzerCustomMain.cpp',
'FuzzerDriver.cpp',
'FuzzerExtFunctionsDlsym.cpp',
'FuzzerExtFunctionsWeak.cpp',
'FuzzerIO.cpp',
'FuzzerLoop.cpp',
'FuzzerMutate.cpp',
'FuzzerSHA1.cpp',
'FuzzerTracePC.cpp',
'FuzzerTraceState.cpp',
'FuzzerUtil.cpp',
]

10
tools/fuzzing/moz.build
View File

@ -1,10 +0,0 @@
# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
# vim: set filetype=python:
# 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/.
if CONFIG['LIBFUZZER']:
DIRS += [
'libfuzzer',
]

12
xpcom/build/nsXULAppAPI.h
View File

@ -520,16 +520,4 @@ XRE_API(void,
XRE_GlibInit, ())
#endif
#ifdef LIBFUZZER
#include "LibFuzzerRegistry.h"
XRE_API(void,
XRE_LibFuzzerSetMain, (int, char**, LibFuzzerMain))
XRE_API(void,
XRE_LibFuzzerGetFuncs, (const char*, LibFuzzerInitFunc*,
LibFuzzerTestingFunc*))
#endif // LIBFUZZER
#endif // _nsXULAppAPI_h__