summaryrefslogtreecommitdiffstats
path: root/mozglue
diff options
context:
space:
mode:
Diffstat (limited to 'mozglue')
-rw-r--r--mozglue/android/APKOpen.cpp551
-rw-r--r--mozglue/android/APKOpen.h29
-rw-r--r--mozglue/android/Ashmem.cpp73
-rw-r--r--mozglue/android/Ashmem.h23
-rw-r--r--mozglue/android/SharedMemNatives.cpp80
-rw-r--r--mozglue/android/moz.build44
-rw-r--r--mozglue/android/nsGeckoUtils.cpp24
-rw-r--r--mozglue/baseprofiler/build/generate_profiling_categories.py350
-rw-r--r--mozglue/baseprofiler/build/profiling_categories.yaml301
-rw-r--r--mozglue/baseprofiler/core/BaseAndGeckoProfilerDetail.cpp92
-rw-r--r--mozglue/baseprofiler/core/EHABIStackWalk.cpp592
-rw-r--r--mozglue/baseprofiler/core/EHABIStackWalk.h30
-rw-r--r--mozglue/baseprofiler/core/PageInformation.cpp49
-rw-r--r--mozglue/baseprofiler/core/PageInformation.h77
-rw-r--r--mozglue/baseprofiler/core/PlatformMacros.h130
-rw-r--r--mozglue/baseprofiler/core/ProfileBuffer.cpp217
-rw-r--r--mozglue/baseprofiler/core/ProfileBuffer.h211
-rw-r--r--mozglue/baseprofiler/core/ProfileBufferEntry.cpp1367
-rw-r--r--mozglue/baseprofiler/core/ProfileBufferEntry.h364
-rw-r--r--mozglue/baseprofiler/core/ProfileJSONWriter.cpp101
-rw-r--r--mozglue/baseprofiler/core/ProfiledThreadData.cpp191
-rw-r--r--mozglue/baseprofiler/core/ProfiledThreadData.h120
-rw-r--r--mozglue/baseprofiler/core/ProfilerBacktrace.cpp125
-rw-r--r--mozglue/baseprofiler/core/ProfilerBacktrace.h162
-rw-r--r--mozglue/baseprofiler/core/ProfilerMarkers.cpp348
-rw-r--r--mozglue/baseprofiler/core/ProfilerUtils.cpp162
-rw-r--r--mozglue/baseprofiler/core/ProfilingCategory.cpp71
-rw-r--r--mozglue/baseprofiler/core/ProfilingStack.cpp52
-rw-r--r--mozglue/baseprofiler/core/RegisteredThread.cpp42
-rw-r--r--mozglue/baseprofiler/core/RegisteredThread.h164
-rw-r--r--mozglue/baseprofiler/core/ThreadInfo.h62
-rw-r--r--mozglue/baseprofiler/core/VTuneProfiler.cpp92
-rw-r--r--mozglue/baseprofiler/core/VTuneProfiler.h84
-rw-r--r--mozglue/baseprofiler/core/platform-linux-android.cpp507
-rw-r--r--mozglue/baseprofiler/core/platform-macos.cpp220
-rw-r--r--mozglue/baseprofiler/core/platform-win32.cpp348
-rw-r--r--mozglue/baseprofiler/core/platform.cpp3824
-rw-r--r--mozglue/baseprofiler/core/platform.h149
-rw-r--r--mozglue/baseprofiler/core/shared-libraries-linux.cc854
-rw-r--r--mozglue/baseprofiler/core/shared-libraries-macos.cc206
-rw-r--r--mozglue/baseprofiler/core/shared-libraries-win32.cc222
-rw-r--r--mozglue/baseprofiler/core/vtune/ittnotify.h4127
-rw-r--r--mozglue/baseprofiler/lul/AutoObjectMapper.cpp80
-rw-r--r--mozglue/baseprofiler/lul/AutoObjectMapper.h64
-rw-r--r--mozglue/baseprofiler/lul/LulCommon.cpp102
-rw-r--r--mozglue/baseprofiler/lul/LulCommonExt.h509
-rw-r--r--mozglue/baseprofiler/lul/LulDwarf.cpp2252
-rw-r--r--mozglue/baseprofiler/lul/LulDwarfExt.h1289
-rw-r--r--mozglue/baseprofiler/lul/LulDwarfInt.h193
-rw-r--r--mozglue/baseprofiler/lul/LulDwarfSummariser.cpp553
-rw-r--r--mozglue/baseprofiler/lul/LulDwarfSummariser.h64
-rw-r--r--mozglue/baseprofiler/lul/LulElf.cpp873
-rw-r--r--mozglue/baseprofiler/lul/LulElfExt.h69
-rw-r--r--mozglue/baseprofiler/lul/LulElfInt.h218
-rw-r--r--mozglue/baseprofiler/lul/LulMain.cpp1958
-rw-r--r--mozglue/baseprofiler/lul/LulMain.h378
-rw-r--r--mozglue/baseprofiler/lul/LulMainInt.h420
-rw-r--r--mozglue/baseprofiler/lul/platform-linux-lul.cpp76
-rw-r--r--mozglue/baseprofiler/lul/platform-linux-lul.h21
-rw-r--r--mozglue/baseprofiler/moz.build133
-rw-r--r--mozglue/baseprofiler/public/BaseAndGeckoProfilerDetail.h64
-rw-r--r--mozglue/baseprofiler/public/BaseProfileJSONWriter.h600
-rw-r--r--mozglue/baseprofiler/public/BaseProfiler.h506
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerCounts.h280
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerDetail.h285
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerLabels.h178
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerMarkerTypes.h125
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerMarkers.h255
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerMarkersDetail.h741
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerMarkersPrerequisites.h886
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerRAIIMacro.h15
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerSharedLibraries.h170
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerState.h405
-rw-r--r--mozglue/baseprofiler/public/BaseProfilerUtils.h227
-rw-r--r--mozglue/baseprofiler/public/BaseProfilingCategory.h68
-rw-r--r--mozglue/baseprofiler/public/BaseProfilingStack.h517
-rw-r--r--mozglue/baseprofiler/public/BlocksRingBuffer.h999
-rw-r--r--mozglue/baseprofiler/public/FailureLatch.h217
-rw-r--r--mozglue/baseprofiler/public/ModuloBuffer.h618
-rw-r--r--mozglue/baseprofiler/public/PowerOfTwo.h322
-rw-r--r--mozglue/baseprofiler/public/ProfileBufferChunk.h547
-rw-r--r--mozglue/baseprofiler/public/ProfileBufferChunkManager.h134
-rw-r--r--mozglue/baseprofiler/public/ProfileBufferChunkManagerSingle.h172
-rw-r--r--mozglue/baseprofiler/public/ProfileBufferChunkManagerWithLocalLimit.h444
-rw-r--r--mozglue/baseprofiler/public/ProfileBufferControlledChunkManager.h203
-rw-r--r--mozglue/baseprofiler/public/ProfileBufferEntryKinds.h105
-rw-r--r--mozglue/baseprofiler/public/ProfileBufferEntrySerialization.h1184
-rw-r--r--mozglue/baseprofiler/public/ProfileBufferIndex.h97
-rw-r--r--mozglue/baseprofiler/public/ProfileChunkedBuffer.h1560
-rw-r--r--mozglue/baseprofiler/public/ProfileChunkedBufferDetail.h400
-rw-r--r--mozglue/baseprofiler/public/ProgressLogger.h500
-rw-r--r--mozglue/baseprofiler/public/ProportionValue.h235
-rw-r--r--mozglue/baseprofiler/public/leb128iterator.h207
-rw-r--r--mozglue/build/AsanOptions.cpp197
-rw-r--r--mozglue/build/BionicGlue.cpp37
-rw-r--r--mozglue/build/Makefile.in15
-rw-r--r--mozglue/build/TsanOptions.cpp314
-rw-r--r--mozglue/build/UbsanOptions.cpp16
-rw-r--r--mozglue/build/arm-eabi-filter4
-rw-r--r--mozglue/build/arm.cpp131
-rw-r--r--mozglue/build/arm.h145
-rw-r--r--mozglue/build/dummy.cpp5
-rw-r--r--mozglue/build/mips.cpp42
-rw-r--r--mozglue/build/mips.h29
-rw-r--r--mozglue/build/moz.build115
-rw-r--r--mozglue/build/mozglue.def22
-rw-r--r--mozglue/build/mozglue.dll.manifest9
-rw-r--r--mozglue/build/mozglue.ver4
-rw-r--r--mozglue/build/ppc.cpp64
-rw-r--r--mozglue/build/ppc.h47
-rw-r--r--mozglue/build/replace_malloc.mozbuild6
-rw-r--r--mozglue/interposers/InterposerHelper.h79
-rw-r--r--mozglue/interposers/env_interposer.cpp79
-rw-r--r--mozglue/interposers/moz.build24
-rw-r--r--mozglue/interposers/pthread_create_interposer.cpp108
-rw-r--r--mozglue/linker/BaseElf.cpp190
-rw-r--r--mozglue/linker/BaseElf.h128
-rw-r--r--mozglue/linker/CustomElf.cpp680
-rw-r--r--mozglue/linker/CustomElf.h147
-rw-r--r--mozglue/linker/ElfLoader.cpp1360
-rw-r--r--mozglue/linker/ElfLoader.h634
-rw-r--r--mozglue/linker/Elfxx.h246
-rw-r--r--mozglue/linker/Linker.h24
-rw-r--r--mozglue/linker/Logging.cpp7
-rw-r--r--mozglue/linker/Logging.h72
-rw-r--r--mozglue/linker/Mappable.cpp376
-rw-r--r--mozglue/linker/Mappable.h161
-rw-r--r--mozglue/linker/Utils.h532
-rw-r--r--mozglue/linker/XZStream.cpp221
-rw-r--r--mozglue/linker/XZStream.h49
-rw-r--r--mozglue/linker/Zip.cpp277
-rw-r--r--mozglue/linker/Zip.h388
-rw-r--r--mozglue/linker/moz.build33
-rw-r--r--mozglue/linker/tests/TestZip.cpp61
-rw-r--r--mozglue/linker/tests/TestZipData.S17
-rw-r--r--mozglue/linker/tests/moz.build20
-rw-r--r--mozglue/linker/tests/no_central_dir.zipbin0 -> 281 bytes
-rw-r--r--mozglue/linker/tests/test.zipbin0 -> 574 bytes
-rw-r--r--mozglue/misc/AutoProfilerLabel.cpp109
-rw-r--r--mozglue/misc/AutoProfilerLabel.h71
-rw-r--r--mozglue/misc/AwakeTimeStamp.cpp93
-rw-r--r--mozglue/misc/AwakeTimeStamp.h118
-rw-r--r--mozglue/misc/ConditionVariable_noop.cpp40
-rw-r--r--mozglue/misc/ConditionVariable_posix.cpp159
-rw-r--r--mozglue/misc/ConditionVariable_windows.cpp98
-rw-r--r--mozglue/misc/Debug.h69
-rw-r--r--mozglue/misc/DynamicallyLinkedFunctionPtr.h137
-rw-r--r--mozglue/misc/GetKnownFolderPath.cpp33
-rw-r--r--mozglue/misc/GetKnownFolderPath.h45
-rw-r--r--mozglue/misc/ImportDir.h94
-rw-r--r--mozglue/misc/IntegerPrintfMacros.h84
-rw-r--r--mozglue/misc/MmapFaultHandler.cpp130
-rw-r--r--mozglue/misc/MmapFaultHandler.h113
-rw-r--r--mozglue/misc/MutexPlatformData_noop.h18
-rw-r--r--mozglue/misc/MutexPlatformData_posix.h18
-rw-r--r--mozglue/misc/MutexPlatformData_windows.h18
-rw-r--r--mozglue/misc/Mutex_noop.cpp34
-rw-r--r--mozglue/misc/Mutex_posix.cpp133
-rw-r--r--mozglue/misc/Mutex_windows.cpp40
-rw-r--r--mozglue/misc/NativeNt.h1729
-rw-r--r--mozglue/misc/PlatformConditionVariable.h71
-rw-r--r--mozglue/misc/PlatformMutex.h66
-rw-r--r--mozglue/misc/PlatformRWLock.h50
-rw-r--r--mozglue/misc/PreXULSkeletonUI.cpp2238
-rw-r--r--mozglue/misc/PreXULSkeletonUI.h186
-rw-r--r--mozglue/misc/Printf.cpp1105
-rw-r--r--mozglue/misc/Printf.h266
-rw-r--r--mozglue/misc/ProcessType.cpp58
-rw-r--r--mozglue/misc/ProcessType.h44
-rw-r--r--mozglue/misc/RWLock_posix.cpp64
-rw-r--r--mozglue/misc/RWLock_windows.cpp48
-rw-r--r--mozglue/misc/RuntimeExceptionModule.cpp111
-rw-r--r--mozglue/misc/RuntimeExceptionModule.h20
-rw-r--r--mozglue/misc/SIMD.cpp565
-rw-r--r--mozglue/misc/SIMD.h81
-rw-r--r--mozglue/misc/SIMD_avx2.cpp294
-rw-r--r--mozglue/misc/SSE.cpp202
-rw-r--r--mozglue/misc/SSE.h371
-rw-r--r--mozglue/misc/Sprintf.h98
-rw-r--r--mozglue/misc/StackWalk.cpp1063
-rw-r--r--mozglue/misc/StackWalk.h215
-rw-r--r--mozglue/misc/StackWalkThread.h34
-rw-r--r--mozglue/misc/StackWalk_windows.h34
-rw-r--r--mozglue/misc/TimeStamp.cpp85
-rw-r--r--mozglue/misc/TimeStamp.h603
-rw-r--r--mozglue/misc/TimeStamp_darwin.cpp187
-rw-r--r--mozglue/misc/TimeStamp_posix.cpp337
-rw-r--r--mozglue/misc/TimeStamp_windows.cpp527
-rw-r--r--mozglue/misc/TimeStamp_windows.h100
-rw-r--r--mozglue/misc/Uptime.cpp155
-rw-r--r--mozglue/misc/Uptime.h26
-rw-r--r--mozglue/misc/WinUtils.h140
-rw-r--r--mozglue/misc/WindowsDllMain.cpp20
-rw-r--r--mozglue/misc/WindowsDpiAwareness.h41
-rw-r--r--mozglue/misc/WindowsDpiInitialization.cpp73
-rw-r--r--mozglue/misc/WindowsDpiInitialization.h54
-rw-r--r--mozglue/misc/WindowsEnumProcessModules.h61
-rw-r--r--mozglue/misc/WindowsMapRemoteView.cpp124
-rw-r--r--mozglue/misc/WindowsMapRemoteView.h25
-rw-r--r--mozglue/misc/WindowsProcessMitigations.cpp91
-rw-r--r--mozglue/misc/WindowsProcessMitigations.h21
-rw-r--r--mozglue/misc/WindowsStackCookie.h63
-rw-r--r--mozglue/misc/WindowsUnicode.cpp59
-rw-r--r--mozglue/misc/WindowsUnicode.h35
-rw-r--r--mozglue/misc/WindowsUnwindInfo.h329
-rw-r--r--mozglue/misc/decimal/Decimal.cpp1063
-rw-r--r--mozglue/misc/decimal/Decimal.h221
-rw-r--r--mozglue/misc/decimal/DoubleConversion.h27
-rw-r--r--mozglue/misc/decimal/UPSTREAM-GIT-SHA1
-rw-r--r--mozglue/misc/decimal/add-doubleconversion-impl.patch42
-rw-r--r--mozglue/misc/decimal/comparison-with-nan.patch67
-rw-r--r--mozglue/misc/decimal/fix-wshadow-warnings.patch171
-rw-r--r--mozglue/misc/decimal/mfbt-abi-markers.patch150
-rw-r--r--mozglue/misc/decimal/moz-decimal-utils.h110
-rw-r--r--mozglue/misc/decimal/to-moz-dependencies.patch224
-rwxr-xr-xmozglue/misc/decimal/update.sh60
-rw-r--r--mozglue/misc/decimal/zero-serialization.patch22
-rw-r--r--mozglue/misc/moz.build156
-rw-r--r--mozglue/moz.build26
-rw-r--r--mozglue/static/README2
-rw-r--r--mozglue/static/rust/Cargo.toml19
-rw-r--r--mozglue/static/rust/build.rs32
-rw-r--r--mozglue/static/rust/lib.rs221
-rw-r--r--mozglue/static/rust/moz_asserts/Cargo.toml11
-rw-r--r--mozglue/static/rust/moz_asserts/lib.rs103
-rw-r--r--mozglue/static/rust/wrappers.cpp23
-rw-r--r--mozglue/tests/ShowSSEConfig.cpp125
-rw-r--r--mozglue/tests/TestBaseProfiler.cpp5732
-rw-r--r--mozglue/tests/TestIntegerPrintfMacros.cpp1128
-rw-r--r--mozglue/tests/TestNativeNt.cpp606
-rw-r--r--mozglue/tests/TestPEExportSection.cpp706
-rw-r--r--mozglue/tests/TestPrintf.cpp264
-rw-r--r--mozglue/tests/TestStackCookie.cpp89
-rw-r--r--mozglue/tests/TestTimeStampWin.cpp96
-rw-r--r--mozglue/tests/glibc_printf_tests/COPYING339
-rw-r--r--mozglue/tests/glibc_printf_tests/COPYING.LIB502
-rw-r--r--mozglue/tests/glibc_printf_tests/README.MOZILLA2
-rw-r--r--mozglue/tests/glibc_printf_tests/tfformat.c4164
-rw-r--r--mozglue/tests/glibc_printf_tests/tiformat.c5070
-rw-r--r--mozglue/tests/glibc_printf_tests/tllformat.c59
-rw-r--r--mozglue/tests/gtest/TestNativeNtGTest.cpp63
-rw-r--r--mozglue/tests/gtest/TestStackWalk.cpp279
-rw-r--r--mozglue/tests/gtest/moz.build20
-rw-r--r--mozglue/tests/moz.build53
244 files changed, 82341 insertions, 0 deletions
diff --git a/mozglue/android/APKOpen.cpp b/mozglue/android/APKOpen.cpp
new file mode 100644
index 0000000000..679ea694d7
--- /dev/null
+++ b/mozglue/android/APKOpen.cpp
@@ -0,0 +1,551 @@
+/* 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 custom library loading code is only meant to be called
+ * during initialization. As a result, it takes no special
+ * precautions to be threadsafe. Any of the library loading functions
+ * like mozload should not be available to other code.
+ */
+
+#include <jni.h>
+#include <android/log.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/limits.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <zlib.h>
+#include "dlfcn.h"
+#include "APKOpen.h"
+#include <sys/time.h>
+#include <sys/syscall.h>
+#include <sys/resource.h>
+#include <sys/prctl.h>
+#include "sqlite3.h"
+#include "Linker.h"
+#include "BaseProfiler.h"
+#include "application.ini.h"
+
+#include "mozilla/arm.h"
+#include "mozilla/Bootstrap.h"
+#include "mozilla/Printf.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+#include "XREChildData.h"
+
+/* Android headers don't define RUSAGE_THREAD */
+#ifndef RUSAGE_THREAD
+# define RUSAGE_THREAD 1
+#endif
+
+#ifndef RELEASE_OR_BETA
+/* Official builds have the debuggable flag set to false, which disables
+ * the backtrace dumper from bionic. However, as it is useful for native
+ * crashes happening before the crash reporter is registered, re-enable
+ * it on non release builds (i.e. nightly and aurora).
+ * Using a constructor so that it is re-enabled as soon as libmozglue.so
+ * is loaded.
+ */
+__attribute__((constructor)) void make_dumpable() { prctl(PR_SET_DUMPABLE, 1); }
+#endif
+
+typedef int mozglueresult;
+
+using LoadGeckoLibsResult =
+ mozilla::Result<mozilla::Ok, mozilla::BootstrapError>;
+
+enum StartupEvent {
+#define mozilla_StartupTimeline_Event(ev, z) ev,
+#include "StartupTimeline.h"
+#undef mozilla_StartupTimeline_Event
+ MAX_STARTUP_EVENT_ID
+};
+
+using namespace mozilla;
+
+void JNI_Throw(JNIEnv* jenv, const char* classname, const char* msg) {
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Throw\n");
+ jclass cls = jenv->FindClass(classname);
+ if (cls == nullptr) {
+ __android_log_print(
+ ANDROID_LOG_ERROR, "GeckoLibLoad",
+ "Couldn't find exception class (or exception pending) %s\n", classname);
+ exit(FAILURE);
+ }
+ int rc = jenv->ThrowNew(cls, msg);
+ if (rc < 0) {
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad",
+ "Error throwing exception %s\n", msg);
+ exit(FAILURE);
+ }
+ jenv->DeleteLocalRef(cls);
+}
+
+namespace {
+JavaVM* sJavaVM;
+}
+
+void abortThroughJava(const char* msg) {
+ struct sigaction sigact = {};
+ if (__wrap_sigaction(SIGSEGV, nullptr, &sigact)) {
+ return; // sigaction call failed.
+ }
+
+ Dl_info info = {};
+ if ((sigact.sa_flags & SA_SIGINFO) &&
+ __wrap_dladdr(reinterpret_cast<void*>(sigact.sa_sigaction), &info) &&
+ info.dli_fname && strstr(info.dli_fname, "libxul.so")) {
+ return; // Existing signal handler is in libxul (i.e. we have crash
+ // reporter).
+ }
+
+ JNIEnv* env = nullptr;
+ if (!sJavaVM ||
+ sJavaVM->AttachCurrentThreadAsDaemon(&env, nullptr) != JNI_OK) {
+ return;
+ }
+
+ if (!env || env->PushLocalFrame(2) != JNI_OK) {
+ return;
+ }
+
+ jclass loader = env->FindClass("org/mozilla/gecko/mozglue/GeckoLoader");
+ if (!loader) {
+ return;
+ }
+
+ jmethodID method =
+ env->GetStaticMethodID(loader, "abort", "(Ljava/lang/String;)V");
+ jstring str = env->NewStringUTF(msg);
+
+ if (method && str) {
+ env->CallStaticVoidMethod(loader, method, str);
+ }
+
+ env->PopLocalFrame(nullptr);
+}
+
+Bootstrap::UniquePtr gBootstrap;
+#ifndef MOZ_FOLD_LIBS
+static void* sqlite_handle = nullptr;
+static void* nspr_handle = nullptr;
+static void* plc_handle = nullptr;
+#else
+# define sqlite_handle nss_handle
+# define nspr_handle nss_handle
+# define plc_handle nss_handle
+#endif
+static void* nss_handle = nullptr;
+
+static UniquePtr<char[]> getUnpackedLibraryName(const char* libraryName) {
+ static const char* libdir = getenv("MOZ_ANDROID_LIBDIR");
+
+ size_t len = strlen(libdir) + 1 /* path separator */ + strlen(libraryName) +
+ 1; /* null terminator */
+ auto file = MakeUnique<char[]>(len);
+ snprintf(file.get(), len, "%s/%s", libdir, libraryName);
+ return file;
+}
+
+static void* dlopenLibrary(const char* libraryName) {
+ return __wrap_dlopen(getUnpackedLibraryName(libraryName).get(),
+ RTLD_GLOBAL | RTLD_LAZY);
+}
+
+static void EnsureBaseProfilerInitialized() {
+ // There is no single entry-point into C++ code on Android.
+ // Instead, GeckoThread and GeckoLibLoader call various functions to load
+ // libraries one-by-one.
+ // We want to capture all that library loading in the profiler, so we need to
+ // kick off the base profiler at the beginning of whichever function is called
+ // first.
+ // We currently assume that all these functions are called on the same thread.
+ static bool sInitialized = false;
+ if (sInitialized) {
+ return;
+ }
+
+ // The stack depth we observe here will be determined by the stack of
+ // whichever caller enters this code first. In practice this means that we may
+ // miss some root-most frames, which hopefully shouldn't ruin profiling.
+ int stackBase = 5;
+ mozilla::baseprofiler::profiler_init(&stackBase);
+ sInitialized = true;
+}
+
+static LoadGeckoLibsResult loadGeckoLibs() {
+ TimeStamp t0 = TimeStamp::Now();
+ struct rusage usage1_thread, usage1;
+ getrusage(RUSAGE_THREAD, &usage1_thread);
+ getrusage(RUSAGE_SELF, &usage1);
+
+ static const char* libxul = getenv("MOZ_ANDROID_LIBDIR_OVERRIDE");
+ MOZ_TRY_VAR(
+ gBootstrap,
+ GetBootstrap(libxul ? libxul : getUnpackedLibraryName("libxul.so").get(),
+ LibLoadingStrategy::ReadAhead));
+
+ TimeStamp t1 = TimeStamp::Now();
+ struct rusage usage2_thread, usage2;
+ getrusage(RUSAGE_THREAD, &usage2_thread);
+ getrusage(RUSAGE_SELF, &usage2);
+
+#define RUSAGE_TIMEDIFF(u1, u2, field) \
+ ((u2.ru_##field.tv_sec - u1.ru_##field.tv_sec) * 1000 + \
+ (u2.ru_##field.tv_usec - u1.ru_##field.tv_usec) / 1000)
+
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad",
+ "Loaded libs in %fms total, %ldms(%ldms) user, "
+ "%ldms(%ldms) system, %ld(%ld) faults",
+ (t1 - t0).ToMilliseconds(),
+ RUSAGE_TIMEDIFF(usage1_thread, usage2_thread, utime),
+ RUSAGE_TIMEDIFF(usage1, usage2, utime),
+ RUSAGE_TIMEDIFF(usage1_thread, usage2_thread, stime),
+ RUSAGE_TIMEDIFF(usage1, usage2, stime),
+ usage2_thread.ru_majflt - usage1_thread.ru_majflt,
+ usage2.ru_majflt - usage1.ru_majflt);
+
+ gBootstrap->XRE_StartupTimelineRecord(LINKER_INITIALIZED, t0);
+ gBootstrap->XRE_StartupTimelineRecord(LIBRARIES_LOADED, t1);
+ return Ok();
+}
+
+static mozglueresult loadNSSLibs();
+
+static mozglueresult loadSQLiteLibs() {
+ if (sqlite_handle) return SUCCESS;
+
+#ifdef MOZ_FOLD_LIBS
+ if (loadNSSLibs() != SUCCESS) return FAILURE;
+#else
+
+ sqlite_handle = dlopenLibrary("libmozsqlite3.so");
+ if (!sqlite_handle) {
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad",
+ "Couldn't get a handle to libmozsqlite3!");
+ return FAILURE;
+ }
+#endif
+
+ return SUCCESS;
+}
+
+static mozglueresult loadNSSLibs() {
+ if (nss_handle && nspr_handle && plc_handle) return SUCCESS;
+
+ nss_handle = dlopenLibrary("libnss3.so");
+
+#ifndef MOZ_FOLD_LIBS
+ nspr_handle = dlopenLibrary("libnspr4.so");
+
+ plc_handle = dlopenLibrary("libplc4.so");
+#endif
+
+ if (!nss_handle) {
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad",
+ "Couldn't get a handle to libnss3!");
+ return FAILURE;
+ }
+
+#ifndef MOZ_FOLD_LIBS
+ if (!nspr_handle) {
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad",
+ "Couldn't get a handle to libnspr4!");
+ return FAILURE;
+ }
+
+ if (!plc_handle) {
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad",
+ "Couldn't get a handle to libplc4!");
+ return FAILURE;
+ }
+#endif
+
+ return SUCCESS;
+}
+
+extern "C" APKOPEN_EXPORT void MOZ_JNICALL
+Java_org_mozilla_gecko_mozglue_GeckoLoader_loadGeckoLibsNative(
+ JNIEnv* jenv, jclass jGeckoAppShellClass) {
+ EnsureBaseProfilerInitialized();
+
+ jenv->GetJavaVM(&sJavaVM);
+
+ LoadGeckoLibsResult res = loadGeckoLibs();
+ if (res.isOk()) {
+ return;
+ }
+
+ const BootstrapError& errorInfo = res.inspectErr();
+
+ auto msg = errorInfo.match(
+ [](const nsresult& aRv) {
+ return Smprintf("Error loading Gecko libraries: nsresult 0x%08X", aRv);
+ },
+ [](const DLErrorType& aErr) {
+ return Smprintf("Error loading Gecko libraries: %s", aErr.get());
+ });
+
+ JNI_Throw(jenv, "java/lang/Exception", msg.get());
+}
+
+extern "C" APKOPEN_EXPORT void MOZ_JNICALL
+Java_org_mozilla_gecko_mozglue_GeckoLoader_loadSQLiteLibsNative(
+ JNIEnv* jenv, jclass jGeckoAppShellClass) {
+ EnsureBaseProfilerInitialized();
+
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Load sqlite start\n");
+ mozglueresult rv = loadSQLiteLibs();
+ if (rv != SUCCESS) {
+ JNI_Throw(jenv, "java/lang/Exception", "Error loading sqlite libraries");
+ }
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Load sqlite done\n");
+}
+
+extern "C" APKOPEN_EXPORT void MOZ_JNICALL
+Java_org_mozilla_gecko_mozglue_GeckoLoader_loadNSSLibsNative(
+ JNIEnv* jenv, jclass jGeckoAppShellClass) {
+ EnsureBaseProfilerInitialized();
+
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Load nss start\n");
+ mozglueresult rv = loadNSSLibs();
+ if (rv != SUCCESS) {
+ JNI_Throw(jenv, "java/lang/Exception", "Error loading nss libraries");
+ }
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Load nss done\n");
+}
+
+static char** CreateArgvFromObjectArray(JNIEnv* jenv, jobjectArray jargs,
+ int* length) {
+ size_t stringCount = jenv->GetArrayLength(jargs);
+
+ if (length) {
+ *length = stringCount;
+ }
+
+ if (!stringCount) {
+ return nullptr;
+ }
+
+ char** argv = new char*[stringCount + 1];
+
+ argv[stringCount] = nullptr;
+
+ for (size_t ix = 0; ix < stringCount; ix++) {
+ jstring string = (jstring)(jenv->GetObjectArrayElement(jargs, ix));
+ const char* rawString = jenv->GetStringUTFChars(string, nullptr);
+ const int strLength = jenv->GetStringUTFLength(string);
+ argv[ix] = strndup(rawString, strLength);
+ jenv->ReleaseStringUTFChars(string, rawString);
+ jenv->DeleteLocalRef(string);
+ }
+
+ return argv;
+}
+
+static void FreeArgv(char** argv, int argc) {
+ for (int ix = 0; ix < argc; ix++) {
+ // String was allocated with strndup, so need to use free to deallocate.
+ free(argv[ix]);
+ }
+ delete[] (argv);
+}
+
+extern "C" APKOPEN_EXPORT void MOZ_JNICALL
+Java_org_mozilla_gecko_mozglue_GeckoLoader_nativeRun(
+ JNIEnv* jenv, jclass jc, jobjectArray jargs, int prefsFd, int prefMapFd,
+ int ipcFd, int crashFd, int crashAnnotationFd, bool xpcshell,
+ jstring outFilePath) {
+ EnsureBaseProfilerInitialized();
+
+ int argc = 0;
+ char** argv = CreateArgvFromObjectArray(jenv, jargs, &argc);
+
+ if (ipcFd < 0) {
+ if (gBootstrap == nullptr) {
+ FreeArgv(argv, argc);
+ return;
+ }
+
+#ifdef MOZ_LINKER
+ ElfLoader::Singleton.ExpectShutdown(false);
+#endif
+ const char* outFilePathRaw = nullptr;
+ if (xpcshell) {
+ MOZ_ASSERT(outFilePath);
+ outFilePathRaw = jenv->GetStringUTFChars(outFilePath, nullptr);
+ }
+ gBootstrap->GeckoStart(jenv, argv, argc, sAppData, xpcshell,
+ outFilePathRaw);
+ if (outFilePathRaw) {
+ jenv->ReleaseStringUTFChars(outFilePath, outFilePathRaw);
+ }
+#ifdef MOZ_LINKER
+ ElfLoader::Singleton.ExpectShutdown(true);
+#endif
+ } else {
+ gBootstrap->XRE_SetAndroidChildFds(
+ jenv, {prefsFd, prefMapFd, ipcFd, crashFd, crashAnnotationFd});
+ gBootstrap->XRE_SetProcessType(argv[argc - 1]);
+
+ XREChildData childData;
+ gBootstrap->XRE_InitChildProcess(argc - 1, argv, &childData);
+ }
+
+#ifdef MOZ_WIDGET_ANDROID
+# ifdef MOZ_PROFILE_GENERATE
+ gBootstrap->XRE_WriteLLVMProfData();
+# endif
+#endif
+ gBootstrap.reset();
+ FreeArgv(argv, argc);
+}
+
+extern "C" APKOPEN_EXPORT mozglueresult ChildProcessInit(int argc,
+ char* argv[]) {
+ EnsureBaseProfilerInitialized();
+
+ if (loadNSSLibs() != SUCCESS) {
+ return FAILURE;
+ }
+ if (loadSQLiteLibs() != SUCCESS) {
+ return FAILURE;
+ }
+ if (loadGeckoLibs().isErr()) {
+ return FAILURE;
+ }
+
+ gBootstrap->XRE_SetProcessType(argv[--argc]);
+
+ XREChildData childData;
+ return NS_FAILED(gBootstrap->XRE_InitChildProcess(argc, argv, &childData));
+}
+
+// Does current process name end with ':media'?
+static bool IsMediaProcess() {
+ pid_t pid = getpid();
+ char str[256];
+ SprintfLiteral(str, "/proc/%d/cmdline", pid);
+ FILE* f = fopen(str, "r");
+ if (f) {
+ fgets(str, sizeof(str), f);
+ fclose(f);
+ const size_t strLen = strlen(str);
+ const char suffix[] = ":media";
+ const size_t suffixLen = sizeof(suffix) - 1;
+ if (strLen >= suffixLen &&
+ !strncmp(str + strLen - suffixLen, suffix, suffixLen)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+#ifndef SYS_rt_tgsigqueueinfo
+# define SYS_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
+#endif
+/* Copy of http://androidxref.com/7.1.1_r6/xref/bionic/linker/debugger.cpp#262,
+ * with debuggerd related code stripped.
+ *
+ * Copyright (C) 2008 The Android Open Source Project
+ * 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 OWNER 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.
+ */
+static void CatchFatalSignals(int num, siginfo_t* info, void* context) {
+ // It's possible somebody cleared the SA_SIGINFO flag, which would mean
+ // our "info" arg holds an undefined value.
+ struct sigaction action = {};
+ if ((sigaction(num, nullptr, &action) < 0) ||
+ !(action.sa_flags & SA_SIGINFO)) {
+ info = nullptr;
+ }
+
+ // We need to return from the signal handler so that debuggerd can dump the
+ // thread that crashed, but returning here does not guarantee that the signal
+ // will be thrown again, even for SIGSEGV and friends, since the signal could
+ // have been sent manually. Resend the signal with rt_tgsigqueueinfo(2) to
+ // preserve the SA_SIGINFO contents.
+ signal(num, SIG_DFL);
+
+ struct siginfo si;
+ if (!info) {
+ memset(&si, 0, sizeof(si));
+ si.si_code = SI_USER;
+ si.si_pid = getpid();
+ si.si_uid = getuid();
+ info = &si;
+ } else if (info->si_code >= 0 || info->si_code == SI_TKILL) {
+ // rt_tgsigqueueinfo(2)'s documentation appears to be incorrect on kernels
+ // that contain commit 66dd34a (3.9+). The manpage claims to only allow
+ // negative si_code values that are not SI_TKILL, but 66dd34a changed the
+ // check to allow all si_code values in calls coming from inside the house.
+ }
+
+ int rc = syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), num, info);
+ if (rc != 0) {
+ __android_log_print(ANDROID_LOG_FATAL, "mozglue",
+ "failed to resend signal during crash: %s",
+ strerror(errno));
+ _exit(0);
+ }
+}
+
+extern "C" APKOPEN_EXPORT void MOZ_JNICALL
+Java_org_mozilla_gecko_mozglue_GeckoLoader_suppressCrashDialog(JNIEnv* jenv,
+ jclass jc) {
+ MOZ_RELEASE_ASSERT(IsMediaProcess(),
+ "Suppress crash dialog only for media process");
+ // Restoring to SIG_DFL will crash on x86/Android M devices (see bug 1374556)
+ // so copy Android code
+ // (http://androidxref.com/7.1.1_r6/xref/bionic/linker/debugger.cpp#302). See
+ // comments above CatchFatalSignals() for copyright notice.
+ struct sigaction action;
+ memset(&action, 0, sizeof(action));
+ sigemptyset(&action.sa_mask);
+ action.sa_sigaction = &CatchFatalSignals;
+ action.sa_flags = SA_RESTART | SA_SIGINFO;
+
+ // Use the alternate signal stack if available so we can catch stack
+ // overflows.
+ action.sa_flags |= SA_ONSTACK;
+
+ sigaction(SIGABRT, &action, nullptr);
+ sigaction(SIGBUS, &action, nullptr);
+ sigaction(SIGFPE, &action, nullptr);
+ sigaction(SIGILL, &action, nullptr);
+ sigaction(SIGSEGV, &action, nullptr);
+#if defined(SIGSTKFLT)
+ sigaction(SIGSTKFLT, &action, nullptr);
+#endif
+ sigaction(SIGTRAP, &action, nullptr);
+}
diff --git a/mozglue/android/APKOpen.h b/mozglue/android/APKOpen.h
new file mode 100644
index 0000000000..f3666bf028
--- /dev/null
+++ b/mozglue/android/APKOpen.h
@@ -0,0 +1,29 @@
+/* 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 APKOpen_h
+#define APKOpen_h
+
+#include <jni.h>
+
+#ifndef APKOPEN_EXPORT
+# define APKOPEN_EXPORT __attribute__((visibility("default")))
+#endif
+
+APKOPEN_EXPORT void abortThroughJava(const char* msg);
+
+static const int SUCCESS = 0;
+static const int FAILURE = 1;
+void JNI_Throw(JNIEnv* jenv, const char* classname, const char* msg);
+
+// Bug 1207642 - Work around Dalvik bug by realigning stack on JNI entry
+#ifndef MOZ_JNICALL
+# ifdef __i386__
+# define MOZ_JNICALL JNICALL __attribute__((force_align_arg_pointer))
+# else
+# define MOZ_JNICALL JNICALL
+# endif
+#endif
+
+#endif /* APKOpen_h */
diff --git a/mozglue/android/Ashmem.cpp b/mozglue/android/Ashmem.cpp
new file mode 100644
index 0000000000..edfeb495dd
--- /dev/null
+++ b/mozglue/android/Ashmem.cpp
@@ -0,0 +1,73 @@
+/* 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 <cstring>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <linux/ashmem.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#include "Ashmem.h"
+
+namespace mozilla {
+namespace android {
+
+static void* libhandle() {
+ static void* handle = dlopen("libandroid.so", RTLD_LAZY | RTLD_LOCAL);
+ return handle;
+}
+
+int ashmem_create(const char* name, size_t size) {
+ static auto fCreate =
+ (int (*)(const char*, size_t))dlsym(libhandle(), "ASharedMemory_create");
+
+ if (fCreate) {
+ return fCreate(name, size);
+ }
+
+ int fd = open("/" ASHMEM_NAME_DEF, O_RDWR);
+ if (fd < 0) {
+ return fd;
+ }
+
+ if (name) {
+ char str[ASHMEM_NAME_LEN];
+ strlcpy(str, name, sizeof(str));
+ ioctl(fd, ASHMEM_SET_NAME, str);
+ }
+
+ if (ioctl(fd, ASHMEM_SET_SIZE, size) != 0) {
+ close(fd);
+ return -1;
+ }
+
+ return fd;
+}
+
+size_t ashmem_getSize(int fd) {
+ static auto fGetSize =
+ (size_t(*)(int))dlsym(libhandle(), "ASharedMemory_getSize");
+ if (fGetSize) {
+ return fGetSize(fd);
+ }
+
+ return (size_t)ioctl(fd, ASHMEM_GET_SIZE, nullptr);
+}
+
+int ashmem_setProt(int fd, int prot) {
+ static auto fSetProt =
+ (int (*)(int, int))dlsym(libhandle(), "ASharedMemory_setProt");
+ if (fSetProt) {
+ return fSetProt(fd, prot);
+ }
+
+ return ioctl(fd, ASHMEM_SET_PROT_MASK, prot);
+}
+
+} // namespace android
+} // namespace mozilla
diff --git a/mozglue/android/Ashmem.h b/mozglue/android/Ashmem.h
new file mode 100644
index 0000000000..3307761e32
--- /dev/null
+++ b/mozglue/android/Ashmem.h
@@ -0,0 +1,23 @@
+/* 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 Ashmem_h__
+#define Ashmem_h__
+
+#include <linux/ashmem.h>
+#include "mozilla/Types.h"
+
+namespace mozilla {
+namespace android {
+
+// Wrappers for the ASharedMemory function in the NDK
+// https://developer.android.com/ndk/reference/group/memory
+MFBT_API int ashmem_create(const char* name, size_t size);
+MFBT_API size_t ashmem_getSize(int fd);
+MFBT_API int ashmem_setProt(int fd, int prot);
+
+} // namespace android
+} // namespace mozilla
+
+#endif // Ashmem_h__
diff --git a/mozglue/android/SharedMemNatives.cpp b/mozglue/android/SharedMemNatives.cpp
new file mode 100644
index 0000000000..f38a2274b3
--- /dev/null
+++ b/mozglue/android/SharedMemNatives.cpp
@@ -0,0 +1,80 @@
+/* -*- Mode: c++; c-basic-offset: 2; tab-width: 20; indent-tabs-mode: nil; -*-
+ * 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 <errno.h>
+#include <jni.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+
+#include "mozilla/Sprintf.h"
+
+extern "C" {
+
+JNIEXPORT
+void JNICALL
+Java_org_mozilla_gecko_media_SampleBuffer_nativeReadFromDirectBuffer(
+ JNIEnv* jenv, jclass, jobject src, jlong dest, jint offset, jint size) {
+ uint8_t* from = static_cast<uint8_t*>(jenv->GetDirectBufferAddress(src));
+ if (from == nullptr) {
+ jenv->ThrowNew(jenv->FindClass("java/lang/NullPointerException"),
+ "Null direct buffer");
+ return;
+ }
+
+ void* to = reinterpret_cast<void*>(dest);
+ if (to == nullptr) {
+ jenv->ThrowNew(jenv->FindClass("java/lang/NullPointerException"),
+ "Null shared memory buffer");
+ return;
+ }
+
+ memcpy(to, from + offset, size);
+}
+
+JNIEXPORT
+void JNICALL
+Java_org_mozilla_gecko_media_SampleBuffer_nativeWriteToDirectBuffer(
+ JNIEnv* jenv, jclass, jlong src, jobject dest, jint offset, jint size) {
+ uint8_t* from = reinterpret_cast<uint8_t*>(src);
+ if (from == nullptr) {
+ jenv->ThrowNew(jenv->FindClass("java/lang/NullPointerException"),
+ "Null shared memory buffer");
+ return;
+ }
+
+ void* to = jenv->GetDirectBufferAddress(dest);
+ if (to == nullptr) {
+ jenv->ThrowNew(jenv->FindClass("java/lang/NullPointerException"),
+ "Null direct buffer");
+ return;
+ }
+
+ memcpy(to, from + offset, size);
+}
+
+JNIEXPORT
+jlong JNICALL Java_org_mozilla_gecko_mozglue_SharedMemory_map(JNIEnv* env,
+ jobject jobj,
+ jint fd,
+ jint length) {
+ void* address = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ if (address == MAP_FAILED) {
+ char msg[128];
+ SprintfLiteral(msg, "mmap failed. errno=%d", errno);
+ env->ThrowNew(env->FindClass("java/lang/NullPointerException"), msg);
+ return 0;
+ }
+ return jlong(address);
+}
+
+JNIEXPORT
+void JNICALL Java_org_mozilla_gecko_mozglue_SharedMemory_unmap(JNIEnv* env,
+ jobject jobj,
+ jlong address,
+ jint size) {
+ munmap((void*)address, (size_t)size);
+}
+}
diff --git a/mozglue/android/moz.build b/mozglue/android/moz.build
new file mode 100644
index 0000000000..bf5813d963
--- /dev/null
+++ b/mozglue/android/moz.build
@@ -0,0 +1,44 @@
+# -*- Mode: python; 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/.
+
+EXPORTS += [
+ "APKOpen.h",
+]
+
+EXPORTS.mozilla += ["Ashmem.h"]
+
+SOURCES += [
+ "APKOpen.cpp",
+ "Ashmem.cpp",
+ "nsGeckoUtils.cpp",
+ "SharedMemNatives.cpp",
+]
+
+FINAL_LIBRARY = "mozglue"
+
+for var in ("ANDROID_PACKAGE_NAME", "ANDROID_CPU_ARCH"):
+ DEFINES[var] = '"%s"' % CONFIG[var]
+
+if CONFIG["MOZ_FOLD_LIBS"]:
+ DEFINES["MOZ_FOLD_LIBS"] = True
+
+LOCAL_INCLUDES += [
+ "!/build",
+ "../linker",
+ "/ipc/chromium/src",
+ "/nsprpub/lib/ds",
+ "/nsprpub/lib/libc/include",
+ "/nsprpub/pr/include",
+ "/third_party/sqlite3/src",
+ "/toolkit/components/startup",
+ "/xpcom/build",
+]
+
+DEFINES["XPCOM_GLUE"] = True
+
+USE_LIBS += [
+ "xpcomglue",
+]
diff --git a/mozglue/android/nsGeckoUtils.cpp b/mozglue/android/nsGeckoUtils.cpp
new file mode 100644
index 0000000000..017353e548
--- /dev/null
+++ b/mozglue/android/nsGeckoUtils.cpp
@@ -0,0 +1,24 @@
+/* -*- Mode: c++; c-basic-offset: 2; tab-width: 20; indent-tabs-mode: nil; -*-
+ * 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 <jni.h>
+
+#include <stdlib.h>
+#include <fcntl.h>
+#include "APKOpen.h"
+#include "Zip.h"
+#include "mozilla/RefPtr.h"
+
+extern "C" __attribute__((visibility("default"))) void MOZ_JNICALL
+Java_org_mozilla_gecko_mozglue_GeckoLoader_putenv(JNIEnv* jenv, jclass,
+ jstring map) {
+ const char* str;
+ // XXX: java doesn't give us true UTF8, we should figure out something
+ // better to do here
+ str = jenv->GetStringUTFChars(map, nullptr);
+ if (str == nullptr) return;
+ putenv(strdup(str));
+ jenv->ReleaseStringUTFChars(map, str);
+}
diff --git a/mozglue/baseprofiler/build/generate_profiling_categories.py b/mozglue/baseprofiler/build/generate_profiling_categories.py
new file mode 100644
index 0000000000..64da056bbd
--- /dev/null
+++ b/mozglue/baseprofiler/build/generate_profiling_categories.py
@@ -0,0 +1,350 @@
+# 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 script generates ProfilingCategoryList.h and profiling_categories.rs
+# files from profiling_categories.yaml.
+
+from collections import OrderedDict
+
+import yaml
+
+CPP_HEADER_TEMPLATE = """\
+/* 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 {includeguard}
+#define {includeguard}
+
+/* This file is generated by generate_profiling_categories.py from
+ profiling_categories.yaml. DO NOT EDIT! */
+
+// Profiler sub-categories are applied to each sampled stack to describe the
+// type of workload that the CPU is busy with. Only one sub-category can be
+// assigned so be mindful that these are non-overlapping. The active category is
+// set by pushing a label to the profiling stack, or by the unwinder in cases
+// such as JITs. A profile sample in arbitrary C++/Rust will typically be
+// categorized based on the top of the label stack.
+//
+// The list of available color names for categories is:
+// transparent
+// blue
+// green
+// grey
+// lightblue
+// magenta
+// orange
+// purple
+// yellow
+
+// clang-format off
+
+{contents}
+
+// clang-format on
+
+#endif // {includeguard}
+"""
+
+CPP_MACRO_DEFINITION = """\
+#define MOZ_PROFILING_CATEGORY_LIST(BEGIN_CATEGORY, SUBCATEGORY, END_CATEGORY) \\
+"""
+
+RUST_TEMPLATE = """\
+/* 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 file is generated by generate_profiling_categories.py from
+ profiling_categories.yaml. DO NOT EDIT! */
+
+{contents}\
+"""
+
+RUST_ENUM_TEMPLATE = """\
+#[repr(u32)]
+#[derive(Debug, Copy, Clone)]
+pub enum {name} {{
+{fields}
+}}
+"""
+
+RUST_CONVERSION_IMPL_TEMPLATE = """\
+impl {name} {{
+ pub fn to_cpp_enum_value(&self) -> u32 {{
+{content}
+ }}
+}}
+"""
+
+RUST_DEFAULT_IMPL_TEMPLATE = """\
+impl Default for {name} {{
+ fn default() -> Self {{
+{content}
+ }}
+}}
+"""
+
+RUST_MATCH_SELF = """\
+ match *self {{
+{fields}
+ }}
+"""
+
+
+def generate_header(c_out, includeguard, contents):
+ c_out.write(
+ CPP_HEADER_TEMPLATE.format(includeguard=includeguard, contents=contents)
+ )
+
+
+def generate_rust_file(c_out, contents):
+ c_out.write(RUST_TEMPLATE.format(contents=contents))
+
+
+def load_yaml(yaml_path):
+ # Load into an OrderedDict to ensure order is preserved. Note: Python 3.7+
+ # also preserves ordering for normal dictionaries.
+ # Code based on https://stackoverflow.com/a/21912744.
+ class OrderedLoader(yaml.Loader):
+ pass
+
+ def construct_mapping(loader, node):
+ loader.flatten_mapping(node)
+ return OrderedDict(loader.construct_pairs(node))
+
+ tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
+ OrderedLoader.add_constructor(tag, construct_mapping)
+
+ file_handler = open(yaml_path)
+ return yaml.load(file_handler, OrderedLoader)
+
+
+def generate_category_macro(name, label, color, subcategories):
+ contents = ' BEGIN_CATEGORY({name}, "{label}", "{color}") \\\n'.format(
+ name=name, label=label, color=color
+ )
+
+ subcategory_items = []
+
+ for subcategory in subcategories:
+ subcat_name = subcategory["name"]
+ assert isinstance(subcat_name, str)
+ subcat_label = subcategory["label"]
+ assert isinstance(subcat_label, str)
+
+ subcategory_items.append(
+ ' SUBCATEGORY({parent_cat}, {name}, "{label}") \\\n'.format(
+ parent_cat=name, name=subcat_name, label=subcat_label
+ )
+ )
+
+ contents += "".join(subcategory_items)
+ contents += " END_CATEGORY"
+
+ return contents
+
+
+def generate_macro_header(c_out, yaml_path):
+ """Generate ProfilingCategoryList.h from profiling_categories.yaml.
+ The generated file has a macro to generate the profiling category enums.
+ """
+
+ data = load_yaml(yaml_path)
+
+ # Stores the macro definition of each categories.
+ category_items = []
+
+ for category in data:
+ name = category["name"]
+ assert isinstance(name, str)
+ label = category["label"]
+ assert isinstance(label, str)
+ color = category["color"]
+ assert isinstance(color, str)
+ subcategories = category.get("subcategories", None)
+ assert (
+ isinstance(subcategories, list) and len(subcategories) > 0
+ ), "At least one subcategory expected as default in {}.".format(name)
+
+ category_items.append(
+ generate_category_macro(name, label, color, subcategories)
+ )
+
+ contents = CPP_MACRO_DEFINITION
+ contents += " \\\n".join(category_items)
+
+ generate_header(c_out, "baseprofiler_ProfilingCategoryList_h", contents)
+
+
+class RustEnum:
+ """Class that keeps the rust enum fields and impls.
+ This is used for generating the Rust ProfilingCategoryPair and ProfilingCategory
+ enums as well as ProfilingCategoryPair's sub category enums.
+ For example, this can either generate an enum with discrimant fields for sub
+ category enums and ProfilingCategory:
+ ```
+ #[repr(u32)]
+ #[derive(Debug, Copy, Clone)]
+ pub enum Graphics {
+ LayerBuilding = 0,
+ ...
+ }
+ ```
+ or can generate an enum with optional tuple values for ProfilingCategoryPair
+ to explicitly mention their sub categories:
+ ```
+ #[repr(u32)]
+ #[derive(Debug, Copy, Clone)]
+ pub enum ProfilingCategoryPair {
+ Network(Option<Network>),
+ ...
+ }
+ ```
+
+ And in addition to enums, it will generate impls for each enum. See one
+ example below:
+ ```
+ impl Default for Network {
+ fn default() -> Self {
+ Network::Other
+ }
+ }
+ ```
+ """
+
+ def __init__(self, name):
+ # Name of the Rust enum.
+ self.name = name
+ # Fields of the Rust enum. This list contains elements of
+ # (field_name, field_string) tuple for convenience.
+ self.fields = []
+ # Impls of the Rust enum. Each element is a string.
+ self.impls = []
+ # Default category of the Rust enum. Main enums won't have it, but all
+ # sub category enums must have one. This is being checked later.
+ self.default_category = None
+
+ def append_optional_tuple_field(self, field_name):
+ """Append the enum fields list with an optional tuple field."""
+ field = (field_name, " {name}(Option<{name}>),".format(name=field_name))
+ self.fields.append(field)
+
+ def append_discriminant_field(self, field_name, field_value):
+ """Append the enum fields list with a discriminant field."""
+ field = (
+ field_name,
+ " {name} = {value},".format(name=field_name, value=field_value),
+ )
+ self.fields.append(field)
+
+ def append_default_impl(self, default_category):
+ """Append the enum impls list with a default implementation."""
+ self.default_category = default_category
+
+ self.impls.append(
+ RUST_DEFAULT_IMPL_TEMPLATE.format(
+ name=self.name,
+ content=" {category}::{subcategory}".format(
+ category=self.name, subcategory=self.default_category
+ ),
+ )
+ )
+
+ def append_conversion_impl(self, content):
+ """Append the enum impls list with a conversion implementation for cpp values."""
+ self.impls.append(
+ RUST_CONVERSION_IMPL_TEMPLATE.format(name=self.name, content=content)
+ )
+
+ def to_rust_string(self):
+ """Serialize the enum with its impls as a string"""
+ joined_fields = "\n".join(map(lambda field: field[1], self.fields))
+ result = RUST_ENUM_TEMPLATE.format(name=self.name, fields=joined_fields)
+ result += "\n"
+ result += "\n".join(self.impls)
+ return result
+
+
+def generate_rust_enums(c_out, yaml_path):
+ """Generate profiling_categories.rs from profiling_categories.yaml.
+ The generated file has a profiling category enums and their impls.
+ """
+
+ data = load_yaml(yaml_path)
+
+ # Each category has its own enum for keeping its subcategories. We are
+ # keeping all of them here.
+ enums = []
+ # Parent enums for prifiling category and profiling category pair. They will
+ # be appended to the end of the `enums`.
+ profiling_category_pair_enum = RustEnum("ProfilingCategoryPair")
+ profiling_category_enum = RustEnum("ProfilingCategory")
+ profiling_category_pair_value = 0
+
+ for cat_index, category in enumerate(data):
+ cat_name = category["name"]
+ assert isinstance(cat_name, str)
+ cat_label = category["label"]
+ assert isinstance(cat_label, str)
+ # This will be used as our main enum field and sub category enum.
+ cat_label = "".join(filter(str.isalnum, cat_label))
+ cat_subcategories = category.get("subcategories", None)
+ assert (
+ isinstance(cat_subcategories, list) and len(cat_subcategories) > 0
+ ), "At least one subcategory expected as default in {}.".format(cat_name)
+
+ # Create a new enum for this sub category and append it to the enums list.
+ category_enum = RustEnum(cat_label)
+ enums.append(category_enum)
+
+ for subcategory in cat_subcategories:
+ subcat_name = subcategory["name"]
+ assert isinstance(subcat_name, str)
+ subcat_label = subcategory["label"]
+ assert isinstance(subcat_label, str)
+ friendly_subcat_name = None
+
+ if cat_name == subcat_name:
+ # This is the default sub-category. It should use the label as name.
+ friendly_subcat_name = subcat_label
+ category_enum.append_default_impl(subcat_label)
+ else:
+ # This is a non-default sub-category.
+ underscore_pos = subcat_name.find("_")
+ friendly_subcat_name = subcat_name[underscore_pos + 1 :]
+
+ friendly_subcat_name = "".join(filter(str.isalnum, friendly_subcat_name))
+ category_enum.append_discriminant_field(
+ friendly_subcat_name, profiling_category_pair_value
+ )
+ profiling_category_pair_value += 1
+
+ assert (
+ category_enum.default_category is not None
+ ), "There must be a default subcategory with the same name."
+
+ # Append the main enums.
+ profiling_category_pair_enum.append_optional_tuple_field(cat_label)
+ profiling_category_enum.append_discriminant_field(cat_label, cat_index)
+
+ # Add the main enums impls for conversion into cpp values.
+ profiling_category_pair_impl_fields = "\n".join(
+ " {enum_name}::{field_name}(val) => val.unwrap_or_default() as u32,".format(
+ enum_name="ProfilingCategoryPair", field_name=field
+ )
+ for field, _ in profiling_category_pair_enum.fields
+ )
+ profiling_category_pair_enum.append_conversion_impl(
+ RUST_MATCH_SELF.format(fields=profiling_category_pair_impl_fields)
+ )
+ profiling_category_enum.append_conversion_impl(" *self as u32")
+
+ # After adding all the sub category enums, we can add the main enums to the list.
+ enums.append(profiling_category_pair_enum)
+ enums.append(profiling_category_enum)
+
+ # Print all the enums and their impls.
+ contents = "\n".join(map(lambda enum: enum.to_rust_string(), enums))
+ generate_rust_file(c_out, contents)
diff --git a/mozglue/baseprofiler/build/profiling_categories.yaml b/mozglue/baseprofiler/build/profiling_categories.yaml
new file mode 100644
index 0000000000..62fd5d0617
--- /dev/null
+++ b/mozglue/baseprofiler/build/profiling_categories.yaml
@@ -0,0 +1,301 @@
+# 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/.
+
+# Profiling categories
+# ====================
+# This file defines all profiling categories with their sub-categories. It is
+# parsed by generate_profiling_categories.py at build time to create
+# ProfilingCategoryList.h and profiling_categories.rs files.
+#
+# Profiling sub-categories are applied to each sampled stack to describe the
+# type of workload that the CPU is busy with. Only one sub-category can be
+# assigned so be mindful that these are non-overlapping. The active category is
+# set by pushing a label to the profiling stack, or by the unwinder in cases
+# such as JITs. A profile sample in arbitrary C++/Rust will typically be
+# categorized based on the top of the label stack.
+#
+# Each category consists of a name and a set of attributes that are described below:
+#
+# name [required]
+# ====
+# Name of the profiling category. This will be used in the C++ enum fields (not
+# by Rust).
+#
+# label [required]
+# =====
+# Label of the profiling category. This a more human readable string for the
+# category. Label will be displayed in the Firefox Profiler front-end. But also
+# this will be used as a Rust enum field (with non-alphanumeric characters
+# removed) because it's more idiomatic for Rust enums than name fields (which
+# are snake cased fields with all caps, which is not idiomatic to rust enum
+# field).
+#
+# color [required]
+# =====
+# Color that this category will show up as in the Firefox Profiler front-end.
+# The list of available color names for categories is:
+# - transparent
+# - blue
+# - green
+# - grey
+# - lightblue
+# - magenta
+# - orange
+# - purple
+# - yellow
+#
+# subcategories [required]
+# =============
+# A list of sub-categories that belong to this category.
+# There must be at least one sub-category for each category and there must be at
+# least one category with the same name as the category to indicate the default
+# sub-category. Each sub-category must have name and label attributes.
+#
+# name attribute should either be the same as the category (for default
+# sub-category) or should start with parent category name + underscore
+# (e.g. JS_Parsing).
+#
+# label attribute has the same purpose as parent category label attribute.
+#
+# For example:
+# - name: JS
+# subcategories:
+# - name: JS
+# label: Other
+# - name: JS_Parsing
+# label: Parsing
+#
+# Note that the first sub-category has the same name with the category. This is
+# the default sub-category. Also note the other sub-categories starting with the
+# category name + underscore.
+#
+
+- name: IDLE
+ label: Idle
+ color: transparent
+ subcategories:
+ - name: IDLE
+ label: Other
+
+- name: OTHER
+ label: Other
+ color: grey
+ subcategories:
+ - name: OTHER
+ label: Other
+ - name: OTHER_PreferenceRead
+ label: Preference Read
+ - name: OTHER_Profiling
+ label: Profiling
+
+- name: TEST
+ label: Test
+ color: darkgray
+ subcategories:
+ - name: TEST
+ label: Test
+
+- name: LAYOUT
+ label: Layout
+ color: purple
+ subcategories:
+ - name: LAYOUT
+ label: Other
+ - name: LAYOUT_FrameConstruction
+ label: Frame construction
+ - name: LAYOUT_Reflow
+ label: Reflow
+ - name: LAYOUT_CSSParsing
+ label: CSS parsing
+ - name: LAYOUT_SelectorQuery
+ label: Selector query
+ - name: LAYOUT_StyleComputation
+ label: Style computation
+ - name: LAYOUT_Destroy
+ label: Layout cleanup
+
+- name: JS
+ label: JavaScript
+ color: yellow
+ subcategories:
+ - name: JS
+ label: Other
+ - name: JS_Parsing
+ label: Parsing
+ - name: JS_BaselineCompilation
+ label: JIT Compile (baseline)
+ - name: JS_IonCompilation
+ label: JIT Compile (ion)
+ - name: JS_Interpreter
+ label: Interpreter
+ - name: JS_BaselineInterpret
+ label: JIT (baseline-interpreter)
+ - name: JS_Baseline
+ label: JIT (baseline)
+ - name: JS_IonMonkey
+ label: JIT (ion)
+ - name: JS_Builtin
+ label: Builtin API
+ - name: JS_Wasm
+ label: Wasm
+
+- name: GCCC
+ label: GC / CC
+ color: orange
+ subcategories:
+ - name: GCCC
+ label: Other
+ - name: GCCC_MinorGC
+ label: Minor GC
+ - name: GCCC_MajorGC
+ label: Major GC (Other)
+ - name: GCCC_MajorGC_Mark
+ label: Major GC (Mark)
+ - name: GCCC_MajorGC_Sweep
+ label: Major GC (Sweep)
+ - name: GCCC_MajorGC_Compact
+ label: Major GC (Compact)
+ - name: GCCC_UnmarkGray
+ label: Unmark Gray
+ - name: GCCC_Barrier
+ label: Barrier
+ - name: GCCC_FreeSnowWhite
+ label: CC (Free Snow White)
+ - name: GCCC_BuildGraph
+ label: CC (Build Graph)
+ - name: GCCC_ScanRoots
+ label: CC (Scan Roots)
+ - name: GCCC_CollectWhite
+ label: CC (Collect White)
+ - name: GCCC_Finalize
+ label: CC (Finalize)
+
+- name: NETWORK
+ label: Network
+ color: lightblue
+ subcategories:
+ - name: NETWORK
+ label: Other
+
+- name: GRAPHICS
+ label: Graphics
+ color: green
+ subcategories:
+ - name: GRAPHICS
+ label: Other
+ - name: GRAPHICS_DisplayListBuilding
+ label: DisplayList building
+ - name: GRAPHICS_DisplayListMerging
+ label: DisplayList merging
+ - name: GRAPHICS_LayerBuilding
+ label: Layer building
+ - name: GRAPHICS_TileAllocation
+ label: Tile allocation
+ - name: GRAPHICS_WRDisplayList
+ label: WebRender display list
+ - name: GRAPHICS_Rasterization
+ label: Rasterization
+ - name: GRAPHICS_FlushingAsyncPaints
+ label: Flushing async paints
+ - name: GRAPHICS_ImageDecoding
+ label: Image decoding
+
+- name: DOM
+ label: DOM
+ color: blue
+ subcategories:
+ - name: DOM
+ label: Other
+
+- name: JAVA_ANDROID
+ label: Android
+ color: yellow
+ subcategories:
+ - name: JAVA_ANDROID
+ label: Other
+
+- name: JAVA_ANDROIDX
+ label: AndroidX
+ color: orange
+ subcategories:
+ - name: JAVA_ANDROIDX
+ label: Other
+
+- name: JAVA_LANGUAGE
+ label: Java
+ color: blue
+ subcategories:
+ - name: JAVA_LANGUAGE
+ label: Other
+
+- name: JAVA_MOZILLA
+ label: Mozilla
+ color: green
+ subcategories:
+ - name: JAVA_MOZILLA
+ label: Other
+
+- name: JAVA_KOTLIN
+ label: Kotlin
+ color: purple
+ subcategories:
+ - name: JAVA_KOTLIN
+ label: Other
+
+- name: JAVA_BLOCKED
+ label: Blocked
+ color: lightblue
+ subcategories:
+ - name: JAVA_BLOCKED
+ label: Other
+
+- name: IPC
+ label: IPC
+ color: lightgreen
+ subcategories:
+ - name: IPC
+ label: Other
+
+- name: MEDIA
+ label: Media
+ color: orange
+ subcategories:
+ - name: MEDIA
+ label: Other
+ - name: MEDIA_CUBEB
+ label: Cubeb
+ - name: MEDIA_PLAYBACK
+ label: Playback
+ - name: MEDIA_RT
+ label: Real-time rendering
+
+# We don't name this category ACCESSIBILITY
+# because it's already defined as a macro.
+- name: A11Y
+ label: Accessibility
+ color: brown
+ subcategories:
+ - name: A11Y
+ label: Other
+
+- name: PROFILER
+ label: Profiler
+ color: lightred
+ subcategories:
+ - name: PROFILER
+ label: Other
+
+- name: TIMER
+ label: Timer
+ color: grey
+ subcategories:
+ - name: TIMER
+ label: Other
+
+- name: REMOTE_PROTOCOL
+ label: Remote-Protocol
+ color: grey
+ subcategories:
+ - name: REMOTE_PROTOCOL
+ label: Other
diff --git a/mozglue/baseprofiler/core/BaseAndGeckoProfilerDetail.cpp b/mozglue/baseprofiler/core/BaseAndGeckoProfilerDetail.cpp
new file mode 100644
index 0000000000..213f25cf16
--- /dev/null
+++ b/mozglue/baseprofiler/core/BaseAndGeckoProfilerDetail.cpp
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "mozilla/BaseAndGeckoProfilerDetail.h"
+
+#include <limits>
+#include <string_view>
+
+namespace mozilla::profiler::detail {
+
+constexpr std::string_view scPidPrefix = "pid:";
+
+// Convert a C string to a BaseProfilerProcessId. Return unspecified
+// BaseProfilerProcessId if the string is not exactly a valid pid.
+static baseprofiler::BaseProfilerProcessId StringToPid(const char* aString) {
+ if (!aString || aString[0] == '\0') {
+ // Null or empty.
+ return baseprofiler::BaseProfilerProcessId{};
+ }
+
+ if (aString[0] == '0') {
+ if (aString[1] != '\0') {
+ // Don't accept leading zeroes.
+ return baseprofiler::BaseProfilerProcessId{};
+ }
+ return baseprofiler::BaseProfilerProcessId::FromNumber(0);
+ }
+
+ using PidNumber = baseprofiler::BaseProfilerProcessId::NumberType;
+ PidNumber pid = 0;
+ for (;;) {
+ const char c = *aString;
+ if (c == '\0') {
+ break;
+ }
+ if (c < '0' || c > '9') {
+ // Only accept decimal digits.
+ return baseprofiler::BaseProfilerProcessId{};
+ }
+ static_assert(!std::numeric_limits<PidNumber>::is_signed,
+ "The following relies on unsigned arithmetic");
+ PidNumber newPid = pid * 10u + PidNumber(c - '0');
+ if (newPid < pid) {
+ // Unsigned overflow.
+ return baseprofiler::BaseProfilerProcessId{};
+ }
+ pid = newPid;
+ ++aString;
+ }
+ return baseprofiler::BaseProfilerProcessId::FromNumber(pid);
+}
+
+[[nodiscard]] MFBT_API bool FilterHasPid(
+ const char* aFilter, baseprofiler::BaseProfilerProcessId aPid) {
+ if (strncmp(aFilter, scPidPrefix.data(), scPidPrefix.length()) != 0) {
+ // The filter is not starting with "pid:".
+ return false;
+ }
+
+ return StringToPid(aFilter + scPidPrefix.length()) == aPid;
+}
+
+[[nodiscard]] MFBT_API bool FiltersExcludePid(
+ Span<const char* const> aFilters,
+ baseprofiler::BaseProfilerProcessId aPid) {
+ if (aFilters.empty()) {
+ return false;
+ }
+
+ // First, check if the list only contains "pid:..." strings.
+ for (const char* const filter : aFilters) {
+ if (strncmp(filter, scPidPrefix.data(), scPidPrefix.length()) != 0) {
+ // At least one filter is *not* a "pid:...", our pid is not excluded.
+ return false;
+ }
+ }
+
+ // Here, all filters start with "pid:". Check if the given pid is included.
+ for (const char* const filter : aFilters) {
+ if (StringToPid(filter + scPidPrefix.length()) == aPid) {
+ // Our pid is present, so it's not excluded.
+ return false;
+ }
+ }
+ // Our pid was not in a list of only pids, so it's excluded.
+ return true;
+}
+
+} // namespace mozilla::profiler::detail
diff --git a/mozglue/baseprofiler/core/EHABIStackWalk.cpp b/mozglue/baseprofiler/core/EHABIStackWalk.cpp
new file mode 100644
index 0000000000..0c2c855c9b
--- /dev/null
+++ b/mozglue/baseprofiler/core/EHABIStackWalk.cpp
@@ -0,0 +1,592 @@
+/* -*- 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 is an implementation of stack unwinding according to a subset
+ * of the ARM Exception Handling ABI, as described in:
+ * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038a/IHI0038A_ehabi.pdf
+ *
+ * This handles only the ARM-defined "personality routines" (chapter
+ * 9), and don't track the value of FP registers, because profiling
+ * needs only chain of PC/SP values.
+ *
+ * Because the exception handling info may not be accurate for all
+ * possible places where an async signal could occur (e.g., in a
+ * prologue or epilogue), this bounds-checks all stack accesses.
+ *
+ * This file uses "struct" for structures in the exception tables and
+ * "class" otherwise. We should avoid violating the C++11
+ * standard-layout rules in the former.
+ */
+
+#include "BaseProfiler.h"
+
+#include "EHABIStackWalk.h"
+
+#include "BaseProfilerSharedLibraries.h"
+#include "platform.h"
+
+#include "mozilla/Atomics.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/EndianUtils.h"
+
+#include <algorithm>
+#include <elf.h>
+#include <stdint.h>
+#include <vector>
+#include <string>
+
+#ifndef PT_ARM_EXIDX
+# define PT_ARM_EXIDX 0x70000001
+#endif
+
+namespace mozilla {
+namespace baseprofiler {
+
+struct PRel31 {
+ uint32_t mBits;
+ bool topBit() const { return mBits & 0x80000000; }
+ uint32_t value() const { return mBits & 0x7fffffff; }
+ int32_t offset() const { return (static_cast<int32_t>(mBits) << 1) >> 1; }
+ const void* compute() const {
+ return reinterpret_cast<const char*>(this) + offset();
+ }
+
+ private:
+ PRel31(const PRel31& copied) = delete;
+ PRel31() = delete;
+};
+
+struct EHEntry {
+ PRel31 startPC;
+ PRel31 exidx;
+
+ private:
+ EHEntry(const EHEntry& copied) = delete;
+ EHEntry() = delete;
+};
+
+class EHState {
+ // Note that any core register can be used as a "frame pointer" to
+ // influence the unwinding process, so this must track all of them.
+ uint32_t mRegs[16];
+
+ public:
+ bool unwind(const EHEntry* aEntry, const void* stackBase);
+ uint32_t& operator[](int i) { return mRegs[i]; }
+ const uint32_t& operator[](int i) const { return mRegs[i]; }
+ explicit EHState(const mcontext_t&);
+};
+
+enum { R_SP = 13, R_LR = 14, R_PC = 15 };
+
+class EHTable {
+ uint32_t mStartPC;
+ uint32_t mEndPC;
+ uint32_t mBaseAddress;
+ const EHEntry* mEntriesBegin;
+ const EHEntry* mEntriesEnd;
+ std::string mName;
+
+ public:
+ EHTable(const void* aELF, size_t aSize, const std::string& aName);
+ const EHEntry* lookup(uint32_t aPC) const;
+ bool isValid() const { return mEntriesEnd != mEntriesBegin; }
+ const std::string& name() const { return mName; }
+ uint32_t startPC() const { return mStartPC; }
+ uint32_t endPC() const { return mEndPC; }
+ uint32_t baseAddress() const { return mBaseAddress; }
+};
+
+class EHAddrSpace {
+ std::vector<uint32_t> mStarts;
+ std::vector<EHTable> mTables;
+ static Atomic<const EHAddrSpace*> sCurrent;
+
+ public:
+ explicit EHAddrSpace(const std::vector<EHTable>& aTables);
+ const EHTable* lookup(uint32_t aPC) const;
+ static void Update();
+ static const EHAddrSpace* Get();
+};
+
+void EHABIStackWalkInit() { EHAddrSpace::Update(); }
+
+size_t EHABIStackWalk(const mcontext_t& aContext, void* stackBase, void** aSPs,
+ void** aPCs, const size_t aNumFrames) {
+ const EHAddrSpace* space = EHAddrSpace::Get();
+ EHState state(aContext);
+ size_t count = 0;
+
+ while (count < aNumFrames) {
+ uint32_t pc = state[R_PC], sp = state[R_SP];
+ aPCs[count] = reinterpret_cast<void*>(pc);
+ aSPs[count] = reinterpret_cast<void*>(sp);
+ count++;
+
+ if (!space) break;
+ // TODO: cache these lookups. Binary-searching libxul is
+ // expensive (possibly more expensive than doing the actual
+ // unwind), and even a small cache should help.
+ const EHTable* table = space->lookup(pc);
+ if (!table) break;
+ const EHEntry* entry = table->lookup(pc);
+ if (!entry) break;
+ if (!state.unwind(entry, stackBase)) break;
+ }
+
+ return count;
+}
+
+class EHInterp {
+ public:
+ // Note that stackLimit is exclusive and stackBase is inclusive
+ // (i.e, stackLimit < SP <= stackBase), following the convention
+ // set by the AAPCS spec.
+ EHInterp(EHState& aState, const EHEntry* aEntry, uint32_t aStackLimit,
+ uint32_t aStackBase)
+ : mState(aState),
+ mStackLimit(aStackLimit),
+ mStackBase(aStackBase),
+ mNextWord(0),
+ mWordsLeft(0),
+ mFailed(false) {
+ const PRel31& exidx = aEntry->exidx;
+ uint32_t firstWord;
+
+ if (exidx.mBits == 1) { // EXIDX_CANTUNWIND
+ mFailed = true;
+ return;
+ }
+ if (exidx.topBit()) {
+ firstWord = exidx.mBits;
+ } else {
+ mNextWord = reinterpret_cast<const uint32_t*>(exidx.compute());
+ firstWord = *mNextWord++;
+ }
+
+ switch (firstWord >> 24) {
+ case 0x80: // short
+ mWord = firstWord << 8;
+ mBytesLeft = 3;
+ break;
+ case 0x81:
+ case 0x82: // long; catch descriptor size ignored
+ mWord = firstWord << 16;
+ mBytesLeft = 2;
+ mWordsLeft = (firstWord >> 16) & 0xff;
+ break;
+ default:
+ // unknown personality
+ mFailed = true;
+ }
+ }
+
+ bool unwind();
+
+ private:
+ // TODO: GCC has been observed not CSEing repeated reads of
+ // mState[R_SP] with writes to mFailed between them, suggesting that
+ // it hasn't determined that they can't alias and is thus missing
+ // optimization opportunities. So, we may want to flatten EHState
+ // into this class; this may also make the code simpler.
+ EHState& mState;
+ uint32_t mStackLimit;
+ uint32_t mStackBase;
+ const uint32_t* mNextWord;
+ uint32_t mWord;
+ uint8_t mWordsLeft;
+ uint8_t mBytesLeft;
+ bool mFailed;
+
+ enum {
+ I_ADDSP = 0x00, // 0sxxxxxx (subtract if s)
+ M_ADDSP = 0x80,
+ I_POPMASK = 0x80, // 1000iiii iiiiiiii (if any i set)
+ M_POPMASK = 0xf0,
+ I_MOVSP = 0x90, // 1001nnnn
+ M_MOVSP = 0xf0,
+ I_POPN = 0xa0, // 1010lnnn
+ M_POPN = 0xf0,
+ I_FINISH = 0xb0, // 10110000
+ I_POPLO = 0xb1, // 10110001 0000iiii (if any i set)
+ I_ADDSPBIG = 0xb2, // 10110010 uleb128
+ I_POPFDX = 0xb3, // 10110011 sssscccc
+ I_POPFDX8 = 0xb8, // 10111nnn
+ M_POPFDX8 = 0xf8,
+ // "Intel Wireless MMX" extensions omitted.
+ I_POPFDD = 0xc8, // 1100100h sssscccc
+ M_POPFDD = 0xfe,
+ I_POPFDD8 = 0xd0, // 11010nnn
+ M_POPFDD8 = 0xf8
+ };
+
+ uint8_t next() {
+ if (mBytesLeft == 0) {
+ if (mWordsLeft == 0) {
+ return I_FINISH;
+ }
+ mWordsLeft--;
+ mWord = *mNextWord++;
+ mBytesLeft = 4;
+ }
+ mBytesLeft--;
+ mWord = (mWord << 8) | (mWord >> 24); // rotate
+ return mWord;
+ }
+
+ uint32_t& vSP() { return mState[R_SP]; }
+ uint32_t* ptrSP() { return reinterpret_cast<uint32_t*>(vSP()); }
+
+ void checkStackBase() {
+ if (vSP() > mStackBase) mFailed = true;
+ }
+ void checkStackLimit() {
+ if (vSP() <= mStackLimit) mFailed = true;
+ }
+ void checkStackAlign() {
+ if ((vSP() & 3) != 0) mFailed = true;
+ }
+ void checkStack() {
+ checkStackBase();
+ checkStackLimit();
+ checkStackAlign();
+ }
+
+ void popRange(uint8_t first, uint8_t last, uint16_t mask) {
+ bool hasSP = false;
+ uint32_t tmpSP;
+ if (mask == 0) mFailed = true;
+ for (uint8_t r = first; r <= last; ++r) {
+ if (mask & 1) {
+ if (r == R_SP) {
+ hasSP = true;
+ tmpSP = *ptrSP();
+ } else
+ mState[r] = *ptrSP();
+ vSP() += 4;
+ checkStackBase();
+ if (mFailed) return;
+ }
+ mask >>= 1;
+ }
+ if (hasSP) {
+ vSP() = tmpSP;
+ checkStack();
+ }
+ }
+};
+
+bool EHState::unwind(const EHEntry* aEntry, const void* stackBasePtr) {
+ // The unwinding program cannot set SP to less than the initial value.
+ uint32_t stackLimit = mRegs[R_SP] - 4;
+ uint32_t stackBase = reinterpret_cast<uint32_t>(stackBasePtr);
+ EHInterp interp(*this, aEntry, stackLimit, stackBase);
+ return interp.unwind();
+}
+
+bool EHInterp::unwind() {
+ mState[R_PC] = 0;
+ checkStack();
+ while (!mFailed) {
+ uint8_t insn = next();
+#if DEBUG_EHABI_UNWIND
+ LOG("unwind insn = %02x", (unsigned)insn);
+#endif
+ // Try to put the common cases first.
+
+ // 00xxxxxx: vsp = vsp + (xxxxxx << 2) + 4
+ // 01xxxxxx: vsp = vsp - (xxxxxx << 2) - 4
+ if ((insn & M_ADDSP) == I_ADDSP) {
+ uint32_t offset = ((insn & 0x3f) << 2) + 4;
+ if (insn & 0x40) {
+ vSP() -= offset;
+ checkStackLimit();
+ } else {
+ vSP() += offset;
+ checkStackBase();
+ }
+ continue;
+ }
+
+ // 10100nnn: Pop r4-r[4+nnn]
+ // 10101nnn: Pop r4-r[4+nnn], r14
+ if ((insn & M_POPN) == I_POPN) {
+ uint8_t n = (insn & 0x07) + 1;
+ bool lr = insn & 0x08;
+ uint32_t* ptr = ptrSP();
+ vSP() += (n + (lr ? 1 : 0)) * 4;
+ checkStackBase();
+ for (uint8_t r = 4; r < 4 + n; ++r) mState[r] = *ptr++;
+ if (lr) mState[R_LR] = *ptr++;
+ continue;
+ }
+
+ // 1011000: Finish
+ if (insn == I_FINISH) {
+ if (mState[R_PC] == 0) {
+ mState[R_PC] = mState[R_LR];
+ // Non-standard change (bug 916106): Prevent the caller from
+ // re-using LR. Since the caller is by definition not a leaf
+ // routine, it will have to restore LR from somewhere to
+ // return to its own caller, so we can safely zero it here.
+ // This makes a difference only if an error in unwinding
+ // (e.g., caused by starting from within a prologue/epilogue)
+ // causes us to load a pointer to a leaf routine as LR; if we
+ // don't do something, we'll go into an infinite loop of
+ // "returning" to that same function.
+ mState[R_LR] = 0;
+ }
+ return true;
+ }
+
+ // 1001nnnn: Set vsp = r[nnnn]
+ if ((insn & M_MOVSP) == I_MOVSP) {
+ vSP() = mState[insn & 0x0f];
+ checkStack();
+ continue;
+ }
+
+ // 11001000 sssscccc: Pop VFP regs D[16+ssss]-D[16+ssss+cccc] (as FLDMFDD)
+ // 11001001 sssscccc: Pop VFP regs D[ssss]-D[ssss+cccc] (as FLDMFDD)
+ if ((insn & M_POPFDD) == I_POPFDD) {
+ uint8_t n = (next() & 0x0f) + 1;
+ // Note: if the 16+ssss+cccc > 31, the encoding is reserved.
+ // As the space is currently unused, we don't try to check.
+ vSP() += 8 * n;
+ checkStackBase();
+ continue;
+ }
+
+ // 11010nnn: Pop VFP regs D[8]-D[8+nnn] (as FLDMFDD)
+ if ((insn & M_POPFDD8) == I_POPFDD8) {
+ uint8_t n = (insn & 0x07) + 1;
+ vSP() += 8 * n;
+ checkStackBase();
+ continue;
+ }
+
+ // 10110010 uleb128: vsp = vsp + 0x204 + (uleb128 << 2)
+ if (insn == I_ADDSPBIG) {
+ uint32_t acc = 0;
+ uint8_t shift = 0;
+ uint8_t byte;
+ do {
+ if (shift >= 32) return false;
+ byte = next();
+ acc |= (byte & 0x7f) << shift;
+ shift += 7;
+ } while (byte & 0x80);
+ uint32_t offset = 0x204 + (acc << 2);
+ // The calculations above could have overflowed.
+ // But the one we care about is this:
+ if (vSP() + offset < vSP()) mFailed = true;
+ vSP() += offset;
+ // ...so that this is the only other check needed:
+ checkStackBase();
+ continue;
+ }
+
+ // 1000iiii iiiiiiii (i not all 0): Pop under masks {r15-r12}, {r11-r4}
+ if ((insn & M_POPMASK) == I_POPMASK) {
+ popRange(4, 15, ((insn & 0x0f) << 8) | next());
+ continue;
+ }
+
+ // 1011001 0000iiii (i not all 0): Pop under mask {r3-r0}
+ if (insn == I_POPLO) {
+ popRange(0, 3, next() & 0x0f);
+ continue;
+ }
+
+ // 10110011 sssscccc: Pop VFP regs D[ssss]-D[ssss+cccc] (as FLDMFDX)
+ if (insn == I_POPFDX) {
+ uint8_t n = (next() & 0x0f) + 1;
+ vSP() += 8 * n + 4;
+ checkStackBase();
+ continue;
+ }
+
+ // 10111nnn: Pop VFP regs D[8]-D[8+nnn] (as FLDMFDX)
+ if ((insn & M_POPFDX8) == I_POPFDX8) {
+ uint8_t n = (insn & 0x07) + 1;
+ vSP() += 8 * n + 4;
+ checkStackBase();
+ continue;
+ }
+
+ // unhandled instruction
+#ifdef DEBUG_EHABI_UNWIND
+ LOG("Unhandled EHABI instruction 0x%02x", insn);
+#endif
+ mFailed = true;
+ }
+ return false;
+}
+
+bool operator<(const EHTable& lhs, const EHTable& rhs) {
+ return lhs.startPC() < rhs.startPC();
+}
+
+// Async signal unsafe.
+EHAddrSpace::EHAddrSpace(const std::vector<EHTable>& aTables)
+ : mTables(aTables) {
+ std::sort(mTables.begin(), mTables.end());
+ DebugOnly<uint32_t> lastEnd = 0;
+ for (std::vector<EHTable>::iterator i = mTables.begin(); i != mTables.end();
+ ++i) {
+ MOZ_ASSERT(i->startPC() >= lastEnd);
+ mStarts.push_back(i->startPC());
+ lastEnd = i->endPC();
+ }
+}
+
+const EHTable* EHAddrSpace::lookup(uint32_t aPC) const {
+ ptrdiff_t i = (std::upper_bound(mStarts.begin(), mStarts.end(), aPC) -
+ mStarts.begin()) -
+ 1;
+
+ if (i < 0 || aPC >= mTables[i].endPC()) return 0;
+ return &mTables[i];
+}
+
+const EHEntry* EHTable::lookup(uint32_t aPC) const {
+ MOZ_ASSERT(aPC >= mStartPC);
+ if (aPC >= mEndPC) return nullptr;
+
+ const EHEntry* begin = mEntriesBegin;
+ const EHEntry* end = mEntriesEnd;
+ MOZ_ASSERT(begin < end);
+ if (aPC < reinterpret_cast<uint32_t>(begin->startPC.compute()))
+ return nullptr;
+
+ while (end - begin > 1) {
+#ifdef EHABI_UNWIND_MORE_ASSERTS
+ if ((end - 1)->startPC.compute() < begin->startPC.compute()) {
+ MOZ_CRASH("unsorted exidx");
+ }
+#endif
+ const EHEntry* mid = begin + (end - begin) / 2;
+ if (aPC < reinterpret_cast<uint32_t>(mid->startPC.compute()))
+ end = mid;
+ else
+ begin = mid;
+ }
+ return begin;
+}
+
+#if MOZ_LITTLE_ENDIAN()
+static const unsigned char hostEndian = ELFDATA2LSB;
+#elif MOZ_BIG_ENDIAN()
+static const unsigned char hostEndian = ELFDATA2MSB;
+#else
+# error "No endian?"
+#endif
+
+// Async signal unsafe: std::vector::reserve, std::string copy ctor.
+EHTable::EHTable(const void* aELF, size_t aSize, const std::string& aName)
+ : mStartPC(~0), // largest uint32_t
+ mEndPC(0),
+ mEntriesBegin(nullptr),
+ mEntriesEnd(nullptr),
+ mName(aName) {
+ const uint32_t fileHeaderAddr = reinterpret_cast<uint32_t>(aELF);
+
+ if (aSize < sizeof(Elf32_Ehdr)) return;
+
+ const Elf32_Ehdr& file = *(reinterpret_cast<Elf32_Ehdr*>(fileHeaderAddr));
+ if (memcmp(&file.e_ident[EI_MAG0], ELFMAG, SELFMAG) != 0 ||
+ file.e_ident[EI_CLASS] != ELFCLASS32 ||
+ file.e_ident[EI_DATA] != hostEndian ||
+ file.e_ident[EI_VERSION] != EV_CURRENT || file.e_machine != EM_ARM ||
+ file.e_version != EV_CURRENT)
+ // e_flags?
+ return;
+
+ MOZ_ASSERT(file.e_phoff + file.e_phnum * file.e_phentsize <= aSize);
+ const Elf32_Phdr *exidxHdr = 0, *zeroHdr = 0;
+ for (unsigned i = 0; i < file.e_phnum; ++i) {
+ const Elf32_Phdr& phdr = *(reinterpret_cast<Elf32_Phdr*>(
+ fileHeaderAddr + file.e_phoff + i * file.e_phentsize));
+ if (phdr.p_type == PT_ARM_EXIDX) {
+ exidxHdr = &phdr;
+ } else if (phdr.p_type == PT_LOAD) {
+ if (phdr.p_offset == 0) {
+ zeroHdr = &phdr;
+ }
+ if (phdr.p_flags & PF_X) {
+ mStartPC = std::min(mStartPC, phdr.p_vaddr);
+ mEndPC = std::max(mEndPC, phdr.p_vaddr + phdr.p_memsz);
+ }
+ }
+ }
+ if (!exidxHdr) return;
+ if (!zeroHdr) return;
+ mBaseAddress = fileHeaderAddr - zeroHdr->p_vaddr;
+ mStartPC += mBaseAddress;
+ mEndPC += mBaseAddress;
+ mEntriesBegin =
+ reinterpret_cast<const EHEntry*>(mBaseAddress + exidxHdr->p_vaddr);
+ mEntriesEnd = reinterpret_cast<const EHEntry*>(
+ mBaseAddress + exidxHdr->p_vaddr + exidxHdr->p_memsz);
+}
+
+Atomic<const EHAddrSpace*> EHAddrSpace::sCurrent(nullptr);
+
+// Async signal safe; can fail if Update() hasn't returned yet.
+const EHAddrSpace* EHAddrSpace::Get() { return sCurrent; }
+
+// Collect unwinding information from loaded objects. Calls after the
+// first have no effect. Async signal unsafe.
+void EHAddrSpace::Update() {
+ const EHAddrSpace* space = sCurrent;
+ if (space) return;
+
+ SharedLibraryInfo info = SharedLibraryInfo::GetInfoForSelf();
+ std::vector<EHTable> tables;
+
+ for (size_t i = 0; i < info.GetSize(); ++i) {
+ const SharedLibrary& lib = info.GetEntry(i);
+ // FIXME: This isn't correct if the start address isn't p_offset 0, because
+ // the start address will not point at the file header. But this is worked
+ // around by magic number checks in the EHTable constructor.
+ EHTable tab(reinterpret_cast<const void*>(lib.GetStart()),
+ lib.GetEnd() - lib.GetStart(), lib.GetDebugPath());
+ if (tab.isValid()) tables.push_back(tab);
+ }
+ space = new EHAddrSpace(tables);
+
+ if (!sCurrent.compareExchange(nullptr, space)) {
+ delete space;
+ space = sCurrent;
+ }
+}
+
+EHState::EHState(const mcontext_t& context) {
+#ifdef linux
+ mRegs[0] = context.arm_r0;
+ mRegs[1] = context.arm_r1;
+ mRegs[2] = context.arm_r2;
+ mRegs[3] = context.arm_r3;
+ mRegs[4] = context.arm_r4;
+ mRegs[5] = context.arm_r5;
+ mRegs[6] = context.arm_r6;
+ mRegs[7] = context.arm_r7;
+ mRegs[8] = context.arm_r8;
+ mRegs[9] = context.arm_r9;
+ mRegs[10] = context.arm_r10;
+ mRegs[11] = context.arm_fp;
+ mRegs[12] = context.arm_ip;
+ mRegs[13] = context.arm_sp;
+ mRegs[14] = context.arm_lr;
+ mRegs[15] = context.arm_pc;
+#else
+# error "Unhandled OS for ARM EHABI unwinding"
+#endif
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/EHABIStackWalk.h b/mozglue/baseprofiler/core/EHABIStackWalk.h
new file mode 100644
index 0000000000..d5f4edc0d7
--- /dev/null
+++ b/mozglue/baseprofiler/core/EHABIStackWalk.h
@@ -0,0 +1,30 @@
+/* -*- 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 is an implementation of stack unwinding according to a subset
+ * of the ARM Exception Handling ABI; see the comment at the top of
+ * the .cpp file for details.
+ */
+
+#ifndef mozilla_EHABIStackWalk_h__
+#define mozilla_EHABIStackWalk_h__
+
+#include <stddef.h>
+#include <ucontext.h>
+
+namespace mozilla {
+namespace baseprofiler {
+
+void EHABIStackWalkInit();
+
+size_t EHABIStackWalk(const mcontext_t& aContext, void* stackBase, void** aSPs,
+ void** aPCs, size_t aNumFrames);
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif
diff --git a/mozglue/baseprofiler/core/PageInformation.cpp b/mozglue/baseprofiler/core/PageInformation.cpp
new file mode 100644
index 0000000000..bb7c7872aa
--- /dev/null
+++ b/mozglue/baseprofiler/core/PageInformation.cpp
@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "PageInformation.h"
+
+#include "BaseProfiler.h"
+
+#include "mozilla/BaseProfileJSONWriter.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+PageInformation::PageInformation(uint64_t aTabID, uint64_t aInnerWindowID,
+ const std::string& aUrl,
+ uint64_t aEmbedderInnerWindowID)
+ : mTabID(aTabID),
+ mInnerWindowID(aInnerWindowID),
+ mUrl(aUrl),
+ mEmbedderInnerWindowID(aEmbedderInnerWindowID),
+ mRefCnt(0) {}
+
+bool PageInformation::Equals(PageInformation* aOtherPageInfo) const {
+ // It's enough to check inner window IDs because they are unique for each
+ // page. Therefore, we don't have to check the tab ID or url.
+ return InnerWindowID() == aOtherPageInfo->InnerWindowID();
+}
+
+void PageInformation::StreamJSON(SpliceableJSONWriter& aWriter) const {
+ aWriter.StartObjectElement();
+ // Here, we are converting uint64_t to double. Both tab and Inner
+ // Window IDs are created using `nsContentUtils::GenerateProcessSpecificId`,
+ // which is specifically designed to only use 53 of the 64 bits to be lossless
+ // when passed into and out of JS as a double.
+ aWriter.DoubleProperty("tabID", TabID());
+ aWriter.DoubleProperty("innerWindowID", InnerWindowID());
+ aWriter.StringProperty("url", Url());
+ aWriter.DoubleProperty("embedderInnerWindowID", EmbedderInnerWindowID());
+ aWriter.EndObject();
+}
+
+size_t PageInformation::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this);
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/PageInformation.h b/mozglue/baseprofiler/core/PageInformation.h
new file mode 100644
index 0000000000..41808877b3
--- /dev/null
+++ b/mozglue/baseprofiler/core/PageInformation.h
@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef PageInformation_h
+#define PageInformation_h
+
+#include "mozilla/Atomics.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+
+#include <string>
+
+namespace mozilla {
+namespace baseprofiler {
+
+class SpliceableJSONWriter;
+
+// This class contains information that's relevant to a single page only
+// while the page information is important and registered with the profiler,
+// but regardless of whether the profiler is running. All accesses to it are
+// protected by the profiler state lock.
+// When the page gets unregistered, we keep the profiler buffer position
+// to determine if we are still using this page. If not, we unregister
+// it in the next page registration.
+class PageInformation final {
+ public:
+ PageInformation(uint64_t aTabID, uint64_t aInnerWindowID,
+ const std::string& aUrl, uint64_t aEmbedderInnerWindowID);
+
+ // Using hand-rolled ref-counting, because RefCounted.h macros don't produce
+ // the same code between mozglue and libxul, see bug 1536656.
+ MFBT_API void AddRef() const { ++mRefCnt; }
+ MFBT_API void Release() const {
+ MOZ_ASSERT(int32_t(mRefCnt) > 0);
+ if (--mRefCnt) {
+ delete this;
+ }
+ }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
+ bool Equals(PageInformation* aOtherPageInfo) const;
+ void StreamJSON(SpliceableJSONWriter& aWriter) const;
+
+ uint64_t InnerWindowID() const { return mInnerWindowID; }
+ uint64_t TabID() const { return mTabID; }
+ const std::string& Url() const { return mUrl; }
+ uint64_t EmbedderInnerWindowID() const { return mEmbedderInnerWindowID; }
+
+ Maybe<uint64_t> BufferPositionWhenUnregistered() const {
+ return mBufferPositionWhenUnregistered;
+ }
+
+ void NotifyUnregistered(uint64_t aBufferPosition) {
+ mBufferPositionWhenUnregistered = Some(aBufferPosition);
+ }
+
+ private:
+ const uint64_t mTabID;
+ const uint64_t mInnerWindowID;
+ const std::string mUrl;
+ const uint64_t mEmbedderInnerWindowID;
+
+ // Holds the buffer position when page is unregistered.
+ // It's used to determine if we still use this page in the profiler or
+ // not.
+ Maybe<uint64_t> mBufferPositionWhenUnregistered;
+
+ mutable Atomic<int32_t, MemoryOrdering::ReleaseAcquire> mRefCnt;
+};
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif // PageInformation_h
diff --git a/mozglue/baseprofiler/core/PlatformMacros.h b/mozglue/baseprofiler/core/PlatformMacros.h
new file mode 100644
index 0000000000..c72e94c128
--- /dev/null
+++ b/mozglue/baseprofiler/core/PlatformMacros.h
@@ -0,0 +1,130 @@
+/* -*- 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 PLATFORM_MACROS_H
+#define PLATFORM_MACROS_H
+
+// Define platform selection macros in a consistent way. Don't add anything
+// else to this file, so it can remain freestanding. The primary factorisation
+// is on (ARCH,OS) pairs ("PLATforms") but ARCH_ and OS_ macros are defined
+// too, since they are sometimes convenient.
+//
+// Note: "GP" is short for "Gecko Profiler".
+
+#undef GP_PLAT_x86_android
+#undef GP_PLAT_amd64_android
+#undef GP_PLAT_arm_android
+#undef GP_PLAT_arm64_android
+#undef GP_PLAT_x86_linux
+#undef GP_PLAT_amd64_linux
+#undef GP_PLAT_arm_linux
+#undef GP_PLAT_mips64_linux
+#undef GP_PLAT_amd64_darwin
+#undef GP_PLAT_arm64_darwin
+#undef GP_PLAT_x86_windows
+#undef GP_PLAT_amd64_windows
+#undef GP_PLAT_arm64_windows
+
+#undef GP_ARCH_x86
+#undef GP_ARCH_amd64
+#undef GP_ARCH_arm
+#undef GP_ARCH_arm64
+#undef GP_ARCH_mips64
+
+#undef GP_OS_android
+#undef GP_OS_linux
+#undef GP_OS_darwin
+#undef GP_OS_windows
+
+// We test __ANDROID__ before __linux__ because __linux__ is defined on both
+// Android and Linux, whereas GP_OS_android is not defined on vanilla Linux.
+
+#if defined(__ANDROID__) && defined(__i386__)
+# define GP_PLAT_x86_android 1
+# define GP_ARCH_x86 1
+# define GP_OS_android 1
+
+#elif defined(__ANDROID__) && defined(__x86_64__)
+# define GP_PLAT_amd64_android 1
+# define GP_ARCH_amd64 1
+# define GP_OS_android 1
+
+#elif defined(__ANDROID__) && defined(__arm__)
+# define GP_PLAT_arm_android 1
+# define GP_ARCH_arm 1
+# define GP_OS_android 1
+
+#elif defined(__ANDROID__) && defined(__aarch64__)
+# define GP_PLAT_arm64_android 1
+# define GP_ARCH_arm64 1
+# define GP_OS_android 1
+
+#elif defined(__linux__) && defined(__i386__)
+# define GP_PLAT_x86_linux 1
+# define GP_ARCH_x86 1
+# define GP_OS_linux 1
+
+#elif defined(__linux__) && defined(__x86_64__)
+# define GP_PLAT_amd64_linux 1
+# define GP_ARCH_amd64 1
+# define GP_OS_linux 1
+
+#elif defined(__linux__) && defined(__arm__)
+# define GP_PLAT_arm_linux 1
+# define GP_ARCH_arm 1
+# define GP_OS_linux 1
+
+#elif defined(__linux__) && defined(__aarch64__)
+# define GP_PLAT_arm64_linux 1
+# define GP_ARCH_arm64 1
+# define GP_OS_linux 1
+
+#elif defined(__linux__) && defined(__mips64)
+# define GP_PLAT_mips64_linux 1
+# define GP_ARCH_mips64 1
+# define GP_OS_linux 1
+
+#elif defined(__APPLE__) && defined(__aarch64__)
+# define GP_PLAT_arm64_darwin 1
+# define GP_ARCH_arm64 1
+# define GP_OS_darwin 1
+
+#elif defined(__APPLE__) && defined(__x86_64__)
+# define GP_PLAT_amd64_darwin 1
+# define GP_ARCH_amd64 1
+# define GP_OS_darwin 1
+
+#elif defined(__FreeBSD__) && defined(__x86_64__)
+# define GP_PLAT_amd64_freebsd 1
+# define GP_ARCH_amd64 1
+# define GP_OS_freebsd 1
+
+#elif defined(__FreeBSD__) && defined(__aarch64__)
+# define GP_PLAT_arm64_freebsd 1
+# define GP_ARCH_arm64 1
+# define GP_OS_freebsd 1
+
+#elif (defined(_MSC_VER) || defined(__MINGW32__)) && \
+ (defined(_M_IX86) || defined(__i386__))
+# define GP_PLAT_x86_windows 1
+# define GP_ARCH_x86 1
+# define GP_OS_windows 1
+
+#elif (defined(_MSC_VER) || defined(__MINGW32__)) && \
+ (defined(_M_X64) || defined(__x86_64__))
+# define GP_PLAT_amd64_windows 1
+# define GP_ARCH_amd64 1
+# define GP_OS_windows 1
+
+#elif defined(_MSC_VER) && defined(_M_ARM64)
+# define GP_PLAT_arm64_windows 1
+# define GP_ARCH_arm64 1
+# define GP_OS_windows 1
+
+#else
+# error "Unsupported platform"
+#endif
+
+#endif /* ndef PLATFORM_MACROS_H */
diff --git a/mozglue/baseprofiler/core/ProfileBuffer.cpp b/mozglue/baseprofiler/core/ProfileBuffer.cpp
new file mode 100644
index 0000000000..dd5504274b
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfileBuffer.cpp
@@ -0,0 +1,217 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "ProfileBuffer.h"
+
+#include "mozilla/MathAlgorithms.h"
+
+#include "BaseProfiler.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+ProfileBuffer::ProfileBuffer(ProfileChunkedBuffer& aBuffer)
+ : mEntries(aBuffer) {
+ // Assume the given buffer is in-session.
+ MOZ_ASSERT(mEntries.IsInSession());
+}
+
+/* static */
+ProfileBufferBlockIndex ProfileBuffer::AddEntry(
+ ProfileChunkedBuffer& aProfileChunkedBuffer,
+ const ProfileBufferEntry& aEntry) {
+ switch (aEntry.GetKind()) {
+#define SWITCH_KIND(KIND, TYPE, SIZE) \
+ case ProfileBufferEntry::Kind::KIND: { \
+ return aProfileChunkedBuffer.PutFrom(&aEntry, 1 + (SIZE)); \
+ break; \
+ }
+
+ FOR_EACH_PROFILE_BUFFER_ENTRY_KIND(SWITCH_KIND)
+
+#undef SWITCH_KIND
+ default:
+ MOZ_ASSERT(false, "Unhandled baseprofiler::ProfilerBuffer entry KIND");
+ return ProfileBufferBlockIndex{};
+ }
+}
+
+// Called from signal, call only reentrant functions
+uint64_t ProfileBuffer::AddEntry(const ProfileBufferEntry& aEntry) {
+ return AddEntry(mEntries, aEntry).ConvertToProfileBufferIndex();
+}
+
+/* static */
+ProfileBufferBlockIndex ProfileBuffer::AddThreadIdEntry(
+ ProfileChunkedBuffer& aProfileChunkedBuffer,
+ BaseProfilerThreadId aThreadId) {
+ return AddEntry(aProfileChunkedBuffer,
+ ProfileBufferEntry::ThreadId(aThreadId));
+}
+
+uint64_t ProfileBuffer::AddThreadIdEntry(BaseProfilerThreadId aThreadId) {
+ return AddThreadIdEntry(mEntries, aThreadId).ConvertToProfileBufferIndex();
+}
+
+void ProfileBuffer::CollectCodeLocation(
+ const char* aLabel, const char* aStr, uint32_t aFrameFlags,
+ uint64_t aInnerWindowID, const Maybe<uint32_t>& aLineNumber,
+ const Maybe<uint32_t>& aColumnNumber,
+ const Maybe<ProfilingCategoryPair>& aCategoryPair) {
+ AddEntry(ProfileBufferEntry::Label(aLabel));
+ AddEntry(ProfileBufferEntry::FrameFlags(uint64_t(aFrameFlags)));
+
+ if (aStr) {
+ // Store the string using one or more DynamicStringFragment entries.
+ size_t strLen = strlen(aStr) + 1; // +1 for the null terminator
+ // If larger than the prescribed limit, we will cut the string and end it
+ // with an ellipsis.
+ const bool tooBig = strLen > kMaxFrameKeyLength;
+ if (tooBig) {
+ strLen = kMaxFrameKeyLength;
+ }
+ char chars[ProfileBufferEntry::kNumChars];
+ for (size_t j = 0;; j += ProfileBufferEntry::kNumChars) {
+ // Store up to kNumChars characters in the entry.
+ size_t len = ProfileBufferEntry::kNumChars;
+ const bool last = j + len >= strLen;
+ if (last) {
+ // Only the last entry may be smaller than kNumChars.
+ len = strLen - j;
+ if (tooBig) {
+ // That last entry is part of a too-big string, replace the end
+ // characters with an ellipsis "...".
+ len = std::max(len, size_t(4));
+ chars[len - 4] = '.';
+ chars[len - 3] = '.';
+ chars[len - 2] = '.';
+ chars[len - 1] = '\0';
+ // Make sure the memcpy will not overwrite our ellipsis!
+ len -= 4;
+ }
+ }
+ memcpy(chars, &aStr[j], len);
+ AddEntry(ProfileBufferEntry::DynamicStringFragment(chars));
+ if (last) {
+ break;
+ }
+ }
+ }
+
+ if (aInnerWindowID) {
+ AddEntry(ProfileBufferEntry::InnerWindowID(aInnerWindowID));
+ }
+
+ if (aLineNumber) {
+ AddEntry(ProfileBufferEntry::LineNumber(*aLineNumber));
+ }
+
+ if (aColumnNumber) {
+ AddEntry(ProfileBufferEntry::ColumnNumber(*aColumnNumber));
+ }
+
+ if (aCategoryPair.isSome()) {
+ AddEntry(ProfileBufferEntry::CategoryPair(int(*aCategoryPair)));
+ }
+}
+
+size_t ProfileBuffer::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+ // Measurement of the following members may be added later if DMD finds it
+ // is worthwhile:
+ // - memory pointed to by the elements within mEntries
+ return mEntries.SizeOfExcludingThis(aMallocSizeOf);
+}
+
+size_t ProfileBuffer::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+
+void ProfileBuffer::CollectOverheadStats(TimeDuration aSamplingTime,
+ TimeDuration aLocking,
+ TimeDuration aCleaning,
+ TimeDuration aCounters,
+ TimeDuration aThreads) {
+ double timeUs = aSamplingTime.ToMilliseconds() * 1000.0;
+ if (mFirstSamplingTimeUs == 0.0) {
+ mFirstSamplingTimeUs = timeUs;
+ } else {
+ // Note that we'll have 1 fewer interval than other numbers (because
+ // we need both ends of an interval to know its duration). The final
+ // difference should be insignificant over the expected many thousands
+ // of iterations.
+ mIntervalsUs.Count(timeUs - mLastSamplingTimeUs);
+ }
+ mLastSamplingTimeUs = timeUs;
+ // Time to take the lock before sampling.
+ double lockingUs = aLocking.ToMilliseconds() * 1000.0;
+ // Time to discard expired data.
+ double cleaningUs = aCleaning.ToMilliseconds() * 1000.0;
+ // Time to gather all counters.
+ double countersUs = aCounters.ToMilliseconds() * 1000.0;
+ // Time to sample all threads.
+ double threadsUs = aThreads.ToMilliseconds() * 1000.0;
+
+ // Add to our gathered stats.
+ mOverheadsUs.Count(lockingUs + cleaningUs + countersUs + threadsUs);
+ mLockingsUs.Count(lockingUs);
+ mCleaningsUs.Count(cleaningUs);
+ mCountersUs.Count(countersUs);
+ mThreadsUs.Count(threadsUs);
+
+ // Record details in buffer, if requested.
+ static const bool sRecordSamplingOverhead = []() {
+ const char* recordOverheads = getenv("MOZ_PROFILER_RECORD_OVERHEADS");
+ return recordOverheads && recordOverheads[0] != '\0';
+ }();
+ if (sRecordSamplingOverhead) {
+ AddEntry(ProfileBufferEntry::ProfilerOverheadTime(timeUs));
+ AddEntry(ProfileBufferEntry::ProfilerOverheadDuration(lockingUs));
+ AddEntry(ProfileBufferEntry::ProfilerOverheadDuration(cleaningUs));
+ AddEntry(ProfileBufferEntry::ProfilerOverheadDuration(countersUs));
+ AddEntry(ProfileBufferEntry::ProfilerOverheadDuration(threadsUs));
+ }
+}
+
+ProfilerBufferInfo ProfileBuffer::GetProfilerBufferInfo() const {
+ return {BufferRangeStart(),
+ BufferRangeEnd(),
+ static_cast<uint32_t>(*mEntries.BufferLength() /
+ 8), // 8 bytes per entry.
+ mIntervalsUs,
+ mOverheadsUs,
+ mLockingsUs,
+ mCleaningsUs,
+ mCountersUs,
+ mThreadsUs};
+}
+
+/* ProfileBufferCollector */
+
+void ProfileBufferCollector::CollectNativeLeafAddr(void* aAddr) {
+ mBuf.AddEntry(ProfileBufferEntry::NativeLeafAddr(aAddr));
+}
+
+void ProfileBufferCollector::CollectProfilingStackFrame(
+ const ProfilingStackFrame& aFrame) {
+ // WARNING: this function runs within the profiler's "critical section".
+
+ MOZ_ASSERT(aFrame.isLabelFrame() ||
+ (aFrame.isJsFrame() && !aFrame.isOSRFrame()));
+
+ const char* label = aFrame.label();
+ const char* dynamicString = aFrame.dynamicString();
+ Maybe<uint32_t> line;
+ Maybe<uint32_t> column;
+
+ MOZ_ASSERT(aFrame.isLabelFrame());
+
+ mBuf.CollectCodeLocation(label, dynamicString, aFrame.flags(),
+ aFrame.realmID(), line, column,
+ Some(aFrame.categoryPair()));
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/ProfileBuffer.h b/mozglue/baseprofiler/core/ProfileBuffer.h
new file mode 100644
index 0000000000..f77b429df8
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfileBuffer.h
@@ -0,0 +1,211 @@
+/* -*- 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 MOZ_PROFILE_BUFFER_H
+#define MOZ_PROFILE_BUFFER_H
+
+#include "ProfileBufferEntry.h"
+
+#include "BaseProfiler.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/PowerOfTwo.h"
+#include "mozilla/ProfileBufferChunkManagerSingle.h"
+#include "mozilla/ProfileChunkedBuffer.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+// Class storing most profiling data in a ProfileChunkedBuffer.
+//
+// This class is used as a queue of entries which, after construction, never
+// allocates. This makes it safe to use in the profiler's "critical section".
+class ProfileBuffer final {
+ public:
+ // ProfileBuffer constructor
+ // @param aBuffer The in-session ProfileChunkedBuffer to use as buffer
+ // manager.
+ explicit ProfileBuffer(ProfileChunkedBuffer& aBuffer);
+
+ ProfileChunkedBuffer& UnderlyingChunkedBuffer() const { return mEntries; }
+
+ bool IsThreadSafe() const { return mEntries.IsThreadSafe(); }
+
+ // Add |aEntry| to the buffer, ignoring what kind of entry it is.
+ // Returns the position of the entry.
+ uint64_t AddEntry(const ProfileBufferEntry& aEntry);
+
+ // Add to the buffer a sample start (ThreadId) entry for aThreadId.
+ // Returns the position of the entry.
+ uint64_t AddThreadIdEntry(BaseProfilerThreadId aThreadId);
+
+ void CollectCodeLocation(const char* aLabel, const char* aStr,
+ uint32_t aFrameFlags, uint64_t aInnerWindowID,
+ const Maybe<uint32_t>& aLineNumber,
+ const Maybe<uint32_t>& aColumnNumber,
+ const Maybe<ProfilingCategoryPair>& aCategoryPair);
+
+ // Maximum size of a frameKey string that we'll handle.
+ static const size_t kMaxFrameKeyLength = 512;
+
+ // Stream JSON for samples in the buffer to aWriter, using the supplied
+ // UniqueStacks object.
+ // Only streams samples for the given thread ID and which were taken at or
+ // after aSinceTime. If ID is 0, ignore the stored thread ID; this should only
+ // be used when the buffer contains only one sample.
+ // Return the thread ID of the streamed sample(s), or 0.
+ BaseProfilerThreadId StreamSamplesToJSON(SpliceableJSONWriter& aWriter,
+ BaseProfilerThreadId aThreadId,
+ double aSinceTime,
+ UniqueStacks& aUniqueStacks) const;
+
+ void StreamMarkersToJSON(SpliceableJSONWriter& aWriter,
+ BaseProfilerThreadId aThreadId,
+ const TimeStamp& aProcessStartTime,
+ double aSinceTime,
+ UniqueStacks& aUniqueStacks) const;
+ void StreamPausedRangesToJSON(SpliceableJSONWriter& aWriter,
+ double aSinceTime) const;
+ void StreamProfilerOverheadToJSON(SpliceableJSONWriter& aWriter,
+ const TimeStamp& aProcessStartTime,
+ double aSinceTime) const;
+ void StreamCountersToJSON(SpliceableJSONWriter& aWriter,
+ const TimeStamp& aProcessStartTime,
+ double aSinceTime) const;
+
+ // Find (via |aLastSample|) the most recent sample for the thread denoted by
+ // |aThreadId| and clone it, patching in the current time as appropriate.
+ // Mutate |aLastSample| to point to the newly inserted sample.
+ // Returns whether duplication was successful.
+ bool DuplicateLastSample(BaseProfilerThreadId aThreadId,
+ const TimeStamp& aProcessStartTime,
+ Maybe<uint64_t>& aLastSample);
+
+ void DiscardSamplesBeforeTime(double aTime);
+
+ size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const;
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
+
+ void CollectOverheadStats(TimeDuration aSamplingTime, TimeDuration aLocking,
+ TimeDuration aCleaning, TimeDuration aCounters,
+ TimeDuration aThreads);
+
+ ProfilerBufferInfo GetProfilerBufferInfo() const;
+
+ private:
+ // Add |aEntry| to the provider ProfileChunkedBuffer.
+ // `static` because it may be used to add an entry to a `ProfileChunkedBuffer`
+ // that is not attached to a `ProfileBuffer`.
+ static ProfileBufferBlockIndex AddEntry(
+ ProfileChunkedBuffer& aProfileChunkedBuffer,
+ const ProfileBufferEntry& aEntry);
+
+ // Add a sample start (ThreadId) entry for aThreadId to the provided
+ // ProfileChunkedBuffer. Returns the position of the entry.
+ // `static` because it may be used to add an entry to a `ProfileChunkedBuffer`
+ // that is not attached to a `ProfileBuffer`.
+ static ProfileBufferBlockIndex AddThreadIdEntry(
+ ProfileChunkedBuffer& aProfileChunkedBuffer,
+ BaseProfilerThreadId aThreadId);
+
+ // The storage in which this ProfileBuffer stores its entries.
+ ProfileChunkedBuffer& mEntries;
+
+ public:
+ // `BufferRangeStart()` and `BufferRangeEnd()` return `uint64_t` values
+ // corresponding to the first entry and past the last entry stored in
+ // `mEntries`.
+ //
+ // The returned values are not guaranteed to be stable, because other threads
+ // may also be accessing the buffer concurrently. But they will always
+ // increase, and can therefore give an indication of how far these values have
+ // *at least* reached. In particular:
+ // - Entries whose index is strictly less that `BufferRangeStart()` have been
+ // discarded by now, so any related data may also be safely discarded.
+ // - It is safe to try and read entries at any index strictly less than
+ // `BufferRangeEnd()` -- but note that these reads may fail by the time you
+ // request them, as old entries get overwritten by new ones.
+ uint64_t BufferRangeStart() const { return mEntries.GetState().mRangeStart; }
+ uint64_t BufferRangeEnd() const { return mEntries.GetState().mRangeEnd; }
+
+ private:
+ // Single pre-allocated chunk (to avoid spurious mallocs), used when:
+ // - Duplicating sleeping stacks (hence scExpectedMaximumStackSize).
+ // - Adding JIT info.
+ // - Streaming stacks to JSON.
+ // Mutable because it's accessed from non-multithreaded const methods.
+ mutable Maybe<ProfileBufferChunkManagerSingle> mMaybeWorkerChunkManager;
+ ProfileBufferChunkManagerSingle& WorkerChunkManager() const {
+ if (mMaybeWorkerChunkManager.isNothing()) {
+ // Only actually allocate it on first use. (Some ProfileBuffers are
+ // temporary and don't actually need this.)
+ mMaybeWorkerChunkManager.emplace(
+ ProfileBufferChunk::SizeofChunkMetadata() +
+ ProfileBufferChunkManager::scExpectedMaximumStackSize);
+ }
+ return *mMaybeWorkerChunkManager;
+ }
+
+ // Time from launch (us) when first sampling was recorded.
+ double mFirstSamplingTimeUs = 0.0;
+ // Time from launch (us) when last sampling was recorded.
+ double mLastSamplingTimeUs = 0.0;
+ // Sampling stats: Interval (us) between successive samplings.
+ ProfilerStats mIntervalsUs;
+ // Sampling stats: Total duration (us) of each sampling. (Split detail below.)
+ ProfilerStats mOverheadsUs;
+ // Sampling stats: Time (us) to acquire the lock before sampling.
+ ProfilerStats mLockingsUs;
+ // Sampling stats: Time (us) to discard expired data.
+ ProfilerStats mCleaningsUs;
+ // Sampling stats: Time (us) to collect counter data.
+ ProfilerStats mCountersUs;
+ // Sampling stats: Time (us) to sample thread stacks.
+ ProfilerStats mThreadsUs;
+};
+
+/**
+ * Helper type used to implement ProfilerStackCollector. This type is used as
+ * the collector for MergeStacks by ProfileBuffer. It holds a reference to the
+ * buffer, as well as additional feature flags which are needed to control the
+ * data collection strategy
+ */
+class ProfileBufferCollector final : public ProfilerStackCollector {
+ public:
+ ProfileBufferCollector(ProfileBuffer& aBuf, uint64_t aSamplePos,
+ uint64_t aBufferRangeStart)
+ : mBuf(aBuf),
+ mSamplePositionInBuffer(aSamplePos),
+ mBufferRangeStart(aBufferRangeStart) {
+ MOZ_ASSERT(
+ mSamplePositionInBuffer >= mBufferRangeStart,
+ "The sample position should always be after the buffer range start");
+ }
+
+ // Position at which the sample starts in the profiler buffer (which may be
+ // different from the buffer in which the sample data is collected here).
+ Maybe<uint64_t> SamplePositionInBuffer() override {
+ return Some(mSamplePositionInBuffer);
+ }
+
+ // Profiler buffer's range start (which may be different from the buffer in
+ // which the sample data is collected here).
+ Maybe<uint64_t> BufferRangeStart() override {
+ return Some(mBufferRangeStart);
+ }
+
+ virtual void CollectNativeLeafAddr(void* aAddr) override;
+ virtual void CollectProfilingStackFrame(
+ const ProfilingStackFrame& aFrame) override;
+
+ private:
+ ProfileBuffer& mBuf;
+ uint64_t mSamplePositionInBuffer;
+ uint64_t mBufferRangeStart;
+};
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif
diff --git a/mozglue/baseprofiler/core/ProfileBufferEntry.cpp b/mozglue/baseprofiler/core/ProfileBufferEntry.cpp
new file mode 100644
index 0000000000..faa3826171
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfileBufferEntry.cpp
@@ -0,0 +1,1367 @@
+/* -*- 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/. */
+
+#include "ProfileBufferEntry.h"
+
+#include <ostream>
+#include <type_traits>
+
+#include "mozilla/Logging.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/StackWalk.h"
+
+#include "BaseProfiler.h"
+#include "mozilla/BaseProfilerMarkers.h"
+#include "platform.h"
+#include "ProfileBuffer.h"
+#include "ProfilerBacktrace.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN ProfileBufferEntry
+
+ProfileBufferEntry::ProfileBufferEntry()
+ : mKind(Kind::INVALID), mStorage{0, 0, 0, 0, 0, 0, 0, 0} {}
+
+// aString must be a static string.
+ProfileBufferEntry::ProfileBufferEntry(Kind aKind, const char* aString)
+ : mKind(aKind) {
+ memcpy(mStorage, &aString, sizeof(aString));
+}
+
+ProfileBufferEntry::ProfileBufferEntry(Kind aKind, char aChars[kNumChars])
+ : mKind(aKind) {
+ memcpy(mStorage, aChars, kNumChars);
+}
+
+ProfileBufferEntry::ProfileBufferEntry(Kind aKind, void* aPtr) : mKind(aKind) {
+ memcpy(mStorage, &aPtr, sizeof(aPtr));
+}
+
+ProfileBufferEntry::ProfileBufferEntry(Kind aKind, double aDouble)
+ : mKind(aKind) {
+ memcpy(mStorage, &aDouble, sizeof(aDouble));
+}
+
+ProfileBufferEntry::ProfileBufferEntry(Kind aKind, int aInt) : mKind(aKind) {
+ memcpy(mStorage, &aInt, sizeof(aInt));
+}
+
+ProfileBufferEntry::ProfileBufferEntry(Kind aKind, int64_t aInt64)
+ : mKind(aKind) {
+ memcpy(mStorage, &aInt64, sizeof(aInt64));
+}
+
+ProfileBufferEntry::ProfileBufferEntry(Kind aKind, uint64_t aUint64)
+ : mKind(aKind) {
+ memcpy(mStorage, &aUint64, sizeof(aUint64));
+}
+
+ProfileBufferEntry::ProfileBufferEntry(Kind aKind,
+ BaseProfilerThreadId aThreadId)
+ : mKind(aKind) {
+ static_assert(std::is_trivially_copyable_v<BaseProfilerThreadId>);
+ static_assert(sizeof(aThreadId) <= sizeof(mStorage));
+ memcpy(mStorage, &aThreadId, sizeof(aThreadId));
+}
+
+const char* ProfileBufferEntry::GetString() const {
+ const char* result;
+ memcpy(&result, mStorage, sizeof(result));
+ return result;
+}
+
+void* ProfileBufferEntry::GetPtr() const {
+ void* result;
+ memcpy(&result, mStorage, sizeof(result));
+ return result;
+}
+
+double ProfileBufferEntry::GetDouble() const {
+ double result;
+ memcpy(&result, mStorage, sizeof(result));
+ return result;
+}
+
+int ProfileBufferEntry::GetInt() const {
+ int result;
+ memcpy(&result, mStorage, sizeof(result));
+ return result;
+}
+
+int64_t ProfileBufferEntry::GetInt64() const {
+ int64_t result;
+ memcpy(&result, mStorage, sizeof(result));
+ return result;
+}
+
+uint64_t ProfileBufferEntry::GetUint64() const {
+ uint64_t result;
+ memcpy(&result, mStorage, sizeof(result));
+ return result;
+}
+
+BaseProfilerThreadId ProfileBufferEntry::GetThreadId() const {
+ BaseProfilerThreadId result;
+ static_assert(std::is_trivially_copyable_v<BaseProfilerThreadId>);
+ memcpy(&result, mStorage, sizeof(result));
+ return result;
+}
+
+void ProfileBufferEntry::CopyCharsInto(char (&aOutArray)[kNumChars]) const {
+ memcpy(aOutArray, mStorage, kNumChars);
+}
+
+// END ProfileBufferEntry
+////////////////////////////////////////////////////////////////////////
+
+// As mentioned in ProfileBufferEntry.h, the JSON format contains many
+// arrays whose elements are laid out according to various schemas to help
+// de-duplication. This RAII class helps write these arrays by keeping track of
+// the last non-null element written and adding the appropriate number of null
+// elements when writing new non-null elements. It also automatically opens and
+// closes an array element on the given JSON writer.
+//
+// You grant the AutoArraySchemaWriter exclusive access to the JSONWriter and
+// the UniqueJSONStrings objects for the lifetime of AutoArraySchemaWriter. Do
+// not access them independently while the AutoArraySchemaWriter is alive.
+// If you need to add complex objects, call FreeFormElement(), which will give
+// you temporary access to the writer.
+//
+// Example usage:
+//
+// // Define the schema of elements in this type of array: [FOO, BAR, BAZ]
+// enum Schema : uint32_t {
+// FOO = 0,
+// BAR = 1,
+// BAZ = 2
+// };
+//
+// AutoArraySchemaWriter writer(someJsonWriter, someUniqueStrings);
+// if (shouldWriteFoo) {
+// writer.IntElement(FOO, getFoo());
+// }
+// ... etc ...
+//
+// The elements need to be added in-order.
+class MOZ_RAII AutoArraySchemaWriter {
+ public:
+ explicit AutoArraySchemaWriter(SpliceableJSONWriter& aWriter)
+ : mJSONWriter(aWriter), mNextFreeIndex(0) {
+ mJSONWriter.StartArrayElement();
+ }
+
+ ~AutoArraySchemaWriter() { mJSONWriter.EndArray(); }
+
+ template <typename T>
+ void IntElement(uint32_t aIndex, T aValue) {
+ static_assert(!std::is_same_v<T, uint64_t>,
+ "Narrowing uint64 -> int64 conversion not allowed");
+ FillUpTo(aIndex);
+ mJSONWriter.IntElement(static_cast<int64_t>(aValue));
+ }
+
+ void DoubleElement(uint32_t aIndex, double aValue) {
+ FillUpTo(aIndex);
+ mJSONWriter.DoubleElement(aValue);
+ }
+
+ void TimeMsElement(uint32_t aIndex, double aTime_ms) {
+ FillUpTo(aIndex);
+ mJSONWriter.TimeDoubleMsElement(aTime_ms);
+ }
+
+ void BoolElement(uint32_t aIndex, bool aValue) {
+ FillUpTo(aIndex);
+ mJSONWriter.BoolElement(aValue);
+ }
+
+ protected:
+ SpliceableJSONWriter& Writer() { return mJSONWriter; }
+
+ void FillUpTo(uint32_t aIndex) {
+ MOZ_ASSERT(aIndex >= mNextFreeIndex);
+ mJSONWriter.NullElements(aIndex - mNextFreeIndex);
+ mNextFreeIndex = aIndex + 1;
+ }
+
+ private:
+ SpliceableJSONWriter& mJSONWriter;
+ uint32_t mNextFreeIndex;
+};
+
+// Same as AutoArraySchemaWriter, but this can also write strings (output as
+// indexes into the table of unique strings).
+class MOZ_RAII AutoArraySchemaWithStringsWriter : public AutoArraySchemaWriter {
+ public:
+ AutoArraySchemaWithStringsWriter(SpliceableJSONWriter& aWriter,
+ UniqueJSONStrings& aStrings)
+ : AutoArraySchemaWriter(aWriter), mStrings(aStrings) {}
+
+ void StringElement(uint32_t aIndex, const Span<const char>& aValue) {
+ FillUpTo(aIndex);
+ mStrings.WriteElement(Writer(), aValue);
+ }
+
+ private:
+ UniqueJSONStrings& mStrings;
+};
+
+UniqueStacks::StackKey UniqueStacks::BeginStack(const FrameKey& aFrame) {
+ return StackKey(GetOrAddFrameIndex(aFrame));
+}
+
+UniqueStacks::StackKey UniqueStacks::AppendFrame(const StackKey& aStack,
+ const FrameKey& aFrame) {
+ return StackKey(aStack, GetOrAddStackIndex(aStack),
+ GetOrAddFrameIndex(aFrame));
+}
+
+bool UniqueStacks::FrameKey::NormalFrameData::operator==(
+ const NormalFrameData& aOther) const {
+ return mLocation == aOther.mLocation &&
+ mRelevantForJS == aOther.mRelevantForJS &&
+ mInnerWindowID == aOther.mInnerWindowID && mLine == aOther.mLine &&
+ mColumn == aOther.mColumn && mCategoryPair == aOther.mCategoryPair;
+}
+
+UniqueStacks::UniqueStacks()
+ : mUniqueStrings(MakeUnique<UniqueJSONStrings>(
+ FailureLatchInfallibleSource::Singleton())),
+ mFrameTableWriter(FailureLatchInfallibleSource::Singleton()),
+ mStackTableWriter(FailureLatchInfallibleSource::Singleton()) {
+ mFrameTableWriter.StartBareList();
+ mStackTableWriter.StartBareList();
+}
+
+uint32_t UniqueStacks::GetOrAddStackIndex(const StackKey& aStack) {
+ uint32_t count = mStackToIndexMap.count();
+ auto entry = mStackToIndexMap.lookupForAdd(aStack);
+ if (entry) {
+ MOZ_ASSERT(entry->value() < count);
+ return entry->value();
+ }
+
+ MOZ_RELEASE_ASSERT(mStackToIndexMap.add(entry, aStack, count));
+ StreamStack(aStack);
+ return count;
+}
+
+uint32_t UniqueStacks::GetOrAddFrameIndex(const FrameKey& aFrame) {
+ uint32_t count = mFrameToIndexMap.count();
+ auto entry = mFrameToIndexMap.lookupForAdd(aFrame);
+ if (entry) {
+ MOZ_ASSERT(entry->value() < count);
+ return entry->value();
+ }
+
+ MOZ_RELEASE_ASSERT(mFrameToIndexMap.add(entry, aFrame, count));
+ StreamNonJITFrame(aFrame);
+ return count;
+}
+
+void UniqueStacks::SpliceFrameTableElements(SpliceableJSONWriter& aWriter) {
+ mFrameTableWriter.EndBareList();
+ aWriter.TakeAndSplice(mFrameTableWriter.TakeChunkedWriteFunc());
+}
+
+void UniqueStacks::SpliceStackTableElements(SpliceableJSONWriter& aWriter) {
+ mStackTableWriter.EndBareList();
+ aWriter.TakeAndSplice(mStackTableWriter.TakeChunkedWriteFunc());
+}
+
+void UniqueStacks::StreamStack(const StackKey& aStack) {
+ enum Schema : uint32_t { PREFIX = 0, FRAME = 1 };
+
+ AutoArraySchemaWriter writer(mStackTableWriter);
+ if (aStack.mPrefixStackIndex.isSome()) {
+ writer.IntElement(PREFIX, *aStack.mPrefixStackIndex);
+ }
+ writer.IntElement(FRAME, aStack.mFrameIndex);
+}
+
+void UniqueStacks::StreamNonJITFrame(const FrameKey& aFrame) {
+ using NormalFrameData = FrameKey::NormalFrameData;
+
+ enum Schema : uint32_t {
+ LOCATION = 0,
+ RELEVANT_FOR_JS = 1,
+ INNER_WINDOW_ID = 2,
+ IMPLEMENTATION = 3,
+ LINE = 4,
+ COLUMN = 5,
+ CATEGORY = 6,
+ SUBCATEGORY = 7
+ };
+
+ AutoArraySchemaWithStringsWriter writer(mFrameTableWriter, *mUniqueStrings);
+
+ const NormalFrameData& data = aFrame.mData.as<NormalFrameData>();
+ writer.StringElement(LOCATION, data.mLocation);
+ writer.BoolElement(RELEVANT_FOR_JS, data.mRelevantForJS);
+
+ // It's okay to convert uint64_t to double here because DOM always creates IDs
+ // that are convertible to double.
+ writer.DoubleElement(INNER_WINDOW_ID, data.mInnerWindowID);
+
+ if (data.mLine.isSome()) {
+ writer.IntElement(LINE, *data.mLine);
+ }
+ if (data.mColumn.isSome()) {
+ writer.IntElement(COLUMN, *data.mColumn);
+ }
+ if (data.mCategoryPair.isSome()) {
+ const ProfilingCategoryPairInfo& info =
+ GetProfilingCategoryPairInfo(*data.mCategoryPair);
+ writer.IntElement(CATEGORY, uint32_t(info.mCategory));
+ writer.IntElement(SUBCATEGORY, info.mSubcategoryIndex);
+ }
+}
+
+struct ProfileSample {
+ uint32_t mStack;
+ double mTime;
+ Maybe<double> mResponsiveness;
+};
+
+static void WriteSample(SpliceableJSONWriter& aWriter,
+ const ProfileSample& aSample) {
+ enum Schema : uint32_t {
+ STACK = 0,
+ TIME = 1,
+ EVENT_DELAY = 2,
+ };
+
+ AutoArraySchemaWriter writer(aWriter);
+
+ writer.IntElement(STACK, aSample.mStack);
+
+ writer.TimeMsElement(TIME, aSample.mTime);
+
+ if (aSample.mResponsiveness.isSome()) {
+ writer.DoubleElement(EVENT_DELAY, *aSample.mResponsiveness);
+ }
+}
+
+class EntryGetter {
+ public:
+ explicit EntryGetter(ProfileChunkedBuffer::Reader& aReader,
+ uint64_t aInitialReadPos = 0)
+ : mBlockIt(
+ aReader.At(ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ aInitialReadPos))),
+ mBlockItEnd(aReader.end()) {
+ if (!ReadLegacyOrEnd()) {
+ // Find and read the next non-legacy entry.
+ Next();
+ }
+ }
+
+ bool Has() const { return mBlockIt != mBlockItEnd; }
+
+ const ProfileBufferEntry& Get() const {
+ MOZ_ASSERT(Has(), "Caller should have checked `Has()` before `Get()`");
+ return mEntry;
+ }
+
+ void Next() {
+ MOZ_ASSERT(Has(), "Caller should have checked `Has()` before `Next()`");
+ for (;;) {
+ ++mBlockIt;
+ if (ReadLegacyOrEnd()) {
+ // Either we're at the end, or we could read a legacy entry -> Done.
+ break;
+ }
+ // Otherwise loop around until we hit the end or a legacy entry.
+ }
+ }
+
+ ProfileBufferBlockIndex CurBlockIndex() const {
+ return mBlockIt.CurrentBlockIndex();
+ }
+
+ uint64_t CurPos() const {
+ return CurBlockIndex().ConvertToProfileBufferIndex();
+ }
+
+ private:
+ // Try to read the entry at the current `mBlockIt` position.
+ // * If we're at the end of the buffer, just return `true`.
+ // * If there is a "legacy" entry (containing a real `ProfileBufferEntry`),
+ // read it into `mEntry`, and return `true` as well.
+ // * Otherwise the entry contains a "modern" type that cannot be read into
+ // `mEntry`, return `false` (so `EntryGetter` can skip to another entry).
+ bool ReadLegacyOrEnd() {
+ if (!Has()) {
+ return true;
+ }
+ // Read the entry "kind", which is always at the start of all entries.
+ ProfileBufferEntryReader aER = *mBlockIt;
+ auto type = static_cast<ProfileBufferEntry::Kind>(
+ aER.ReadObject<ProfileBufferEntry::KindUnderlyingType>());
+ MOZ_ASSERT(static_cast<ProfileBufferEntry::KindUnderlyingType>(type) <
+ static_cast<ProfileBufferEntry::KindUnderlyingType>(
+ ProfileBufferEntry::Kind::MODERN_LIMIT));
+ if (type >= ProfileBufferEntry::Kind::LEGACY_LIMIT) {
+ aER.SetRemainingBytes(0);
+ return false;
+ }
+ // Here, we have a legacy item, we need to read it from the start.
+ // Because the above `ReadObject` moved the reader, we ned to reset it to
+ // the start of the entry before reading the whole entry.
+ aER = *mBlockIt;
+ aER.ReadBytes(&mEntry, aER.RemainingBytes());
+ return true;
+ }
+
+ ProfileBufferEntry mEntry;
+ ProfileChunkedBuffer::BlockIterator mBlockIt;
+ const ProfileChunkedBuffer::BlockIterator mBlockItEnd;
+};
+
+// The following grammar shows legal sequences of profile buffer entries.
+// The sequences beginning with a ThreadId entry are known as "samples".
+//
+// (
+// ( /* Samples */
+// ThreadId
+// Time
+// ( NativeLeafAddr
+// | Label FrameFlags? DynamicStringFragment* LineNumber? CategoryPair?
+// | JitReturnAddr
+// )+
+// Responsiveness?
+// )
+// | MarkerData
+// | ( /* Counters */
+// CounterId
+// Time
+// (
+// CounterKey
+// Count
+// Number?
+// )*
+// )
+// | CollectionStart
+// | CollectionEnd
+// | Pause
+// | Resume
+// | ( ProfilerOverheadTime /* Sampling start timestamp */
+// ProfilerOverheadDuration /* Lock acquisition */
+// ProfilerOverheadDuration /* Expired data cleaning */
+// ProfilerOverheadDuration /* Counters */
+// ProfilerOverheadDuration /* Threads */
+// )
+// )*
+//
+// The most complicated part is the stack entry sequence that begins with
+// Label. Here are some examples.
+//
+// - ProfilingStack frames without a dynamic string:
+//
+// Label("js::RunScript")
+// CategoryPair(ProfilingCategoryPair::JS)
+//
+// Label("XREMain::XRE_main")
+// LineNumber(4660)
+// CategoryPair(ProfilingCategoryPair::OTHER)
+//
+// Label("ElementRestyler::ComputeStyleChangeFor")
+// LineNumber(3003)
+// CategoryPair(ProfilingCategoryPair::CSS)
+//
+// - ProfilingStack frames with a dynamic string:
+//
+// Label("nsObserverService::NotifyObservers")
+// FrameFlags(uint64_t(ProfilingStackFrame::Flags::IS_LABEL_FRAME))
+// DynamicStringFragment("domwindo")
+// DynamicStringFragment("wopened")
+// LineNumber(291)
+// CategoryPair(ProfilingCategoryPair::OTHER)
+//
+// Label("")
+// FrameFlags(uint64_t(ProfilingStackFrame::Flags::IS_JS_FRAME))
+// DynamicStringFragment("closeWin")
+// DynamicStringFragment("dow (chr")
+// DynamicStringFragment("ome://gl")
+// DynamicStringFragment("obal/con")
+// DynamicStringFragment("tent/glo")
+// DynamicStringFragment("balOverl")
+// DynamicStringFragment("ay.js:5)")
+// DynamicStringFragment("") # this string holds the closing '\0'
+// LineNumber(25)
+// CategoryPair(ProfilingCategoryPair::JS)
+//
+// Label("")
+// FrameFlags(uint64_t(ProfilingStackFrame::Flags::IS_JS_FRAME))
+// DynamicStringFragment("bound (s")
+// DynamicStringFragment("elf-host")
+// DynamicStringFragment("ed:914)")
+// LineNumber(945)
+// CategoryPair(ProfilingCategoryPair::JS)
+//
+// - A profiling stack frame with an overly long dynamic string:
+//
+// Label("")
+// FrameFlags(uint64_t(ProfilingStackFrame::Flags::IS_LABEL_FRAME))
+// DynamicStringFragment("(too lon")
+// DynamicStringFragment("g)")
+// LineNumber(100)
+// CategoryPair(ProfilingCategoryPair::NETWORK)
+//
+// - A wasm JIT frame:
+//
+// Label("")
+// FrameFlags(uint64_t(0))
+// DynamicStringFragment("wasm-fun")
+// DynamicStringFragment("ction[87")
+// DynamicStringFragment("36] (blo")
+// DynamicStringFragment("b:http:/")
+// DynamicStringFragment("/webasse")
+// DynamicStringFragment("mbly.org")
+// DynamicStringFragment("/3dc5759")
+// DynamicStringFragment("4-ce58-4")
+// DynamicStringFragment("626-975b")
+// DynamicStringFragment("-08ad116")
+// DynamicStringFragment("30bc1:38")
+// DynamicStringFragment("29856)")
+//
+// - A JS frame in a synchronous sample:
+//
+// Label("")
+// FrameFlags(uint64_t(ProfilingStackFrame::Flags::IS_LABEL_FRAME))
+// DynamicStringFragment("u (https")
+// DynamicStringFragment("://perf-")
+// DynamicStringFragment("html.io/")
+// DynamicStringFragment("ac0da204")
+// DynamicStringFragment("aaa44d75")
+// DynamicStringFragment("a800.bun")
+// DynamicStringFragment("dle.js:2")
+// DynamicStringFragment("5)")
+
+// Because this is a format entirely internal to the Profiler, any parsing
+// error indicates a bug in the ProfileBuffer writing or the parser itself,
+// or possibly flaky hardware.
+#define ERROR_AND_CONTINUE(msg) \
+ { \
+ fprintf(stderr, "ProfileBuffer parse error: %s", msg); \
+ MOZ_ASSERT(false, msg); \
+ continue; \
+ }
+
+BaseProfilerThreadId ProfileBuffer::StreamSamplesToJSON(
+ SpliceableJSONWriter& aWriter, BaseProfilerThreadId aThreadId,
+ double aSinceTime, UniqueStacks& aUniqueStacks) const {
+ UniquePtr<char[]> dynStrBuf = MakeUnique<char[]>(kMaxFrameKeyLength);
+
+ return mEntries.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ MOZ_ASSERT(aReader,
+ "ProfileChunkedBuffer cannot be out-of-session when sampler is "
+ "running");
+
+ BaseProfilerThreadId processedThreadId;
+
+ EntryGetter e(*aReader);
+
+ for (;;) {
+ // This block skips entries until we find the start of the next sample.
+ // This is useful in three situations.
+ //
+ // - The circular buffer overwrites old entries, so when we start parsing
+ // we might be in the middle of a sample, and we must skip forward to
+ // the start of the next sample.
+ //
+ // - We skip samples that don't have an appropriate ThreadId or Time.
+ //
+ // - We skip range Pause, Resume, CollectionStart, Counter and
+ // CollectionEnd entries between samples.
+ while (e.Has()) {
+ if (e.Get().IsThreadId()) {
+ break;
+ }
+ e.Next();
+ }
+
+ if (!e.Has()) {
+ break;
+ }
+
+ // Due to the skip_to_next_sample block above, if we have an entry here it
+ // must be a ThreadId entry.
+ MOZ_ASSERT(e.Get().IsThreadId());
+
+ BaseProfilerThreadId threadId = e.Get().GetThreadId();
+ e.Next();
+
+ // Ignore samples that are for the wrong thread.
+ if (threadId != aThreadId && aThreadId.IsSpecified()) {
+ continue;
+ }
+
+ MOZ_ASSERT(
+ aThreadId.IsSpecified() || !processedThreadId.IsSpecified(),
+ "Unspecified aThreadId should only be used with 1-sample buffer");
+
+ ProfileSample sample;
+
+ if (e.Has() && e.Get().IsTime()) {
+ sample.mTime = e.Get().GetDouble();
+ e.Next();
+
+ // Ignore samples that are too old.
+ if (sample.mTime < aSinceTime) {
+ continue;
+ }
+ } else {
+ ERROR_AND_CONTINUE("expected a Time entry");
+ }
+
+ UniqueStacks::StackKey stack =
+ aUniqueStacks.BeginStack(UniqueStacks::FrameKey("(root)"));
+
+ int numFrames = 0;
+ while (e.Has()) {
+ if (e.Get().IsNativeLeafAddr()) {
+ numFrames++;
+
+ void* pc = e.Get().GetPtr();
+ e.Next();
+
+ static const uint32_t BUF_SIZE = 256;
+ char buf[BUF_SIZE];
+
+ // Bug 753041: We need a double cast here to tell GCC that we don't
+ // want to sign extend 32-bit addresses starting with 0xFXXXXXX.
+ unsigned long long pcULL = (unsigned long long)(uintptr_t)pc;
+ SprintfLiteral(buf, "0x%llx", pcULL);
+
+ // If the "MOZ_PROFILER_SYMBOLICATE" env-var is set, we add a local
+ // symbolication description to the PC address. This is off by
+ // default, and mainly intended for local development.
+ static const bool preSymbolicate = []() {
+ const char* symbolicate = getenv("MOZ_PROFILER_SYMBOLICATE");
+ return symbolicate && symbolicate[0] != '\0';
+ }();
+ if (preSymbolicate) {
+ MozCodeAddressDetails details;
+ if (MozDescribeCodeAddress(pc, &details)) {
+ // Replace \0 terminator with space.
+ const uint32_t pcLen = strlen(buf);
+ buf[pcLen] = ' ';
+ // Add description after space. Note: Using a frame number of 0,
+ // as using `numFrames` wouldn't help here, and would prevent
+ // combining same function calls that happen at different depths.
+ // TODO: Remove unsightly "#00: " if too annoying. :-)
+ MozFormatCodeAddressDetails(
+ buf + pcLen + 1, BUF_SIZE - (pcLen + 1), 0, pc, &details);
+ }
+ }
+
+ stack = aUniqueStacks.AppendFrame(stack, UniqueStacks::FrameKey(buf));
+
+ } else if (e.Get().IsLabel()) {
+ numFrames++;
+
+ const char* label = e.Get().GetString();
+ e.Next();
+
+ using FrameFlags = ProfilingStackFrame::Flags;
+ uint32_t frameFlags = 0;
+ if (e.Has() && e.Get().IsFrameFlags()) {
+ frameFlags = uint32_t(e.Get().GetUint64());
+ e.Next();
+ }
+
+ bool relevantForJS =
+ frameFlags & uint32_t(FrameFlags::RELEVANT_FOR_JS);
+
+ // Copy potential dynamic string fragments into dynStrBuf, so that
+ // dynStrBuf will then contain the entire dynamic string.
+ size_t i = 0;
+ dynStrBuf[0] = '\0';
+ while (e.Has()) {
+ if (e.Get().IsDynamicStringFragment()) {
+ char chars[ProfileBufferEntry::kNumChars];
+ e.Get().CopyCharsInto(chars);
+ for (char c : chars) {
+ if (i < kMaxFrameKeyLength) {
+ dynStrBuf[i] = c;
+ i++;
+ }
+ }
+ e.Next();
+ } else {
+ break;
+ }
+ }
+ dynStrBuf[kMaxFrameKeyLength - 1] = '\0';
+ bool hasDynamicString = (i != 0);
+
+ std::string frameLabel;
+ if (label[0] != '\0' && hasDynamicString) {
+ if (frameFlags & uint32_t(FrameFlags::STRING_TEMPLATE_METHOD)) {
+ frameLabel += label;
+ frameLabel += '.';
+ frameLabel += dynStrBuf.get();
+ } else if (frameFlags &
+ uint32_t(FrameFlags::STRING_TEMPLATE_GETTER)) {
+ frameLabel += "get ";
+ frameLabel += label;
+ frameLabel += '.';
+ frameLabel += dynStrBuf.get();
+ } else if (frameFlags &
+ uint32_t(FrameFlags::STRING_TEMPLATE_SETTER)) {
+ frameLabel += "set ";
+ frameLabel += label;
+ frameLabel += '.';
+ frameLabel += dynStrBuf.get();
+ } else {
+ frameLabel += label;
+ frameLabel += ' ';
+ frameLabel += dynStrBuf.get();
+ }
+ } else if (hasDynamicString) {
+ frameLabel += dynStrBuf.get();
+ } else {
+ frameLabel += label;
+ }
+
+ uint64_t innerWindowID = 0;
+ if (e.Has() && e.Get().IsInnerWindowID()) {
+ innerWindowID = uint64_t(e.Get().GetUint64());
+ e.Next();
+ }
+
+ Maybe<unsigned> line;
+ if (e.Has() && e.Get().IsLineNumber()) {
+ line = Some(unsigned(e.Get().GetInt()));
+ e.Next();
+ }
+
+ Maybe<unsigned> column;
+ if (e.Has() && e.Get().IsColumnNumber()) {
+ column = Some(unsigned(e.Get().GetInt()));
+ e.Next();
+ }
+
+ Maybe<ProfilingCategoryPair> categoryPair;
+ if (e.Has() && e.Get().IsCategoryPair()) {
+ categoryPair =
+ Some(ProfilingCategoryPair(uint32_t(e.Get().GetInt())));
+ e.Next();
+ }
+
+ stack = aUniqueStacks.AppendFrame(
+ stack, UniqueStacks::FrameKey(std::move(frameLabel),
+ relevantForJS, innerWindowID, line,
+ column, categoryPair));
+
+ } else {
+ break;
+ }
+ }
+
+ if (numFrames == 0) {
+ // It is possible to have empty stacks if native stackwalking is
+ // disabled. Skip samples with empty stacks. (See Bug 1497985).
+ // Thus, don't use ERROR_AND_CONTINUE, but just continue.
+ continue;
+ }
+
+ sample.mStack = aUniqueStacks.GetOrAddStackIndex(stack);
+
+ if (e.Has() && e.Get().IsResponsiveness()) {
+ sample.mResponsiveness = Some(e.Get().GetDouble());
+ e.Next();
+ }
+
+ WriteSample(aWriter, sample);
+
+ processedThreadId = threadId;
+ }
+
+ return processedThreadId;
+ });
+}
+
+void ProfileBuffer::StreamMarkersToJSON(SpliceableJSONWriter& aWriter,
+ BaseProfilerThreadId aThreadId,
+ const TimeStamp& aProcessStartTime,
+ double aSinceTime,
+ UniqueStacks& aUniqueStacks) const {
+ mEntries.ReadEach([&](ProfileBufferEntryReader& aER) {
+ auto type = static_cast<ProfileBufferEntry::Kind>(
+ aER.ReadObject<ProfileBufferEntry::KindUnderlyingType>());
+ MOZ_ASSERT(static_cast<ProfileBufferEntry::KindUnderlyingType>(type) <
+ static_cast<ProfileBufferEntry::KindUnderlyingType>(
+ ProfileBufferEntry::Kind::MODERN_LIMIT));
+ if (type == ProfileBufferEntry::Kind::Marker) {
+ ::mozilla::base_profiler_markers_detail::DeserializeAfterKindAndStream(
+ aER,
+ [&](const BaseProfilerThreadId& aMarkerThreadId) {
+ return (aMarkerThreadId == aThreadId) ? &aWriter : nullptr;
+ },
+ [&](ProfileChunkedBuffer& aChunkedBuffer) {
+ ProfilerBacktrace backtrace("", &aChunkedBuffer);
+ backtrace.StreamJSON(aWriter, TimeStamp::ProcessCreation(),
+ aUniqueStacks);
+ },
+ // We don't have Rust markers in the mozglue.
+ [&](mozilla::base_profiler_markers_detail::Streaming::
+ DeserializerTag) {
+ MOZ_ASSERT_UNREACHABLE("No Rust markers in mozglue.");
+ });
+ } else {
+ // The entry was not a marker, we need to skip to the end.
+ aER.SetRemainingBytes(0);
+ }
+ });
+}
+
+void ProfileBuffer::StreamProfilerOverheadToJSON(
+ SpliceableJSONWriter& aWriter, const TimeStamp& aProcessStartTime,
+ double aSinceTime) const {
+ mEntries.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ MOZ_ASSERT(aReader,
+ "ProfileChunkedBuffer cannot be out-of-session when sampler is "
+ "running");
+
+ EntryGetter e(*aReader);
+
+ enum Schema : uint32_t {
+ TIME = 0,
+ LOCKING = 1,
+ MARKER_CLEANING = 2,
+ COUNTERS = 3,
+ THREADS = 4
+ };
+
+ aWriter.StartObjectProperty("profilerOverhead");
+ aWriter.StartObjectProperty("samples");
+ // Stream all sampling overhead data. We skip other entries, because we
+ // process them in StreamSamplesToJSON()/etc.
+ {
+ JSONSchemaWriter schema(aWriter);
+ schema.WriteField("time");
+ schema.WriteField("locking");
+ schema.WriteField("expiredMarkerCleaning");
+ schema.WriteField("counters");
+ schema.WriteField("threads");
+ }
+
+ aWriter.StartArrayProperty("data");
+ double firstTime = 0.0;
+ double lastTime = 0.0;
+ ProfilerStats intervals, overheads, lockings, cleanings, counters, threads;
+ while (e.Has()) {
+ // valid sequence: ProfilerOverheadTime, ProfilerOverheadDuration * 4
+ if (e.Get().IsProfilerOverheadTime()) {
+ double time = e.Get().GetDouble();
+ if (time >= aSinceTime) {
+ e.Next();
+ if (!e.Has() || !e.Get().IsProfilerOverheadDuration()) {
+ ERROR_AND_CONTINUE(
+ "expected a ProfilerOverheadDuration entry after "
+ "ProfilerOverheadTime");
+ }
+ double locking = e.Get().GetDouble();
+ e.Next();
+ if (!e.Has() || !e.Get().IsProfilerOverheadDuration()) {
+ ERROR_AND_CONTINUE(
+ "expected a ProfilerOverheadDuration entry after "
+ "ProfilerOverheadTime,ProfilerOverheadDuration");
+ }
+ double cleaning = e.Get().GetDouble();
+ e.Next();
+ if (!e.Has() || !e.Get().IsProfilerOverheadDuration()) {
+ ERROR_AND_CONTINUE(
+ "expected a ProfilerOverheadDuration entry after "
+ "ProfilerOverheadTime,ProfilerOverheadDuration*2");
+ }
+ double counter = e.Get().GetDouble();
+ e.Next();
+ if (!e.Has() || !e.Get().IsProfilerOverheadDuration()) {
+ ERROR_AND_CONTINUE(
+ "expected a ProfilerOverheadDuration entry after "
+ "ProfilerOverheadTime,ProfilerOverheadDuration*3");
+ }
+ double thread = e.Get().GetDouble();
+
+ if (firstTime == 0.0) {
+ firstTime = time;
+ } else {
+ // Note that we'll have 1 fewer interval than other numbers (because
+ // we need both ends of an interval to know its duration). The final
+ // difference should be insignificant over the expected many
+ // thousands of iterations.
+ intervals.Count(time - lastTime);
+ }
+ lastTime = time;
+ overheads.Count(locking + cleaning + counter + thread);
+ lockings.Count(locking);
+ cleanings.Count(cleaning);
+ counters.Count(counter);
+ threads.Count(thread);
+
+ AutoArraySchemaWriter writer(aWriter);
+ writer.TimeMsElement(TIME, time);
+ writer.DoubleElement(LOCKING, locking);
+ writer.DoubleElement(MARKER_CLEANING, cleaning);
+ writer.DoubleElement(COUNTERS, counter);
+ writer.DoubleElement(THREADS, thread);
+ }
+ }
+ e.Next();
+ }
+ aWriter.EndArray(); // data
+ aWriter.EndObject(); // samples
+
+ // Only output statistics if there is at least one full interval (and
+ // therefore at least two samplings.)
+ if (intervals.n > 0) {
+ aWriter.StartObjectProperty("statistics");
+ aWriter.DoubleProperty("profiledDuration", lastTime - firstTime);
+ aWriter.IntProperty("samplingCount", overheads.n);
+ aWriter.DoubleProperty("overheadDurations", overheads.sum);
+ aWriter.DoubleProperty("overheadPercentage",
+ overheads.sum / (lastTime - firstTime));
+#define PROFILER_STATS(name, var) \
+ aWriter.DoubleProperty("mean" name, (var).sum / (var).n); \
+ aWriter.DoubleProperty("min" name, (var).min); \
+ aWriter.DoubleProperty("max" name, (var).max);
+ PROFILER_STATS("Interval", intervals);
+ PROFILER_STATS("Overhead", overheads);
+ PROFILER_STATS("Lockings", lockings);
+ PROFILER_STATS("Cleaning", cleanings);
+ PROFILER_STATS("Counter", counters);
+ PROFILER_STATS("Thread", threads);
+#undef PROFILER_STATS
+ aWriter.EndObject(); // statistics
+ }
+ aWriter.EndObject(); // profilerOverhead
+ });
+}
+
+struct CounterKeyedSample {
+ double mTime;
+ uint64_t mNumber;
+ int64_t mCount;
+};
+
+using CounterKeyedSamples = Vector<CounterKeyedSample>;
+
+using CounterMap = HashMap<uint64_t, CounterKeyedSamples>;
+
+// HashMap lookup, if not found, a default value is inserted.
+// Returns reference to (existing or new) value inside the HashMap.
+template <typename HashM, typename Key>
+static auto& LookupOrAdd(HashM& aMap, Key&& aKey) {
+ auto addPtr = aMap.lookupForAdd(aKey);
+ if (!addPtr) {
+ MOZ_RELEASE_ASSERT(aMap.add(addPtr, std::forward<Key>(aKey),
+ typename HashM::Entry::ValueType{}));
+ MOZ_ASSERT(!!addPtr);
+ }
+ return addPtr->value();
+}
+
+void ProfileBuffer::StreamCountersToJSON(SpliceableJSONWriter& aWriter,
+ const TimeStamp& aProcessStartTime,
+ double aSinceTime) const {
+ // Because this is a format entirely internal to the Profiler, any parsing
+ // error indicates a bug in the ProfileBuffer writing or the parser itself,
+ // or possibly flaky hardware.
+
+ mEntries.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ MOZ_ASSERT(aReader,
+ "ProfileChunkedBuffer cannot be out-of-session when sampler is "
+ "running");
+
+ EntryGetter e(*aReader);
+
+ enum Schema : uint32_t { TIME = 0, COUNT = 1, NUMBER = 2 };
+
+ // Stream all counters. We skip other entries, because we process them in
+ // StreamSamplesToJSON()/etc.
+ //
+ // Valid sequence in the buffer:
+ // CounterID
+ // Time
+ // ( CounterKey Count Number? )*
+ //
+ // And the JSON (example):
+ // "counters": {
+ // "name": "malloc",
+ // "category": "Memory",
+ // "description": "Amount of allocated memory",
+ // "sample_groups": {
+ // "id": 0,
+ // "samples": {
+ // "schema": {"time": 0, "number": 1, "count": 2},
+ // "data": [
+ // [
+ // 16117.033968000002,
+ // 2446216,
+ // 6801320
+ // ],
+ // [
+ // 16118.037638,
+ // 2446216,
+ // 6801320
+ // ],
+ // ],
+ // }
+ // }
+ // },
+
+ // Build the map of counters and populate it
+ HashMap<void*, CounterMap> counters;
+
+ while (e.Has()) {
+ // skip all non-Counters, including if we start in the middle of a counter
+ if (e.Get().IsCounterId()) {
+ void* id = e.Get().GetPtr();
+ CounterMap& counter = LookupOrAdd(counters, id);
+ e.Next();
+ if (!e.Has() || !e.Get().IsTime()) {
+ ERROR_AND_CONTINUE("expected a Time entry");
+ }
+ double time = e.Get().GetDouble();
+ e.Next();
+ if (time >= aSinceTime) {
+ while (e.Has() && e.Get().IsCounterKey()) {
+ uint64_t key = e.Get().GetUint64();
+ CounterKeyedSamples& data = LookupOrAdd(counter, key);
+ e.Next();
+ if (!e.Has() || !e.Get().IsCount()) {
+ ERROR_AND_CONTINUE("expected a Count entry");
+ }
+ int64_t count = e.Get().GetUint64();
+ e.Next();
+ uint64_t number;
+ if (!e.Has() || !e.Get().IsNumber()) {
+ number = 0;
+ } else {
+ number = e.Get().GetInt64();
+ e.Next();
+ }
+ CounterKeyedSample sample = {time, number, count};
+ MOZ_RELEASE_ASSERT(data.append(sample));
+ }
+ } else {
+ // skip counter sample - only need to skip the initial counter
+ // id, then let the loop at the top skip the rest
+ }
+ } else {
+ e.Next();
+ }
+ }
+ // we have a map of a map of counter entries; dump them to JSON
+ if (counters.count() == 0) {
+ return;
+ }
+
+ aWriter.StartArrayProperty("counters");
+ for (auto iter = counters.iter(); !iter.done(); iter.next()) {
+ CounterMap& counter = iter.get().value();
+ const BaseProfilerCount* base_counter =
+ static_cast<const BaseProfilerCount*>(iter.get().key());
+
+ aWriter.Start();
+ aWriter.StringProperty("name", MakeStringSpan(base_counter->mLabel));
+ aWriter.StringProperty("category",
+ MakeStringSpan(base_counter->mCategory));
+ aWriter.StringProperty("description",
+ MakeStringSpan(base_counter->mDescription));
+
+ aWriter.StartArrayProperty("sample_groups");
+ for (auto counter_iter = counter.iter(); !counter_iter.done();
+ counter_iter.next()) {
+ CounterKeyedSamples& samples = counter_iter.get().value();
+ uint64_t key = counter_iter.get().key();
+
+ size_t size = samples.length();
+ if (size == 0) {
+ continue;
+ }
+
+ bool hasNumber = false;
+ for (size_t i = 0; i < size; i++) {
+ if (samples[i].mNumber != 0) {
+ hasNumber = true;
+ break;
+ }
+ }
+
+ aWriter.StartObjectElement();
+ {
+ aWriter.IntProperty("id", static_cast<int64_t>(key));
+ aWriter.StartObjectProperty("samples");
+ {
+ JSONSchemaWriter schema(aWriter);
+ schema.WriteField("time");
+ schema.WriteField("count");
+ if (hasNumber) {
+ schema.WriteField("number");
+ }
+ }
+
+ aWriter.StartArrayProperty("data");
+ uint64_t previousNumber = 0;
+ int64_t previousCount = 0;
+ for (size_t i = 0; i < size; i++) {
+ // Encode as deltas, and only encode if different than the last
+ // sample
+ if (i == 0 || samples[i].mNumber != previousNumber ||
+ samples[i].mCount != previousCount) {
+ MOZ_ASSERT(i == 0 || samples[i].mTime >= samples[i - 1].mTime);
+ MOZ_ASSERT(samples[i].mNumber >= previousNumber);
+ MOZ_ASSERT(samples[i].mNumber - previousNumber <=
+ uint64_t(std::numeric_limits<int64_t>::max()));
+
+ AutoArraySchemaWriter writer(aWriter);
+ writer.TimeMsElement(TIME, samples[i].mTime);
+ writer.IntElement(COUNT, samples[i].mCount - previousCount);
+ if (hasNumber) {
+ writer.IntElement(
+ NUMBER,
+ static_cast<int64_t>(samples[i].mNumber - previousNumber));
+ }
+ previousNumber = samples[i].mNumber;
+ previousCount = samples[i].mCount;
+ }
+ }
+ aWriter.EndArray(); // data
+ aWriter.EndObject(); // samples
+ }
+ aWriter.EndObject(); // sample_groups item
+ }
+ aWriter.EndArray(); // sample groups
+ aWriter.End(); // for each counter
+ }
+ aWriter.EndArray(); // counters
+ });
+}
+
+#undef ERROR_AND_CONTINUE
+
+static void AddPausedRange(SpliceableJSONWriter& aWriter, const char* aReason,
+ const Maybe<double>& aStartTime,
+ const Maybe<double>& aEndTime) {
+ aWriter.Start();
+ if (aStartTime) {
+ aWriter.TimeDoubleMsProperty("startTime", *aStartTime);
+ } else {
+ aWriter.NullProperty("startTime");
+ }
+ if (aEndTime) {
+ aWriter.TimeDoubleMsProperty("endTime", *aEndTime);
+ } else {
+ aWriter.NullProperty("endTime");
+ }
+ aWriter.StringProperty("reason", MakeStringSpan(aReason));
+ aWriter.End();
+}
+
+void ProfileBuffer::StreamPausedRangesToJSON(SpliceableJSONWriter& aWriter,
+ double aSinceTime) const {
+ mEntries.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ MOZ_ASSERT(aReader,
+ "ProfileChunkedBuffer cannot be out-of-session when sampler is "
+ "running");
+
+ EntryGetter e(*aReader);
+
+ Maybe<double> currentPauseStartTime;
+ Maybe<double> currentCollectionStartTime;
+
+ while (e.Has()) {
+ if (e.Get().IsPause()) {
+ currentPauseStartTime = Some(e.Get().GetDouble());
+ } else if (e.Get().IsResume()) {
+ AddPausedRange(aWriter, "profiler-paused", currentPauseStartTime,
+ Some(e.Get().GetDouble()));
+ currentPauseStartTime = Nothing();
+ } else if (e.Get().IsCollectionStart()) {
+ currentCollectionStartTime = Some(e.Get().GetDouble());
+ } else if (e.Get().IsCollectionEnd()) {
+ AddPausedRange(aWriter, "collecting", currentCollectionStartTime,
+ Some(e.Get().GetDouble()));
+ currentCollectionStartTime = Nothing();
+ }
+ e.Next();
+ }
+
+ if (currentPauseStartTime) {
+ AddPausedRange(aWriter, "profiler-paused", currentPauseStartTime,
+ Nothing());
+ }
+ if (currentCollectionStartTime) {
+ AddPausedRange(aWriter, "collecting", currentCollectionStartTime,
+ Nothing());
+ }
+ });
+}
+
+bool ProfileBuffer::DuplicateLastSample(BaseProfilerThreadId aThreadId,
+ const TimeStamp& aProcessStartTime,
+ Maybe<uint64_t>& aLastSample) {
+ if (!aLastSample) {
+ return false;
+ }
+
+ ProfileChunkedBuffer tempBuffer(
+ ProfileChunkedBuffer::ThreadSafety::WithoutMutex, WorkerChunkManager());
+
+ auto retrieveWorkerChunk = MakeScopeExit(
+ [&]() { WorkerChunkManager().Reset(tempBuffer.GetAllChunks()); });
+
+ const bool ok = mEntries.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ MOZ_ASSERT(aReader,
+ "ProfileChunkedBuffer cannot be out-of-session when sampler is "
+ "running");
+
+ EntryGetter e(*aReader, *aLastSample);
+
+ if (e.CurPos() != *aLastSample) {
+ // The last sample is no longer within the buffer range, so we cannot
+ // use it. Reset the stored buffer position to Nothing().
+ aLastSample.reset();
+ return false;
+ }
+
+ MOZ_RELEASE_ASSERT(e.Has() && e.Get().IsThreadId() &&
+ e.Get().GetThreadId() == aThreadId);
+
+ e.Next();
+
+ // Go through the whole entry and duplicate it, until we find the next
+ // one.
+ while (e.Has()) {
+ switch (e.Get().GetKind()) {
+ case ProfileBufferEntry::Kind::Pause:
+ case ProfileBufferEntry::Kind::Resume:
+ case ProfileBufferEntry::Kind::PauseSampling:
+ case ProfileBufferEntry::Kind::ResumeSampling:
+ case ProfileBufferEntry::Kind::CollectionStart:
+ case ProfileBufferEntry::Kind::CollectionEnd:
+ case ProfileBufferEntry::Kind::ThreadId:
+ // We're done.
+ return true;
+ case ProfileBufferEntry::Kind::Time:
+ // Copy with new time
+ AddEntry(
+ tempBuffer,
+ ProfileBufferEntry::Time(
+ (TimeStamp::Now() - aProcessStartTime).ToMilliseconds()));
+ break;
+ case ProfileBufferEntry::Kind::CounterKey:
+ case ProfileBufferEntry::Kind::Number:
+ case ProfileBufferEntry::Kind::Count:
+ case ProfileBufferEntry::Kind::Responsiveness:
+ // Don't copy anything not part of a thread's stack sample
+ break;
+ case ProfileBufferEntry::Kind::CounterId:
+ // CounterId is normally followed by Time - if so, we'd like
+ // to skip it. If we duplicate Time, it won't hurt anything, just
+ // waste buffer space (and this can happen if the CounterId has
+ // fallen off the end of the buffer, but Time (and Number/Count)
+ // are still in the buffer).
+ e.Next();
+ if (e.Has() && e.Get().GetKind() != ProfileBufferEntry::Kind::Time) {
+ // this would only happen if there was an invalid sequence
+ // in the buffer. Don't skip it.
+ continue;
+ }
+ // we've skipped Time
+ break;
+ case ProfileBufferEntry::Kind::ProfilerOverheadTime:
+ // ProfilerOverheadTime is normally followed by
+ // ProfilerOverheadDuration*4 - if so, we'd like to skip it. Don't
+ // duplicate, as we are in the middle of a sampling and will soon
+ // capture its own overhead.
+ e.Next();
+ // A missing Time would only happen if there was an invalid
+ // sequence in the buffer. Don't skip unexpected entry.
+ if (e.Has() &&
+ e.Get().GetKind() !=
+ ProfileBufferEntry::Kind::ProfilerOverheadDuration) {
+ continue;
+ }
+ e.Next();
+ if (e.Has() &&
+ e.Get().GetKind() !=
+ ProfileBufferEntry::Kind::ProfilerOverheadDuration) {
+ continue;
+ }
+ e.Next();
+ if (e.Has() &&
+ e.Get().GetKind() !=
+ ProfileBufferEntry::Kind::ProfilerOverheadDuration) {
+ continue;
+ }
+ e.Next();
+ if (e.Has() &&
+ e.Get().GetKind() !=
+ ProfileBufferEntry::Kind::ProfilerOverheadDuration) {
+ continue;
+ }
+ // we've skipped ProfilerOverheadTime and
+ // ProfilerOverheadDuration*4.
+ break;
+ default: {
+ // Copy anything else we don't know about.
+ AddEntry(tempBuffer, e.Get());
+ break;
+ }
+ }
+ e.Next();
+ }
+ return true;
+ });
+
+ if (!ok) {
+ return false;
+ }
+
+ // If the buffer was big enough, there won't be any cleared blocks.
+ if (tempBuffer.GetState().mClearedBlockCount != 0) {
+ // No need to try to read stack again as it won't fit. Reset the stored
+ // buffer position to Nothing().
+ aLastSample.reset();
+ return false;
+ }
+
+ aLastSample = Some(AddThreadIdEntry(aThreadId));
+
+ tempBuffer.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ MOZ_ASSERT(aReader, "tempBuffer cannot be out-of-session");
+
+ EntryGetter e(*aReader);
+
+ while (e.Has()) {
+ AddEntry(e.Get());
+ e.Next();
+ }
+ });
+
+ return true;
+}
+
+void ProfileBuffer::DiscardSamplesBeforeTime(double aTime) {
+ // This function does nothing!
+ // The duration limit will be removed from Firefox, see bug 1632365.
+ Unused << aTime;
+}
+
+// END ProfileBuffer
+////////////////////////////////////////////////////////////////////////
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/ProfileBufferEntry.h b/mozglue/baseprofiler/core/ProfileBufferEntry.h
new file mode 100644
index 0000000000..ee6e401bd8
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfileBufferEntry.h
@@ -0,0 +1,364 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferEntry_h
+#define ProfileBufferEntry_h
+
+#include "BaseProfilingCategory.h"
+#include "gtest/MozGtestFriend.h"
+#include "mozilla/BaseProfileJSONWriter.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/HashTable.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ProfileBufferEntryKinds.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Variant.h"
+#include "mozilla/Vector.h"
+
+#include <string>
+#include <type_traits>
+
+namespace mozilla {
+namespace baseprofiler {
+
+class ProfileBufferEntry {
+ public:
+ using KindUnderlyingType =
+ std::underlying_type_t<::mozilla::ProfileBufferEntryKind>;
+ using Kind = ::mozilla::ProfileBufferEntryKind;
+
+ ProfileBufferEntry();
+
+ static constexpr size_t kNumChars = ::mozilla::ProfileBufferEntryNumChars;
+
+ private:
+ // aString must be a static string.
+ ProfileBufferEntry(Kind aKind, const char* aString);
+ ProfileBufferEntry(Kind aKind, char aChars[kNumChars]);
+ ProfileBufferEntry(Kind aKind, void* aPtr);
+ ProfileBufferEntry(Kind aKind, double aDouble);
+ ProfileBufferEntry(Kind aKind, int64_t aInt64);
+ ProfileBufferEntry(Kind aKind, uint64_t aUint64);
+ ProfileBufferEntry(Kind aKind, int aInt);
+ ProfileBufferEntry(Kind aKind, BaseProfilerThreadId aThreadId);
+
+ public:
+#define CTOR(KIND, TYPE, SIZE) \
+ static ProfileBufferEntry KIND(TYPE aVal) { \
+ return ProfileBufferEntry(Kind::KIND, aVal); \
+ }
+ FOR_EACH_PROFILE_BUFFER_ENTRY_KIND(CTOR)
+#undef CTOR
+
+ Kind GetKind() const { return mKind; }
+
+#define IS_KIND(KIND, TYPE, SIZE) \
+ bool Is##KIND() const { return mKind == Kind::KIND; }
+ FOR_EACH_PROFILE_BUFFER_ENTRY_KIND(IS_KIND)
+#undef IS_KIND
+
+ private:
+ FRIEND_TEST(ThreadProfile, InsertOneEntry);
+ FRIEND_TEST(ThreadProfile, InsertOneEntryWithTinyBuffer);
+ FRIEND_TEST(ThreadProfile, InsertEntriesNoWrap);
+ FRIEND_TEST(ThreadProfile, InsertEntriesWrap);
+ FRIEND_TEST(ThreadProfile, MemoryMeasure);
+ friend class ProfileBuffer;
+
+ Kind mKind;
+ uint8_t mStorage[kNumChars];
+
+ const char* GetString() const;
+ void* GetPtr() const;
+ double GetDouble() const;
+ int GetInt() const;
+ int64_t GetInt64() const;
+ uint64_t GetUint64() const;
+ BaseProfilerThreadId GetThreadId() const;
+ void CopyCharsInto(char (&aOutArray)[kNumChars]) const;
+};
+
+// Packed layout: 1 byte for the tag + 8 bytes for the value.
+static_assert(sizeof(ProfileBufferEntry) == 9, "bad ProfileBufferEntry size");
+
+class UniqueStacks {
+ public:
+ struct FrameKey {
+ explicit FrameKey(const char* aLocation)
+ : mData(NormalFrameData{std::string(aLocation), false, 0, Nothing(),
+ Nothing()}) {}
+
+ FrameKey(std::string&& aLocation, bool aRelevantForJS,
+ uint64_t aInnerWindowID, const Maybe<unsigned>& aLine,
+ const Maybe<unsigned>& aColumn,
+ const Maybe<ProfilingCategoryPair>& aCategoryPair)
+ : mData(NormalFrameData{aLocation, aRelevantForJS, aInnerWindowID,
+ aLine, aColumn, aCategoryPair}) {}
+
+ FrameKey(const FrameKey& aToCopy) = default;
+
+ uint32_t Hash() const;
+ bool operator==(const FrameKey& aOther) const {
+ return mData == aOther.mData;
+ }
+
+ struct NormalFrameData {
+ bool operator==(const NormalFrameData& aOther) const;
+
+ std::string mLocation;
+ bool mRelevantForJS;
+ uint64_t mInnerWindowID;
+ Maybe<unsigned> mLine;
+ Maybe<unsigned> mColumn;
+ Maybe<ProfilingCategoryPair> mCategoryPair;
+ };
+ Variant<NormalFrameData> mData;
+ };
+
+ struct FrameKeyHasher {
+ using Lookup = FrameKey;
+
+ static HashNumber hash(const FrameKey& aLookup) {
+ HashNumber hash = 0;
+ if (aLookup.mData.is<FrameKey::NormalFrameData>()) {
+ const FrameKey::NormalFrameData& data =
+ aLookup.mData.as<FrameKey::NormalFrameData>();
+ if (!data.mLocation.empty()) {
+ hash = AddToHash(hash, HashString(data.mLocation.c_str()));
+ }
+ hash = AddToHash(hash, data.mRelevantForJS);
+ hash = mozilla::AddToHash(hash, data.mInnerWindowID);
+ if (data.mLine.isSome()) {
+ hash = AddToHash(hash, *data.mLine);
+ }
+ if (data.mColumn.isSome()) {
+ hash = AddToHash(hash, *data.mColumn);
+ }
+ if (data.mCategoryPair.isSome()) {
+ hash = AddToHash(hash, static_cast<uint32_t>(*data.mCategoryPair));
+ }
+ }
+ return hash;
+ }
+
+ static bool match(const FrameKey& aKey, const FrameKey& aLookup) {
+ return aKey == aLookup;
+ }
+
+ static void rekey(FrameKey& aKey, const FrameKey& aNewKey) {
+ aKey = aNewKey;
+ }
+ };
+
+ struct StackKey {
+ Maybe<uint32_t> mPrefixStackIndex;
+ uint32_t mFrameIndex;
+
+ explicit StackKey(uint32_t aFrame)
+ : mFrameIndex(aFrame), mHash(HashGeneric(aFrame)) {}
+
+ StackKey(const StackKey& aPrefix, uint32_t aPrefixStackIndex,
+ uint32_t aFrame)
+ : mPrefixStackIndex(Some(aPrefixStackIndex)),
+ mFrameIndex(aFrame),
+ mHash(AddToHash(aPrefix.mHash, aFrame)) {}
+
+ HashNumber Hash() const { return mHash; }
+
+ bool operator==(const StackKey& aOther) const {
+ return mPrefixStackIndex == aOther.mPrefixStackIndex &&
+ mFrameIndex == aOther.mFrameIndex;
+ }
+
+ private:
+ HashNumber mHash;
+ };
+
+ struct StackKeyHasher {
+ using Lookup = StackKey;
+
+ static HashNumber hash(const StackKey& aLookup) { return aLookup.Hash(); }
+
+ static bool match(const StackKey& aKey, const StackKey& aLookup) {
+ return aKey == aLookup;
+ }
+
+ static void rekey(StackKey& aKey, const StackKey& aNewKey) {
+ aKey = aNewKey;
+ }
+ };
+
+ UniqueStacks();
+
+ // Return a StackKey for aFrame as the stack's root frame (no prefix).
+ [[nodiscard]] StackKey BeginStack(const FrameKey& aFrame);
+
+ // Return a new StackKey that is obtained by appending aFrame to aStack.
+ [[nodiscard]] StackKey AppendFrame(const StackKey& aStack,
+ const FrameKey& aFrame);
+
+ [[nodiscard]] uint32_t GetOrAddFrameIndex(const FrameKey& aFrame);
+ [[nodiscard]] uint32_t GetOrAddStackIndex(const StackKey& aStack);
+
+ void SpliceFrameTableElements(SpliceableJSONWriter& aWriter);
+ void SpliceStackTableElements(SpliceableJSONWriter& aWriter);
+
+ UniqueJSONStrings& UniqueStrings() {
+ MOZ_RELEASE_ASSERT(mUniqueStrings.get());
+ return *mUniqueStrings;
+ }
+
+ private:
+ void StreamNonJITFrame(const FrameKey& aFrame);
+ void StreamStack(const StackKey& aStack);
+
+ UniquePtr<UniqueJSONStrings> mUniqueStrings;
+
+ SpliceableChunkedJSONWriter mFrameTableWriter;
+ HashMap<FrameKey, uint32_t, FrameKeyHasher> mFrameToIndexMap;
+
+ SpliceableChunkedJSONWriter mStackTableWriter;
+ HashMap<StackKey, uint32_t, StackKeyHasher> mStackToIndexMap;
+};
+
+//
+// Thread profile JSON Format
+// --------------------------
+//
+// The profile contains much duplicate information. The output JSON of the
+// profile attempts to deduplicate strings, frames, and stack prefixes, to cut
+// down on size and to increase JSON streaming speed. Deduplicated values are
+// streamed as indices into their respective tables.
+//
+// Further, arrays of objects with the same set of properties (e.g., samples,
+// frames) are output as arrays according to a schema instead of an object
+// with property names. A property that is not present is represented in the
+// array as null or undefined.
+//
+// The format of the thread profile JSON is shown by the following example
+// with 1 sample and 1 marker:
+//
+// {
+// "name": "Foo",
+// "tid": 42,
+// "samples":
+// {
+// "schema":
+// {
+// "stack": 0, /* index into stackTable */
+// "time": 1, /* number */
+// "eventDelay": 2, /* number */
+// },
+// "data":
+// [
+// [ 1, 0.0, 0.0 ] /* { stack: 1, time: 0.0, eventDelay: 0.0 } */
+// ]
+// },
+//
+// "markers":
+// {
+// "schema":
+// {
+// "name": 0, /* index into stringTable */
+// "time": 1, /* number */
+// "data": 2 /* arbitrary JSON */
+// },
+// "data":
+// [
+// [ 3, 0.1 ] /* { name: 'example marker', time: 0.1 } */
+// ]
+// },
+//
+// "stackTable":
+// {
+// "schema":
+// {
+// "prefix": 0, /* index into stackTable */
+// "frame": 1 /* index into frameTable */
+// },
+// "data":
+// [
+// [ null, 0 ], /* (root) */
+// [ 0, 1 ] /* (root) > foo.js */
+// ]
+// },
+//
+// "frameTable":
+// {
+// "schema":
+// {
+// "location": 0, /* index into stringTable */
+// "relevantForJS": 1, /* bool */
+// "innerWindowID": 2, /* inner window ID of global JS `window` object */
+// "implementation": 3, /* index into stringTable */
+// "line": 4, /* number */
+// "column": 5, /* number */
+// "category": 6, /* index into profile.meta.categories */
+// "subcategory": 7 /* index into
+// profile.meta.categories[category].subcategories */
+// },
+// "data":
+// [
+// [ 0 ], /* { location: '(root)' } */
+// [ 1, 2 ] /* { location: 'foo.js',
+// implementation: 'baseline' } */
+// ]
+// },
+//
+// "stringTable":
+// [
+// "(root)",
+// "foo.js",
+// "baseline",
+// "example marker"
+// ]
+// }
+//
+// Process:
+// {
+// "name": "Bar",
+// "pid": 24,
+// "threads":
+// [
+// <0-N threads from above>
+// ],
+// "counters": /* includes the memory counter */
+// [
+// {
+// "name": "qwerty",
+// "category": "uiop",
+// "description": "this is qwerty uiop",
+// "sample_groups:
+// [
+// {
+// "id": 42, /* number (thread id, or object identifier (tab), etc) */
+// "samples:
+// {
+// "schema":
+// {
+// "time": 1, /* number */
+// "number": 2, /* number (of times the counter was touched) */
+// "count": 3 /* number (total for the counter) */
+// },
+// "data":
+// [
+// [ 0.1, 1824,
+// 454622 ] /* { time: 0.1, number: 1824, count: 454622 } */
+// ]
+// },
+// },
+// /* more sample-group objects with different id's */
+// ]
+// },
+// /* more counters */
+// ],
+// }
+//
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif /* ndef ProfileBufferEntry_h */
diff --git a/mozglue/baseprofiler/core/ProfileJSONWriter.cpp b/mozglue/baseprofiler/core/ProfileJSONWriter.cpp
new file mode 100644
index 0000000000..dc51f6958e
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfileJSONWriter.cpp
@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "mozilla/BaseProfileJSONWriter.h"
+
+namespace mozilla::baseprofiler {
+
+UniqueJSONStrings::UniqueJSONStrings(FailureLatch& aFailureLatch)
+ : mStringTableWriter(aFailureLatch) {
+ mStringTableWriter.StartBareList();
+ if (const char* failure = mStringTableWriter.GetFailure(); failure) {
+ ClearAndSetFailure(failure);
+ return;
+ }
+}
+
+UniqueJSONStrings::UniqueJSONStrings(FailureLatch& aFailureLatch,
+ const UniqueJSONStrings& aOther,
+ ProgressLogger aProgressLogger)
+ : mStringTableWriter(aFailureLatch) {
+ using namespace mozilla::literals::ProportionValue_literals; // For `10_pc`.
+
+ if (mStringTableWriter.Failed()) {
+ return;
+ }
+
+ if (const char* failure = aOther.GetFailure(); failure) {
+ ClearAndSetFailure(failure);
+ return;
+ }
+
+ mStringTableWriter.StartBareList();
+ uint32_t count = aOther.mStringHashToIndexMap.count();
+ if (count != 0) {
+ if (!mStringHashToIndexMap.reserve(count)) {
+ ClearAndSetFailure("Cannot reserve UniqueJSONStrings map storage");
+ return;
+ }
+ auto iter = aOther.mStringHashToIndexMap.iter();
+ for (auto&& [unusedIndex, progressLogger] :
+ aProgressLogger.CreateLoopSubLoggersFromTo(
+ 10_pc, 90_pc, count, "Copying unique strings...")) {
+ (void)unusedIndex;
+ if (iter.done()) {
+ break;
+ }
+ mStringHashToIndexMap.putNewInfallible(iter.get().key(),
+ iter.get().value());
+ iter.next();
+ }
+ aProgressLogger.SetLocalProgress(90_pc, "Copied unique strings");
+ mStringTableWriter.CopyAndSplice(
+ aOther.mStringTableWriter.ChunkedWriteFunc());
+ if (const char* failure = aOther.GetFailure(); failure) {
+ ClearAndSetFailure(failure);
+ }
+ aProgressLogger.SetLocalProgress(100_pc, "Spliced unique strings");
+ }
+}
+
+UniqueJSONStrings::~UniqueJSONStrings() = default;
+
+void UniqueJSONStrings::SpliceStringTableElements(
+ SpliceableJSONWriter& aWriter) {
+ aWriter.TakeAndSplice(mStringTableWriter.TakeChunkedWriteFunc());
+}
+
+void UniqueJSONStrings::ClearAndSetFailure(std::string aFailure) {
+ mStringTableWriter.SetFailure(std::move(aFailure));
+ mStringHashToIndexMap.clear();
+}
+
+Maybe<uint32_t> UniqueJSONStrings::GetOrAddIndex(const Span<const char>& aStr) {
+ if (Failed()) {
+ return Nothing{};
+ }
+
+ uint32_t count = mStringHashToIndexMap.count();
+ HashNumber hash = HashString(aStr.data(), aStr.size());
+ auto entry = mStringHashToIndexMap.lookupForAdd(hash);
+ if (entry) {
+ MOZ_ASSERT(entry->value() < count);
+ return Some(entry->value());
+ }
+
+ if (!mStringHashToIndexMap.add(entry, hash, count)) {
+ ClearAndSetFailure("OOM in UniqueJSONStrings::GetOrAddIndex adding a map");
+ return Nothing{};
+ }
+ mStringTableWriter.StringElement(aStr);
+ if (const char* failure = mStringTableWriter.GetFailure(); failure) {
+ ClearAndSetFailure(failure);
+ return Nothing{};
+ }
+ return Some(count);
+}
+
+} // namespace mozilla::baseprofiler
diff --git a/mozglue/baseprofiler/core/ProfiledThreadData.cpp b/mozglue/baseprofiler/core/ProfiledThreadData.cpp
new file mode 100644
index 0000000000..62cb994ae2
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfiledThreadData.cpp
@@ -0,0 +1,191 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "ProfiledThreadData.h"
+
+#include "BaseProfiler.h"
+#include "ProfileBuffer.h"
+
+#include "mozilla/BaseProfileJSONWriter.h"
+
+#if defined(GP_OS_darwin)
+# include <pthread.h>
+#endif
+
+namespace mozilla {
+namespace baseprofiler {
+
+ProfiledThreadData::ProfiledThreadData(ThreadInfo* aThreadInfo)
+ : mThreadInfo(aThreadInfo) {}
+
+ProfiledThreadData::~ProfiledThreadData() {}
+
+void ProfiledThreadData::StreamJSON(const ProfileBuffer& aBuffer,
+ SpliceableJSONWriter& aWriter,
+ const std::string& aProcessName,
+ const std::string& aETLDplus1,
+ const TimeStamp& aProcessStartTime,
+ double aSinceTime) {
+ UniqueStacks uniqueStacks;
+
+ aWriter.SetUniqueStrings(uniqueStacks.UniqueStrings());
+
+ aWriter.Start();
+ {
+ StreamSamplesAndMarkers(mThreadInfo->Name(), mThreadInfo->ThreadId(),
+ aBuffer, aWriter, aProcessName, aETLDplus1,
+ aProcessStartTime, mThreadInfo->RegisterTime(),
+ mUnregisterTime, aSinceTime, uniqueStacks);
+
+ aWriter.StartObjectProperty("stackTable");
+ {
+ {
+ JSONSchemaWriter schema(aWriter);
+ schema.WriteField("prefix");
+ schema.WriteField("frame");
+ }
+
+ aWriter.StartArrayProperty("data");
+ { uniqueStacks.SpliceStackTableElements(aWriter); }
+ aWriter.EndArray();
+ }
+ aWriter.EndObject();
+
+ aWriter.StartObjectProperty("frameTable");
+ {
+ {
+ JSONSchemaWriter schema(aWriter);
+ schema.WriteField("location");
+ schema.WriteField("relevantForJS");
+ schema.WriteField("innerWindowID");
+ schema.WriteField("implementation");
+ schema.WriteField("line");
+ schema.WriteField("column");
+ schema.WriteField("category");
+ schema.WriteField("subcategory");
+ }
+
+ aWriter.StartArrayProperty("data");
+ { uniqueStacks.SpliceFrameTableElements(aWriter); }
+ aWriter.EndArray();
+ }
+ aWriter.EndObject();
+
+ aWriter.StartArrayProperty("stringTable");
+ {
+ std::move(uniqueStacks.UniqueStrings())
+ .SpliceStringTableElements(aWriter);
+ }
+ aWriter.EndArray();
+ }
+ aWriter.End();
+
+ aWriter.ResetUniqueStrings();
+}
+
+BaseProfilerThreadId StreamSamplesAndMarkers(
+ const char* aName, BaseProfilerThreadId aThreadId,
+ const ProfileBuffer& aBuffer, SpliceableJSONWriter& aWriter,
+ const std::string& aProcessName, const std::string& aETLDplus1,
+ const TimeStamp& aProcessStartTime, const TimeStamp& aRegisterTime,
+ const TimeStamp& aUnregisterTime, double aSinceTime,
+ UniqueStacks& aUniqueStacks) {
+ BaseProfilerThreadId processedThreadId;
+
+ aWriter.StringProperty(
+ "processType",
+ "(unknown)" /* XRE_GeckoProcessTypeToString(XRE_GetProcessType()) */);
+
+ {
+ std::string name = aName;
+ // We currently need to distinguish threads output by Base Profiler from
+ // those in Gecko Profiler, as the frontend could get confused and lose
+ // tracks with the same name.
+ // TODO: As part of the profilers de-duplication, thread data from both
+ // profilers should end up in the same track, at which point this won't be
+ // necessary anymore. See meta bug 1557566.
+ name += " (pre-xul)";
+ aWriter.StringProperty("name", name);
+ }
+
+ // Use given process name (if any).
+ if (!aProcessName.empty()) {
+ aWriter.StringProperty("processName", aProcessName);
+ }
+ if (!aETLDplus1.empty()) {
+ aWriter.StringProperty("eTLD+1", aETLDplus1);
+ }
+
+ if (aRegisterTime) {
+ aWriter.DoubleProperty(
+ "registerTime", (aRegisterTime - aProcessStartTime).ToMilliseconds());
+ } else {
+ aWriter.NullProperty("registerTime");
+ }
+
+ if (aUnregisterTime) {
+ aWriter.DoubleProperty(
+ "unregisterTime",
+ (aUnregisterTime - aProcessStartTime).ToMilliseconds());
+ } else {
+ aWriter.NullProperty("unregisterTime");
+ }
+
+ aWriter.StartObjectProperty("samples");
+ {
+ {
+ JSONSchemaWriter schema(aWriter);
+ schema.WriteField("stack");
+ schema.WriteField("time");
+ schema.WriteField("eventDelay");
+ }
+
+ aWriter.StartArrayProperty("data");
+ {
+ processedThreadId = aBuffer.StreamSamplesToJSON(
+ aWriter, aThreadId, aSinceTime, aUniqueStacks);
+ }
+ aWriter.EndArray();
+ }
+ aWriter.EndObject();
+
+ aWriter.StartObjectProperty("markers");
+ {
+ {
+ JSONSchemaWriter schema(aWriter);
+ schema.WriteField("name");
+ schema.WriteField("startTime");
+ schema.WriteField("endTime");
+ schema.WriteField("phase");
+ schema.WriteField("category");
+ schema.WriteField("data");
+ }
+
+ aWriter.StartArrayProperty("data");
+ {
+ aBuffer.StreamMarkersToJSON(aWriter, aThreadId, aProcessStartTime,
+ aSinceTime, aUniqueStacks);
+ }
+ aWriter.EndArray();
+ }
+ aWriter.EndObject();
+
+ // Tech note: If `ToNumber()` returns a uint64_t, the conversion to int64_t is
+ // "implementation-defined" before C++20. This is acceptable here, because
+ // this is a one-way conversion to a unique identifier that's used to visually
+ // separate data by thread on the front-end.
+ aWriter.IntProperty(
+ "pid", static_cast<int64_t>(profiler_current_process_id().ToNumber()));
+ aWriter.IntProperty("tid",
+ static_cast<int64_t>(aThreadId.IsSpecified()
+ ? aThreadId.ToNumber()
+ : processedThreadId.ToNumber()));
+
+ return processedThreadId;
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/ProfiledThreadData.h b/mozglue/baseprofiler/core/ProfiledThreadData.h
new file mode 100644
index 0000000000..0590b03326
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfiledThreadData.h
@@ -0,0 +1,120 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfiledThreadData_h
+#define ProfiledThreadData_h
+
+#include "BaseProfilingStack.h"
+#include "platform.h"
+#include "ProfileBufferEntry.h"
+#include "ThreadInfo.h"
+
+#include "mozilla/RefPtr.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+
+#include <string>
+
+namespace mozilla {
+namespace baseprofiler {
+
+class ProfileBuffer;
+
+// This class contains information about a thread that is only relevant while
+// the profiler is running, for any threads (both alive and dead) whose thread
+// name matches the "thread filter" in the current profiler run.
+// ProfiledThreadData objects may be kept alive even after the thread is
+// unregistered, as long as there is still data for that thread in the profiler
+// buffer.
+//
+// Accesses to this class are protected by the profiler state lock.
+//
+// Created as soon as the following are true for the thread:
+// - The profiler is running, and
+// - the thread matches the profiler's thread filter, and
+// - the thread is registered with the profiler.
+// So it gets created in response to either (1) the profiler being started (for
+// an existing registered thread) or (2) the thread being registered (if the
+// profiler is already running).
+//
+// The thread may be unregistered during the lifetime of ProfiledThreadData.
+// If that happens, NotifyUnregistered() is called.
+//
+// This class is the right place to store buffer positions. Profiler buffer
+// positions become invalid if the profiler buffer is destroyed, which happens
+// when the profiler is stopped.
+class ProfiledThreadData final {
+ public:
+ explicit ProfiledThreadData(ThreadInfo* aThreadInfo);
+ ~ProfiledThreadData();
+
+ void NotifyUnregistered(uint64_t aBufferPosition) {
+ mLastSample = Nothing();
+ MOZ_ASSERT(!mBufferPositionWhenReceivedJSContext,
+ "JSContext should have been cleared before the thread was "
+ "unregistered");
+ mUnregisterTime = TimeStamp::Now();
+ mBufferPositionWhenUnregistered = Some(aBufferPosition);
+ }
+ Maybe<uint64_t> BufferPositionWhenUnregistered() {
+ return mBufferPositionWhenUnregistered;
+ }
+
+ Maybe<uint64_t>& LastSample() { return mLastSample; }
+
+ void StreamJSON(const ProfileBuffer& aBuffer, SpliceableJSONWriter& aWriter,
+ const std::string& aProcessName,
+ const std::string& aETLDplus1,
+ const TimeStamp& aProcessStartTime, double aSinceTime);
+
+ const RefPtr<ThreadInfo> Info() const { return mThreadInfo; }
+
+ void NotifyReceivedJSContext(uint64_t aCurrentBufferPosition) {
+ mBufferPositionWhenReceivedJSContext = Some(aCurrentBufferPosition);
+ }
+
+ private:
+ // Group A:
+ // The following fields are interesting for the entire lifetime of a
+ // ProfiledThreadData object.
+
+ // This thread's thread info.
+ const RefPtr<ThreadInfo> mThreadInfo;
+
+ // Group B:
+ // The following fields are only used while this thread is alive and
+ // registered. They become Nothing() once the thread is unregistered.
+
+ // When sampling, this holds the position in ActivePS::mBuffer of the most
+ // recent sample for this thread, or Nothing() if there is no sample for this
+ // thread in the buffer.
+ Maybe<uint64_t> mLastSample;
+
+ // Only non-Nothing() if the thread currently has a JSContext.
+ Maybe<uint64_t> mBufferPositionWhenReceivedJSContext;
+
+ // Group C:
+ // The following fields are only used once this thread has been unregistered.
+
+ Maybe<uint64_t> mBufferPositionWhenUnregistered;
+ TimeStamp mUnregisterTime;
+};
+
+// Stream all samples and markers from aBuffer with the given aThreadId (or 0
+// for everything, which is assumed to be a single backtrace sample.)
+// Returns the thread id of the output sample(s), or 0 if none was present.
+BaseProfilerThreadId StreamSamplesAndMarkers(
+ const char* aName, BaseProfilerThreadId aThreadId,
+ const ProfileBuffer& aBuffer, SpliceableJSONWriter& aWriter,
+ const std::string& aProcessName, const std::string& aETLDplus1,
+ const TimeStamp& aProcessStartTime, const TimeStamp& aRegisterTime,
+ const TimeStamp& aUnregisterTime, double aSinceTime,
+ UniqueStacks& aUniqueStacks);
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif // ProfiledThreadData_h
diff --git a/mozglue/baseprofiler/core/ProfilerBacktrace.cpp b/mozglue/baseprofiler/core/ProfilerBacktrace.cpp
new file mode 100644
index 0000000000..8343888351
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfilerBacktrace.cpp
@@ -0,0 +1,125 @@
+/* -*- 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/. */
+
+#include "ProfilerBacktrace.h"
+
+#include "BaseProfiler.h"
+#include "ProfileBuffer.h"
+#include "ProfiledThreadData.h"
+#include "ThreadInfo.h"
+
+#include "mozilla/BaseProfileJSONWriter.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+ProfilerBacktrace::ProfilerBacktrace(
+ const char* aName,
+ UniquePtr<ProfileChunkedBuffer> aProfileChunkedBufferStorage,
+ UniquePtr<ProfileBuffer> aProfileBufferStorageOrNull /* = nullptr */)
+ : mName(aName),
+ mOptionalProfileChunkedBufferStorage(
+ std::move(aProfileChunkedBufferStorage)),
+ mProfileChunkedBuffer(mOptionalProfileChunkedBufferStorage.get()),
+ mOptionalProfileBufferStorage(std::move(aProfileBufferStorageOrNull)),
+ mProfileBuffer(mOptionalProfileBufferStorage.get()) {
+ if (mProfileBuffer) {
+ MOZ_RELEASE_ASSERT(mProfileChunkedBuffer,
+ "If we take ownership of a ProfileBuffer, we must also "
+ "receive ownership of a ProfileChunkedBuffer");
+ MOZ_RELEASE_ASSERT(
+ mProfileChunkedBuffer == &mProfileBuffer->UnderlyingChunkedBuffer(),
+ "If we take ownership of a ProfileBuffer, we must also receive "
+ "ownership of its ProfileChunkedBuffer");
+ }
+ MOZ_ASSERT(
+ !mProfileChunkedBuffer || !mProfileChunkedBuffer->IsThreadSafe(),
+ "ProfilerBacktrace only takes a non-thread-safe ProfileChunkedBuffer");
+}
+
+ProfilerBacktrace::ProfilerBacktrace(
+ const char* aName,
+ ProfileChunkedBuffer* aExternalProfileChunkedBufferOrNull /* = nullptr */,
+ ProfileBuffer* aExternalProfileBufferOrNull /* = nullptr */)
+ : mName(aName),
+ mProfileChunkedBuffer(aExternalProfileChunkedBufferOrNull),
+ mProfileBuffer(aExternalProfileBufferOrNull) {
+ if (!mProfileChunkedBuffer) {
+ if (mProfileBuffer) {
+ // We don't have a ProfileChunkedBuffer but we have a ProfileBuffer, use
+ // the latter's ProfileChunkedBuffer.
+ mProfileChunkedBuffer = &mProfileBuffer->UnderlyingChunkedBuffer();
+ MOZ_ASSERT(!mProfileChunkedBuffer->IsThreadSafe(),
+ "ProfilerBacktrace only takes a non-thread-safe "
+ "ProfileChunkedBuffer");
+ }
+ } else {
+ if (mProfileBuffer) {
+ MOZ_RELEASE_ASSERT(
+ mProfileChunkedBuffer == &mProfileBuffer->UnderlyingChunkedBuffer(),
+ "If we reference both ProfileChunkedBuffer and ProfileBuffer, they "
+ "must already be connected");
+ }
+ MOZ_ASSERT(!mProfileChunkedBuffer->IsThreadSafe(),
+ "ProfilerBacktrace only takes a non-thread-safe "
+ "ProfileChunkedBuffer");
+ }
+}
+
+ProfilerBacktrace::~ProfilerBacktrace() {}
+
+BaseProfilerThreadId ProfilerBacktrace::StreamJSON(
+ SpliceableJSONWriter& aWriter, const TimeStamp& aProcessStartTime,
+ UniqueStacks& aUniqueStacks) {
+ BaseProfilerThreadId processedThreadId;
+
+ // Unlike ProfiledThreadData::StreamJSON, we don't need to call
+ // ProfileBuffer::AddJITInfoForRange because ProfileBuffer does not contain
+ // any JitReturnAddr entries. For synchronous samples, JIT frames get expanded
+ // at sample time.
+ if (mProfileBuffer) {
+ processedThreadId = StreamSamplesAndMarkers(
+ mName.c_str(), BaseProfilerThreadId{}, *mProfileBuffer, aWriter, "", "",
+ aProcessStartTime,
+ /* aRegisterTime */ TimeStamp(),
+ /* aUnregisterTime */ TimeStamp(),
+ /* aSinceTime */ 0, aUniqueStacks);
+ } else if (mProfileChunkedBuffer) {
+ ProfileBuffer profileBuffer(*mProfileChunkedBuffer);
+ processedThreadId = StreamSamplesAndMarkers(
+ mName.c_str(), BaseProfilerThreadId{}, profileBuffer, aWriter, "", "",
+ aProcessStartTime,
+ /* aRegisterTime */ TimeStamp(),
+ /* aUnregisterTime */ TimeStamp(),
+ /* aSinceTime */ 0, aUniqueStacks);
+ }
+ // If there are no buffers, the backtrace is empty and nothing is streamed.
+
+ return processedThreadId;
+}
+
+} // namespace baseprofiler
+
+// static
+template <typename Destructor>
+UniquePtr<baseprofiler::ProfilerBacktrace, Destructor>
+ProfileBufferEntryReader::
+ Deserializer<UniquePtr<baseprofiler::ProfilerBacktrace, Destructor>>::Read(
+ ProfileBufferEntryReader& aER) {
+ auto profileChunkedBuffer = aER.ReadObject<UniquePtr<ProfileChunkedBuffer>>();
+ if (!profileChunkedBuffer) {
+ return nullptr;
+ }
+ MOZ_ASSERT(
+ !profileChunkedBuffer->IsThreadSafe(),
+ "ProfilerBacktrace only stores non-thread-safe ProfileChunkedBuffers");
+ std::string name = aER.ReadObject<std::string>();
+ return UniquePtr<baseprofiler::ProfilerBacktrace, Destructor>{
+ new baseprofiler::ProfilerBacktrace(name.c_str(),
+ std::move(profileChunkedBuffer))};
+};
+
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/ProfilerBacktrace.h b/mozglue/baseprofiler/core/ProfilerBacktrace.h
new file mode 100644
index 0000000000..0b5b69e738
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfilerBacktrace.h
@@ -0,0 +1,162 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef __PROFILER_BACKTRACE_H
+#define __PROFILER_BACKTRACE_H
+
+#include "mozilla/ProfileChunkedBuffer.h"
+#include "mozilla/UniquePtr.h"
+
+#include <string>
+
+namespace mozilla {
+
+class TimeStamp;
+
+namespace baseprofiler {
+
+class ProfileBuffer;
+class SpliceableJSONWriter;
+class ThreadInfo;
+class UniqueStacks;
+
+// ProfilerBacktrace encapsulates a synchronous sample.
+// It can work with a ProfileBuffer and/or a ProfileChunkedBuffer (if both, they
+// must already be linked together). The ProfileChunkedBuffer contains all the
+// data; the ProfileBuffer is not strictly needed, only provide it if it is
+// already available at the call site.
+// And these buffers can either be:
+// - owned here, so that the ProfilerBacktrace object can be kept for later
+// use), OR
+// - referenced through pointers (in cases where the backtrace is immediately
+// streamed out, so we only need temporary references to external buffers);
+// these pointers may be null for empty backtraces.
+class ProfilerBacktrace {
+ public:
+ // Take ownership of external buffers and use them to keep, and to stream a
+ // backtrace. If a ProfileBuffer is given, its underlying chunked buffer must
+ // be provided as well.
+ explicit ProfilerBacktrace(
+ const char* aName,
+ UniquePtr<ProfileChunkedBuffer> aProfileChunkedBufferStorage,
+ UniquePtr<ProfileBuffer> aProfileBufferStorageOrNull = nullptr);
+
+ // Take pointers to external buffers and use them to stream a backtrace.
+ // If null, the backtrace is effectively empty.
+ // If both are provided, they must already be connected.
+ explicit ProfilerBacktrace(
+ const char* aName,
+ ProfileChunkedBuffer* aExternalProfileChunkedBufferOrNull = nullptr,
+ ProfileBuffer* aExternalProfileBufferOrNull = nullptr);
+
+ ~ProfilerBacktrace();
+
+ [[nodiscard]] bool IsEmpty() const {
+ return !mProfileChunkedBuffer ||
+ ProfileBufferEntryWriter::Serializer<ProfileChunkedBuffer>::Bytes(
+ *mProfileChunkedBuffer) <= ULEB128Size(0u);
+ }
+
+ // ProfilerBacktraces' stacks are deduplicated in the context of the
+ // profile that contains the backtrace as a marker payload.
+ //
+ // That is, markers that contain backtraces should not need their own stack,
+ // frame, and string tables. They should instead reuse their parent
+ // profile's tables.
+ BaseProfilerThreadId StreamJSON(SpliceableJSONWriter& aWriter,
+ const TimeStamp& aProcessStartTime,
+ UniqueStacks& aUniqueStacks);
+
+ private:
+ // Used to de/serialize a ProfilerBacktrace.
+ friend ProfileBufferEntryWriter::Serializer<ProfilerBacktrace>;
+ friend ProfileBufferEntryReader::Deserializer<ProfilerBacktrace>;
+
+ std::string mName;
+
+ // `ProfileChunkedBuffer` in which `mProfileBuffer` stores its data; must be
+ // located before `mProfileBuffer` so that it's destroyed after.
+ UniquePtr<ProfileChunkedBuffer> mOptionalProfileChunkedBufferStorage;
+ // If null, there is no need to check mProfileBuffer's (if present) underlying
+ // buffer because this is done when constructed.
+ ProfileChunkedBuffer* mProfileChunkedBuffer;
+
+ UniquePtr<ProfileBuffer> mOptionalProfileBufferStorage;
+ ProfileBuffer* mProfileBuffer;
+};
+
+} // namespace baseprofiler
+
+// Format: [ UniquePtr<BlockRingsBuffer> | name ]
+// Initial len==0 marks a nullptr or empty backtrace.
+template <>
+struct ProfileBufferEntryWriter::Serializer<baseprofiler::ProfilerBacktrace> {
+ static Length Bytes(const baseprofiler::ProfilerBacktrace& aBacktrace) {
+ if (!aBacktrace.mProfileChunkedBuffer) {
+ // No buffer.
+ return ULEB128Size(0u);
+ }
+ auto bufferBytes = SumBytes(*aBacktrace.mProfileChunkedBuffer);
+ if (bufferBytes <= ULEB128Size(0u)) {
+ // Empty buffer.
+ return ULEB128Size(0u);
+ }
+ return bufferBytes + SumBytes(aBacktrace.mName);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const baseprofiler::ProfilerBacktrace& aBacktrace) {
+ if (!aBacktrace.mProfileChunkedBuffer ||
+ SumBytes(*aBacktrace.mProfileChunkedBuffer) <= ULEB128Size(0u)) {
+ // No buffer, or empty buffer.
+ aEW.WriteULEB128(0u);
+ return;
+ }
+ aEW.WriteObject(*aBacktrace.mProfileChunkedBuffer);
+ aEW.WriteObject(aBacktrace.mName);
+ }
+};
+
+template <typename Destructor>
+struct ProfileBufferEntryWriter::Serializer<
+ UniquePtr<baseprofiler::ProfilerBacktrace, Destructor>> {
+ static Length Bytes(const UniquePtr<baseprofiler::ProfilerBacktrace,
+ Destructor>& aBacktrace) {
+ if (!aBacktrace) {
+ // Null backtrace pointer (treated like an empty backtrace).
+ return ULEB128Size(0u);
+ }
+ return SumBytes(*aBacktrace);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const UniquePtr<baseprofiler::ProfilerBacktrace,
+ Destructor>& aBacktrace) {
+ if (!aBacktrace) {
+ // Null backtrace pointer (treated like an empty backtrace).
+ aEW.WriteULEB128(0u);
+ return;
+ }
+ aEW.WriteObject(*aBacktrace);
+ }
+};
+
+template <typename Destructor>
+struct ProfileBufferEntryReader::Deserializer<
+ UniquePtr<baseprofiler::ProfilerBacktrace, Destructor>> {
+ static void ReadInto(
+ ProfileBufferEntryReader& aER,
+ UniquePtr<baseprofiler::ProfilerBacktrace, Destructor>& aBacktrace) {
+ aBacktrace = Read(aER);
+ }
+
+ static UniquePtr<baseprofiler::ProfilerBacktrace, Destructor> Read(
+ ProfileBufferEntryReader& aER);
+};
+
+} // namespace mozilla
+
+#endif // __PROFILER_BACKTRACE_H
diff --git a/mozglue/baseprofiler/core/ProfilerMarkers.cpp b/mozglue/baseprofiler/core/ProfilerMarkers.cpp
new file mode 100644
index 0000000000..eff6c7e364
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfilerMarkers.cpp
@@ -0,0 +1,348 @@
+/* -*- 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 "mozilla/BaseProfilerMarkers.h"
+
+#include "mozilla/BaseProfilerUtils.h"
+
+#include <limits>
+
+namespace mozilla {
+namespace base_profiler_markers_detail {
+
+// We need an atomic type that can hold a `DeserializerTag`. (Atomic doesn't
+// work with too-small types.)
+using DeserializerTagAtomic = unsigned;
+
+// The atomic sDeserializerCount still also include bits that act as a "RWLock":
+// Whoever can set this bit gets exclusive access to the count and the whole
+// sMarkerTypeFunctions1Based array, guaranteeing that it cannot be modified.
+static constexpr DeserializerTagAtomic scExclusiveLock = 0x80'00'00'00u;
+// Code that wants shared access can add this value, then ensure there is no
+// exclusive lock, after which it's guaranteed that no exclusive lock can be
+// taken until the shared lock count goes back to zero.
+static constexpr DeserializerTagAtomic scSharedLockUnit = 0x00'01'00'00u;
+// This mask isolates the actual count value from the lock bits.
+static constexpr DeserializerTagAtomic scTagMask = 0x00'00'FF'FFu;
+
+// Number of currently-registered deserializers and other marker type functions.
+// The high bits contain lock bits, see above.
+static Atomic<DeserializerTagAtomic, MemoryOrdering::ReleaseAcquire>
+ sDeserializerCount{0};
+
+// This needs to be big enough to handle all possible marker types. If one day
+// this needs to be higher, the underlying DeserializerTag type will have to be
+// changed.
+static constexpr DeserializerTagAtomic DeserializerMax = 250;
+static_assert(DeserializerMax <= scTagMask,
+ "DeserializerMax doesn't fit in scTagMask");
+
+static_assert(
+ DeserializerMax <= std::numeric_limits<Streaming::DeserializerTag>::max(),
+ "The maximum number of deserializers must fit in the DeserializerTag type");
+
+// Array of marker type functions.
+// 1-based, i.e.: [0] -> tag 1, [DeserializerMax - 1] -> tag DeserializerMax.
+// Elements are added at the next available atomically-incremented
+// `sDeserializerCount` (minus 1) whenever a new marker type is used in a
+// Firefox session; the content is kept between profiler runs in that session.
+// There is theoretically a race between the increment and the time the entry is
+// fully written, but in practice all new elements are written (during
+// profiling, using a marker type for the first time) long before they are read
+// (after profiling is paused).
+static Streaming::MarkerTypeFunctions
+ sMarkerTypeFunctions1Based[DeserializerMax];
+
+/* static */ Streaming::DeserializerTag Streaming::TagForMarkerTypeFunctions(
+ Streaming::MarkerDataDeserializer aDeserializer,
+ Streaming::MarkerTypeNameFunction aMarkerTypeNameFunction,
+ Streaming::MarkerSchemaFunction aMarkerSchemaFunction) {
+ MOZ_RELEASE_ASSERT(!!aDeserializer);
+ MOZ_RELEASE_ASSERT(!!aMarkerTypeNameFunction);
+ MOZ_RELEASE_ASSERT(!!aMarkerSchemaFunction);
+
+ // Add a shared lock request, which will prevent future exclusive locking.
+ DeserializerTagAtomic tagWithLock = (sDeserializerCount += scSharedLockUnit);
+
+ // An exclusive locker may have arrived before us, just wait for it to finish.
+ while ((tagWithLock & scExclusiveLock) != 0u) {
+ tagWithLock = sDeserializerCount;
+ }
+
+ MOZ_ASSERT(
+ // This is equivalent to shifting right to only keep the lock counts.
+ tagWithLock / scSharedLockUnit <
+ // This is effectively half of the permissible shared lock range,
+ // that would mean way too many threads doing this work here!
+ scExclusiveLock / scSharedLockUnit / 2,
+ "The shared lock count is getting unexpectedly high, verify the "
+ "algorithm, and tweak constants if needed");
+
+ // Reserve a tag. Even if there are multiple shared-lock holders here, each
+ // one will get a different value, and therefore will access a different part
+ // of the sMarkerTypeFunctions1Based array.
+ const DeserializerTagAtomic tag = ++sDeserializerCount & scTagMask;
+
+ MOZ_RELEASE_ASSERT(
+ tag <= DeserializerMax,
+ "Too many deserializers, consider increasing DeserializerMax. "
+ "Or is a deserializer stored again and again?");
+ sMarkerTypeFunctions1Based[tag - 1] = {aDeserializer, aMarkerTypeNameFunction,
+ aMarkerSchemaFunction};
+
+ // And release our shared lock, to allow exclusive readers.
+ sDeserializerCount -= scSharedLockUnit;
+
+ return static_cast<DeserializerTag>(tag);
+}
+
+/* static */ Streaming::MarkerDataDeserializer Streaming::DeserializerForTag(
+ Streaming::DeserializerTag aTag) {
+ MOZ_RELEASE_ASSERT(
+ aTag > 0 && static_cast<DeserializerTagAtomic>(aTag) <=
+ static_cast<DeserializerTagAtomic>(sDeserializerCount),
+ "Out-of-range tag value");
+ return sMarkerTypeFunctions1Based[aTag - 1].mMarkerDataDeserializer;
+}
+
+Streaming::LockedMarkerTypeFunctionsList::LockedMarkerTypeFunctionsList() {
+ for (;;) {
+ const DeserializerTagAtomic count = sDeserializerCount;
+ if ((count & scTagMask) != count) {
+ // Someone already has a lock, loop around.
+ continue;
+ }
+
+ // There are currently no locks, try to add our exclusive lock.
+ if (!sDeserializerCount.compareExchange(count, count | scExclusiveLock)) {
+ // Someone else modified sDeserializerCount since our read, loop around.
+ continue;
+ }
+
+ // We applied our exclusive lock, we can now read the list of functions,
+ // without interference until ~LockedMarkerTypeFunctionsList().
+ // (Note that sDeserializerCount may receive shared lock requests, but the
+ // count won't change.)
+ mMarkerTypeFunctionsSpan = {sMarkerTypeFunctions1Based, count};
+ break;
+ }
+}
+
+Streaming::LockedMarkerTypeFunctionsList::~LockedMarkerTypeFunctionsList() {
+ MOZ_ASSERT(
+ (sDeserializerCount & scExclusiveLock) == scExclusiveLock,
+ "sDeserializerCount should still have the the exclusive lock bit set");
+ MOZ_ASSERT(
+ (sDeserializerCount & scTagMask) ==
+ DeserializerTagAtomic(mMarkerTypeFunctionsSpan.size()),
+ "sDeserializerCount should have the same count since construction");
+ sDeserializerCount &= ~scExclusiveLock;
+}
+
+// Only accessed on the main thread.
+// Both profilers (Base and Gecko) could be active at the same time, so keep a
+// ref-count to only allocate at most one buffer at any time.
+static int sBufferForMainThreadAddMarkerRefCount = 0;
+static ProfileChunkedBuffer* sBufferForMainThreadAddMarker = nullptr;
+
+ProfileChunkedBuffer* GetClearedBufferForMainThreadAddMarker() {
+ if (!mozilla::baseprofiler::profiler_is_main_thread()) {
+ return nullptr;
+ }
+
+ if (sBufferForMainThreadAddMarker) {
+ MOZ_ASSERT(sBufferForMainThreadAddMarker->IsInSession(),
+ "sBufferForMainThreadAddMarker should always be in-session");
+ sBufferForMainThreadAddMarker->Clear();
+ MOZ_ASSERT(
+ sBufferForMainThreadAddMarker->IsInSession(),
+ "Cleared sBufferForMainThreadAddMarker should still be in-session");
+ }
+
+ return sBufferForMainThreadAddMarker;
+}
+
+MFBT_API void EnsureBufferForMainThreadAddMarker() {
+ if (!mozilla::baseprofiler::profiler_is_main_thread()) {
+ return;
+ }
+
+ if (sBufferForMainThreadAddMarkerRefCount++ == 0) {
+ // First `Ensure`, allocate the buffer.
+ MOZ_ASSERT(!sBufferForMainThreadAddMarker);
+ sBufferForMainThreadAddMarker = new ProfileChunkedBuffer(
+ ProfileChunkedBuffer::ThreadSafety::WithoutMutex,
+ MakeUnique<ProfileBufferChunkManagerSingle>(
+ ProfileBufferChunkManager::scExpectedMaximumStackSize));
+ MOZ_ASSERT(sBufferForMainThreadAddMarker);
+ MOZ_ASSERT(sBufferForMainThreadAddMarker->IsInSession());
+ }
+}
+
+MFBT_API void ReleaseBufferForMainThreadAddMarker() {
+ if (!mozilla::baseprofiler::profiler_is_main_thread()) {
+ return;
+ }
+
+ if (sBufferForMainThreadAddMarkerRefCount == 0) {
+ // Unexpected Release! This should not normally happen, but it's harmless in
+ // practice, it means the buffer is not alive anyway.
+ return;
+ }
+
+ MOZ_ASSERT(sBufferForMainThreadAddMarker);
+ MOZ_ASSERT(sBufferForMainThreadAddMarker->IsInSession());
+ if (--sBufferForMainThreadAddMarkerRefCount == 0) {
+ // Last `Release`, destroy the buffer.
+ delete sBufferForMainThreadAddMarker;
+ sBufferForMainThreadAddMarker = nullptr;
+ }
+}
+
+} // namespace base_profiler_markers_detail
+
+void MarkerSchema::Stream(JSONWriter& aWriter,
+ const Span<const char>& aName) && {
+ // The caller should have started a JSON array, in which we can add an object
+ // that defines a marker schema.
+
+ if (mLocations.empty()) {
+ // SpecialFrontendLocation case, don't output anything for this type.
+ return;
+ }
+
+ aWriter.StartObjectElement();
+ {
+ aWriter.StringProperty("name", aName);
+
+ if (!mChartLabel.empty()) {
+ aWriter.StringProperty("chartLabel", mChartLabel);
+ }
+
+ if (!mTooltipLabel.empty()) {
+ aWriter.StringProperty("tooltipLabel", mTooltipLabel);
+ }
+
+ if (!mTableLabel.empty()) {
+ aWriter.StringProperty("tableLabel", mTableLabel);
+ }
+
+ aWriter.StartArrayProperty("display");
+ {
+ for (Location location : mLocations) {
+ aWriter.StringElement(LocationToStringSpan(location));
+ }
+ }
+ aWriter.EndArray();
+
+ aWriter.StartArrayProperty("data");
+ {
+ for (const DataRow& row : mData) {
+ aWriter.StartObjectElement();
+ {
+ row.match(
+ [&aWriter](const DynamicData& aData) {
+ aWriter.StringProperty("key", aData.mKey);
+ if (aData.mLabel) {
+ aWriter.StringProperty("label", *aData.mLabel);
+ }
+ aWriter.StringProperty("format",
+ FormatToStringSpan(aData.mFormat));
+ if (aData.mSearchable) {
+ aWriter.BoolProperty(
+ "searchable",
+ *aData.mSearchable == Searchable::Searchable);
+ }
+ },
+ [&aWriter](const StaticData& aStaticData) {
+ aWriter.StringProperty("label", aStaticData.mLabel);
+ aWriter.StringProperty("value", aStaticData.mValue);
+ });
+ }
+ aWriter.EndObject();
+ }
+ }
+ aWriter.EndArray();
+ }
+ aWriter.EndObject();
+}
+
+/* static */
+Span<const char> MarkerSchema::LocationToStringSpan(
+ MarkerSchema::Location aLocation) {
+ switch (aLocation) {
+ case Location::MarkerChart:
+ return mozilla::MakeStringSpan("marker-chart");
+ case Location::MarkerTable:
+ return mozilla::MakeStringSpan("marker-table");
+ case Location::TimelineOverview:
+ return mozilla::MakeStringSpan("timeline-overview");
+ case Location::TimelineMemory:
+ return mozilla::MakeStringSpan("timeline-memory");
+ case Location::TimelineIPC:
+ return mozilla::MakeStringSpan("timeline-ipc");
+ case Location::TimelineFileIO:
+ return mozilla::MakeStringSpan("timeline-fileio");
+ case Location::StackChart:
+ return mozilla::MakeStringSpan("stack-chart");
+ default:
+ MOZ_CRASH("Unexpected Location enum");
+ return {};
+ }
+}
+
+/* static */
+Span<const char> MarkerSchema::FormatToStringSpan(
+ MarkerSchema::Format aFormat) {
+ switch (aFormat) {
+ case Format::Url:
+ return mozilla::MakeStringSpan("url");
+ case Format::FilePath:
+ return mozilla::MakeStringSpan("file-path");
+ case Format::String:
+ return mozilla::MakeStringSpan("string");
+ case Format::Duration:
+ return mozilla::MakeStringSpan("duration");
+ case Format::Time:
+ return mozilla::MakeStringSpan("time");
+ case Format::Seconds:
+ return mozilla::MakeStringSpan("seconds");
+ case Format::Milliseconds:
+ return mozilla::MakeStringSpan("milliseconds");
+ case Format::Microseconds:
+ return mozilla::MakeStringSpan("microseconds");
+ case Format::Nanoseconds:
+ return mozilla::MakeStringSpan("nanoseconds");
+ case Format::Bytes:
+ return mozilla::MakeStringSpan("bytes");
+ case Format::Percentage:
+ return mozilla::MakeStringSpan("percentage");
+ case Format::Integer:
+ return mozilla::MakeStringSpan("integer");
+ case Format::Decimal:
+ return mozilla::MakeStringSpan("decimal");
+ default:
+ MOZ_CRASH("Unexpected Format enum");
+ return {};
+ }
+}
+
+} // namespace mozilla
+
+namespace mozilla::baseprofiler {
+template MFBT_API ProfileBufferBlockIndex AddMarker(const ProfilerString8View&,
+ const MarkerCategory&,
+ MarkerOptions&&,
+ markers::TextMarker,
+ const std::string&);
+
+template MFBT_API ProfileBufferBlockIndex
+AddMarkerToBuffer(ProfileChunkedBuffer&, const ProfilerString8View&,
+ const MarkerCategory&, MarkerOptions&&, markers::NoPayload);
+
+template MFBT_API ProfileBufferBlockIndex AddMarkerToBuffer(
+ ProfileChunkedBuffer&, const ProfilerString8View&, const MarkerCategory&,
+ MarkerOptions&&, markers::TextMarker, const std::string&);
+} // namespace mozilla::baseprofiler
diff --git a/mozglue/baseprofiler/core/ProfilerUtils.cpp b/mozglue/baseprofiler/core/ProfilerUtils.cpp
new file mode 100644
index 0000000000..5f53910774
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfilerUtils.cpp
@@ -0,0 +1,162 @@
+/* -*- Mode: C++; tab-width: 2; 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 file implements functions from BaseProfilerUtils.h on all platforms.
+// Functions with platform-specific implementations are separated in #if blocks
+// below, with each block being self-contained with all the #includes and
+// definitions it needs, to keep platform code easier to maintain in isolation.
+
+#include "mozilla/BaseProfilerUtils.h"
+
+// --------------------------------------------- WASI process & thread ids
+#if defined(__wasi__)
+
+namespace mozilla::baseprofiler {
+
+// WASI is single-process and single-thread for now.
+
+BaseProfilerProcessId profiler_current_process_id() {
+ return BaseProfilerProcessId::FromNativeId(1u);
+}
+
+BaseProfilerThreadId profiler_current_thread_id() {
+ return BaseProfilerThreadId::FromNativeId(1u);
+}
+
+} // namespace mozilla::baseprofiler
+
+// --------------------------------------------- Windows process & thread ids
+#elif defined(XP_WIN)
+
+# include <process.h>
+# include <processthreadsapi.h>
+
+namespace mozilla::baseprofiler {
+
+BaseProfilerProcessId profiler_current_process_id() {
+ return BaseProfilerProcessId::FromNativeId(_getpid());
+}
+
+BaseProfilerThreadId profiler_current_thread_id() {
+ static_assert(std::is_same_v<BaseProfilerThreadId::NativeType,
+ decltype(GetCurrentThreadId())>,
+ "BaseProfilerThreadId::NativeType must be exactly the type "
+ "returned by GetCurrentThreadId()");
+ return BaseProfilerThreadId::FromNativeId(GetCurrentThreadId());
+}
+
+} // namespace mozilla::baseprofiler
+
+// --------------------------------------------- Non-Windows process id
+#else
+// All non-Windows platforms are assumed to be POSIX, which has getpid().
+
+# include <unistd.h>
+
+namespace mozilla::baseprofiler {
+
+BaseProfilerProcessId profiler_current_process_id() {
+ return BaseProfilerProcessId::FromNativeId(getpid());
+}
+
+} // namespace mozilla::baseprofiler
+
+// --------------------------------------------- Non-Windows thread id
+// ------------------------------------------------------- macOS
+# if defined(XP_MACOSX)
+
+# include <pthread.h>
+
+namespace mozilla::baseprofiler {
+
+BaseProfilerThreadId profiler_current_thread_id() {
+ uint64_t tid;
+ if (pthread_threadid_np(nullptr, &tid) != 0) {
+ return BaseProfilerThreadId{};
+ }
+ return BaseProfilerThreadId::FromNativeId(tid);
+}
+
+} // namespace mozilla::baseprofiler
+
+// ------------------------------------------------------- Android
+// Test Android before Linux, because Linux includes Android.
+# elif defined(__ANDROID__) || defined(ANDROID)
+
+namespace mozilla::baseprofiler {
+
+BaseProfilerThreadId profiler_current_thread_id() {
+ return BaseProfilerThreadId::FromNativeId(gettid());
+}
+
+} // namespace mozilla::baseprofiler
+
+// ------------------------------------------------------- Linux
+# elif defined(XP_LINUX)
+
+# include <sys/syscall.h>
+
+namespace mozilla::baseprofiler {
+
+BaseProfilerThreadId profiler_current_thread_id() {
+ // glibc doesn't provide a wrapper for gettid() until 2.30
+ return BaseProfilerThreadId::FromNativeId(syscall(SYS_gettid));
+}
+
+} // namespace mozilla::baseprofiler
+
+// ------------------------------------------------------- FreeBSD
+# elif defined(XP_FREEBSD)
+
+# include <sys/thr.h>
+
+namespace mozilla::baseprofiler {
+
+BaseProfilerThreadId profiler_current_thread_id() {
+ long id;
+ if (thr_self(&id) != 0) {
+ return BaseProfilerThreadId{};
+ }
+ return BaseProfilerThreadId::FromNativeId(id);
+}
+
+} // namespace mozilla::baseprofiler
+
+// ------------------------------------------------------- Others
+# else
+
+namespace mozilla::baseprofiler {
+
+BaseProfilerThreadId profiler_current_thread_id() {
+ return BaseProfilerThreadId::FromNativeId(std::this_thread::get_id());
+}
+
+} // namespace mozilla::baseprofiler
+
+# endif
+#endif // End of non-XP_WIN.
+
+// --------------------------------------------- Platform-agnostic definitions
+
+namespace mozilla::baseprofiler {
+
+static BaseProfilerThreadId scBaseProfilerMainThreadId{};
+
+void profiler_init_main_thread_id() {
+ if (!scBaseProfilerMainThreadId.IsSpecified()) {
+ scBaseProfilerMainThreadId = profiler_current_thread_id();
+ }
+}
+
+BaseProfilerThreadId profiler_main_thread_id() {
+ return scBaseProfilerMainThreadId;
+}
+
+bool profiler_is_main_thread() {
+ return profiler_current_thread_id() == scBaseProfilerMainThreadId;
+}
+
+} // namespace mozilla::baseprofiler
diff --git a/mozglue/baseprofiler/core/ProfilingCategory.cpp b/mozglue/baseprofiler/core/ProfilingCategory.cpp
new file mode 100644
index 0000000000..8ff2b15555
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfilingCategory.cpp
@@ -0,0 +1,71 @@
+/* -*- 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/. */
+
+#include "BaseProfilingCategory.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Assertions.h"
+
+#include "BaseProfiler.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+// clang-format off
+
+// ProfilingSubcategory_X:
+// One enum for each category X, listing that category's subcategories. This
+// allows the sProfilingCategoryInfo macro construction below to look up a
+// per-category index for a subcategory.
+#define SUBCATEGORY_ENUMS_BEGIN_CATEGORY(name, labelAsString, color) \
+ enum class ProfilingSubcategory_##name : uint32_t {
+#define SUBCATEGORY_ENUMS_SUBCATEGORY(category, name, labelAsString) \
+ name,
+#define SUBCATEGORY_ENUMS_END_CATEGORY \
+ };
+MOZ_PROFILING_CATEGORY_LIST(SUBCATEGORY_ENUMS_BEGIN_CATEGORY,
+ SUBCATEGORY_ENUMS_SUBCATEGORY,
+ SUBCATEGORY_ENUMS_END_CATEGORY)
+#undef SUBCATEGORY_ENUMS_BEGIN_CATEGORY
+#undef SUBCATEGORY_ENUMS_SUBCATEGORY
+#undef SUBCATEGORY_ENUMS_END_CATEGORY
+
+// sProfilingCategoryPairInfo:
+// A list of ProfilingCategoryPairInfos with the same order as
+// ProfilingCategoryPair, which can be used to map a ProfilingCategoryPair to
+// its information.
+#define CATEGORY_INFO_BEGIN_CATEGORY(name, labelAsString, color)
+#define CATEGORY_INFO_SUBCATEGORY(category, name, labelAsString) \
+ {ProfilingCategory::category, \
+ uint32_t(ProfilingSubcategory_##category::name), labelAsString},
+#define CATEGORY_INFO_END_CATEGORY
+const ProfilingCategoryPairInfo sProfilingCategoryPairInfo[] = {
+ MOZ_PROFILING_CATEGORY_LIST(CATEGORY_INFO_BEGIN_CATEGORY,
+ CATEGORY_INFO_SUBCATEGORY,
+ CATEGORY_INFO_END_CATEGORY)
+};
+#undef CATEGORY_INFO_BEGIN_CATEGORY
+#undef CATEGORY_INFO_SUBCATEGORY
+#undef CATEGORY_INFO_END_CATEGORY
+
+// clang-format on
+
+const ProfilingCategoryPairInfo& GetProfilingCategoryPairInfo(
+ ProfilingCategoryPair aCategoryPair) {
+ static_assert(
+ MOZ_ARRAY_LENGTH(sProfilingCategoryPairInfo) ==
+ uint32_t(ProfilingCategoryPair::COUNT),
+ "sProfilingCategoryPairInfo and ProfilingCategory need to have the "
+ "same order and the same length");
+
+ uint32_t categoryPairIndex = uint32_t(aCategoryPair);
+ MOZ_RELEASE_ASSERT(categoryPairIndex <=
+ uint32_t(ProfilingCategoryPair::LAST));
+ return sProfilingCategoryPairInfo[categoryPairIndex];
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/ProfilingStack.cpp b/mozglue/baseprofiler/core/ProfilingStack.cpp
new file mode 100644
index 0000000000..f5cd2ddd04
--- /dev/null
+++ b/mozglue/baseprofiler/core/ProfilingStack.cpp
@@ -0,0 +1,52 @@
+/* -*- 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/. */
+
+#include "BaseProfilingStack.h"
+
+#include <algorithm>
+
+#include "mozilla/IntegerRange.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/UniquePtrExtensions.h"
+
+#include "BaseProfiler.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+ProfilingStack::~ProfilingStack() {
+ // The label macros keep a reference to the ProfilingStack to avoid a TLS
+ // access. If these are somehow not all cleared we will get a
+ // use-after-free so better to crash now.
+ MOZ_RELEASE_ASSERT(stackPointer == 0);
+
+ delete[] frames;
+}
+
+void ProfilingStack::ensureCapacitySlow() {
+ MOZ_ASSERT(stackPointer >= capacity);
+ const uint32_t kInitialCapacity = 128;
+
+ uint32_t sp = stackPointer;
+ auto newCapacity =
+ std::max(sp + 1, capacity ? capacity * 2 : kInitialCapacity);
+
+ auto* newFrames = new ProfilingStackFrame[newCapacity];
+
+ // It's important that `frames` / `capacity` / `stackPointer` remain
+ // consistent here at all times.
+ for (auto i : IntegerRange(capacity)) {
+ newFrames[i] = frames[i];
+ }
+
+ ProfilingStackFrame* oldFrames = frames;
+ frames = newFrames;
+ capacity = newCapacity;
+ delete[] oldFrames;
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/RegisteredThread.cpp b/mozglue/baseprofiler/core/RegisteredThread.cpp
new file mode 100644
index 0000000000..85a7fc2c6d
--- /dev/null
+++ b/mozglue/baseprofiler/core/RegisteredThread.cpp
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "RegisteredThread.h"
+
+#include "BaseProfiler.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+RegisteredThread::RegisteredThread(ThreadInfo* aInfo, void* aStackTop)
+ : mRacyRegisteredThread(aInfo->ThreadId()),
+ mPlatformData(AllocPlatformData(aInfo->ThreadId())),
+ mStackTop(aStackTop),
+ mThreadInfo(aInfo) {
+ // We don't have to guess on mac
+#if defined(GP_OS_darwin)
+ pthread_t self = pthread_self();
+ mStackTop = pthread_get_stackaddr_np(self);
+#endif
+}
+
+RegisteredThread::~RegisteredThread() {}
+
+size_t RegisteredThread::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ size_t n = aMallocSizeOf(this);
+
+ // Measurement of the following members may be added later if DMD finds it
+ // is worthwhile:
+ // - mPlatformData
+ //
+ // The following members are not measured:
+ // - mThreadInfo: because it is non-owning
+
+ return n;
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/RegisteredThread.h b/mozglue/baseprofiler/core/RegisteredThread.h
new file mode 100644
index 0000000000..baaf7dced6
--- /dev/null
+++ b/mozglue/baseprofiler/core/RegisteredThread.h
@@ -0,0 +1,164 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef RegisteredThread_h
+#define RegisteredThread_h
+
+#include "platform.h"
+#include "ThreadInfo.h"
+
+#include "mozilla/UniquePtr.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+// This class contains the state for a single thread that is accessible without
+// protection from gPSMutex in platform.cpp. Because there is no external
+// protection against data races, it must provide internal protection. Hence
+// the "Racy" prefix.
+//
+class RacyRegisteredThread final {
+ public:
+ explicit RacyRegisteredThread(BaseProfilerThreadId aThreadId)
+ : mThreadId(aThreadId), mSleep(AWAKE), mIsBeingProfiled(false) {}
+
+ ~RacyRegisteredThread() {}
+
+ void SetIsBeingProfiled(bool aIsBeingProfiled) {
+ mIsBeingProfiled = aIsBeingProfiled;
+ }
+
+ bool IsBeingProfiled() const { return mIsBeingProfiled; }
+
+ // This is called on every profiler restart. Put things that should happen at
+ // that time here.
+ void ReinitializeOnResume() {
+ // This is needed to cause an initial sample to be taken from sleeping
+ // threads that had been observed prior to the profiler stopping and
+ // restarting. Otherwise sleeping threads would not have any samples to
+ // copy forward while sleeping.
+ (void)mSleep.compareExchange(SLEEPING_OBSERVED, SLEEPING_NOT_OBSERVED);
+ }
+
+ // This returns true for the second and subsequent calls in each sleep cycle.
+ bool CanDuplicateLastSampleDueToSleep() {
+ if (mSleep == AWAKE) {
+ return false;
+ }
+
+ if (mSleep.compareExchange(SLEEPING_NOT_OBSERVED, SLEEPING_OBSERVED)) {
+ return false;
+ }
+
+ return true;
+ }
+
+ // Call this whenever the current thread sleeps. Calling it twice in a row
+ // without an intervening setAwake() call is an error.
+ void SetSleeping() {
+ MOZ_ASSERT(mSleep == AWAKE);
+ mSleep = SLEEPING_NOT_OBSERVED;
+ }
+
+ // Call this whenever the current thread wakes. Calling it twice in a row
+ // without an intervening setSleeping() call is an error.
+ void SetAwake() {
+ MOZ_ASSERT(mSleep != AWAKE);
+ mSleep = AWAKE;
+ }
+
+ bool IsSleeping() { return mSleep != AWAKE; }
+
+ BaseProfilerThreadId ThreadId() const { return mThreadId; }
+
+ class ProfilingStack& ProfilingStack() { return mProfilingStack; }
+ const class ProfilingStack& ProfilingStack() const { return mProfilingStack; }
+
+ private:
+ class ProfilingStack mProfilingStack;
+
+ // mThreadId contains the thread ID of the current thread. It is safe to read
+ // this from multiple threads concurrently, as it will never be mutated.
+ const BaseProfilerThreadId mThreadId;
+
+ // mSleep tracks whether the thread is sleeping, and if so, whether it has
+ // been previously observed. This is used for an optimization: in some cases,
+ // when a thread is asleep, we duplicate the previous sample, which is
+ // cheaper than taking a new sample.
+ //
+ // mSleep is atomic because it is accessed from multiple threads.
+ //
+ // - It is written only by this thread, via setSleeping() and setAwake().
+ //
+ // - It is read by SamplerThread::Run().
+ //
+ // There are two cases where racing between threads can cause an issue.
+ //
+ // - If CanDuplicateLastSampleDueToSleep() returns false but that result is
+ // invalidated before being acted upon, we will take a full sample
+ // unnecessarily. This is additional work but won't cause any correctness
+ // issues. (In actual fact, this case is impossible. In order to go from
+ // CanDuplicateLastSampleDueToSleep() returning false to it returning true
+ // requires an intermediate call to it in order for mSleep to go from
+ // SLEEPING_NOT_OBSERVED to SLEEPING_OBSERVED.)
+ //
+ // - If CanDuplicateLastSampleDueToSleep() returns true but that result is
+ // invalidated before being acted upon -- i.e. the thread wakes up before
+ // DuplicateLastSample() is called -- we will duplicate the previous
+ // sample. This is inaccurate, but only slightly... we will effectively
+ // treat the thread as having slept a tiny bit longer than it really did.
+ //
+ // This latter inaccuracy could be avoided by moving the
+ // CanDuplicateLastSampleDueToSleep() check within the thread-freezing code,
+ // e.g. the section where Tick() is called. But that would reduce the
+ // effectiveness of the optimization because more code would have to be run
+ // before we can tell that duplication is allowed.
+ //
+ static const int AWAKE = 0;
+ static const int SLEEPING_NOT_OBSERVED = 1;
+ static const int SLEEPING_OBSERVED = 2;
+ Atomic<int> mSleep;
+
+ // Is this thread being profiled? (e.g., should markers be recorded?)
+ Atomic<bool, MemoryOrdering::Relaxed> mIsBeingProfiled;
+};
+
+// This class contains information that's relevant to a single thread only
+// while that thread is running and registered with the profiler, but
+// regardless of whether the profiler is running. All accesses to it are
+// protected by the profiler state lock.
+class RegisteredThread final {
+ public:
+ RegisteredThread(ThreadInfo* aInfo, void* aStackTop);
+ ~RegisteredThread();
+
+ class RacyRegisteredThread& RacyRegisteredThread() {
+ return mRacyRegisteredThread;
+ }
+ const class RacyRegisteredThread& RacyRegisteredThread() const {
+ return mRacyRegisteredThread;
+ }
+
+ PlatformData* GetPlatformData() const { return mPlatformData.get(); }
+ const void* StackTop() const { return mStackTop; }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
+
+ const RefPtr<ThreadInfo> Info() const { return mThreadInfo; }
+
+ private:
+ class RacyRegisteredThread mRacyRegisteredThread;
+
+ const UniquePlatformData mPlatformData;
+ const void* mStackTop;
+
+ const RefPtr<ThreadInfo> mThreadInfo;
+};
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif // RegisteredThread_h
diff --git a/mozglue/baseprofiler/core/ThreadInfo.h b/mozglue/baseprofiler/core/ThreadInfo.h
new file mode 100644
index 0000000000..80211396ac
--- /dev/null
+++ b/mozglue/baseprofiler/core/ThreadInfo.h
@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ThreadInfo_h
+#define ThreadInfo_h
+
+#include "mozilla/Atomics.h"
+#include "mozilla/BaseProfilerUtils.h"
+#include "mozilla/TimeStamp.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+// This class contains information about a thread which needs to be stored
+// across restarts of the profiler and which can be useful even after the
+// thread has stopped running.
+// It uses threadsafe refcounting and only contains immutable data.
+class ThreadInfo final {
+ public:
+ ThreadInfo(const char* aName, BaseProfilerThreadId aThreadId,
+ bool aIsMainThread,
+ const TimeStamp& aRegisterTime = TimeStamp::Now())
+ : mName(aName),
+ mRegisterTime(aRegisterTime),
+ mThreadId(aThreadId),
+ mIsMainThread(aIsMainThread),
+ mRefCnt(0) {
+ MOZ_ASSERT(aThreadId.IsSpecified(),
+ "Given aThreadId should not be unspecified");
+ }
+
+ // Using hand-rolled ref-counting, because RefCounted.h macros don't produce
+ // the same code between mozglue and libxul, see bug 1536656.
+ MFBT_API void AddRef() const { ++mRefCnt; }
+ MFBT_API void Release() const {
+ MOZ_ASSERT(int32_t(mRefCnt) > 0);
+ if (--mRefCnt == 0) {
+ delete this;
+ }
+ }
+
+ const char* Name() const { return mName.c_str(); }
+ TimeStamp RegisterTime() const { return mRegisterTime; }
+ BaseProfilerThreadId ThreadId() const { return mThreadId; }
+ bool IsMainThread() const { return mIsMainThread; }
+
+ private:
+ const std::string mName;
+ const TimeStamp mRegisterTime;
+ const BaseProfilerThreadId mThreadId;
+ const bool mIsMainThread;
+
+ mutable Atomic<int32_t, MemoryOrdering::ReleaseAcquire> mRefCnt;
+};
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif // ThreadInfo_h
diff --git a/mozglue/baseprofiler/core/VTuneProfiler.cpp b/mozglue/baseprofiler/core/VTuneProfiler.cpp
new file mode 100644
index 0000000000..2911c39f08
--- /dev/null
+++ b/mozglue/baseprofiler/core/VTuneProfiler.cpp
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifdef XP_WIN
+# undef UNICODE
+# undef _UNICODE
+#endif
+
+#include "VTuneProfiler.h"
+
+#include <memory>
+
+#include "BaseProfiler.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+VTuneProfiler* VTuneProfiler::mInstance = nullptr;
+
+void VTuneProfiler::Initialize() {
+ // This is just a 'dirty trick' to find out if the ittnotify DLL was found.
+ // If it wasn't this function always returns 0, otherwise it returns
+ // incrementing numbers, if the library was found this wastes 2 events but
+ // that should be okay.
+ // TODO re-implement here if vtune is needed
+ // __itt_event testEvent =
+ // __itt_event_create("Test event", strlen("Test event"));
+ // testEvent = __itt_event_create("Test event 2", strlen("Test event 2"));
+
+ // if (testEvent) {
+ // mInstance = new VTuneProfiler();
+ // }
+}
+
+void VTuneProfiler::Shutdown() {}
+
+void VTuneProfiler::TraceInternal(const char* aName, TracingKind aKind) {
+ // TODO re-implement here if vtune is needed
+ // std::string str(aName);
+
+ // auto iter = mStrings.find(str);
+
+ // __itt_event event;
+ // if (iter != mStrings.end()) {
+ // event = iter->second;
+ // } else {
+ // event = __itt_event_create(aName, str.length());
+ // mStrings.insert({str, event});
+ // }
+
+ // if (aKind == TRACING_INTERVAL_START || aKind == TRACING_EVENT) {
+ // // VTune will consider starts not matched with an end to be single point
+ // in
+ // // time events.
+ // __itt_event_start(event);
+ // } else {
+ // __itt_event_end(event);
+ // }
+}
+
+void VTuneProfiler::RegisterThreadInternal(const char* aName) {
+ // TODO re-implement here if vtune is needed
+ // std::string str(aName);
+
+ // if (!str.compare("Main Thread (Base Profiler)")) {
+ // // Process main thread.
+ // switch (XRE_GetProcessType()) {
+ // case GeckoProcessType::GeckoProcessType_Default:
+ // __itt_thread_set_name("Main Process");
+ // break;
+ // case GeckoProcessType::GeckoProcessType_Content:
+ // __itt_thread_set_name("Content Process");
+ // break;
+ // case GeckoProcessType::GeckoProcessType_GMPlugin:
+ // __itt_thread_set_name("Plugin Process");
+ // break;
+ // case GeckoProcessType::GeckoProcessType_GPU:
+ // __itt_thread_set_name("GPU Process");
+ // break;
+ // default:
+ // __itt_thread_set_name("Unknown Process");
+ // }
+ // return;
+ // }
+ // __itt_thread_set_name(aName);
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/VTuneProfiler.h b/mozglue/baseprofiler/core/VTuneProfiler.h
new file mode 100644
index 0000000000..cf94ab7242
--- /dev/null
+++ b/mozglue/baseprofiler/core/VTuneProfiler.h
@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef VTuneProfiler_h
+#define VTuneProfiler_h
+
+// The intent here is to add 0 overhead for regular users. In order to build
+// the VTune profiler code at all --enable-vtune-instrumentation needs to be
+// set as a build option. Even then, when none of the environment variables
+// is specified that allow us to find the ittnotify DLL, these functions
+// should be minimal overhead. When starting Firefox under VTune, these
+// env vars will be automatically defined, otherwise INTEL_LIBITTNOTIFY32/64
+// should be set to point at the ittnotify DLL.
+#ifndef MOZ_VTUNE_INSTRUMENTATION
+
+# define VTUNE_INIT()
+# define VTUNE_SHUTDOWN()
+
+# define VTUNE_TRACING(name, kind)
+# define VTUNE_REGISTER_THREAD(name)
+
+#else
+
+# include "BaseProfiler.h"
+
+// This is the regular Intel header, these functions are actually defined for
+// us inside js/src/vtune by an intel C file which actually dynamically resolves
+// them to the correct DLL. Through libxul these will 'magically' resolve.
+# include "vtune/ittnotify.h"
+
+# include <stddef.h>
+# include <unordered_map>
+# include <string>
+
+namespace mozilla {
+namespace baseprofiler {
+
+class VTuneProfiler {
+ public:
+ static void Initialize();
+ static void Shutdown();
+
+ enum TracingKind {
+ TRACING_EVENT,
+ TRACING_INTERVAL_START,
+ TRACING_INTERVAL_END,
+ };
+
+ static void Trace(const char* aName, TracingKind aKind) {
+ if (mInstance) {
+ mInstance->TraceInternal(aName, aKind);
+ }
+ }
+ static void RegisterThread(const char* aName) {
+ if (mInstance) {
+ mInstance->RegisterThreadInternal(aName);
+ }
+ }
+
+ private:
+ void TraceInternal(const char* aName, TracingKind aKind);
+ void RegisterThreadInternal(const char* aName);
+
+ // This is null when the ittnotify DLL could not be found.
+ static VTuneProfiler* mInstance;
+
+ std::unordered_map<std::string, __itt_event> mStrings;
+};
+
+# define VTUNE_INIT() VTuneProfiler::Initialize()
+# define VTUNE_SHUTDOWN() VTuneProfiler::Shutdown()
+
+# define VTUNE_TRACING(name, kind) VTuneProfiler::Trace(name, kind)
+# define VTUNE_REGISTER_THREAD(name) VTuneProfiler::RegisterThread(name)
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif
+
+#endif /* VTuneProfiler_h */
diff --git a/mozglue/baseprofiler/core/platform-linux-android.cpp b/mozglue/baseprofiler/core/platform-linux-android.cpp
new file mode 100644
index 0000000000..7921d9f4fd
--- /dev/null
+++ b/mozglue/baseprofiler/core/platform-linux-android.cpp
@@ -0,0 +1,507 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+// Copyright (c) 2006-2011 The Chromium 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.
+// * Neither the name of Google, Inc. nor the names of its contributors
+// may be used to endorse or promote products derived from this
+// software without specific prior written permission.
+//
+// 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 OWNER 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.
+
+// This file is used for both Linux and Android.
+
+#include <stdio.h>
+#include <math.h>
+
+#include <pthread.h>
+#if defined(GP_OS_freebsd)
+# include <sys/thr.h>
+#endif
+#include <semaphore.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <sched.h>
+#include <ucontext.h>
+// Ubuntu Dapper requires memory pages to be marked as
+// executable. Otherwise, OS raises an exception when executing code
+// in that page.
+#include <sys/types.h> // mmap & munmap
+#include <sys/mman.h> // mmap & munmap
+#include <sys/stat.h> // open
+#include <fcntl.h> // open
+#include <unistd.h> // sysconf
+#include <semaphore.h>
+#ifdef __GLIBC__
+# include <execinfo.h> // backtrace, backtrace_symbols
+#endif // def __GLIBC__
+#include <strings.h> // index
+#include <errno.h>
+#include <stdarg.h>
+
+#include "prenv.h"
+#include "mozilla/PodOperations.h"
+#include "mozilla/DebugOnly.h"
+
+#include <string.h>
+#include <list>
+
+using namespace mozilla;
+
+namespace mozilla {
+namespace baseprofiler {
+
+static int64_t MicrosecondsSince1970() {
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ return int64_t(tv.tv_sec) * 1000000 + int64_t(tv.tv_usec);
+}
+
+void* GetStackTop(void* aGuess) { return aGuess; }
+
+static void PopulateRegsFromContext(Registers& aRegs, ucontext_t* aContext) {
+ aRegs.mContext = aContext;
+ mcontext_t& mcontext = aContext->uc_mcontext;
+
+ // Extracting the sample from the context is extremely machine dependent.
+#if defined(GP_PLAT_x86_linux) || defined(GP_PLAT_x86_android)
+ aRegs.mPC = reinterpret_cast<Address>(mcontext.gregs[REG_EIP]);
+ aRegs.mSP = reinterpret_cast<Address>(mcontext.gregs[REG_ESP]);
+ aRegs.mFP = reinterpret_cast<Address>(mcontext.gregs[REG_EBP]);
+ aRegs.mLR = 0;
+#elif defined(GP_PLAT_amd64_linux) || defined(GP_PLAT_amd64_android)
+ aRegs.mPC = reinterpret_cast<Address>(mcontext.gregs[REG_RIP]);
+ aRegs.mSP = reinterpret_cast<Address>(mcontext.gregs[REG_RSP]);
+ aRegs.mFP = reinterpret_cast<Address>(mcontext.gregs[REG_RBP]);
+ aRegs.mLR = 0;
+#elif defined(GP_PLAT_amd64_freebsd)
+ aRegs.mPC = reinterpret_cast<Address>(mcontext.mc_rip);
+ aRegs.mSP = reinterpret_cast<Address>(mcontext.mc_rsp);
+ aRegs.mFP = reinterpret_cast<Address>(mcontext.mc_rbp);
+ aRegs.mLR = 0;
+#elif defined(GP_PLAT_arm_linux) || defined(GP_PLAT_arm_android)
+ aRegs.mPC = reinterpret_cast<Address>(mcontext.arm_pc);
+ aRegs.mSP = reinterpret_cast<Address>(mcontext.arm_sp);
+ aRegs.mFP = reinterpret_cast<Address>(mcontext.arm_fp);
+ aRegs.mLR = reinterpret_cast<Address>(mcontext.arm_lr);
+#elif defined(GP_PLAT_arm64_linux) || defined(GP_PLAT_arm64_android)
+ aRegs.mPC = reinterpret_cast<Address>(mcontext.pc);
+ aRegs.mSP = reinterpret_cast<Address>(mcontext.sp);
+ aRegs.mFP = reinterpret_cast<Address>(mcontext.regs[29]);
+ aRegs.mLR = reinterpret_cast<Address>(mcontext.regs[30]);
+#elif defined(GP_PLAT_arm64_freebsd)
+ aRegs.mPC = reinterpret_cast<Address>(mcontext.mc_gpregs.gp_elr);
+ aRegs.mSP = reinterpret_cast<Address>(mcontext.mc_gpregs.gp_sp);
+ aRegs.mFP = reinterpret_cast<Address>(mcontext.mc_gpregs.gp_x[29]);
+ aRegs.mLR = reinterpret_cast<Address>(mcontext.mc_gpregs.gp_lr);
+#elif defined(GP_PLAT_mips64_linux) || defined(GP_PLAT_mips64_android)
+ aRegs.mPC = reinterpret_cast<Address>(mcontext.pc);
+ aRegs.mSP = reinterpret_cast<Address>(mcontext.gregs[29]);
+ aRegs.mFP = reinterpret_cast<Address>(mcontext.gregs[30]);
+
+#else
+# error "bad platform"
+#endif
+}
+
+#if defined(GP_OS_android)
+# define SYS_tgkill __NR_tgkill
+#endif
+
+#if defined(GP_OS_linux) || defined(GP_OS_android)
+int tgkill(pid_t tgid, pid_t tid, int signalno) {
+ return syscall(SYS_tgkill, tgid, tid, signalno);
+}
+#endif
+
+#if defined(GP_OS_freebsd)
+# define tgkill thr_kill2
+#endif
+
+class PlatformData {
+ public:
+ explicit PlatformData(BaseProfilerThreadId aThreadId) {}
+
+ ~PlatformData() {}
+};
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN Sampler target specifics
+
+// The only way to reliably interrupt a Linux thread and inspect its register
+// and stack state is by sending a signal to it, and doing the work inside the
+// signal handler. But we don't want to run much code inside the signal
+// handler, since POSIX severely restricts what we can do in signal handlers.
+// So we use a system of semaphores to suspend the thread and allow the
+// sampler thread to do all the work of unwinding and copying out whatever
+// data it wants.
+//
+// A four-message protocol is used to reliably suspend and later resume the
+// thread to be sampled (the samplee):
+//
+// Sampler (signal sender) thread Samplee (thread to be sampled)
+//
+// Prepare the SigHandlerCoordinator
+// and point sSigHandlerCoordinator at it
+//
+// send SIGPROF to samplee ------- MSG 1 ----> (enter signal handler)
+// wait(mMessage2) Copy register state
+// into sSigHandlerCoordinator
+// <------ MSG 2 ----- post(mMessage2)
+// Samplee is now suspended. wait(mMessage3)
+// Examine its stack/register
+// state at leisure
+//
+// Release samplee:
+// post(mMessage3) ------- MSG 3 ----->
+// wait(mMessage4) Samplee now resumes. Tell
+// the sampler that we are done.
+// <------ MSG 4 ------ post(mMessage4)
+// Now we know the samplee's signal (leave signal handler)
+// handler has finished using
+// sSigHandlerCoordinator. We can
+// safely reuse it for some other thread.
+//
+
+// A type used to coordinate between the sampler (signal sending) thread and
+// the thread currently being sampled (the samplee, which receives the
+// signals).
+//
+// The first message is sent using a SIGPROF signal delivery. The subsequent
+// three are sent using sem_wait/sem_post pairs. They are named accordingly
+// in the following struct.
+struct SigHandlerCoordinator {
+ SigHandlerCoordinator() {
+ PodZero(&mUContext);
+ int r = sem_init(&mMessage2, /* pshared */ 0, 0);
+ r |= sem_init(&mMessage3, /* pshared */ 0, 0);
+ r |= sem_init(&mMessage4, /* pshared */ 0, 0);
+ MOZ_ASSERT(r == 0);
+ (void)r;
+ }
+
+ ~SigHandlerCoordinator() {
+ int r = sem_destroy(&mMessage2);
+ r |= sem_destroy(&mMessage3);
+ r |= sem_destroy(&mMessage4);
+ MOZ_ASSERT(r == 0);
+ (void)r;
+ }
+
+ sem_t mMessage2; // To sampler: "context is in sSigHandlerCoordinator"
+ sem_t mMessage3; // To samplee: "resume"
+ sem_t mMessage4; // To sampler: "finished with sSigHandlerCoordinator"
+ ucontext_t mUContext; // Context at signal
+};
+
+struct SigHandlerCoordinator* Sampler::sSigHandlerCoordinator = nullptr;
+
+static void SigprofHandler(int aSignal, siginfo_t* aInfo, void* aContext) {
+ // Avoid TSan warning about clobbering errno.
+ int savedErrno = errno;
+
+ MOZ_ASSERT(aSignal == SIGPROF);
+ MOZ_ASSERT(Sampler::sSigHandlerCoordinator);
+
+ // By sending us this signal, the sampler thread has sent us message 1 in
+ // the comment above, with the meaning "|sSigHandlerCoordinator| is ready
+ // for use, please copy your register context into it."
+ Sampler::sSigHandlerCoordinator->mUContext =
+ *static_cast<ucontext_t*>(aContext);
+
+ // Send message 2: tell the sampler thread that the context has been copied
+ // into |sSigHandlerCoordinator->mUContext|. sem_post can never fail by
+ // being interrupted by a signal, so there's no loop around this call.
+ int r = sem_post(&Sampler::sSigHandlerCoordinator->mMessage2);
+ MOZ_ASSERT(r == 0);
+
+ // At this point, the sampler thread assumes we are suspended, so we must
+ // not touch any global state here.
+
+ // Wait for message 3: the sampler thread tells us to resume.
+ while (true) {
+ r = sem_wait(&Sampler::sSigHandlerCoordinator->mMessage3);
+ if (r == -1 && errno == EINTR) {
+ // Interrupted by a signal. Try again.
+ continue;
+ }
+ // We don't expect any other kind of failure
+ MOZ_ASSERT(r == 0);
+ break;
+ }
+
+ // Send message 4: tell the sampler thread that we are finished accessing
+ // |sSigHandlerCoordinator|. After this point it is not safe to touch
+ // |sSigHandlerCoordinator|.
+ r = sem_post(&Sampler::sSigHandlerCoordinator->mMessage4);
+ MOZ_ASSERT(r == 0);
+
+ errno = savedErrno;
+}
+
+Sampler::Sampler(PSLockRef aLock) : mMyPid(profiler_current_process_id()) {
+#if defined(USE_EHABI_STACKWALK)
+ EHABIStackWalkInit();
+#endif
+
+ // NOTE: We don't initialize LUL here, instead initializing it in
+ // SamplerThread's constructor. This is because with the
+ // profiler_suspend_and_sample_thread entry point, we want to be able to
+ // sample without waiting for LUL to be initialized.
+
+ // Request profiling signals.
+ struct sigaction sa;
+ sa.sa_sigaction = SigprofHandler;
+ sigemptyset(&sa.sa_mask);
+ sa.sa_flags = SA_RESTART | SA_SIGINFO;
+ if (sigaction(SIGPROF, &sa, &mOldSigprofHandler) != 0) {
+ MOZ_CRASH("Error installing SIGPROF handler in the profiler");
+ }
+}
+
+void Sampler::Disable(PSLockRef aLock) {
+ // Restore old signal handler. This is global state so it's important that
+ // we do it now, while gPSMutex is locked.
+ sigaction(SIGPROF, &mOldSigprofHandler, 0);
+}
+
+template <typename Func>
+void Sampler::SuspendAndSampleAndResumeThread(
+ PSLockRef aLock, const RegisteredThread& aRegisteredThread,
+ const TimeStamp& aNow, const Func& aProcessRegs) {
+ // Only one sampler thread can be sampling at once. So we expect to have
+ // complete control over |sSigHandlerCoordinator|.
+ MOZ_ASSERT(!sSigHandlerCoordinator);
+
+ if (!mSamplerTid.IsSpecified()) {
+ mSamplerTid = profiler_current_thread_id();
+ }
+ BaseProfilerThreadId sampleeTid = aRegisteredThread.Info()->ThreadId();
+ MOZ_RELEASE_ASSERT(sampleeTid != mSamplerTid);
+
+ //----------------------------------------------------------------//
+ // Suspend the samplee thread and get its context.
+
+ SigHandlerCoordinator coord; // on sampler thread's stack
+ sSigHandlerCoordinator = &coord;
+
+ // Send message 1 to the samplee (the thread to be sampled), by
+ // signalling at it.
+ // This could fail if the thread doesn't exist anymore.
+ int r = tgkill(mMyPid.ToNumber(), sampleeTid.ToNumber(), SIGPROF);
+ if (r == 0) {
+ // Wait for message 2 from the samplee, indicating that the context
+ // is available and that the thread is suspended.
+ while (true) {
+ r = sem_wait(&sSigHandlerCoordinator->mMessage2);
+ if (r == -1 && errno == EINTR) {
+ // Interrupted by a signal. Try again.
+ continue;
+ }
+ // We don't expect any other kind of failure.
+ MOZ_ASSERT(r == 0);
+ break;
+ }
+
+ //----------------------------------------------------------------//
+ // Sample the target thread.
+
+ // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+ //
+ // The profiler's "critical section" begins here. In the critical section,
+ // we must not do any dynamic memory allocation, nor try to acquire any lock
+ // or any other unshareable resource. This is because the thread to be
+ // sampled has been suspended at some entirely arbitrary point, and we have
+ // no idea which unsharable resources (locks, essentially) it holds. So any
+ // attempt to acquire any lock, including the implied locks used by the
+ // malloc implementation, risks deadlock. This includes TimeStamp::Now(),
+ // which gets a lock on Windows.
+
+ // The samplee thread is now frozen and sSigHandlerCoordinator->mUContext is
+ // valid. We can poke around in it and unwind its stack as we like.
+
+ // Extract the current register values.
+ Registers regs;
+ PopulateRegsFromContext(regs, &sSigHandlerCoordinator->mUContext);
+ aProcessRegs(regs, aNow);
+
+ //----------------------------------------------------------------//
+ // Resume the target thread.
+
+ // Send message 3 to the samplee, which tells it to resume.
+ r = sem_post(&sSigHandlerCoordinator->mMessage3);
+ MOZ_ASSERT(r == 0);
+
+ // Wait for message 4 from the samplee, which tells us that it has
+ // finished with |sSigHandlerCoordinator|.
+ while (true) {
+ r = sem_wait(&sSigHandlerCoordinator->mMessage4);
+ if (r == -1 && errno == EINTR) {
+ continue;
+ }
+ MOZ_ASSERT(r == 0);
+ break;
+ }
+
+ // The profiler's critical section ends here. After this point, none of the
+ // critical section limitations documented above apply.
+ //
+ // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+ }
+
+ // This isn't strictly necessary, but doing so does help pick up anomalies
+ // in which the signal handler is running when it shouldn't be.
+ sSigHandlerCoordinator = nullptr;
+}
+
+// END Sampler target specifics
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN SamplerThread target specifics
+
+static void* ThreadEntry(void* aArg) {
+ auto thread = static_cast<SamplerThread*>(aArg);
+ thread->Run();
+ return nullptr;
+}
+
+SamplerThread::SamplerThread(PSLockRef aLock, uint32_t aActivityGeneration,
+ double aIntervalMilliseconds, uint32_t aFeatures)
+ : mSampler(aLock),
+ mActivityGeneration(aActivityGeneration),
+ mIntervalMicroseconds(
+ std::max(1, int(floor(aIntervalMilliseconds * 1000 + 0.5)))) {
+#if defined(USE_LUL_STACKWALK)
+ lul::LUL* lul = CorePS::Lul(aLock);
+ if (!lul && ProfilerFeature::HasStackWalkEnabled(aFeatures)) {
+ CorePS::SetLul(aLock, MakeUnique<lul::LUL>(logging_sink_for_LUL));
+ // Read all the unwind info currently available.
+ lul = CorePS::Lul(aLock);
+ read_procmaps(lul);
+
+ // Switch into unwind mode. After this point, we can't add or remove any
+ // unwind info to/from this LUL instance. The only thing we can do with
+ // it is Unwind() calls.
+ lul->EnableUnwinding();
+
+ // Has a test been requested?
+ if (getenv("MOZ_PROFILER_LUL_TEST")) {
+ int nTests = 0, nTestsPassed = 0;
+ RunLulUnitTests(&nTests, &nTestsPassed, lul);
+ }
+ }
+#endif
+
+ // Start the sampling thread. It repeatedly sends a SIGPROF signal. Sending
+ // the signal ourselves instead of relying on itimer provides much better
+ // accuracy.
+ if (pthread_create(&mThread, nullptr, ThreadEntry, this) != 0) {
+ MOZ_CRASH("pthread_create failed");
+ }
+}
+
+SamplerThread::~SamplerThread() { pthread_join(mThread, nullptr); }
+
+void SamplerThread::SleepMicro(uint32_t aMicroseconds) {
+ if (aMicroseconds >= 1000000) {
+ // Use usleep for larger intervals, because the nanosleep
+ // code below only supports intervals < 1 second.
+ MOZ_ALWAYS_TRUE(!::usleep(aMicroseconds));
+ return;
+ }
+
+ struct timespec ts;
+ ts.tv_sec = 0;
+ ts.tv_nsec = aMicroseconds * 1000UL;
+
+ int rv = ::nanosleep(&ts, &ts);
+
+ while (rv != 0 && errno == EINTR) {
+ // Keep waiting in case of interrupt.
+ // nanosleep puts the remaining time back into ts.
+ rv = ::nanosleep(&ts, &ts);
+ }
+
+ MOZ_ASSERT(!rv, "nanosleep call failed");
+}
+
+void SamplerThread::Stop(PSLockRef aLock) {
+ // Restore old signal handler. This is global state so it's important that
+ // we do it now, while gPSMutex is locked. It's safe to do this now even
+ // though this SamplerThread is still alive, because the next time the main
+ // loop of Run() iterates it won't get past the mActivityGeneration check,
+ // and so won't send any signals.
+ mSampler.Disable(aLock);
+}
+
+// END SamplerThread target specifics
+////////////////////////////////////////////////////////////////////////
+
+#if defined(GP_OS_linux) || defined(GP_OS_freebsd)
+
+// We use pthread_atfork() to temporarily disable signal delivery during any
+// fork() call. Without that, fork() can be repeatedly interrupted by signal
+// delivery, requiring it to be repeatedly restarted, which can lead to *long*
+// delays. See bug 837390.
+//
+// We provide no paf_child() function to run in the child after forking. This
+// is fine because we always immediately exec() after fork(), and exec()
+// clobbers all process state. Also, we don't want the sampler to resume in the
+// child process between fork() and exec(), it would be wasteful.
+//
+// Unfortunately all this is only doable on non-Android because Bionic doesn't
+// have pthread_atfork.
+
+// In the parent, before the fork, increase gSkipSampling to ensure that
+// profiler sampling loops will be skipped. There could be one in progress now,
+// causing a small delay, but further sampling will be skipped, allowing `fork`
+// to complete.
+static void paf_prepare() { ++gSkipSampling; }
+
+// In the parent, after the fork, decrease gSkipSampling to let the sampler
+// resume sampling (unless other places have made it non-zero as well).
+static void paf_parent() { --gSkipSampling; }
+
+static void PlatformInit(PSLockRef aLock) {
+ // Set up the fork handlers.
+ pthread_atfork(paf_prepare, paf_parent, nullptr);
+}
+
+#else
+
+static void PlatformInit(PSLockRef aLock) {}
+
+#endif
+
+#if defined(HAVE_NATIVE_UNWIND)
+// TODO port getcontext from breakpad, if profiler_get_backtrace is needed.
+# define REGISTERS_SYNC_POPULATE(regs) \
+ MOZ_CRASH("profiler_get_backtrace() unsupported");
+#endif
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/platform-macos.cpp b/mozglue/baseprofiler/core/platform-macos.cpp
new file mode 100644
index 0000000000..6e6e801f1f
--- /dev/null
+++ b/mozglue/baseprofiler/core/platform-macos.cpp
@@ -0,0 +1,220 @@
+/* -*- 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/. */
+
+#include <unistd.h>
+#include <sys/mman.h>
+#include <mach/mach_init.h>
+#include <mach-o/getsect.h>
+
+#include <AvailabilityMacros.h>
+
+#include <pthread.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <libkern/OSAtomic.h>
+#include <mach/mach.h>
+#include <mach/semaphore.h>
+#include <mach/task.h>
+#include <mach/thread_act.h>
+#include <mach/vm_statistics.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <math.h>
+
+// this port is based off of v8 svn revision 9837
+
+namespace mozilla {
+namespace baseprofiler {
+
+static int64_t MicrosecondsSince1970() {
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ return int64_t(tv.tv_sec) * 1000000 + int64_t(tv.tv_usec);
+}
+
+void* GetStackTop(void* aGuess) {
+ pthread_t thread = pthread_self();
+ return pthread_get_stackaddr_np(thread);
+}
+
+class PlatformData {
+ public:
+ explicit PlatformData(BaseProfilerThreadId aThreadId)
+ : mProfiledThread(mach_thread_self()) {}
+
+ ~PlatformData() {
+ // Deallocate Mach port for thread.
+ mach_port_deallocate(mach_task_self(), mProfiledThread);
+ }
+
+ thread_act_t ProfiledThread() { return mProfiledThread; }
+
+ private:
+ // Note: for mProfiledThread Mach primitives are used instead of pthread's
+ // because the latter doesn't provide thread manipulation primitives required.
+ // For details, consult "Mac OS X Internals" book, Section 7.3.
+ thread_act_t mProfiledThread;
+};
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN Sampler target specifics
+
+Sampler::Sampler(PSLockRef aLock) {}
+
+void Sampler::Disable(PSLockRef aLock) {}
+
+template <typename Func>
+void Sampler::SuspendAndSampleAndResumeThread(
+ PSLockRef aLock, const RegisteredThread& aRegisteredThread,
+ const TimeStamp& aNow, const Func& aProcessRegs) {
+ thread_act_t samplee_thread =
+ aRegisteredThread.GetPlatformData()->ProfiledThread();
+
+ //----------------------------------------------------------------//
+ // Suspend the samplee thread and get its context.
+
+ // We're using thread_suspend on OS X because pthread_kill (which is what we
+ // at one time used on Linux) has less consistent performance and causes
+ // strange crashes, see bug 1166778 and bug 1166808. thread_suspend
+ // is also just a lot simpler to use.
+
+ if (KERN_SUCCESS != thread_suspend(samplee_thread)) {
+ return;
+ }
+
+ //----------------------------------------------------------------//
+ // Sample the target thread.
+
+ // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+ //
+ // The profiler's "critical section" begins here. We must be very careful
+ // what we do here, or risk deadlock. See the corresponding comment in
+ // platform-linux-android.cpp for details.
+
+#if defined(__x86_64__)
+ thread_state_flavor_t flavor = x86_THREAD_STATE64;
+ x86_thread_state64_t state;
+ mach_msg_type_number_t count = x86_THREAD_STATE64_COUNT;
+# if __DARWIN_UNIX03
+# define REGISTER_FIELD(name) __r##name
+# else
+# define REGISTER_FIELD(name) r##name
+# endif // __DARWIN_UNIX03
+#elif defined(__aarch64__)
+ thread_state_flavor_t flavor = ARM_THREAD_STATE64;
+ arm_thread_state64_t state;
+ mach_msg_type_number_t count = ARM_THREAD_STATE64_COUNT;
+# if __DARWIN_UNIX03
+# define REGISTER_FIELD(name) __##name
+# else
+# define REGISTER_FIELD(name) name
+# endif // __DARWIN_UNIX03
+#else
+# error "unknown architecture"
+#endif
+
+ if (thread_get_state(samplee_thread, flavor,
+ reinterpret_cast<natural_t*>(&state),
+ &count) == KERN_SUCCESS) {
+ Registers regs;
+#if defined(__x86_64__)
+ regs.mPC = reinterpret_cast<Address>(state.REGISTER_FIELD(ip));
+ regs.mSP = reinterpret_cast<Address>(state.REGISTER_FIELD(sp));
+ regs.mFP = reinterpret_cast<Address>(state.REGISTER_FIELD(bp));
+ regs.mLR = 0;
+#elif defined(__aarch64__)
+ regs.mPC = reinterpret_cast<Address>(state.REGISTER_FIELD(pc));
+ regs.mSP = reinterpret_cast<Address>(state.REGISTER_FIELD(sp));
+ regs.mFP = reinterpret_cast<Address>(state.REGISTER_FIELD(fp));
+ regs.mLR = reinterpret_cast<Address>(state.REGISTER_FIELD(lr));
+#else
+# error "unknown architecture"
+#endif
+
+ aProcessRegs(regs, aNow);
+ }
+
+#undef REGISTER_FIELD
+
+ //----------------------------------------------------------------//
+ // Resume the target thread.
+
+ thread_resume(samplee_thread);
+
+ // The profiler's critical section ends here.
+ //
+ // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+}
+
+// END Sampler target specifics
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN SamplerThread target specifics
+
+static void* ThreadEntry(void* aArg) {
+ auto thread = static_cast<SamplerThread*>(aArg);
+ thread->Run();
+ return nullptr;
+}
+
+SamplerThread::SamplerThread(PSLockRef aLock, uint32_t aActivityGeneration,
+ double aIntervalMilliseconds, uint32_t aFeatures)
+ : mSampler(aLock),
+ mActivityGeneration(aActivityGeneration),
+ mIntervalMicroseconds(
+ std::max(1, int(floor(aIntervalMilliseconds * 1000 + 0.5)))),
+ mThread{nullptr} {
+ pthread_attr_t* attr_ptr = nullptr;
+ if (pthread_create(&mThread, attr_ptr, ThreadEntry, this) != 0) {
+ MOZ_CRASH("pthread_create failed");
+ }
+}
+
+SamplerThread::~SamplerThread() { pthread_join(mThread, nullptr); }
+
+void SamplerThread::SleepMicro(uint32_t aMicroseconds) {
+ usleep(aMicroseconds);
+ // FIXME: the OSX 10.12 page for usleep says "The usleep() function is
+ // obsolescent. Use nanosleep(2) instead." This implementation could be
+ // merged with the linux-android version. Also, this doesn't handle the
+ // case where the usleep call is interrupted by a signal.
+}
+
+void SamplerThread::Stop(PSLockRef aLock) { mSampler.Disable(aLock); }
+
+// END SamplerThread target specifics
+////////////////////////////////////////////////////////////////////////
+
+static void PlatformInit(PSLockRef aLock) {}
+
+// clang-format off
+#if defined(HAVE_NATIVE_UNWIND)
+// Derive the stack pointer from the frame pointer. The 0x10 offset is
+// 8 bytes for the previous frame pointer and 8 bytes for the return
+// address both stored on the stack after at the beginning of the current
+// frame.
+# define REGISTERS_SYNC_POPULATE(regs) \
+ regs.mSP = reinterpret_cast<Address>(__builtin_frame_address(0)) + 0x10; \
+ _Pragma("GCC diagnostic push") \
+ _Pragma("GCC diagnostic ignored \"-Wframe-address\"") \
+ regs.mFP = reinterpret_cast<Address>(__builtin_frame_address(1)); \
+ _Pragma("GCC diagnostic pop") \
+ regs.mPC = reinterpret_cast<Address>( \
+ __builtin_extract_return_addr(__builtin_return_address(0))); \
+ regs.mLR = 0;
+#endif
+// clang-format on
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/platform-win32.cpp b/mozglue/baseprofiler/core/platform-win32.cpp
new file mode 100644
index 0000000000..808bd9d618
--- /dev/null
+++ b/mozglue/baseprofiler/core/platform-win32.cpp
@@ -0,0 +1,348 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+// Copyright (c) 2006-2011 The Chromium 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.
+// * Neither the name of Google, Inc. nor the names of its contributors
+// may be used to endorse or promote products derived from this
+// software without specific prior written permission.
+//
+// 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 OWNER 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.
+
+#include <windows.h>
+#include <mmsystem.h>
+#include <process.h>
+
+#include "nsWindowsDllInterceptor.h"
+#include "mozilla/StackWalk_windows.h"
+#include "mozilla/WindowsVersion.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+static int64_t MicrosecondsSince1970() {
+ int64_t prt;
+ FILETIME ft;
+ SYSTEMTIME st;
+
+ GetSystemTime(&st);
+ SystemTimeToFileTime(&st, &ft);
+ static_assert(sizeof(ft) == sizeof(prt), "Expect FILETIME to be 64 bits");
+ memcpy(&prt, &ft, sizeof(prt));
+ const int64_t epochBias = 116444736000000000LL;
+ prt = (prt - epochBias) / 10;
+
+ return prt;
+}
+
+void* GetStackTop(void* aGuess) {
+ PNT_TIB pTib = reinterpret_cast<PNT_TIB>(NtCurrentTeb());
+ return reinterpret_cast<void*>(pTib->StackBase);
+}
+
+static void PopulateRegsFromContext(Registers& aRegs, CONTEXT* aContext) {
+#if defined(GP_ARCH_amd64)
+ aRegs.mPC = reinterpret_cast<Address>(aContext->Rip);
+ aRegs.mSP = reinterpret_cast<Address>(aContext->Rsp);
+ aRegs.mFP = reinterpret_cast<Address>(aContext->Rbp);
+ aRegs.mLR = 0;
+#elif defined(GP_ARCH_x86)
+ aRegs.mPC = reinterpret_cast<Address>(aContext->Eip);
+ aRegs.mSP = reinterpret_cast<Address>(aContext->Esp);
+ aRegs.mFP = reinterpret_cast<Address>(aContext->Ebp);
+ aRegs.mLR = 0;
+#elif defined(GP_ARCH_arm64)
+ aRegs.mPC = reinterpret_cast<Address>(aContext->Pc);
+ aRegs.mSP = reinterpret_cast<Address>(aContext->Sp);
+ aRegs.mFP = reinterpret_cast<Address>(aContext->Fp);
+ aRegs.mLR = reinterpret_cast<Address>(aContext->Lr);
+#else
+# error "bad arch"
+#endif
+}
+
+// Gets a real (i.e. not pseudo) handle for the current thread, with the
+// permissions needed for profiling.
+// @return a real HANDLE for the current thread.
+static HANDLE GetRealCurrentThreadHandleForProfiling() {
+ HANDLE realCurrentThreadHandle;
+ if (!::DuplicateHandle(
+ ::GetCurrentProcess(), ::GetCurrentThread(), ::GetCurrentProcess(),
+ &realCurrentThreadHandle,
+ THREAD_GET_CONTEXT | THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION,
+ FALSE, 0)) {
+ return nullptr;
+ }
+
+ return realCurrentThreadHandle;
+}
+
+class PlatformData {
+ public:
+ // Get a handle to the calling thread. This is the thread that we are
+ // going to profile. We need a real handle because we are going to use it in
+ // the sampler thread.
+ explicit PlatformData(BaseProfilerThreadId aThreadId)
+ : mProfiledThread(GetRealCurrentThreadHandleForProfiling()) {
+ MOZ_ASSERT(DWORD(aThreadId.ToNumber()) == ::GetCurrentThreadId());
+ }
+
+ ~PlatformData() {
+ if (mProfiledThread != nullptr) {
+ CloseHandle(mProfiledThread);
+ mProfiledThread = nullptr;
+ }
+ }
+
+ HANDLE ProfiledThread() { return mProfiledThread; }
+
+ private:
+ HANDLE mProfiledThread;
+};
+
+#if defined(USE_MOZ_STACK_WALK)
+HANDLE
+GetThreadHandle(PlatformData* aData) { return aData->ProfiledThread(); }
+#endif
+
+static const HANDLE kNoThread = INVALID_HANDLE_VALUE;
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN Sampler target specifics
+
+Sampler::Sampler(PSLockRef aLock) {}
+
+void Sampler::Disable(PSLockRef aLock) {}
+
+template <typename Func>
+void Sampler::SuspendAndSampleAndResumeThread(
+ PSLockRef aLock, const RegisteredThread& aRegisteredThread,
+ const TimeStamp& aNow, const Func& aProcessRegs) {
+ HANDLE profiled_thread =
+ aRegisteredThread.GetPlatformData()->ProfiledThread();
+ if (profiled_thread == nullptr) {
+ return;
+ }
+
+ // Context used for sampling the register state of the profiled thread.
+ CONTEXT context;
+ memset(&context, 0, sizeof(context));
+
+ //----------------------------------------------------------------//
+ // Suspend the samplee thread and get its context.
+
+ static const DWORD kSuspendFailed = static_cast<DWORD>(-1);
+ if (SuspendThread(profiled_thread) == kSuspendFailed) {
+ return;
+ }
+
+ // SuspendThread is asynchronous, so the thread may still be running.
+ // Call GetThreadContext first to ensure the thread is really suspended.
+ // See https://blogs.msdn.microsoft.com/oldnewthing/20150205-00/?p=44743.
+
+ // Using only CONTEXT_CONTROL is faster but on 64-bit it causes crashes in
+ // RtlVirtualUnwind (see bug 1120126) so we set all the flags.
+#if defined(GP_ARCH_amd64)
+ context.ContextFlags = CONTEXT_FULL;
+#else
+ context.ContextFlags = CONTEXT_CONTROL;
+#endif
+ if (!GetThreadContext(profiled_thread, &context)) {
+ ResumeThread(profiled_thread);
+ return;
+ }
+
+ //----------------------------------------------------------------//
+ // Sample the target thread.
+
+ // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+ //
+ // The profiler's "critical section" begins here. We must be very careful
+ // what we do here, or risk deadlock. See the corresponding comment in
+ // platform-linux-android.cpp for details.
+
+ Registers regs;
+ PopulateRegsFromContext(regs, &context);
+ aProcessRegs(regs, aNow);
+
+ //----------------------------------------------------------------//
+ // Resume the target thread.
+
+ ResumeThread(profiled_thread);
+
+ // The profiler's critical section ends here.
+ //
+ // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+}
+
+// END Sampler target specifics
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN SamplerThread target specifics
+
+static unsigned int __stdcall ThreadEntry(void* aArg) {
+ auto thread = static_cast<SamplerThread*>(aArg);
+ thread->Run();
+ return 0;
+}
+
+SamplerThread::SamplerThread(PSLockRef aLock, uint32_t aActivityGeneration,
+ double aIntervalMilliseconds, uint32_t aFeatures)
+ : mSampler(aLock),
+ mActivityGeneration(aActivityGeneration),
+ mIntervalMicroseconds(
+ std::max(1, int(floor(aIntervalMilliseconds * 1000 + 0.5)))),
+ mNoTimerResolutionChange(
+ ProfilerFeature::HasNoTimerResolutionChange(aFeatures)) {
+ if ((!mNoTimerResolutionChange) && (mIntervalMicroseconds < 10 * 1000)) {
+ // By default the timer resolution (which tends to be 1/64Hz, around 16ms)
+ // is not changed. However, if the requested interval is sufficiently low,
+ // the resolution will be adjusted to match. Note that this affects all
+ // timers in Firefox, and could therefore hide issues while profiling. This
+ // change may be prevented with the "notimerresolutionchange" feature.
+ ::timeBeginPeriod(mIntervalMicroseconds / 1000);
+ }
+
+ // Create a new thread. It is important to use _beginthreadex() instead of
+ // the Win32 function CreateThread(), because the CreateThread() does not
+ // initialize thread-specific structures in the C runtime library.
+ mThread = reinterpret_cast<HANDLE>(_beginthreadex(nullptr,
+ /* stack_size */ 0,
+ ThreadEntry, this,
+ /* initflag */ 0, nullptr));
+ if (mThread == 0) {
+ MOZ_CRASH("_beginthreadex failed");
+ }
+}
+
+SamplerThread::~SamplerThread() {
+ WaitForSingleObject(mThread, INFINITE);
+
+ // Close our own handle for the thread.
+ if (mThread != kNoThread) {
+ CloseHandle(mThread);
+ }
+}
+
+void SamplerThread::SleepMicro(uint32_t aMicroseconds) {
+ // For now, keep the old behaviour of minimum Sleep(1), even for
+ // smaller-than-usual sleeps after an overshoot, unless the user has
+ // explicitly opted into a sub-millisecond profiler interval.
+ if (mIntervalMicroseconds >= 1000) {
+ ::Sleep(std::max(1u, aMicroseconds / 1000));
+ } else {
+ TimeStamp start = TimeStamp::Now();
+ TimeStamp end = start + TimeDuration::FromMicroseconds(aMicroseconds);
+
+ // First, sleep for as many whole milliseconds as possible.
+ if (aMicroseconds >= 1000) {
+ ::Sleep(aMicroseconds / 1000);
+ }
+
+ // Then, spin until enough time has passed.
+ while (TimeStamp::Now() < end) {
+ YieldProcessor();
+ }
+ }
+}
+
+void SamplerThread::Stop(PSLockRef aLock) {
+ if ((!mNoTimerResolutionChange) && (mIntervalMicroseconds < 10 * 1000)) {
+ // Disable any timer resolution changes we've made. Do it now while
+ // gPSMutex is locked, i.e. before any other SamplerThread can be created
+ // and call ::timeBeginPeriod().
+ //
+ // It's safe to do this now even though this SamplerThread is still alive,
+ // because the next time the main loop of Run() iterates it won't get past
+ // the mActivityGeneration check, and so it won't make any more ::Sleep()
+ // calls.
+ ::timeEndPeriod(mIntervalMicroseconds / 1000);
+ }
+
+ mSampler.Disable(aLock);
+}
+
+// END SamplerThread target specifics
+////////////////////////////////////////////////////////////////////////
+
+static void PlatformInit(PSLockRef aLock) {}
+
+#if defined(HAVE_NATIVE_UNWIND)
+# define REGISTERS_SYNC_POPULATE(regs) \
+ CONTEXT context; \
+ RtlCaptureContext(&context); \
+ PopulateRegsFromContext(regs, &context);
+#endif
+
+#if defined(GP_PLAT_amd64_windows)
+static WindowsDllInterceptor NtDllIntercept;
+
+typedef NTSTATUS(NTAPI* LdrUnloadDll_func)(HMODULE module);
+static WindowsDllInterceptor::FuncHookType<LdrUnloadDll_func> stub_LdrUnloadDll;
+
+static NTSTATUS NTAPI patched_LdrUnloadDll(HMODULE module) {
+ // Prevent the stack walker from suspending this thread when LdrUnloadDll
+ // holds the RtlLookupFunctionEntry lock.
+ AutoSuppressStackWalking suppress;
+ return stub_LdrUnloadDll(module);
+}
+
+// These pointers are disguised as PVOID to avoid pulling in obscure headers
+typedef PVOID(WINAPI* LdrResolveDelayLoadedAPI_func)(
+ PVOID ParentModuleBase, PVOID DelayloadDescriptor, PVOID FailureDllHook,
+ PVOID FailureSystemHook, PVOID ThunkAddress, ULONG Flags);
+static WindowsDllInterceptor::FuncHookType<LdrResolveDelayLoadedAPI_func>
+ stub_LdrResolveDelayLoadedAPI;
+
+static PVOID WINAPI patched_LdrResolveDelayLoadedAPI(
+ PVOID ParentModuleBase, PVOID DelayloadDescriptor, PVOID FailureDllHook,
+ PVOID FailureSystemHook, PVOID ThunkAddress, ULONG Flags) {
+ // Prevent the stack walker from suspending this thread when
+ // LdrResolveDelayLoadAPI holds the RtlLookupFunctionEntry lock.
+ AutoSuppressStackWalking suppress;
+ return stub_LdrResolveDelayLoadedAPI(ParentModuleBase, DelayloadDescriptor,
+ FailureDllHook, FailureSystemHook,
+ ThunkAddress, Flags);
+}
+
+MFBT_API void InitializeWin64ProfilerHooks() {
+ // This function could be called by both profilers, but we only want to run
+ // it once.
+ static bool ran = false;
+ if (ran) {
+ return;
+ }
+ ran = true;
+
+ NtDllIntercept.Init("ntdll.dll");
+ stub_LdrUnloadDll.Set(NtDllIntercept, "LdrUnloadDll", &patched_LdrUnloadDll);
+ if (IsWin8OrLater()) { // LdrResolveDelayLoadedAPI was introduced in Win8
+ stub_LdrResolveDelayLoadedAPI.Set(NtDllIntercept,
+ "LdrResolveDelayLoadedAPI",
+ &patched_LdrResolveDelayLoadedAPI);
+ }
+}
+#endif // defined(GP_PLAT_amd64_windows)
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/platform.cpp b/mozglue/baseprofiler/core/platform.cpp
new file mode 100644
index 0000000000..dd3bfe6674
--- /dev/null
+++ b/mozglue/baseprofiler/core/platform.cpp
@@ -0,0 +1,3824 @@
+/* -*- 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/. */
+
+// There are three kinds of samples done by the profiler.
+//
+// - A "periodic" sample is the most complex kind. It is done in response to a
+// timer while the profiler is active. It involves writing a stack trace plus
+// a variety of other values (memory measurements, responsiveness
+// measurements, etc.) into the main ProfileBuffer. The sampling is done from
+// off-thread, and so SuspendAndSampleAndResumeThread() is used to get the
+// register values.
+//
+// - A "synchronous" sample is a simpler kind. It is done in response to an API
+// call (profiler_get_backtrace()). It involves writing a stack trace and
+// little else into a temporary ProfileBuffer, and wrapping that up in a
+// ProfilerBacktrace that can be subsequently used in a marker. The sampling
+// is done on-thread, and so REGISTERS_SYNC_POPULATE() is used to get the
+// register values.
+//
+// - A "backtrace" sample is the simplest kind. It is done in response to an
+// API call (profiler_suspend_and_sample_thread()). It involves getting a
+// stack trace via a ProfilerStackCollector; it does not write to a
+// ProfileBuffer. The sampling is done from off-thread, and so uses
+// SuspendAndSampleAndResumeThread() to get the register values.
+
+#include "platform.h"
+
+#include <algorithm>
+#include <errno.h>
+#include <fstream>
+#include <ostream>
+#include <set>
+#include <sstream>
+#include <string_view>
+
+// #include "memory_hooks.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/AutoProfilerLabel.h"
+#include "mozilla/BaseAndGeckoProfilerDetail.h"
+#include "mozilla/BaseProfilerDetail.h"
+#include "mozilla/DoubleConversion.h"
+#include "mozilla/Printf.h"
+#include "mozilla/ProfileBufferChunkManagerSingle.h"
+#include "mozilla/ProfileBufferChunkManagerWithLocalLimit.h"
+#include "mozilla/ProfileChunkedBuffer.h"
+#include "mozilla/Services.h"
+#include "mozilla/Span.h"
+#include "mozilla/StackWalk.h"
+#ifdef XP_WIN
+# include "mozilla/StackWalkThread.h"
+#endif
+#include "mozilla/StaticPtr.h"
+#include "mozilla/ThreadLocal.h"
+#include "mozilla/TimeStamp.h"
+
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Vector.h"
+#include "prdtoa.h"
+#include "prtime.h"
+
+#include "BaseProfiler.h"
+#include "BaseProfilingCategory.h"
+#include "PageInformation.h"
+#include "ProfiledThreadData.h"
+#include "ProfilerBacktrace.h"
+#include "ProfileBuffer.h"
+#include "RegisteredThread.h"
+#include "BaseProfilerSharedLibraries.h"
+#include "ThreadInfo.h"
+#include "VTuneProfiler.h"
+
+// Win32 builds always have frame pointers, so FramePointerStackWalk() always
+// works.
+#if defined(GP_PLAT_x86_windows)
+# define HAVE_NATIVE_UNWIND
+# define USE_FRAME_POINTER_STACK_WALK
+#endif
+
+// Win64 builds always omit frame pointers, so we use the slower
+// MozStackWalk(), which works in that case.
+#if defined(GP_PLAT_amd64_windows)
+# define HAVE_NATIVE_UNWIND
+# define USE_MOZ_STACK_WALK
+#endif
+
+// AArch64 Win64 doesn't seem to use frame pointers, so we use the slower
+// MozStackWalk().
+#if defined(GP_PLAT_arm64_windows)
+# define HAVE_NATIVE_UNWIND
+# define USE_MOZ_STACK_WALK
+#endif
+
+// Mac builds use FramePointerStackWalk(). Even if we build without
+// frame pointers, we'll still get useful stacks in system libraries
+// because those always have frame pointers.
+// We don't use MozStackWalk() on Mac.
+#if defined(GP_OS_darwin)
+# define HAVE_NATIVE_UNWIND
+# define USE_FRAME_POINTER_STACK_WALK
+#endif
+
+// No stack-walking in baseprofiler on linux, android, bsd.
+// APIs now make it easier to capture backtraces from the Base Profiler, which
+// is currently not supported on these platform, and would lead to a MOZ_CRASH
+// in REGISTERS_SYNC_POPULATE(). `#if 0` added in bug 1658232, follow-up bugs
+// should be referenced in meta bug 1557568.
+#if 0
+// Android builds use the ARM Exception Handling ABI to unwind.
+# if defined(GP_PLAT_arm_linux) || defined(GP_PLAT_arm_android)
+# define HAVE_NATIVE_UNWIND
+# define USE_EHABI_STACKWALK
+# include "EHABIStackWalk.h"
+# endif
+
+// Linux/BSD builds use LUL, which uses DWARF info to unwind stacks.
+# if defined(GP_PLAT_amd64_linux) || defined(GP_PLAT_x86_linux) || \
+ defined(GP_PLAT_amd64_android) || defined(GP_PLAT_x86_android) || \
+ defined(GP_PLAT_mips64_linux) || defined(GP_PLAT_arm64_linux) || \
+ defined(GP_PLAT_arm64_android) || defined(GP_PLAT_amd64_freebsd) || \
+ defined(GP_PLAT_arm64_freebsd)
+# define HAVE_NATIVE_UNWIND
+# define USE_LUL_STACKWALK
+# include "lul/LulMain.h"
+# include "lul/platform-linux-lul.h"
+
+// On linux we use LUL for periodic samples and synchronous samples, but we use
+// FramePointerStackWalk for backtrace samples when MOZ_PROFILING is enabled.
+// (See the comment at the top of the file for a definition of
+// periodic/synchronous/backtrace.).
+//
+// FramePointerStackWalk can produce incomplete stacks when the current entry is
+// in a shared library without framepointers, however LUL can take a long time
+// to initialize, which is undesirable for consumers of
+// profiler_suspend_and_sample_thread like the Background Hang Reporter.
+# if defined(MOZ_PROFILING)
+# define USE_FRAME_POINTER_STACK_WALK
+# endif
+# endif
+#endif
+
+// We can only stackwalk without expensive initialization on platforms which
+// support FramePointerStackWalk or MozStackWalk. LUL Stackwalking requires
+// initializing LUL, and EHABIStackWalk requires initializing EHABI, both of
+// which can be expensive.
+#if defined(USE_FRAME_POINTER_STACK_WALK) || defined(USE_MOZ_STACK_WALK)
+# define HAVE_FASTINIT_NATIVE_UNWIND
+#endif
+
+#ifdef MOZ_VALGRIND
+# include <valgrind/memcheck.h>
+#else
+# define VALGRIND_MAKE_MEM_DEFINED(_addr, _len) ((void)0)
+#endif
+
+#if defined(GP_OS_linux) || defined(GP_OS_android) || defined(GP_OS_freebsd)
+# include <ucontext.h>
+#endif
+
+namespace mozilla {
+namespace baseprofiler {
+
+using detail::RacyFeatures;
+
+bool LogTest(int aLevelToTest) {
+ static const int maxLevel = getenv("MOZ_BASE_PROFILER_VERBOSE_LOGGING") ? 5
+ : getenv("MOZ_BASE_PROFILER_DEBUG_LOGGING") ? 4
+ : getenv("MOZ_BASE_PROFILER_LOGGING") ? 3
+ : 0;
+ return aLevelToTest <= maxLevel;
+}
+
+void PrintToConsole(const char* aFmt, ...) {
+ va_list args;
+ va_start(args, aFmt);
+#if defined(ANDROID)
+ __android_log_vprint(ANDROID_LOG_INFO, "Gecko", aFmt, args);
+#else
+ vfprintf(stderr, aFmt, args);
+#endif
+ va_end(args);
+}
+
+ProfileChunkedBuffer& profiler_get_core_buffer() {
+ // This needs its own mutex, because it is used concurrently from functions
+ // guarded by gPSMutex as well as others without safety (e.g.,
+ // profiler_add_marker). It is *not* used inside the critical section of the
+ // sampler, because mutexes cannot be used there.
+ static ProfileChunkedBuffer sProfileChunkedBuffer{
+ ProfileChunkedBuffer::ThreadSafety::WithMutex};
+ return sProfileChunkedBuffer;
+}
+
+Atomic<int, MemoryOrdering::Relaxed> gSkipSampling;
+
+constexpr static bool ValidateFeatures() {
+ int expectedFeatureNumber = 0;
+
+ // Feature numbers should start at 0 and increase by 1 each.
+#define CHECK_FEATURE(n_, str_, Name_, desc_) \
+ if ((n_) != expectedFeatureNumber) { \
+ return false; \
+ } \
+ ++expectedFeatureNumber;
+
+ BASE_PROFILER_FOR_EACH_FEATURE(CHECK_FEATURE)
+
+#undef CHECK_FEATURE
+
+ return true;
+}
+
+static_assert(ValidateFeatures(), "Feature list is invalid");
+
+// Return all features that are available on this platform.
+static uint32_t AvailableFeatures() {
+ uint32_t features = 0;
+
+#define ADD_FEATURE(n_, str_, Name_, desc_) \
+ ProfilerFeature::Set##Name_(features);
+
+ // Add all the possible features.
+ BASE_PROFILER_FOR_EACH_FEATURE(ADD_FEATURE)
+
+#undef ADD_FEATURE
+
+ // Now remove features not supported on this platform/configuration.
+ ProfilerFeature::ClearJava(features);
+ ProfilerFeature::ClearJS(features);
+ ProfilerFeature::ClearScreenshots(features);
+#if !defined(HAVE_NATIVE_UNWIND)
+ ProfilerFeature::ClearStackWalk(features);
+#endif
+#if !defined(GP_OS_windows)
+ ProfilerFeature::ClearNoTimerResolutionChange(features);
+#endif
+
+ return features;
+}
+
+// Default features common to all contexts (even if not available).
+static constexpr uint32_t DefaultFeatures() {
+ return ProfilerFeature::Java | ProfilerFeature::JS |
+ ProfilerFeature::StackWalk | ProfilerFeature::CPUUtilization |
+ ProfilerFeature::ProcessCPU;
+}
+
+// Extra default features when MOZ_PROFILER_STARTUP is set (even if not
+// available).
+static constexpr uint32_t StartupExtraDefaultFeatures() {
+ // Enable mainthreadio by default for startup profiles as startup is heavy on
+ // I/O operations, and main thread I/O is really important to see there.
+ return ProfilerFeature::MainThreadIO | ProfilerFeature::IPCMessages;
+}
+
+// The auto-lock/unlock mutex that guards accesses to CorePS and ActivePS.
+// Use `PSAutoLock lock;` to take the lock until the end of the enclosing block.
+// External profilers may use this same lock for their own data, but as the lock
+// is non-recursive, *only* `f(PSLockRef, ...)` functions below should be
+// called, to avoid double-locking.
+class MOZ_RAII PSAutoLock {
+ public:
+ PSAutoLock() : mLock(gPSMutex) {}
+
+ PSAutoLock(const PSAutoLock&) = delete;
+ void operator=(const PSAutoLock&) = delete;
+
+ [[nodiscard]] static bool IsLockedOnCurrentThread() {
+ return gPSMutex.IsLockedOnCurrentThread();
+ }
+
+ private:
+ static detail::BaseProfilerMutex gPSMutex;
+ detail::BaseProfilerAutoLock mLock;
+};
+
+detail::BaseProfilerMutex PSAutoLock::gPSMutex{"Base Profiler mutex"};
+
+// Only functions that take a PSLockRef arg can access CorePS's and ActivePS's
+// fields.
+typedef const PSAutoLock& PSLockRef;
+
+#define PS_GET(type_, name_) \
+ static type_ name_(PSLockRef) { \
+ MOZ_ASSERT(sInstance); \
+ return sInstance->m##name_; \
+ }
+
+#define PS_GET_LOCKLESS(type_, name_) \
+ static type_ name_() { \
+ MOZ_ASSERT(sInstance); \
+ return sInstance->m##name_; \
+ }
+
+#define PS_GET_AND_SET(type_, name_) \
+ PS_GET(type_, name_) \
+ static void Set##name_(PSLockRef, type_ a##name_) { \
+ MOZ_ASSERT(sInstance); \
+ sInstance->m##name_ = a##name_; \
+ }
+
+// All functions in this file can run on multiple threads unless they have an
+// NS_IsMainThread() assertion.
+
+// This class contains the profiler's core global state, i.e. that which is
+// valid even when the profiler is not active. Most profile operations can't do
+// anything useful when this class is not instantiated, so we release-assert
+// its non-nullness in all such operations.
+//
+// Accesses to CorePS are guarded by gPSMutex. Getters and setters take a
+// PSAutoLock reference as an argument as proof that the gPSMutex is currently
+// locked. This makes it clear when gPSMutex is locked and helps avoid
+// accidental unlocked accesses to global state. There are ways to circumvent
+// this mechanism, but please don't do so without *very* good reason and a
+// detailed explanation.
+//
+// The exceptions to this rule:
+//
+// - mProcessStartTime, because it's immutable;
+//
+// - each thread's RacyRegisteredThread object is accessible without locking via
+// TLSRegisteredThread::RacyRegisteredThread().
+class CorePS {
+ private:
+ CorePS()
+ : mProcessStartTime(TimeStamp::ProcessCreation())
+#ifdef USE_LUL_STACKWALK
+ ,
+ mLul(nullptr)
+#endif
+ {
+ }
+
+ ~CorePS() {}
+
+ public:
+ static void Create(PSLockRef aLock) {
+ MOZ_ASSERT(!sInstance);
+ sInstance = new CorePS();
+ }
+
+ static void Destroy(PSLockRef aLock) {
+ MOZ_ASSERT(sInstance);
+ delete sInstance;
+ sInstance = nullptr;
+ }
+
+ // Unlike ActivePS::Exists(), CorePS::Exists() can be called without gPSMutex
+ // being locked. This is because CorePS is instantiated so early on the main
+ // thread that we don't have to worry about it being racy.
+ static bool Exists() { return !!sInstance; }
+
+ static void AddSizeOf(PSLockRef, MallocSizeOf aMallocSizeOf,
+ size_t& aProfSize, size_t& aLulSize) {
+ MOZ_ASSERT(sInstance);
+
+ aProfSize += aMallocSizeOf(sInstance);
+
+ for (auto& registeredThread : sInstance->mRegisteredThreads) {
+ aProfSize += registeredThread->SizeOfIncludingThis(aMallocSizeOf);
+ }
+
+ for (auto& registeredPage : sInstance->mRegisteredPages) {
+ aProfSize += registeredPage->SizeOfIncludingThis(aMallocSizeOf);
+ }
+
+ // Measurement of the following things may be added later if DMD finds it
+ // is worthwhile:
+ // - CorePS::mRegisteredThreads itself (its elements' children are
+ // measured above)
+ // - CorePS::mRegisteredPages itself (its elements' children are
+ // measured above)
+ // - CorePS::mInterposeObserver
+
+#if defined(USE_LUL_STACKWALK)
+ if (sInstance->mLul) {
+ aLulSize += sInstance->mLul->SizeOfIncludingThis(aMallocSizeOf);
+ }
+#endif
+ }
+
+ // No PSLockRef is needed for this field because it's immutable.
+ PS_GET_LOCKLESS(const TimeStamp&, ProcessStartTime)
+
+ PS_GET(const Vector<UniquePtr<RegisteredThread>>&, RegisteredThreads)
+
+ static void AppendRegisteredThread(
+ PSLockRef, UniquePtr<RegisteredThread>&& aRegisteredThread) {
+ MOZ_ASSERT(sInstance);
+ MOZ_RELEASE_ASSERT(
+ sInstance->mRegisteredThreads.append(std::move(aRegisteredThread)));
+ }
+
+ static void RemoveRegisteredThread(PSLockRef,
+ RegisteredThread* aRegisteredThread) {
+ MOZ_ASSERT(sInstance);
+ // Remove aRegisteredThread from mRegisteredThreads.
+ for (UniquePtr<RegisteredThread>& rt : sInstance->mRegisteredThreads) {
+ if (rt.get() == aRegisteredThread) {
+ sInstance->mRegisteredThreads.erase(&rt);
+ return;
+ }
+ }
+ }
+
+ PS_GET(Vector<RefPtr<PageInformation>>&, RegisteredPages)
+
+ static void AppendRegisteredPage(PSLockRef,
+ RefPtr<PageInformation>&& aRegisteredPage) {
+ MOZ_ASSERT(sInstance);
+ struct RegisteredPageComparator {
+ PageInformation* aA;
+ bool operator()(PageInformation* aB) const { return aA->Equals(aB); }
+ };
+
+ auto foundPageIter = std::find_if(
+ sInstance->mRegisteredPages.begin(), sInstance->mRegisteredPages.end(),
+ RegisteredPageComparator{aRegisteredPage.get()});
+
+ if (foundPageIter != sInstance->mRegisteredPages.end()) {
+ if ((*foundPageIter)->Url() == "about:blank") {
+ // When a BrowsingContext is loaded, the first url loaded in it will be
+ // about:blank, and if the principal matches, the first document loaded
+ // in it will share an inner window. That's why we should delete the
+ // intermittent about:blank if they share the inner window.
+ sInstance->mRegisteredPages.erase(foundPageIter);
+ } else {
+ // Do not register the same page again.
+ return;
+ }
+ }
+ MOZ_RELEASE_ASSERT(
+ sInstance->mRegisteredPages.append(std::move(aRegisteredPage)));
+ }
+
+ static void RemoveRegisteredPage(PSLockRef,
+ uint64_t aRegisteredInnerWindowID) {
+ MOZ_ASSERT(sInstance);
+ // Remove RegisteredPage from mRegisteredPages by given inner window ID.
+ sInstance->mRegisteredPages.eraseIf([&](const RefPtr<PageInformation>& rd) {
+ return rd->InnerWindowID() == aRegisteredInnerWindowID;
+ });
+ }
+
+ static void ClearRegisteredPages(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ sInstance->mRegisteredPages.clear();
+ }
+
+ PS_GET(const Vector<BaseProfilerCount*>&, Counters)
+
+ static void AppendCounter(PSLockRef, BaseProfilerCount* aCounter) {
+ MOZ_ASSERT(sInstance);
+ // we don't own the counter; they may be stored in static objects
+ MOZ_RELEASE_ASSERT(sInstance->mCounters.append(aCounter));
+ }
+
+ static void RemoveCounter(PSLockRef, BaseProfilerCount* aCounter) {
+ // we may be called to remove a counter after the profiler is stopped or
+ // late in shutdown.
+ if (sInstance) {
+ auto* counter = std::find(sInstance->mCounters.begin(),
+ sInstance->mCounters.end(), aCounter);
+ MOZ_RELEASE_ASSERT(counter != sInstance->mCounters.end());
+ sInstance->mCounters.erase(counter);
+ }
+ }
+
+#ifdef USE_LUL_STACKWALK
+ static lul::LUL* Lul(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ return sInstance->mLul.get();
+ }
+ static void SetLul(PSLockRef, UniquePtr<lul::LUL> aLul) {
+ MOZ_ASSERT(sInstance);
+ sInstance->mLul = std::move(aLul);
+ }
+#endif
+
+ PS_GET_AND_SET(const std::string&, ProcessName)
+ PS_GET_AND_SET(const std::string&, ETLDplus1)
+
+ private:
+ // The singleton instance
+ static CorePS* sInstance;
+
+ // The time that the process started.
+ const TimeStamp mProcessStartTime;
+
+ // Info on all the registered threads.
+ // ThreadIds in mRegisteredThreads are unique.
+ Vector<UniquePtr<RegisteredThread>> mRegisteredThreads;
+
+ // Info on all the registered pages.
+ // InnerWindowIDs in mRegisteredPages are unique.
+ Vector<RefPtr<PageInformation>> mRegisteredPages;
+
+ // Non-owning pointers to all active counters
+ Vector<BaseProfilerCount*> mCounters;
+
+#ifdef USE_LUL_STACKWALK
+ // LUL's state. Null prior to the first activation, non-null thereafter.
+ UniquePtr<lul::LUL> mLul;
+#endif
+
+ // Process name, provided by child process initialization code.
+ std::string mProcessName;
+ // Private name, provided by child process initialization code (eTLD+1 in
+ // fission)
+ std::string mETLDplus1;
+};
+
+CorePS* CorePS::sInstance = nullptr;
+
+class SamplerThread;
+
+static SamplerThread* NewSamplerThread(PSLockRef aLock, uint32_t aGeneration,
+ double aInterval, uint32_t aFeatures);
+
+struct LiveProfiledThreadData {
+ RegisteredThread* mRegisteredThread;
+ UniquePtr<ProfiledThreadData> mProfiledThreadData;
+};
+
+// The buffer size is provided as a number of "entries", this is their size in
+// bytes.
+constexpr static uint32_t scBytesPerEntry = 8;
+
+// This class contains the profiler's global state that is valid only when the
+// profiler is active. When not instantiated, the profiler is inactive.
+//
+// Accesses to ActivePS are guarded by gPSMutex, in much the same fashion as
+// CorePS.
+//
+class ActivePS {
+ private:
+ // We need to decide how many chunks of what size we want to fit in the given
+ // total maximum capacity for this process, in the (likely) context of
+ // multiple processes doing the same choice and having an inter-process
+ // mechanism to control the overal memory limit.
+
+ // Minimum chunk size allowed, enough for at least one stack.
+ constexpr static uint32_t scMinimumChunkSize =
+ 2 * ProfileBufferChunkManager::scExpectedMaximumStackSize;
+
+ // Ideally we want at least 2 unreleased chunks to work with (1 current and 1
+ // next), and 2 released chunks (so that one can be recycled when old, leaving
+ // one with some data).
+ constexpr static uint32_t scMinimumNumberOfChunks = 4;
+
+ // And we want to limit chunks to a maximum size, which is a compromise
+ // between:
+ // - A big size, which helps with reducing the rate of allocations and IPCs.
+ // - A small size, which helps with equalizing the duration of recorded data
+ // (as the inter-process controller will discard the oldest chunks in all
+ // Firefox processes).
+ constexpr static uint32_t scMaximumChunkSize = 1024 * 1024;
+
+ public:
+ // We should be able to store at least the minimum number of the smallest-
+ // possible chunks.
+ constexpr static uint32_t scMinimumBufferSize =
+ scMinimumNumberOfChunks * scMinimumChunkSize;
+ constexpr static uint32_t scMinimumBufferEntries =
+ scMinimumBufferSize / scBytesPerEntry;
+
+ // Limit to 2GiB.
+ constexpr static uint32_t scMaximumBufferSize = 2u * 1024u * 1024u * 1024u;
+ constexpr static uint32_t scMaximumBufferEntries =
+ scMaximumBufferSize / scBytesPerEntry;
+
+ constexpr static uint32_t ClampToAllowedEntries(uint32_t aEntries) {
+ if (aEntries <= scMinimumBufferEntries) {
+ return scMinimumBufferEntries;
+ }
+ if (aEntries >= scMaximumBufferEntries) {
+ return scMaximumBufferEntries;
+ }
+ return aEntries;
+ }
+
+ private:
+ constexpr static uint32_t ChunkSizeForEntries(uint32_t aEntries) {
+ return uint32_t(std::min(size_t(ClampToAllowedEntries(aEntries)) *
+ scBytesPerEntry / scMinimumNumberOfChunks,
+ size_t(scMaximumChunkSize)));
+ }
+
+ static uint32_t AdjustFeatures(uint32_t aFeatures, uint32_t aFilterCount) {
+ // Filter out any features unavailable in this platform/configuration.
+ aFeatures &= AvailableFeatures();
+
+ // Some features imply others.
+ if (aFeatures & ProfilerFeature::FileIOAll) {
+ aFeatures |= ProfilerFeature::MainThreadIO | ProfilerFeature::FileIO;
+ } else if (aFeatures & ProfilerFeature::FileIO) {
+ aFeatures |= ProfilerFeature::MainThreadIO;
+ }
+
+ return aFeatures;
+ }
+
+ ActivePS(PSLockRef aLock, const TimeStamp& aProfilingStartTime,
+ PowerOfTwo32 aCapacity, double aInterval, uint32_t aFeatures,
+ const char** aFilters, uint32_t aFilterCount,
+ const Maybe<double>& aDuration)
+ : mProfilingStartTime(aProfilingStartTime),
+ mGeneration(sNextGeneration++),
+ mCapacity(aCapacity),
+ mDuration(aDuration),
+ mInterval(aInterval),
+ mFeatures(AdjustFeatures(aFeatures, aFilterCount)),
+ mProfileBufferChunkManager(
+ MakeUnique<ProfileBufferChunkManagerWithLocalLimit>(
+ size_t(ClampToAllowedEntries(aCapacity.Value())) *
+ scBytesPerEntry,
+ ChunkSizeForEntries(aCapacity.Value()))),
+ mProfileBuffer([this]() -> ProfileChunkedBuffer& {
+ ProfileChunkedBuffer& buffer = profiler_get_core_buffer();
+ buffer.SetChunkManager(*mProfileBufferChunkManager);
+ return buffer;
+ }()),
+ // The new sampler thread doesn't start sampling immediately because the
+ // main loop within Run() is blocked until this function's caller
+ // unlocks gPSMutex.
+ mSamplerThread(
+ NewSamplerThread(aLock, mGeneration, aInterval, aFeatures)),
+ mIsPaused(false),
+ mIsSamplingPaused(false) {
+ // Deep copy and lower-case aFilters.
+ MOZ_ALWAYS_TRUE(mFilters.resize(aFilterCount));
+ MOZ_ALWAYS_TRUE(mFiltersLowered.resize(aFilterCount));
+ for (uint32_t i = 0; i < aFilterCount; ++i) {
+ mFilters[i] = aFilters[i];
+ mFiltersLowered[i].reserve(mFilters[i].size());
+ std::transform(mFilters[i].cbegin(), mFilters[i].cend(),
+ std::back_inserter(mFiltersLowered[i]), ::tolower);
+ }
+ }
+
+ ~ActivePS() {
+ if (mProfileBufferChunkManager) {
+ // We still control the chunk manager, remove it from the core buffer.
+ profiler_get_core_buffer().ResetChunkManager();
+ }
+ }
+
+ bool ThreadSelected(const char* aThreadName) {
+ if (mFiltersLowered.empty()) {
+ return true;
+ }
+
+ std::string name = aThreadName;
+ std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+
+ for (const auto& filter : mFiltersLowered) {
+ if (filter == "*") {
+ return true;
+ }
+
+ // Crude, non UTF-8 compatible, case insensitive substring search
+ if (name.find(filter) != std::string::npos) {
+ return true;
+ }
+
+ // If the filter is "pid:<my pid>", profile all threads.
+ if (mozilla::profiler::detail::FilterHasPid(filter.c_str())) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public:
+ static void Create(PSLockRef aLock, const TimeStamp& aProfilingStartTime,
+ PowerOfTwo32 aCapacity, double aInterval,
+ uint32_t aFeatures, const char** aFilters,
+ uint32_t aFilterCount, const Maybe<double>& aDuration) {
+ MOZ_ASSERT(!sInstance);
+ sInstance = new ActivePS(aLock, aProfilingStartTime, aCapacity, aInterval,
+ aFeatures, aFilters, aFilterCount, aDuration);
+ }
+
+ [[nodiscard]] static SamplerThread* Destroy(PSLockRef aLock) {
+ MOZ_ASSERT(sInstance);
+ auto samplerThread = sInstance->mSamplerThread;
+ delete sInstance;
+ sInstance = nullptr;
+
+ return samplerThread;
+ }
+
+ static bool Exists(PSLockRef) { return !!sInstance; }
+
+ static bool Equals(PSLockRef, PowerOfTwo32 aCapacity,
+ const Maybe<double>& aDuration, double aInterval,
+ uint32_t aFeatures, const char** aFilters,
+ uint32_t aFilterCount) {
+ MOZ_ASSERT(sInstance);
+ if (sInstance->mCapacity != aCapacity ||
+ sInstance->mDuration != aDuration ||
+ sInstance->mInterval != aInterval ||
+ sInstance->mFeatures != aFeatures ||
+ sInstance->mFilters.length() != aFilterCount) {
+ return false;
+ }
+
+ for (uint32_t i = 0; i < sInstance->mFilters.length(); ++i) {
+ if (strcmp(sInstance->mFilters[i].c_str(), aFilters[i]) != 0) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ static size_t SizeOf(PSLockRef, MallocSizeOf aMallocSizeOf) {
+ MOZ_ASSERT(sInstance);
+
+ size_t n = aMallocSizeOf(sInstance);
+
+ n += sInstance->mProfileBuffer.SizeOfExcludingThis(aMallocSizeOf);
+
+ // Measurement of the following members may be added later if DMD finds it
+ // is worthwhile:
+ // - mLiveProfiledThreads (both the array itself, and the contents)
+ // - mDeadProfiledThreads (both the array itself, and the contents)
+ //
+
+ return n;
+ }
+
+ static UniquePtr<ProfileBufferChunkManagerWithLocalLimit>
+ ExtractBaseProfilerChunkManager(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ return std::move(sInstance->mProfileBufferChunkManager);
+ }
+
+ static bool ShouldProfileThread(PSLockRef aLock, ThreadInfo* aInfo) {
+ MOZ_ASSERT(sInstance);
+ return sInstance->ThreadSelected(aInfo->Name());
+ }
+
+ PS_GET_LOCKLESS(TimeStamp, ProfilingStartTime)
+
+ PS_GET(uint32_t, Generation)
+
+ PS_GET(PowerOfTwo32, Capacity)
+
+ PS_GET(Maybe<double>, Duration)
+
+ PS_GET(double, Interval)
+
+ PS_GET(uint32_t, Features)
+
+#define PS_GET_FEATURE(n_, str_, Name_, desc_) \
+ static bool Feature##Name_(PSLockRef) { \
+ MOZ_ASSERT(sInstance); \
+ return ProfilerFeature::Has##Name_(sInstance->mFeatures); \
+ }
+
+ BASE_PROFILER_FOR_EACH_FEATURE(PS_GET_FEATURE)
+
+#undef PS_GET_FEATURE
+
+ PS_GET(const Vector<std::string>&, Filters)
+ PS_GET(const Vector<std::string>&, FiltersLowered)
+
+ static void FulfillChunkRequests(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ if (sInstance->mProfileBufferChunkManager) {
+ sInstance->mProfileBufferChunkManager->FulfillChunkRequests();
+ }
+ }
+
+ static ProfileBuffer& Buffer(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ return sInstance->mProfileBuffer;
+ }
+
+ static const Vector<LiveProfiledThreadData>& LiveProfiledThreads(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ return sInstance->mLiveProfiledThreads;
+ }
+
+ // Returns an array containing (RegisteredThread*, ProfiledThreadData*) pairs
+ // for all threads that should be included in a profile, both for threads
+ // that are still registered, and for threads that have been unregistered but
+ // still have data in the buffer.
+ // For threads that have already been unregistered, the RegisteredThread
+ // pointer will be null.
+ // The returned array is sorted by thread register time.
+ // Do not hold on to the return value across thread registration or profiler
+ // restarts.
+ static Vector<std::pair<RegisteredThread*, ProfiledThreadData*>>
+ ProfiledThreads(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ Vector<std::pair<RegisteredThread*, ProfiledThreadData*>> array;
+ MOZ_RELEASE_ASSERT(
+ array.initCapacity(sInstance->mLiveProfiledThreads.length() +
+ sInstance->mDeadProfiledThreads.length()));
+ for (auto& t : sInstance->mLiveProfiledThreads) {
+ MOZ_RELEASE_ASSERT(array.append(
+ std::make_pair(t.mRegisteredThread, t.mProfiledThreadData.get())));
+ }
+ for (auto& t : sInstance->mDeadProfiledThreads) {
+ MOZ_RELEASE_ASSERT(
+ array.append(std::make_pair((RegisteredThread*)nullptr, t.get())));
+ }
+
+ std::sort(array.begin(), array.end(),
+ [](const std::pair<RegisteredThread*, ProfiledThreadData*>& a,
+ const std::pair<RegisteredThread*, ProfiledThreadData*>& b) {
+ return a.second->Info()->RegisterTime() <
+ b.second->Info()->RegisterTime();
+ });
+ return array;
+ }
+
+ static Vector<RefPtr<PageInformation>> ProfiledPages(PSLockRef aLock) {
+ MOZ_ASSERT(sInstance);
+ Vector<RefPtr<PageInformation>> array;
+ for (auto& d : CorePS::RegisteredPages(aLock)) {
+ MOZ_RELEASE_ASSERT(array.append(d));
+ }
+ for (auto& d : sInstance->mDeadProfiledPages) {
+ MOZ_RELEASE_ASSERT(array.append(d));
+ }
+ // We don't need to sort the pages like threads since we won't show them
+ // as a list.
+ return array;
+ }
+
+ // Do a linear search through mLiveProfiledThreads to find the
+ // ProfiledThreadData object for a RegisteredThread.
+ static ProfiledThreadData* GetProfiledThreadData(
+ PSLockRef, RegisteredThread* aRegisteredThread) {
+ MOZ_ASSERT(sInstance);
+ for (const LiveProfiledThreadData& thread :
+ sInstance->mLiveProfiledThreads) {
+ if (thread.mRegisteredThread == aRegisteredThread) {
+ return thread.mProfiledThreadData.get();
+ }
+ }
+ return nullptr;
+ }
+
+ static ProfiledThreadData* AddLiveProfiledThread(
+ PSLockRef, RegisteredThread* aRegisteredThread,
+ UniquePtr<ProfiledThreadData>&& aProfiledThreadData) {
+ MOZ_ASSERT(sInstance);
+ MOZ_RELEASE_ASSERT(
+ sInstance->mLiveProfiledThreads.append(LiveProfiledThreadData{
+ aRegisteredThread, std::move(aProfiledThreadData)}));
+
+ // Return a weak pointer to the ProfiledThreadData object.
+ return sInstance->mLiveProfiledThreads.back().mProfiledThreadData.get();
+ }
+
+ static void UnregisterThread(PSLockRef aLockRef,
+ RegisteredThread* aRegisteredThread) {
+ MOZ_ASSERT(sInstance);
+
+ DiscardExpiredDeadProfiledThreads(aLockRef);
+
+ // Find the right entry in the mLiveProfiledThreads array and remove the
+ // element, moving the ProfiledThreadData object for the thread into the
+ // mDeadProfiledThreads array.
+ // The thread's RegisteredThread object gets destroyed here.
+ for (size_t i = 0; i < sInstance->mLiveProfiledThreads.length(); i++) {
+ LiveProfiledThreadData& thread = sInstance->mLiveProfiledThreads[i];
+ if (thread.mRegisteredThread == aRegisteredThread) {
+ thread.mProfiledThreadData->NotifyUnregistered(
+ sInstance->mProfileBuffer.BufferRangeEnd());
+ MOZ_RELEASE_ASSERT(sInstance->mDeadProfiledThreads.append(
+ std::move(thread.mProfiledThreadData)));
+ sInstance->mLiveProfiledThreads.erase(
+ &sInstance->mLiveProfiledThreads[i]);
+ return;
+ }
+ }
+ }
+
+ PS_GET_AND_SET(bool, IsPaused)
+
+ // True if sampling is paused (though generic `SetIsPaused()` or specific
+ // `SetIsSamplingPaused()`).
+ static bool IsSamplingPaused(PSLockRef lock) {
+ MOZ_ASSERT(sInstance);
+ return IsPaused(lock) || sInstance->mIsSamplingPaused;
+ }
+
+ static void SetIsSamplingPaused(PSLockRef, bool aIsSamplingPaused) {
+ MOZ_ASSERT(sInstance);
+ sInstance->mIsSamplingPaused = aIsSamplingPaused;
+ }
+
+ static void DiscardExpiredDeadProfiledThreads(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ uint64_t bufferRangeStart = sInstance->mProfileBuffer.BufferRangeStart();
+ // Discard any dead threads that were unregistered before bufferRangeStart.
+ sInstance->mDeadProfiledThreads.eraseIf(
+ [bufferRangeStart](
+ const UniquePtr<ProfiledThreadData>& aProfiledThreadData) {
+ Maybe<uint64_t> bufferPosition =
+ aProfiledThreadData->BufferPositionWhenUnregistered();
+ MOZ_RELEASE_ASSERT(bufferPosition,
+ "should have unregistered this thread");
+ return *bufferPosition < bufferRangeStart;
+ });
+ }
+
+ static void UnregisterPage(PSLockRef aLock,
+ uint64_t aRegisteredInnerWindowID) {
+ MOZ_ASSERT(sInstance);
+ auto& registeredPages = CorePS::RegisteredPages(aLock);
+ for (size_t i = 0; i < registeredPages.length(); i++) {
+ RefPtr<PageInformation>& page = registeredPages[i];
+ if (page->InnerWindowID() == aRegisteredInnerWindowID) {
+ page->NotifyUnregistered(sInstance->mProfileBuffer.BufferRangeEnd());
+ MOZ_RELEASE_ASSERT(
+ sInstance->mDeadProfiledPages.append(std::move(page)));
+ registeredPages.erase(&registeredPages[i--]);
+ }
+ }
+ }
+
+ static void DiscardExpiredPages(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ uint64_t bufferRangeStart = sInstance->mProfileBuffer.BufferRangeStart();
+ // Discard any dead pages that were unregistered before
+ // bufferRangeStart.
+ sInstance->mDeadProfiledPages.eraseIf(
+ [bufferRangeStart](const RefPtr<PageInformation>& aProfiledPage) {
+ Maybe<uint64_t> bufferPosition =
+ aProfiledPage->BufferPositionWhenUnregistered();
+ MOZ_RELEASE_ASSERT(bufferPosition,
+ "should have unregistered this page");
+ return *bufferPosition < bufferRangeStart;
+ });
+ }
+
+ static void ClearUnregisteredPages(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ sInstance->mDeadProfiledPages.clear();
+ }
+
+ static void ClearExpiredExitProfiles(PSLockRef) {
+ MOZ_ASSERT(sInstance);
+ uint64_t bufferRangeStart = sInstance->mProfileBuffer.BufferRangeStart();
+ // Discard exit profiles that were gathered before our buffer RangeStart.
+ sInstance->mExitProfiles.eraseIf(
+ [bufferRangeStart](const ExitProfile& aExitProfile) {
+ return aExitProfile.mBufferPositionAtGatherTime < bufferRangeStart;
+ });
+ }
+
+ static void AddExitProfile(PSLockRef aLock, const std::string& aExitProfile) {
+ MOZ_ASSERT(sInstance);
+
+ ClearExpiredExitProfiles(aLock);
+
+ MOZ_RELEASE_ASSERT(sInstance->mExitProfiles.append(
+ ExitProfile{aExitProfile, sInstance->mProfileBuffer.BufferRangeEnd()}));
+ }
+
+ static Vector<std::string> MoveExitProfiles(PSLockRef aLock) {
+ MOZ_ASSERT(sInstance);
+
+ ClearExpiredExitProfiles(aLock);
+
+ Vector<std::string> profiles;
+ MOZ_RELEASE_ASSERT(
+ profiles.initCapacity(sInstance->mExitProfiles.length()));
+ for (auto& profile : sInstance->mExitProfiles) {
+ MOZ_RELEASE_ASSERT(profiles.append(std::move(profile.mJSON)));
+ }
+ sInstance->mExitProfiles.clear();
+ return profiles;
+ }
+
+ private:
+ // The singleton instance.
+ static ActivePS* sInstance;
+
+ const TimeStamp mProfilingStartTime;
+
+ // We need to track activity generations. If we didn't we could have the
+ // following scenario.
+ //
+ // - profiler_stop() locks gPSMutex, de-instantiates ActivePS, unlocks
+ // gPSMutex, deletes the SamplerThread (which does a join).
+ //
+ // - profiler_start() runs on a different thread, locks gPSMutex,
+ // re-instantiates ActivePS, unlocks gPSMutex -- all before the join
+ // completes.
+ //
+ // - SamplerThread::Run() locks gPSMutex, sees that ActivePS is instantiated,
+ // and continues as if the start/stop pair didn't occur. Also
+ // profiler_stop() is stuck, unable to finish.
+ //
+ // By checking ActivePS *and* the generation, we can avoid this scenario.
+ // sNextGeneration is used to track the next generation number; it is static
+ // because it must persist across different ActivePS instantiations.
+ const uint32_t mGeneration;
+ static uint32_t sNextGeneration;
+
+ // The maximum number of 8-byte entries in mProfileBuffer.
+ const PowerOfTwo32 mCapacity;
+
+ // The maximum duration of entries in mProfileBuffer, in seconds.
+ const Maybe<double> mDuration;
+
+ // The interval between samples, measured in milliseconds.
+ const double mInterval;
+
+ // The profile features that are enabled.
+ const uint32_t mFeatures;
+
+ // Substrings of names of threads we want to profile.
+ Vector<std::string> mFilters;
+ Vector<std::string> mFiltersLowered;
+
+ // The chunk manager used by `mProfileBuffer` below.
+ // May become null if it gets transferred to the Gecko Profiler.
+ UniquePtr<ProfileBufferChunkManagerWithLocalLimit> mProfileBufferChunkManager;
+
+ // The buffer into which all samples are recorded.
+ ProfileBuffer mProfileBuffer;
+
+ // ProfiledThreadData objects for any threads that were profiled at any point
+ // during this run of the profiler:
+ // - mLiveProfiledThreads contains all threads that are still registered, and
+ // - mDeadProfiledThreads contains all threads that have already been
+ // unregistered but for which there is still data in the profile buffer.
+ Vector<LiveProfiledThreadData> mLiveProfiledThreads;
+ Vector<UniquePtr<ProfiledThreadData>> mDeadProfiledThreads;
+
+ // Info on all the dead pages.
+ // Registered pages are being moved to this array after unregistration.
+ // We are keeping them in case we need them in the profile data.
+ // We are removing them when we ensure that we won't need them anymore.
+ Vector<RefPtr<PageInformation>> mDeadProfiledPages;
+
+ // The current sampler thread. This class is not responsible for destroying
+ // the SamplerThread object; the Destroy() method returns it so the caller
+ // can destroy it.
+ SamplerThread* const mSamplerThread;
+
+ // Is the profiler fully paused?
+ bool mIsPaused;
+
+ // Is the profiler periodic sampling paused?
+ bool mIsSamplingPaused;
+
+ struct ExitProfile {
+ std::string mJSON;
+ uint64_t mBufferPositionAtGatherTime;
+ };
+ Vector<ExitProfile> mExitProfiles;
+};
+
+ActivePS* ActivePS::sInstance = nullptr;
+uint32_t ActivePS::sNextGeneration = 0;
+
+#undef PS_GET
+#undef PS_GET_LOCKLESS
+#undef PS_GET_AND_SET
+
+namespace detail {
+
+TimeStamp GetProfilingStartTime() {
+ if (!CorePS::Exists()) {
+ return {};
+ }
+ PSAutoLock lock;
+ if (!ActivePS::Exists(lock)) {
+ return {};
+ }
+ return ActivePS::ProfilingStartTime();
+}
+
+[[nodiscard]] MFBT_API UniquePtr<ProfileBufferChunkManagerWithLocalLimit>
+ExtractBaseProfilerChunkManager() {
+ PSAutoLock lock;
+ if (MOZ_UNLIKELY(!ActivePS::Exists(lock))) {
+ return nullptr;
+ }
+ return ActivePS::ExtractBaseProfilerChunkManager(lock);
+}
+
+} // namespace detail
+
+Atomic<uint32_t, MemoryOrdering::Relaxed> RacyFeatures::sActiveAndFeatures(0);
+
+/* static */
+void RacyFeatures::SetActive(uint32_t aFeatures) {
+ sActiveAndFeatures = Active | aFeatures;
+}
+
+/* static */
+void RacyFeatures::SetInactive() { sActiveAndFeatures = 0; }
+
+/* static */
+bool RacyFeatures::IsActive() { return uint32_t(sActiveAndFeatures) & Active; }
+
+/* static */
+void RacyFeatures::SetPaused() { sActiveAndFeatures |= Paused; }
+
+/* static */
+void RacyFeatures::SetUnpaused() { sActiveAndFeatures &= ~Paused; }
+
+/* static */
+void RacyFeatures::SetSamplingPaused() { sActiveAndFeatures |= SamplingPaused; }
+
+/* static */
+void RacyFeatures::SetSamplingUnpaused() {
+ sActiveAndFeatures &= ~SamplingPaused;
+}
+
+/* static */
+bool RacyFeatures::IsActiveWithFeature(uint32_t aFeature) {
+ uint32_t af = sActiveAndFeatures; // copy it first
+ return (af & Active) && (af & aFeature);
+}
+
+/* static */
+bool RacyFeatures::IsActiveWithoutFeature(uint32_t aFeature) {
+ uint32_t af = sActiveAndFeatures; // copy it first
+ return (af & Active) && !(af & aFeature);
+}
+
+/* static */
+bool RacyFeatures::IsActiveAndUnpaused() {
+ uint32_t af = sActiveAndFeatures; // copy it first
+ return (af & Active) && !(af & Paused);
+}
+
+/* static */
+bool RacyFeatures::IsActiveAndSamplingUnpaused() {
+ uint32_t af = sActiveAndFeatures; // copy it first
+ return (af & Active) && !(af & (Paused | SamplingPaused));
+}
+
+// Each live thread has a RegisteredThread, and we store a reference to it in
+// TLS. This class encapsulates that TLS.
+class TLSRegisteredThread {
+ public:
+ static bool Init(PSLockRef) {
+ bool ok1 = sRegisteredThread.init();
+ bool ok2 = AutoProfilerLabel::sProfilingStack.init();
+ return ok1 && ok2;
+ }
+
+ // Get the entire RegisteredThread. Accesses are guarded by gPSMutex.
+ static class RegisteredThread* RegisteredThread(PSLockRef) {
+ return sRegisteredThread.get();
+ }
+
+ // Get only the RacyRegisteredThread. Accesses are not guarded by gPSMutex.
+ static class RacyRegisteredThread* RacyRegisteredThread() {
+ class RegisteredThread* registeredThread = sRegisteredThread.get();
+ return registeredThread ? &registeredThread->RacyRegisteredThread()
+ : nullptr;
+ }
+
+ // Get only the ProfilingStack. Accesses are not guarded by gPSMutex.
+ // RacyRegisteredThread() can also be used to get the ProfilingStack, but that
+ // is marginally slower because it requires an extra pointer indirection.
+ static ProfilingStack* Stack() {
+ return AutoProfilerLabel::sProfilingStack.get();
+ }
+
+ static void SetRegisteredThread(PSLockRef,
+ class RegisteredThread* aRegisteredThread) {
+ sRegisteredThread.set(aRegisteredThread);
+ AutoProfilerLabel::sProfilingStack.set(
+ aRegisteredThread
+ ? &aRegisteredThread->RacyRegisteredThread().ProfilingStack()
+ : nullptr);
+ }
+
+ private:
+ // This is a non-owning reference to the RegisteredThread;
+ // CorePS::mRegisteredThreads is the owning reference. On thread
+ // deregistration, this reference is cleared and the RegisteredThread is
+ // destroyed.
+ static MOZ_THREAD_LOCAL(class RegisteredThread*) sRegisteredThread;
+};
+
+MOZ_THREAD_LOCAL(RegisteredThread*) TLSRegisteredThread::sRegisteredThread;
+
+/* static */
+ProfilingStack* AutoProfilerLabel::GetProfilingStack() {
+ return sProfilingStack.get();
+}
+
+// Although you can access a thread's ProfilingStack via
+// TLSRegisteredThread::sRegisteredThread, we also have a second TLS pointer
+// directly to the ProfilingStack. Here's why.
+//
+// - We need to be able to push to and pop from the ProfilingStack in
+// AutoProfilerLabel.
+//
+// - The class functions are hot and must be defined in BaseProfiler.h so they
+// can be inlined.
+//
+// - We don't want to expose TLSRegisteredThread (and RegisteredThread) in
+// BaseProfiler.h.
+//
+// This second pointer isn't ideal, but does provide a way to satisfy those
+// constraints. TLSRegisteredThread is responsible for updating it.
+MOZ_THREAD_LOCAL(ProfilingStack*) AutoProfilerLabel::sProfilingStack;
+
+namespace detail {
+
+[[nodiscard]] MFBT_API TimeStamp GetThreadRegistrationTime() {
+ if (!CorePS::Exists()) {
+ return {};
+ }
+
+ PSAutoLock lock;
+
+ RegisteredThread* registeredThread =
+ TLSRegisteredThread::RegisteredThread(lock);
+ if (!registeredThread) {
+ return {};
+ }
+
+ return registeredThread->Info()->RegisterTime();
+}
+
+} // namespace detail
+
+// The name of the main thread.
+static const char* const kMainThreadName = "GeckoMain";
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN sampling/unwinding code
+
+// The registers used for stack unwinding and a few other sampling purposes.
+// The ctor does nothing; users are responsible for filling in the fields.
+class Registers {
+ public:
+ Registers() : mPC{nullptr}, mSP{nullptr}, mFP{nullptr}, mLR{nullptr} {}
+
+ void Clear() { memset(this, 0, sizeof(*this)); }
+
+ // These fields are filled in by
+ // Sampler::SuspendAndSampleAndResumeThread() for periodic and backtrace
+ // samples, and by REGISTERS_SYNC_POPULATE for synchronous samples.
+ Address mPC; // Instruction pointer.
+ Address mSP; // Stack pointer.
+ Address mFP; // Frame pointer.
+ Address mLR; // ARM link register.
+#if defined(GP_OS_linux) || defined(GP_OS_android) || defined(GP_OS_freebsd)
+ // This contains all the registers, which means it duplicates the four fields
+ // above. This is ok.
+ ucontext_t* mContext; // The context from the signal handler.
+#endif
+};
+
+// Setting MAX_NATIVE_FRAMES too high risks the unwinder wasting a lot of time
+// looping on corrupted stacks.
+static const size_t MAX_NATIVE_FRAMES = 1024;
+
+struct NativeStack {
+ void* mPCs[MAX_NATIVE_FRAMES];
+ void* mSPs[MAX_NATIVE_FRAMES];
+ size_t mCount; // Number of frames filled.
+
+ NativeStack() : mPCs(), mSPs(), mCount(0) {}
+};
+
+// Merges the profiling stack and native stack, outputting the details to
+// aCollector.
+static void MergeStacks(uint32_t aFeatures, bool aIsSynchronous,
+ const RegisteredThread& aRegisteredThread,
+ const Registers& aRegs, const NativeStack& aNativeStack,
+ ProfilerStackCollector& aCollector) {
+ // WARNING: this function runs within the profiler's "critical section".
+ // WARNING: this function might be called while the profiler is inactive, and
+ // cannot rely on ActivePS.
+
+ const ProfilingStack& profilingStack =
+ aRegisteredThread.RacyRegisteredThread().ProfilingStack();
+ const ProfilingStackFrame* profilingStackFrames = profilingStack.frames;
+ uint32_t profilingStackFrameCount = profilingStack.stackSize();
+
+ Maybe<uint64_t> samplePosInBuffer;
+ if (!aIsSynchronous) {
+ // aCollector.SamplePositionInBuffer() will return Nothing() when
+ // profiler_suspend_and_sample_thread is called from the background hang
+ // reporter.
+ samplePosInBuffer = aCollector.SamplePositionInBuffer();
+ }
+ // While the profiling stack array is ordered oldest-to-youngest, the JS and
+ // native arrays are ordered youngest-to-oldest. We must add frames to aInfo
+ // oldest-to-youngest. Thus, iterate over the profiling stack forwards and JS
+ // and native arrays backwards. Note: this means the terminating condition
+ // jsIndex and nativeIndex is being < 0.
+ uint32_t profilingStackIndex = 0;
+ int32_t nativeIndex = aNativeStack.mCount - 1;
+
+ uint8_t* lastLabelFrameStackAddr = nullptr;
+
+ // Iterate as long as there is at least one frame remaining.
+ while (profilingStackIndex != profilingStackFrameCount || nativeIndex >= 0) {
+ // There are 1 to 3 frames available. Find and add the oldest.
+ uint8_t* profilingStackAddr = nullptr;
+ uint8_t* nativeStackAddr = nullptr;
+
+ if (profilingStackIndex != profilingStackFrameCount) {
+ const ProfilingStackFrame& profilingStackFrame =
+ profilingStackFrames[profilingStackIndex];
+
+ if (profilingStackFrame.isLabelFrame() ||
+ profilingStackFrame.isSpMarkerFrame()) {
+ lastLabelFrameStackAddr = (uint8_t*)profilingStackFrame.stackAddress();
+ }
+
+ // Skip any JS_OSR frames. Such frames are used when the JS interpreter
+ // enters a jit frame on a loop edge (via on-stack-replacement, or OSR).
+ // To avoid both the profiling stack frame and jit frame being recorded
+ // (and showing up twice), the interpreter marks the interpreter
+ // profiling stack frame as JS_OSR to ensure that it doesn't get counted.
+ if (profilingStackFrame.isOSRFrame()) {
+ profilingStackIndex++;
+ continue;
+ }
+
+ MOZ_ASSERT(lastLabelFrameStackAddr);
+ profilingStackAddr = lastLabelFrameStackAddr;
+ }
+
+ if (nativeIndex >= 0) {
+ nativeStackAddr = (uint8_t*)aNativeStack.mSPs[nativeIndex];
+ }
+
+ // If there's a native stack frame which has the same SP as a profiling
+ // stack frame, pretend we didn't see the native stack frame. Ditto for a
+ // native stack frame which has the same SP as a JS stack frame. In effect
+ // this means profiling stack frames or JS frames trump conflicting native
+ // frames.
+ if (nativeStackAddr && (profilingStackAddr == nativeStackAddr)) {
+ nativeStackAddr = nullptr;
+ nativeIndex--;
+ MOZ_ASSERT(profilingStackAddr);
+ }
+
+ // Sanity checks.
+ MOZ_ASSERT_IF(profilingStackAddr, profilingStackAddr != nativeStackAddr);
+ MOZ_ASSERT_IF(nativeStackAddr, nativeStackAddr != profilingStackAddr);
+
+ // Check to see if profiling stack frame is top-most.
+ if (profilingStackAddr > nativeStackAddr) {
+ MOZ_ASSERT(profilingStackIndex < profilingStackFrameCount);
+ const ProfilingStackFrame& profilingStackFrame =
+ profilingStackFrames[profilingStackIndex];
+
+ // Sp marker frames are just annotations and should not be recorded in
+ // the profile.
+ if (!profilingStackFrame.isSpMarkerFrame()) {
+ if (aIsSynchronous && profilingStackFrame.categoryPair() ==
+ ProfilingCategoryPair::PROFILER) {
+ // For stacks captured synchronously (ie. marker stacks), stop
+ // walking the stack as soon as we enter the profiler category,
+ // to avoid showing profiler internal code in marker stacks.
+ return;
+ }
+ aCollector.CollectProfilingStackFrame(profilingStackFrame);
+ }
+ profilingStackIndex++;
+ continue;
+ }
+
+ // If we reach here, there must be a native stack frame and it must be the
+ // greatest frame.
+ if (nativeStackAddr) {
+ MOZ_ASSERT(nativeIndex >= 0);
+ void* addr = (void*)aNativeStack.mPCs[nativeIndex];
+ aCollector.CollectNativeLeafAddr(addr);
+ }
+ if (nativeIndex >= 0) {
+ nativeIndex--;
+ }
+ }
+}
+
+#if defined(GP_OS_windows) && defined(USE_MOZ_STACK_WALK)
+static HANDLE GetThreadHandle(PlatformData* aData);
+#endif
+
+#if defined(USE_FRAME_POINTER_STACK_WALK) || defined(USE_MOZ_STACK_WALK)
+static void StackWalkCallback(uint32_t aFrameNumber, void* aPC, void* aSP,
+ void* aClosure) {
+ NativeStack* nativeStack = static_cast<NativeStack*>(aClosure);
+ MOZ_ASSERT(nativeStack->mCount < MAX_NATIVE_FRAMES);
+ nativeStack->mSPs[nativeStack->mCount] = aSP;
+ nativeStack->mPCs[nativeStack->mCount] = aPC;
+ nativeStack->mCount++;
+}
+#endif
+
+#if defined(USE_FRAME_POINTER_STACK_WALK)
+static void DoFramePointerBacktrace(PSLockRef aLock,
+ const RegisteredThread& aRegisteredThread,
+ const Registers& aRegs,
+ NativeStack& aNativeStack) {
+ // WARNING: this function runs within the profiler's "critical section".
+ // WARNING: this function might be called while the profiler is inactive, and
+ // cannot rely on ActivePS.
+
+ // Start with the current function. We use 0 as the frame number here because
+ // the FramePointerStackWalk() call below will use 1..N. This is a bit weird
+ // but it doesn't matter because StackWalkCallback() doesn't use the frame
+ // number argument.
+ StackWalkCallback(/* frameNum */ 0, aRegs.mPC, aRegs.mSP, &aNativeStack);
+
+ uint32_t maxFrames = uint32_t(MAX_NATIVE_FRAMES - aNativeStack.mCount);
+
+ const void* stackEnd = aRegisteredThread.StackTop();
+ if (aRegs.mFP >= aRegs.mSP && aRegs.mFP <= stackEnd) {
+ FramePointerStackWalk(StackWalkCallback, maxFrames, &aNativeStack,
+ reinterpret_cast<void**>(aRegs.mFP),
+ const_cast<void*>(stackEnd));
+ }
+}
+#endif
+
+#if defined(USE_MOZ_STACK_WALK)
+static void DoMozStackWalkBacktrace(PSLockRef aLock,
+ const RegisteredThread& aRegisteredThread,
+ const Registers& aRegs,
+ NativeStack& aNativeStack) {
+ // WARNING: this function runs within the profiler's "critical section".
+ // WARNING: this function might be called while the profiler is inactive, and
+ // cannot rely on ActivePS.
+
+ // Start with the current function. We use 0 as the frame number here because
+ // the MozStackWalkThread() call below will use 1..N. This is a bit weird but
+ // it doesn't matter because StackWalkCallback() doesn't use the frame number
+ // argument.
+ StackWalkCallback(/* frameNum */ 0, aRegs.mPC, aRegs.mSP, &aNativeStack);
+
+ uint32_t maxFrames = uint32_t(MAX_NATIVE_FRAMES - aNativeStack.mCount);
+
+ HANDLE thread = GetThreadHandle(aRegisteredThread.GetPlatformData());
+ MOZ_ASSERT(thread);
+ MozStackWalkThread(StackWalkCallback, maxFrames, &aNativeStack, thread,
+ /* context */ nullptr);
+}
+#endif
+
+#ifdef USE_EHABI_STACKWALK
+static void DoEHABIBacktrace(PSLockRef aLock,
+ const RegisteredThread& aRegisteredThread,
+ const Registers& aRegs,
+ NativeStack& aNativeStack) {
+ // WARNING: this function runs within the profiler's "critical section".
+ // WARNING: this function might be called while the profiler is inactive, and
+ // cannot rely on ActivePS.
+
+ aNativeStack.mCount =
+ EHABIStackWalk(aRegs.mContext->uc_mcontext,
+ const_cast<void*>(aRegisteredThread.StackTop()),
+ aNativeStack.mSPs, aNativeStack.mPCs, MAX_NATIVE_FRAMES);
+}
+#endif
+
+#ifdef USE_LUL_STACKWALK
+
+// See the comment at the callsite for why this function is necessary.
+# if defined(MOZ_HAVE_ASAN_IGNORE)
+MOZ_ASAN_IGNORE static void ASAN_memcpy(void* aDst, const void* aSrc,
+ size_t aLen) {
+ // The obvious thing to do here is call memcpy(). However, although
+ // ASAN_memcpy() is not instrumented by ASAN, memcpy() still is, and the
+ // false positive still manifests! So we must implement memcpy() ourselves
+ // within this function.
+ char* dst = static_cast<char*>(aDst);
+ const char* src = static_cast<const char*>(aSrc);
+
+ for (size_t i = 0; i < aLen; i++) {
+ dst[i] = src[i];
+ }
+}
+# endif
+
+static void DoLULBacktrace(PSLockRef aLock,
+ const RegisteredThread& aRegisteredThread,
+ const Registers& aRegs, NativeStack& aNativeStack) {
+ // WARNING: this function runs within the profiler's "critical section".
+ // WARNING: this function might be called while the profiler is inactive, and
+ // cannot rely on ActivePS.
+
+ const mcontext_t* mc = &aRegs.mContext->uc_mcontext;
+
+ lul::UnwindRegs startRegs;
+ memset(&startRegs, 0, sizeof(startRegs));
+
+# if defined(GP_PLAT_amd64_linux) || defined(GP_PLAT_amd64_android)
+ startRegs.xip = lul::TaggedUWord(mc->gregs[REG_RIP]);
+ startRegs.xsp = lul::TaggedUWord(mc->gregs[REG_RSP]);
+ startRegs.xbp = lul::TaggedUWord(mc->gregs[REG_RBP]);
+# elif defined(GP_PLAT_amd64_freebsd)
+ startRegs.xip = lul::TaggedUWord(mc->mc_rip);
+ startRegs.xsp = lul::TaggedUWord(mc->mc_rsp);
+ startRegs.xbp = lul::TaggedUWord(mc->mc_rbp);
+# elif defined(GP_PLAT_arm_linux) || defined(GP_PLAT_arm_android)
+ startRegs.r15 = lul::TaggedUWord(mc->arm_pc);
+ startRegs.r14 = lul::TaggedUWord(mc->arm_lr);
+ startRegs.r13 = lul::TaggedUWord(mc->arm_sp);
+ startRegs.r12 = lul::TaggedUWord(mc->arm_ip);
+ startRegs.r11 = lul::TaggedUWord(mc->arm_fp);
+ startRegs.r7 = lul::TaggedUWord(mc->arm_r7);
+# elif defined(GP_PLAT_arm64_linux) || defined(GP_PLAT_arm64_android)
+ startRegs.pc = lul::TaggedUWord(mc->pc);
+ startRegs.x29 = lul::TaggedUWord(mc->regs[29]);
+ startRegs.x30 = lul::TaggedUWord(mc->regs[30]);
+ startRegs.sp = lul::TaggedUWord(mc->sp);
+# elif defined(GP_PLAT_arm64_freebsd)
+ startRegs.pc = lul::TaggedUWord(mc->mc_gpregs.gp_elr);
+ startRegs.x29 = lul::TaggedUWord(mc->mc_gpregs.gp_x[29]);
+ startRegs.x30 = lul::TaggedUWord(mc->mc_gpregs.gp_lr);
+ startRegs.sp = lul::TaggedUWord(mc->mc_gpregs.gp_sp);
+# elif defined(GP_PLAT_x86_linux) || defined(GP_PLAT_x86_android)
+ startRegs.xip = lul::TaggedUWord(mc->gregs[REG_EIP]);
+ startRegs.xsp = lul::TaggedUWord(mc->gregs[REG_ESP]);
+ startRegs.xbp = lul::TaggedUWord(mc->gregs[REG_EBP]);
+# elif defined(GP_PLAT_mips64_linux)
+ startRegs.pc = lul::TaggedUWord(mc->pc);
+ startRegs.sp = lul::TaggedUWord(mc->gregs[29]);
+ startRegs.fp = lul::TaggedUWord(mc->gregs[30]);
+# else
+# error "Unknown plat"
+# endif
+
+ // Copy up to N_STACK_BYTES from rsp-REDZONE upwards, but not going past the
+ // stack's registered top point. Do some basic sanity checks too. This
+ // assumes that the TaggedUWord holding the stack pointer value is valid, but
+ // it should be, since it was constructed that way in the code just above.
+
+ // We could construct |stackImg| so that LUL reads directly from the stack in
+ // question, rather than from a copy of it. That would reduce overhead and
+ // space use a bit. However, it gives a problem with dynamic analysis tools
+ // (ASan, TSan, Valgrind) which is that such tools will report invalid or
+ // racing memory accesses, and such accesses will be reported deep inside LUL.
+ // By taking a copy here, we can either sanitise the copy (for Valgrind) or
+ // copy it using an unchecked memcpy (for ASan, TSan). That way we don't have
+ // to try and suppress errors inside LUL.
+ //
+ // N_STACK_BYTES is set to 160KB. This is big enough to hold all stacks
+ // observed in some minutes of testing, whilst keeping the size of this
+ // function (DoNativeBacktrace)'s frame reasonable. Most stacks observed in
+ // practice are small, 4KB or less, and so the copy costs are insignificant
+ // compared to other profiler overhead.
+ //
+ // |stackImg| is allocated on this (the sampling thread's) stack. That
+ // implies that the frame for this function is at least N_STACK_BYTES large.
+ // In general it would be considered unacceptable to have such a large frame
+ // on a stack, but it only exists for the unwinder thread, and so is not
+ // expected to be a problem. Allocating it on the heap is troublesome because
+ // this function runs whilst the sampled thread is suspended, so any heap
+ // allocation risks deadlock. Allocating it as a global variable is not
+ // thread safe, which would be a problem if we ever allow multiple sampler
+ // threads. Hence allocating it on the stack seems to be the least-worst
+ // option.
+
+ lul::StackImage stackImg;
+
+ {
+# if defined(GP_PLAT_amd64_linux) || defined(GP_PLAT_amd64_android) || \
+ defined(GP_PLAT_amd64_freebsd)
+ uintptr_t rEDZONE_SIZE = 128;
+ uintptr_t start = startRegs.xsp.Value() - rEDZONE_SIZE;
+# elif defined(GP_PLAT_arm_linux) || defined(GP_PLAT_arm_android)
+ uintptr_t rEDZONE_SIZE = 0;
+ uintptr_t start = startRegs.r13.Value() - rEDZONE_SIZE;
+# elif defined(GP_PLAT_arm64_linux) || defined(GP_PLAT_arm64_android) || \
+ defined(GP_PLAT_arm64_freebsd)
+ uintptr_t rEDZONE_SIZE = 0;
+ uintptr_t start = startRegs.sp.Value() - rEDZONE_SIZE;
+# elif defined(GP_PLAT_x86_linux) || defined(GP_PLAT_x86_android)
+ uintptr_t rEDZONE_SIZE = 0;
+ uintptr_t start = startRegs.xsp.Value() - rEDZONE_SIZE;
+# elif defined(GP_PLAT_mips64_linux)
+ uintptr_t rEDZONE_SIZE = 0;
+ uintptr_t start = startRegs.sp.Value() - rEDZONE_SIZE;
+# else
+# error "Unknown plat"
+# endif
+ uintptr_t end = reinterpret_cast<uintptr_t>(aRegisteredThread.StackTop());
+ uintptr_t ws = sizeof(void*);
+ start &= ~(ws - 1);
+ end &= ~(ws - 1);
+ uintptr_t nToCopy = 0;
+ if (start < end) {
+ nToCopy = end - start;
+ if (nToCopy > lul::N_STACK_BYTES) nToCopy = lul::N_STACK_BYTES;
+ }
+ MOZ_ASSERT(nToCopy <= lul::N_STACK_BYTES);
+ stackImg.mLen = nToCopy;
+ stackImg.mStartAvma = start;
+ if (nToCopy > 0) {
+ // If this is a vanilla memcpy(), ASAN makes the following complaint:
+ //
+ // ERROR: AddressSanitizer: stack-buffer-underflow ...
+ // ...
+ // HINT: this may be a false positive if your program uses some custom
+ // stack unwind mechanism or swapcontext
+ //
+ // This code is very much a custom stack unwind mechanism! So we use an
+ // alternative memcpy() implementation that is ignored by ASAN.
+# if defined(MOZ_HAVE_ASAN_IGNORE)
+ ASAN_memcpy(&stackImg.mContents[0], (void*)start, nToCopy);
+# else
+ memcpy(&stackImg.mContents[0], (void*)start, nToCopy);
+# endif
+ (void)VALGRIND_MAKE_MEM_DEFINED(&stackImg.mContents[0], nToCopy);
+ }
+ }
+
+ size_t framePointerFramesAcquired = 0;
+ lul::LUL* lul = CorePS::Lul(aLock);
+ lul->Unwind(reinterpret_cast<uintptr_t*>(aNativeStack.mPCs),
+ reinterpret_cast<uintptr_t*>(aNativeStack.mSPs),
+ &aNativeStack.mCount, &framePointerFramesAcquired,
+ MAX_NATIVE_FRAMES, &startRegs, &stackImg);
+
+ // Update stats in the LUL stats object. Unfortunately this requires
+ // three global memory operations.
+ lul->mStats.mContext += 1;
+ lul->mStats.mCFI += aNativeStack.mCount - 1 - framePointerFramesAcquired;
+ lul->mStats.mFP += framePointerFramesAcquired;
+}
+
+#endif
+
+#ifdef HAVE_NATIVE_UNWIND
+static void DoNativeBacktrace(PSLockRef aLock,
+ const RegisteredThread& aRegisteredThread,
+ const Registers& aRegs,
+ NativeStack& aNativeStack) {
+ // This method determines which stackwalker is used for periodic and
+ // synchronous samples. (Backtrace samples are treated differently, see
+ // profiler_suspend_and_sample_thread() for details). The only part of the
+ // ordering that matters is that LUL must precede FRAME_POINTER, because on
+ // Linux they can both be present.
+# if defined(USE_LUL_STACKWALK)
+ DoLULBacktrace(aLock, aRegisteredThread, aRegs, aNativeStack);
+# elif defined(USE_EHABI_STACKWALK)
+ DoEHABIBacktrace(aLock, aRegisteredThread, aRegs, aNativeStack);
+# elif defined(USE_FRAME_POINTER_STACK_WALK)
+ DoFramePointerBacktrace(aLock, aRegisteredThread, aRegs, aNativeStack);
+# elif defined(USE_MOZ_STACK_WALK)
+ DoMozStackWalkBacktrace(aLock, aRegisteredThread, aRegs, aNativeStack);
+# else
+# error "Invalid configuration"
+# endif
+}
+#endif
+
+// Writes some components shared by periodic and synchronous profiles to
+// ActivePS's ProfileBuffer. (This should only be called from DoSyncSample()
+// and DoPeriodicSample().)
+//
+// The grammar for entry sequences is in a comment above
+// ProfileBuffer::StreamSamplesToJSON.
+static inline void DoSharedSample(
+ PSLockRef aLock, bool aIsSynchronous, RegisteredThread& aRegisteredThread,
+ const Registers& aRegs, uint64_t aSamplePos, uint64_t aBufferRangeStart,
+ ProfileBuffer& aBuffer,
+ StackCaptureOptions aCaptureOptions = StackCaptureOptions::Full) {
+ // WARNING: this function runs within the profiler's "critical section".
+
+ MOZ_ASSERT(!aBuffer.IsThreadSafe(),
+ "Mutexes cannot be used inside this critical section");
+
+ MOZ_RELEASE_ASSERT(ActivePS::Exists(aLock));
+
+ ProfileBufferCollector collector(aBuffer, aSamplePos, aBufferRangeStart);
+ NativeStack nativeStack;
+#if defined(HAVE_NATIVE_UNWIND)
+ if (ActivePS::FeatureStackWalk(aLock) &&
+ aCaptureOptions == StackCaptureOptions::Full) {
+ DoNativeBacktrace(aLock, aRegisteredThread, aRegs, nativeStack);
+
+ MergeStacks(ActivePS::Features(aLock), aIsSynchronous, aRegisteredThread,
+ aRegs, nativeStack, collector);
+ } else
+#endif
+ {
+ MergeStacks(ActivePS::Features(aLock), aIsSynchronous, aRegisteredThread,
+ aRegs, nativeStack, collector);
+
+ // We can't walk the whole native stack, but we can record the top frame.
+ if (aCaptureOptions == StackCaptureOptions::Full) {
+ aBuffer.AddEntry(ProfileBufferEntry::NativeLeafAddr((void*)aRegs.mPC));
+ }
+ }
+}
+
+// Writes the components of a synchronous sample to the given ProfileBuffer.
+static void DoSyncSample(PSLockRef aLock, RegisteredThread& aRegisteredThread,
+ const TimeStamp& aNow, const Registers& aRegs,
+ ProfileBuffer& aBuffer,
+ StackCaptureOptions aCaptureOptions) {
+ // WARNING: this function runs within the profiler's "critical section".
+
+ MOZ_ASSERT(aCaptureOptions != StackCaptureOptions::NoStack,
+ "DoSyncSample should not be called when no capture is needed");
+
+ const uint64_t bufferRangeStart = aBuffer.BufferRangeStart();
+
+ const uint64_t samplePos =
+ aBuffer.AddThreadIdEntry(aRegisteredThread.Info()->ThreadId());
+
+ TimeDuration delta = aNow - CorePS::ProcessStartTime();
+ aBuffer.AddEntry(ProfileBufferEntry::Time(delta.ToMilliseconds()));
+
+ DoSharedSample(aLock, /* aIsSynchronous = */ true, aRegisteredThread, aRegs,
+ samplePos, bufferRangeStart, aBuffer, aCaptureOptions);
+}
+
+// Writes the components of a periodic sample to ActivePS's ProfileBuffer.
+// The ThreadId entry is already written in the main ProfileBuffer, its location
+// is `aSamplePos`, we can write the rest to `aBuffer` (which may be different).
+static void DoPeriodicSample(PSLockRef aLock,
+ RegisteredThread& aRegisteredThread,
+ ProfiledThreadData& aProfiledThreadData,
+ const Registers& aRegs, uint64_t aSamplePos,
+ uint64_t aBufferRangeStart,
+ ProfileBuffer& aBuffer) {
+ // WARNING: this function runs within the profiler's "critical section".
+
+ DoSharedSample(aLock, /* aIsSynchronous = */ false, aRegisteredThread, aRegs,
+ aSamplePos, aBufferRangeStart, aBuffer);
+}
+
+// END sampling/unwinding code
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN saving/streaming code
+
+const static uint64_t kJS_MAX_SAFE_UINTEGER = +9007199254740991ULL;
+
+static int64_t SafeJSInteger(uint64_t aValue) {
+ return aValue <= kJS_MAX_SAFE_UINTEGER ? int64_t(aValue) : -1;
+}
+
+static void AddSharedLibraryInfoToStream(JSONWriter& aWriter,
+ const SharedLibrary& aLib) {
+ aWriter.StartObjectElement();
+ aWriter.IntProperty("start", SafeJSInteger(aLib.GetStart()));
+ aWriter.IntProperty("end", SafeJSInteger(aLib.GetEnd()));
+ aWriter.IntProperty("offset", SafeJSInteger(aLib.GetOffset()));
+ aWriter.StringProperty("name", aLib.GetModuleName());
+ aWriter.StringProperty("path", aLib.GetModulePath());
+ aWriter.StringProperty("debugName", aLib.GetDebugName());
+ aWriter.StringProperty("debugPath", aLib.GetDebugPath());
+ aWriter.StringProperty("breakpadId", aLib.GetBreakpadId());
+ aWriter.StringProperty("codeId", aLib.GetCodeId());
+ aWriter.StringProperty("arch", aLib.GetArch());
+ aWriter.EndObject();
+}
+
+void AppendSharedLibraries(JSONWriter& aWriter) {
+ SharedLibraryInfo info = SharedLibraryInfo::GetInfoForSelf();
+ info.SortByAddress();
+ for (size_t i = 0; i < info.GetSize(); i++) {
+ AddSharedLibraryInfoToStream(aWriter, info.GetEntry(i));
+ }
+}
+
+static void StreamCategories(SpliceableJSONWriter& aWriter) {
+ // Same order as ProfilingCategory. Format:
+ // [
+ // {
+ // name: "Idle",
+ // color: "transparent",
+ // subcategories: ["Other"],
+ // },
+ // {
+ // name: "Other",
+ // color: "grey",
+ // subcategories: [
+ // "JSM loading",
+ // "Subprocess launching",
+ // "DLL loading"
+ // ]
+ // },
+ // ...
+ // ]
+
+#define CATEGORY_JSON_BEGIN_CATEGORY(name, labelAsString, color) \
+ aWriter.Start(); \
+ aWriter.StringProperty("name", labelAsString); \
+ aWriter.StringProperty("color", color); \
+ aWriter.StartArrayProperty("subcategories");
+#define CATEGORY_JSON_SUBCATEGORY(supercategory, name, labelAsString) \
+ aWriter.StringElement(labelAsString);
+#define CATEGORY_JSON_END_CATEGORY \
+ aWriter.EndArray(); \
+ aWriter.EndObject();
+
+ MOZ_PROFILING_CATEGORY_LIST(CATEGORY_JSON_BEGIN_CATEGORY,
+ CATEGORY_JSON_SUBCATEGORY,
+ CATEGORY_JSON_END_CATEGORY)
+
+#undef CATEGORY_JSON_BEGIN_CATEGORY
+#undef CATEGORY_JSON_SUBCATEGORY
+#undef CATEGORY_JSON_END_CATEGORY
+}
+
+static void StreamMarkerSchema(SpliceableJSONWriter& aWriter) {
+ // Get an array view with all registered marker-type-specific functions.
+ base_profiler_markers_detail::Streaming::LockedMarkerTypeFunctionsList
+ markerTypeFunctionsArray;
+ // List of streamed marker names, this is used to spot duplicates.
+ std::set<std::string> names;
+ // Stream the display schema for each different one. (Duplications may come
+ // from the same code potentially living in different libraries.)
+ for (const auto& markerTypeFunctions : markerTypeFunctionsArray) {
+ auto name = markerTypeFunctions.mMarkerTypeNameFunction();
+ // std::set.insert(T&&) returns a pair, its `second` is true if the element
+ // was actually inserted (i.e., it was not there yet.)
+ const bool didInsert =
+ names.insert(std::string(name.data(), name.size())).second;
+ if (didInsert) {
+ markerTypeFunctions.mMarkerSchemaFunction().Stream(aWriter, name);
+ }
+ }
+}
+
+static int64_t MicrosecondsSince1970();
+
+static void StreamMetaJSCustomObject(PSLockRef aLock,
+ SpliceableJSONWriter& aWriter,
+ bool aIsShuttingDown) {
+ MOZ_RELEASE_ASSERT(CorePS::Exists() && ActivePS::Exists(aLock));
+
+ aWriter.IntProperty("version", 27);
+
+ // The "startTime" field holds the number of milliseconds since midnight
+ // January 1, 1970 GMT. This grotty code computes (Now - (Now -
+ // ProcessStartTime)) to convert CorePS::ProcessStartTime() into that form.
+ // Note: This is the only absolute time in the profile! All other timestamps
+ // are relative to this startTime.
+ TimeDuration delta = TimeStamp::Now() - CorePS::ProcessStartTime();
+ aWriter.DoubleProperty(
+ "startTime", MicrosecondsSince1970() / 1000.0 - delta.ToMilliseconds());
+
+ aWriter.DoubleProperty("profilingStartTime", (ActivePS::ProfilingStartTime() -
+ CorePS::ProcessStartTime())
+ .ToMilliseconds());
+
+ if (const TimeStamp contentEarliestTime =
+ ActivePS::Buffer(aLock)
+ .UnderlyingChunkedBuffer()
+ .GetEarliestChunkStartTimeStamp();
+ !contentEarliestTime.IsNull()) {
+ aWriter.DoubleProperty(
+ "contentEarliestTime",
+ (contentEarliestTime - CorePS::ProcessStartTime()).ToMilliseconds());
+ } else {
+ aWriter.NullProperty("contentEarliestTime");
+ }
+
+ const double profilingEndTime = profiler_time();
+ aWriter.DoubleProperty("profilingEndTime", profilingEndTime);
+
+ if (aIsShuttingDown) {
+ aWriter.DoubleProperty("shutdownTime", profilingEndTime);
+ } else {
+ aWriter.NullProperty("shutdownTime");
+ }
+
+ aWriter.StartArrayProperty("categories");
+ StreamCategories(aWriter);
+ aWriter.EndArray();
+
+ aWriter.StartArrayProperty("markerSchema");
+ StreamMarkerSchema(aWriter);
+ aWriter.EndArray();
+
+ if (!profiler_is_main_thread()) {
+ // Leave the rest of the properties out if we're not on the main thread.
+ // At the moment, the only case in which this function is called on a
+ // background thread is if we're in a content process and are going to
+ // send this profile to the parent process. In that case, the parent
+ // process profile's "meta" object already has the rest of the properties,
+ // and the parent process profile is dumped on that process's main thread.
+ return;
+ }
+
+ aWriter.DoubleProperty("interval", ActivePS::Interval(aLock));
+ aWriter.IntProperty("stackwalk", ActivePS::FeatureStackWalk(aLock));
+
+#ifdef DEBUG
+ aWriter.IntProperty("debug", 1);
+#else
+ aWriter.IntProperty("debug", 0);
+#endif
+
+ aWriter.IntProperty("gcpoison", 0);
+
+ aWriter.IntProperty("asyncstack", 0);
+
+ aWriter.IntProperty("processType", 0);
+}
+
+static void StreamPages(PSLockRef aLock, SpliceableJSONWriter& aWriter) {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+ ActivePS::DiscardExpiredPages(aLock);
+ for (const auto& page : ActivePS::ProfiledPages(aLock)) {
+ page->StreamJSON(aWriter);
+ }
+}
+
+static void locked_profiler_stream_json_for_this_process(
+ PSLockRef aLock, SpliceableJSONWriter& aWriter, double aSinceTime,
+ bool aIsShuttingDown, bool aOnlyThreads = false) {
+ LOG("locked_profiler_stream_json_for_this_process");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists() && ActivePS::Exists(aLock));
+
+ AUTO_PROFILER_STATS(base_locked_profiler_stream_json_for_this_process);
+
+ const double collectionStartMs = profiler_time();
+
+ ProfileBuffer& buffer = ActivePS::Buffer(aLock);
+
+ // If there is a set "Window length", discard older data.
+ Maybe<double> durationS = ActivePS::Duration(aLock);
+ if (durationS.isSome()) {
+ const double durationStartMs = collectionStartMs - *durationS * 1000;
+ buffer.DiscardSamplesBeforeTime(durationStartMs);
+ }
+
+ if (!aOnlyThreads) {
+ // Put shared library info
+ aWriter.StartArrayProperty("libs");
+ AppendSharedLibraries(aWriter);
+ aWriter.EndArray();
+
+ // Put meta data
+ aWriter.StartObjectProperty("meta");
+ { StreamMetaJSCustomObject(aLock, aWriter, aIsShuttingDown); }
+ aWriter.EndObject();
+
+ // Put page data
+ aWriter.StartArrayProperty("pages");
+ { StreamPages(aLock, aWriter); }
+ aWriter.EndArray();
+
+ buffer.StreamProfilerOverheadToJSON(aWriter, CorePS::ProcessStartTime(),
+ aSinceTime);
+ buffer.StreamCountersToJSON(aWriter, CorePS::ProcessStartTime(),
+ aSinceTime);
+
+ // Lists the samples for each thread profile
+ aWriter.StartArrayProperty("threads");
+ }
+
+ // if aOnlyThreads is true, the only output will be the threads array items.
+ {
+ ActivePS::DiscardExpiredDeadProfiledThreads(aLock);
+ Vector<std::pair<RegisteredThread*, ProfiledThreadData*>> threads =
+ ActivePS::ProfiledThreads(aLock);
+ for (auto& thread : threads) {
+ ProfiledThreadData* profiledThreadData = thread.second;
+ profiledThreadData->StreamJSON(
+ buffer, aWriter, CorePS::ProcessName(aLock), CorePS::ETLDplus1(aLock),
+ CorePS::ProcessStartTime(), aSinceTime);
+ }
+ }
+
+ if (!aOnlyThreads) {
+ aWriter.EndArray();
+
+ aWriter.StartArrayProperty("pausedRanges");
+ { buffer.StreamPausedRangesToJSON(aWriter, aSinceTime); }
+ aWriter.EndArray();
+ }
+
+ const double collectionEndMs = profiler_time();
+
+ // Record timestamps for the collection into the buffer, so that consumers
+ // know why we didn't collect any samples for its duration.
+ // We put these entries into the buffer after we've collected the profile,
+ // so they'll be visible for the *next* profile collection (if they haven't
+ // been overwritten due to buffer wraparound by then).
+ buffer.AddEntry(ProfileBufferEntry::CollectionStart(collectionStartMs));
+ buffer.AddEntry(ProfileBufferEntry::CollectionEnd(collectionEndMs));
+}
+
+bool profiler_stream_json_for_this_process(SpliceableJSONWriter& aWriter,
+ double aSinceTime,
+ bool aIsShuttingDown,
+ bool aOnlyThreads) {
+ LOG("profiler_stream_json_for_this_process");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return false;
+ }
+
+ locked_profiler_stream_json_for_this_process(lock, aWriter, aSinceTime,
+ aIsShuttingDown, aOnlyThreads);
+ return true;
+}
+
+// END saving/streaming code
+////////////////////////////////////////////////////////////////////////
+
+static char FeatureCategory(uint32_t aFeature) {
+ if (aFeature & DefaultFeatures()) {
+ if (aFeature & AvailableFeatures()) {
+ return 'D';
+ }
+ return 'd';
+ }
+
+ if (aFeature & StartupExtraDefaultFeatures()) {
+ if (aFeature & AvailableFeatures()) {
+ return 'S';
+ }
+ return 's';
+ }
+
+ if (aFeature & AvailableFeatures()) {
+ return '-';
+ }
+ return 'x';
+}
+
+static void PrintUsage() {
+ PrintToConsole(
+ "\n"
+ "Profiler environment variable usage:\n"
+ "\n"
+ " MOZ_BASE_PROFILER_HELP\n"
+ " If set to any value, prints this message.\n"
+ " (Only BaseProfiler features are known here; Use MOZ_PROFILER_HELP\n"
+ " for Gecko Profiler help, with more features).\n"
+ "\n"
+ " MOZ_BASE_PROFILER_{,DEBUG_,VERBOSE}LOGGING\n"
+ " Enables BaseProfiler logging to stdout. The levels of logging\n"
+ " available are MOZ_BASE_PROFILER_LOGGING' (least verbose),\n"
+ " '..._DEBUG_LOGGING', '..._VERBOSE_LOGGING' (most verbose)\n"
+ "\n"
+ " MOZ_PROFILER_STARTUP\n"
+ " If set to any value other than '' or '0'/'N'/'n', starts the\n"
+ " profiler immediately on start-up.\n"
+ " Useful if you want profile code that runs very early.\n"
+ "\n"
+ " MOZ_PROFILER_STARTUP_ENTRIES=<%u..%u>\n"
+ " If MOZ_PROFILER_STARTUP is set, specifies the number of entries\n"
+ " per process in the profiler's circular buffer when the profiler is\n"
+ " first started.\n"
+ " If unset, the platform default is used:\n"
+ " %u entries per process, or %u when MOZ_PROFILER_STARTUP is set.\n"
+ " (%u bytes per entry -> %u or %u total bytes per process)\n"
+ " Optional units in bytes: KB, KiB, MB, MiB, GB, GiB\n"
+ "\n"
+ " MOZ_PROFILER_STARTUP_DURATION=<1..>\n"
+ " If MOZ_PROFILER_STARTUP is set, specifies the maximum life time\n"
+ " of entries in the the profiler's circular buffer when the profiler\n"
+ " is first started, in seconds.\n"
+ " If unset, the life time of the entries will only be restricted by\n"
+ " MOZ_PROFILER_STARTUP_ENTRIES (or its default value), and no\n"
+ " additional time duration restriction will be applied.\n"
+ "\n"
+ " MOZ_PROFILER_STARTUP_INTERVAL=<1..1000>\n"
+ " If MOZ_PROFILER_STARTUP is set, specifies the sample interval,\n"
+ " measured in milliseconds, when the profiler is first started.\n"
+ " If unset, the platform default is used.\n"
+ "\n"
+ " MOZ_PROFILER_STARTUP_FEATURES_BITFIELD=<Number>\n"
+ " If MOZ_PROFILER_STARTUP is set, specifies the profiling\n"
+ " features, as the integer value of the features bitfield.\n"
+ " If unset, the value from MOZ_PROFILER_STARTUP_FEATURES is used.\n"
+ "\n"
+ " MOZ_PROFILER_STARTUP_FEATURES=<Features>\n"
+ " If MOZ_PROFILER_STARTUP is set, specifies the profiling\n"
+ " features, as a comma-separated list of strings.\n"
+ " Ignored if MOZ_PROFILER_STARTUP_FEATURES_BITFIELD is set.\n"
+ " If unset, the platform default is used.\n"
+ "\n"
+ " Features: (x=unavailable, D/d=default/unavailable,\n"
+ " S/s=MOZ_PROFILER_STARTUP extra "
+ "default/unavailable)\n",
+ unsigned(ActivePS::scMinimumBufferEntries),
+ unsigned(ActivePS::scMaximumBufferEntries),
+ unsigned(BASE_PROFILER_DEFAULT_ENTRIES.Value()),
+ unsigned(BASE_PROFILER_DEFAULT_STARTUP_ENTRIES.Value()),
+ unsigned(scBytesPerEntry),
+ unsigned(BASE_PROFILER_DEFAULT_ENTRIES.Value() * scBytesPerEntry),
+ unsigned(BASE_PROFILER_DEFAULT_STARTUP_ENTRIES.Value() *
+ scBytesPerEntry));
+
+#define PRINT_FEATURE(n_, str_, Name_, desc_) \
+ PrintToConsole(" %c %7u: \"%s\" (%s)\n", \
+ FeatureCategory(ProfilerFeature::Name_), \
+ ProfilerFeature::Name_, str_, desc_);
+
+ BASE_PROFILER_FOR_EACH_FEATURE(PRINT_FEATURE)
+
+#undef PRINT_FEATURE
+
+ PrintToConsole(
+ " - \"default\" (All above D+S defaults)\n"
+ "\n"
+ " MOZ_PROFILER_STARTUP_FILTERS=<Filters>\n"
+ " If MOZ_PROFILER_STARTUP is set, specifies the thread filters, as "
+ "a\n"
+ " comma-separated list of strings. A given thread will be sampled if\n"
+ " any of the filters is a case-insensitive substring of the thread\n"
+ " name. If unset, a default is used.\n"
+ "\n"
+ " MOZ_PROFILER_SHUTDOWN\n"
+ " If set, the profiler saves a profile to the named file on shutdown.\n"
+ "\n"
+ " MOZ_PROFILER_SYMBOLICATE\n"
+ " If set, the profiler will pre-symbolicate profiles.\n"
+ " *Note* This will add a significant pause when gathering data, and\n"
+ " is intended mainly for local development.\n"
+ "\n"
+ " MOZ_PROFILER_LUL_TEST\n"
+ " If set to any value, runs LUL unit tests at startup.\n"
+ "\n"
+ " This platform %s native unwinding.\n"
+ "\n",
+#if defined(HAVE_NATIVE_UNWIND)
+ "supports"
+#else
+ "does not support"
+#endif
+ );
+}
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN Sampler
+
+#if defined(GP_OS_linux) || defined(GP_OS_android)
+struct SigHandlerCoordinator;
+#endif
+
+// Sampler performs setup and teardown of the state required to sample with the
+// profiler. Sampler may exist when ActivePS is not present.
+//
+// SuspendAndSampleAndResumeThread must only be called from a single thread,
+// and must not sample the thread it is being called from. A separate Sampler
+// instance must be used for each thread which wants to capture samples.
+
+// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+//
+// With the exception of SamplerThread, all Sampler objects must be Disable-d
+// before releasing the lock which was used to create them. This avoids races
+// on linux with the SIGPROF signal handler.
+
+class Sampler {
+ public:
+ // Sets up the profiler such that it can begin sampling.
+ explicit Sampler(PSLockRef aLock);
+
+ // Disable the sampler, restoring it to its previous state. This must be
+ // called once, and only once, before the Sampler is destroyed.
+ void Disable(PSLockRef aLock);
+
+ // This method suspends and resumes the samplee thread. It calls the passed-in
+ // function-like object aProcessRegs (passing it a populated |const
+ // Registers&| arg) while the samplee thread is suspended.
+ //
+ // Func must be a function-like object of type `void()`.
+ template <typename Func>
+ void SuspendAndSampleAndResumeThread(
+ PSLockRef aLock, const RegisteredThread& aRegisteredThread,
+ const TimeStamp& aNow, const Func& aProcessRegs);
+
+ private:
+#if defined(GP_OS_linux) || defined(GP_OS_android) || defined(GP_OS_freebsd)
+ // Used to restore the SIGPROF handler when ours is removed.
+ struct sigaction mOldSigprofHandler;
+
+ // This process' ID. Needed as an argument for tgkill in
+ // SuspendAndSampleAndResumeThread.
+ BaseProfilerProcessId mMyPid;
+
+ // The sampler thread's ID. Used to assert that it is not sampling itself,
+ // which would lead to deadlock.
+ BaseProfilerThreadId mSamplerTid;
+
+ public:
+ // This is the one-and-only variable used to communicate between the sampler
+ // thread and the samplee thread's signal handler. It's static because the
+ // samplee thread's signal handler is static.
+ static struct SigHandlerCoordinator* sSigHandlerCoordinator;
+#endif
+};
+
+// END Sampler
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN SamplerThread
+
+// The sampler thread controls sampling and runs whenever the profiler is
+// active. It periodically runs through all registered threads, finds those
+// that should be sampled, then pauses and samples them.
+
+class SamplerThread {
+ public:
+ // Creates a sampler thread, but doesn't start it.
+ SamplerThread(PSLockRef aLock, uint32_t aActivityGeneration,
+ double aIntervalMilliseconds, uint32_t aFeatures);
+ ~SamplerThread();
+
+ // This runs on (is!) the sampler thread.
+ void Run();
+
+ // This runs on the main thread.
+ void Stop(PSLockRef aLock);
+
+ private:
+ // This suspends the calling thread for the given number of microseconds.
+ // Best effort timing.
+ void SleepMicro(uint32_t aMicroseconds);
+
+ // The sampler used to suspend and sample threads.
+ Sampler mSampler;
+
+ // The activity generation, for detecting when the sampler thread must stop.
+ const uint32_t mActivityGeneration;
+
+ // The interval between samples, measured in microseconds.
+ const int mIntervalMicroseconds;
+
+ // The OS-specific handle for the sampler thread.
+#if defined(GP_OS_windows)
+ HANDLE mThread;
+#elif defined(GP_OS_darwin) || defined(GP_OS_linux) || \
+ defined(GP_OS_android) || defined(GP_OS_freebsd)
+ pthread_t mThread;
+#endif
+
+#if defined(GP_OS_windows)
+ bool mNoTimerResolutionChange = true;
+#endif
+
+ SamplerThread(const SamplerThread&) = delete;
+ void operator=(const SamplerThread&) = delete;
+};
+
+// This function is required because we need to create a SamplerThread within
+// ActivePS's constructor, but SamplerThread is defined after ActivePS. It
+// could probably be removed by moving some code around.
+static SamplerThread* NewSamplerThread(PSLockRef aLock, uint32_t aGeneration,
+ double aInterval, uint32_t aFeatures) {
+ return new SamplerThread(aLock, aGeneration, aInterval, aFeatures);
+}
+
+// This function is the sampler thread. This implementation is used for all
+// targets.
+void SamplerThread::Run() {
+ // TODO: If possible, name this thread later on, after NSPR becomes available.
+ // PR_SetCurrentThreadName("SamplerThread");
+
+ // Features won't change during this SamplerThread's lifetime, so we can read
+ // them once and store them locally.
+ const uint32_t features = []() -> uint32_t {
+ PSAutoLock lock;
+ if (!ActivePS::Exists(lock)) {
+ // If there is no active profiler, it doesn't matter what we return,
+ // because this thread will exit before any feature is used.
+ return 0;
+ }
+ return ActivePS::Features(lock);
+ }();
+
+ // Not *no*-stack-sampling means we do want stack sampling.
+ const bool stackSampling = !ProfilerFeature::HasNoStackSampling(features);
+
+ // Use local BlocksRingBuffer&ProfileBuffer to capture the stack.
+ // (This is to avoid touching the CorePS::CoreBuffer lock while
+ // a thread is suspended, because that thread could be working with
+ // the CorePS::CoreBuffer as well.)
+ ProfileBufferChunkManagerSingle localChunkManager(
+ ProfileBufferChunkManager::scExpectedMaximumStackSize);
+ ProfileChunkedBuffer localBuffer(
+ ProfileChunkedBuffer::ThreadSafety::WithoutMutex, localChunkManager);
+ ProfileBuffer localProfileBuffer(localBuffer);
+
+ // Will be kept between collections, to know what each collection does.
+ auto previousState = localBuffer.GetState();
+
+ // This will be positive if we are running behind schedule (sampling less
+ // frequently than desired) and negative if we are ahead of schedule.
+ TimeDuration lastSleepOvershoot = 0;
+ TimeStamp sampleStart = TimeStamp::Now();
+
+ while (true) {
+ // This scope is for |lock|. It ends before we sleep below.
+ {
+ PSAutoLock lock;
+ TimeStamp lockAcquired = TimeStamp::Now();
+
+ if (!ActivePS::Exists(lock)) {
+ return;
+ }
+
+ // At this point profiler_stop() might have been called, and
+ // profiler_start() might have been called on another thread. If this
+ // happens the generation won't match.
+ if (ActivePS::Generation(lock) != mActivityGeneration) {
+ return;
+ }
+
+ ActivePS::ClearExpiredExitProfiles(lock);
+
+ TimeStamp expiredMarkersCleaned = TimeStamp::Now();
+
+ if (int(gSkipSampling) <= 0 && !ActivePS::IsSamplingPaused(lock)) {
+ TimeDuration delta = sampleStart - CorePS::ProcessStartTime();
+ ProfileBuffer& buffer = ActivePS::Buffer(lock);
+
+ // handle per-process generic counters
+ const Vector<BaseProfilerCount*>& counters = CorePS::Counters(lock);
+ for (auto& counter : counters) {
+ // create Buffer entries for each counter
+ buffer.AddEntry(ProfileBufferEntry::CounterId(counter));
+ buffer.AddEntry(ProfileBufferEntry::Time(delta.ToMilliseconds()));
+ // XXX support keyed maps of counts
+ // In the future, we'll support keyed counters - for example, counters
+ // with a key which is a thread ID. For "simple" counters we'll just
+ // use a key of 0.
+ int64_t count;
+ uint64_t number;
+ counter->Sample(count, number);
+ buffer.AddEntry(ProfileBufferEntry::CounterKey(0));
+ buffer.AddEntry(ProfileBufferEntry::Count(count));
+ if (number) {
+ buffer.AddEntry(ProfileBufferEntry::Number(number));
+ }
+ }
+ TimeStamp countersSampled = TimeStamp::Now();
+
+ if (stackSampling) {
+ const Vector<LiveProfiledThreadData>& liveThreads =
+ ActivePS::LiveProfiledThreads(lock);
+
+ for (auto& thread : liveThreads) {
+ RegisteredThread* registeredThread = thread.mRegisteredThread;
+ ProfiledThreadData* profiledThreadData =
+ thread.mProfiledThreadData.get();
+ RefPtr<ThreadInfo> info = registeredThread->Info();
+
+ // If the thread is asleep and has been sampled before in the same
+ // sleep episode, find and copy the previous sample, as that's
+ // cheaper than taking a new sample.
+ if (registeredThread->RacyRegisteredThread()
+ .CanDuplicateLastSampleDueToSleep()) {
+ bool dup_ok = ActivePS::Buffer(lock).DuplicateLastSample(
+ info->ThreadId(), CorePS::ProcessStartTime(),
+ profiledThreadData->LastSample());
+ if (dup_ok) {
+ continue;
+ }
+ }
+
+ AUTO_PROFILER_STATS(base_SamplerThread_Run_DoPeriodicSample);
+
+ TimeStamp now = TimeStamp::Now();
+
+ // Record the global profiler buffer's range start now, before
+ // adding the first entry for this thread's sample.
+ const uint64_t bufferRangeStart = buffer.BufferRangeStart();
+
+ // Add the thread ID now, so we know its position in the main
+ // buffer, which is used by some JS data. (DoPeriodicSample only
+ // knows about the temporary local buffer.)
+ const uint64_t samplePos =
+ buffer.AddThreadIdEntry(registeredThread->Info()->ThreadId());
+ profiledThreadData->LastSample() = Some(samplePos);
+
+ // Also add the time, so it's always there after the thread ID, as
+ // expected by the parser. (Other stack data is optional.)
+ TimeDuration delta = now - CorePS::ProcessStartTime();
+ buffer.AddEntry(ProfileBufferEntry::Time(delta.ToMilliseconds()));
+
+ mSampler.SuspendAndSampleAndResumeThread(
+ lock, *registeredThread, now,
+ [&](const Registers& aRegs, const TimeStamp& aNow) {
+ DoPeriodicSample(lock, *registeredThread, *profiledThreadData,
+ aRegs, samplePos, bufferRangeStart,
+ localProfileBuffer);
+ });
+
+ // If data is complete, copy it into the global buffer.
+ auto state = localBuffer.GetState();
+ if (state.mClearedBlockCount != previousState.mClearedBlockCount) {
+ LOG("Stack sample too big for local storage, needed %u bytes",
+ unsigned(state.mRangeEnd - previousState.mRangeEnd));
+ } else if (state.mRangeEnd - previousState.mRangeEnd >=
+ *profiler_get_core_buffer().BufferLength()) {
+ LOG("Stack sample too big for profiler storage, needed %u bytes",
+ unsigned(state.mRangeEnd - previousState.mRangeEnd));
+ } else {
+ profiler_get_core_buffer().AppendContents(localBuffer);
+ }
+
+ // Clean up for the next run.
+ localBuffer.Clear();
+ previousState = localBuffer.GetState();
+ }
+ }
+
+#if defined(USE_LUL_STACKWALK)
+ // The LUL unwind object accumulates frame statistics. Periodically we
+ // should poke it to give it a chance to print those statistics. This
+ // involves doing I/O (fprintf, __android_log_print, etc.) and so
+ // can't safely be done from the critical section inside
+ // SuspendAndSampleAndResumeThread, which is why it is done here.
+ lul::LUL* lul = CorePS::Lul(lock);
+ if (lul) {
+ lul->MaybeShowStats();
+ }
+#endif
+ TimeStamp threadsSampled = TimeStamp::Now();
+
+ {
+ AUTO_PROFILER_STATS(Sampler_FulfillChunkRequests);
+ ActivePS::FulfillChunkRequests(lock);
+ }
+
+ buffer.CollectOverheadStats(delta, lockAcquired - sampleStart,
+ expiredMarkersCleaned - lockAcquired,
+ countersSampled - expiredMarkersCleaned,
+ threadsSampled - countersSampled);
+ }
+ }
+ // gPSMutex is not held after this point.
+
+ // Calculate how long a sleep to request. After the sleep, measure how
+ // long we actually slept and take the difference into account when
+ // calculating the sleep interval for the next iteration. This is an
+ // attempt to keep "to schedule" in the presence of inaccuracy of the
+ // actual sleep intervals.
+ TimeStamp targetSleepEndTime =
+ sampleStart + TimeDuration::FromMicroseconds(mIntervalMicroseconds);
+ TimeStamp beforeSleep = TimeStamp::Now();
+ TimeDuration targetSleepDuration = targetSleepEndTime - beforeSleep;
+ double sleepTime = std::max(
+ 0.0, (targetSleepDuration - lastSleepOvershoot).ToMicroseconds());
+ SleepMicro(static_cast<uint32_t>(sleepTime));
+ sampleStart = TimeStamp::Now();
+ lastSleepOvershoot =
+ sampleStart - (beforeSleep + TimeDuration::FromMicroseconds(sleepTime));
+ }
+}
+
+// Temporary closing namespaces from enclosing platform.cpp.
+} // namespace baseprofiler
+} // namespace mozilla
+
+// We #include these files directly because it means those files can use
+// declarations from this file trivially. These provide target-specific
+// implementations of all SamplerThread methods except Run().
+#if defined(GP_OS_windows)
+# include "platform-win32.cpp"
+#elif defined(GP_OS_darwin)
+# include "platform-macos.cpp"
+#elif defined(GP_OS_linux) || defined(GP_OS_android) || defined(GP_OS_freebsd)
+# include "platform-linux-android.cpp"
+#else
+# error "bad platform"
+#endif
+
+namespace mozilla {
+namespace baseprofiler {
+
+UniquePlatformData AllocPlatformData(BaseProfilerThreadId aThreadId) {
+ return UniquePlatformData(new PlatformData(aThreadId));
+}
+
+void PlatformDataDestructor::operator()(PlatformData* aData) { delete aData; }
+
+// END SamplerThread
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+// BEGIN externally visible functions
+
+static uint32_t ParseFeature(const char* aFeature, bool aIsStartup) {
+ if (strcmp(aFeature, "default") == 0) {
+ return (aIsStartup ? (DefaultFeatures() | StartupExtraDefaultFeatures())
+ : DefaultFeatures()) &
+ AvailableFeatures();
+ }
+
+#define PARSE_FEATURE_BIT(n_, str_, Name_, desc_) \
+ if (strcmp(aFeature, str_) == 0) { \
+ return ProfilerFeature::Name_; \
+ }
+
+ BASE_PROFILER_FOR_EACH_FEATURE(PARSE_FEATURE_BIT)
+
+#undef PARSE_FEATURE_BIT
+
+ PrintToConsole("\nUnrecognized feature \"%s\".\n\n", aFeature);
+ // Since we may have an old feature we don't implement anymore, don't exit.
+ PrintUsage();
+ return 0;
+}
+
+uint32_t ParseFeaturesFromStringArray(const char** aFeatures,
+ uint32_t aFeatureCount,
+ bool aIsStartup /* = false */) {
+ uint32_t features = 0;
+ for (size_t i = 0; i < aFeatureCount; i++) {
+ features |= ParseFeature(aFeatures[i], aIsStartup);
+ }
+ return features;
+}
+
+// Find the RegisteredThread for the current thread. This should only be called
+// in places where TLSRegisteredThread can't be used.
+static RegisteredThread* FindCurrentThreadRegisteredThread(PSLockRef aLock) {
+ BaseProfilerThreadId id = profiler_current_thread_id();
+ const Vector<UniquePtr<RegisteredThread>>& registeredThreads =
+ CorePS::RegisteredThreads(aLock);
+ for (auto& registeredThread : registeredThreads) {
+ if (registeredThread->Info()->ThreadId() == id) {
+ return registeredThread.get();
+ }
+ }
+
+ return nullptr;
+}
+
+static ProfilingStack* locked_register_thread(PSLockRef aLock,
+ const char* aName,
+ void* aStackTop) {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ MOZ_ASSERT(!FindCurrentThreadRegisteredThread(aLock));
+
+ VTUNE_REGISTER_THREAD(aName);
+
+ if (!TLSRegisteredThread::Init(aLock)) {
+ return nullptr;
+ }
+
+ RefPtr<ThreadInfo> info = new ThreadInfo(aName, profiler_current_thread_id(),
+ profiler_is_main_thread());
+ UniquePtr<RegisteredThread> registeredThread =
+ MakeUnique<RegisteredThread>(info, aStackTop);
+
+ TLSRegisteredThread::SetRegisteredThread(aLock, registeredThread.get());
+
+ if (ActivePS::Exists(aLock) && ActivePS::ShouldProfileThread(aLock, info)) {
+ registeredThread->RacyRegisteredThread().SetIsBeingProfiled(true);
+ ActivePS::AddLiveProfiledThread(aLock, registeredThread.get(),
+ MakeUnique<ProfiledThreadData>(info));
+ }
+
+ ProfilingStack* profilingStack =
+ &registeredThread->RacyRegisteredThread().ProfilingStack();
+
+ CorePS::AppendRegisteredThread(aLock, std::move(registeredThread));
+
+ return profilingStack;
+}
+
+static void locked_profiler_start(PSLockRef aLock, PowerOfTwo32 aCapacity,
+ double aInterval, uint32_t aFeatures,
+ const char** aFilters, uint32_t aFilterCount,
+ const Maybe<double>& aDuration);
+
+static Vector<const char*> SplitAtCommas(const char* aString,
+ UniquePtr<char[]>& aStorage) {
+ size_t len = strlen(aString);
+ aStorage = MakeUnique<char[]>(len + 1);
+ PodCopy(aStorage.get(), aString, len + 1);
+
+ // Iterate over all characters in aStorage and split at commas, by
+ // overwriting commas with the null char.
+ Vector<const char*> array;
+ size_t currentElementStart = 0;
+ for (size_t i = 0; i <= len; i++) {
+ if (aStorage[i] == ',') {
+ aStorage[i] = '\0';
+ }
+ if (aStorage[i] == '\0') {
+ // Only add non-empty elements, otherwise ParseFeatures would later
+ // complain about unrecognized features.
+ if (currentElementStart != i) {
+ MOZ_RELEASE_ASSERT(array.append(&aStorage[currentElementStart]));
+ }
+ currentElementStart = i + 1;
+ }
+ }
+ return array;
+}
+
+static const char* get_size_suffix(const char* str) {
+ const char* ptr = str;
+
+ while (isdigit(*ptr)) {
+ ptr++;
+ }
+
+ return ptr;
+}
+
+void profiler_init(void* aStackTop) {
+ LOG("profiler_init");
+
+ profiler_init_main_thread_id();
+
+ VTUNE_INIT();
+
+ MOZ_RELEASE_ASSERT(!CorePS::Exists());
+
+ if (getenv("MOZ_BASE_PROFILER_HELP")) {
+ PrintUsage();
+ exit(0);
+ }
+
+ SharedLibraryInfo::Initialize();
+
+ uint32_t features = DefaultFeatures() & AvailableFeatures();
+
+ UniquePtr<char[]> filterStorage;
+
+ Vector<const char*> filters;
+ MOZ_RELEASE_ASSERT(filters.append(kMainThreadName));
+
+ PowerOfTwo32 capacity = BASE_PROFILER_DEFAULT_ENTRIES;
+ Maybe<double> duration = Nothing();
+ double interval = BASE_PROFILER_DEFAULT_INTERVAL;
+
+ {
+ PSAutoLock lock;
+
+ // We've passed the possible failure point. Instantiate CorePS, which
+ // indicates that the profiler has initialized successfully.
+ CorePS::Create(lock);
+
+ Unused << locked_register_thread(lock, kMainThreadName, aStackTop);
+
+ // Platform-specific initialization.
+ PlatformInit(lock);
+
+ // (Linux-only) We could create CorePS::mLul and read unwind info into it
+ // at this point. That would match the lifetime implied by destruction of
+ // it in profiler_shutdown() just below. However, that gives a big delay on
+ // startup, even if no profiling is actually to be done. So, instead, it is
+ // created on demand at the first call to PlatformStart().
+
+ const char* startupEnv = getenv("MOZ_PROFILER_STARTUP");
+ if (!startupEnv || startupEnv[0] == '\0' ||
+ ((startupEnv[0] == '0' || startupEnv[0] == 'N' ||
+ startupEnv[0] == 'n') &&
+ startupEnv[1] == '\0')) {
+ return;
+ }
+
+ // Hidden option to stop Base Profiler, mostly due to Talos intermittents,
+ // see https://bugzilla.mozilla.org/show_bug.cgi?id=1638851#c3
+ // TODO: Investigate root cause and remove this in bugs 1648324 and 1648325.
+ if (getenv("MOZ_PROFILER_STARTUP_NO_BASE")) {
+ return;
+ }
+
+ LOG("- MOZ_PROFILER_STARTUP is set");
+
+ // Startup default capacity may be different.
+ capacity = BASE_PROFILER_DEFAULT_STARTUP_ENTRIES;
+
+ const char* startupCapacity = getenv("MOZ_PROFILER_STARTUP_ENTRIES");
+ if (startupCapacity && startupCapacity[0] != '\0') {
+ errno = 0;
+ long capacityLong = strtol(startupCapacity, nullptr, 10);
+ std::string_view sizeSuffix = get_size_suffix(startupCapacity);
+
+ if (sizeSuffix == "KB") {
+ capacityLong *= 1000 / scBytesPerEntry;
+ } else if (sizeSuffix == "KiB") {
+ capacityLong *= 1024 / scBytesPerEntry;
+ } else if (sizeSuffix == "MB") {
+ capacityLong *= (1000 * 1000) / scBytesPerEntry;
+ } else if (sizeSuffix == "MiB") {
+ capacityLong *= (1024 * 1024) / scBytesPerEntry;
+ } else if (sizeSuffix == "GB") {
+ capacityLong *= (1000 * 1000 * 1000) / scBytesPerEntry;
+ } else if (sizeSuffix == "GiB") {
+ capacityLong *= (1024 * 1024 * 1024) / scBytesPerEntry;
+ } else if (!sizeSuffix.empty()) {
+ PrintToConsole(
+ "- MOZ_PROFILER_STARTUP_ENTRIES unit must be one of the "
+ "following: KB, KiB, MB, MiB, GB, GiB");
+ PrintUsage();
+ exit(1);
+ }
+
+ // `long` could be 32 or 64 bits, so we force a 64-bit comparison with
+ // the maximum 32-bit signed number (as more than that is clamped down to
+ // 2^31 anyway).
+ if (errno == 0 && capacityLong > 0 &&
+ static_cast<uint64_t>(capacityLong) <=
+ static_cast<uint64_t>(INT32_MAX)) {
+ capacity = PowerOfTwo32(ActivePS::ClampToAllowedEntries(
+ static_cast<uint32_t>(capacityLong)));
+ LOG("- MOZ_PROFILER_STARTUP_ENTRIES = %u", unsigned(capacity.Value()));
+ } else {
+ PrintToConsole("- MOZ_PROFILER_STARTUP_ENTRIES not a valid integer: %s",
+ startupCapacity);
+ PrintUsage();
+ exit(1);
+ }
+ }
+
+ const char* startupDuration = getenv("MOZ_PROFILER_STARTUP_DURATION");
+ if (startupDuration && startupDuration[0] != '\0') {
+ // The duration is a floating point number. Use StringToDouble rather than
+ // strtod, so that "." is used as the decimal separator regardless of OS
+ // locale.
+ auto durationVal = StringToDouble(std::string(startupDuration));
+ if (durationVal && *durationVal >= 0.0) {
+ if (*durationVal > 0.0) {
+ duration = Some(*durationVal);
+ }
+ LOG("- MOZ_PROFILER_STARTUP_DURATION = %f", *durationVal);
+ } else {
+ PrintToConsole("- MOZ_PROFILER_STARTUP_DURATION not a valid float: %s",
+ startupDuration);
+ PrintUsage();
+ exit(1);
+ }
+ }
+
+ const char* startupInterval = getenv("MOZ_PROFILER_STARTUP_INTERVAL");
+ if (startupInterval && startupInterval[0] != '\0') {
+ // The interval is a floating point number. Use StringToDouble rather than
+ // strtod, so that "." is used as the decimal separator regardless of OS
+ // locale.
+ auto intervalValue = StringToDouble(MakeStringSpan(startupInterval));
+ if (intervalValue && *intervalValue > 0.0 && *intervalValue <= 1000.0) {
+ interval = *intervalValue;
+ LOG("- MOZ_PROFILER_STARTUP_INTERVAL = %f", interval);
+ } else {
+ PrintToConsole("- MOZ_PROFILER_STARTUP_INTERVAL not a valid float: %s",
+ startupInterval);
+ PrintUsage();
+ exit(1);
+ }
+ }
+
+ features |= StartupExtraDefaultFeatures() & AvailableFeatures();
+
+ const char* startupFeaturesBitfield =
+ getenv("MOZ_PROFILER_STARTUP_FEATURES_BITFIELD");
+ if (startupFeaturesBitfield && startupFeaturesBitfield[0] != '\0') {
+ errno = 0;
+ features = strtol(startupFeaturesBitfield, nullptr, 10);
+ if (errno == 0) {
+ LOG("- MOZ_PROFILER_STARTUP_FEATURES_BITFIELD = %d", features);
+ } else {
+ PrintToConsole(
+ "- MOZ_PROFILER_STARTUP_FEATURES_BITFIELD not a valid integer: %s",
+ startupFeaturesBitfield);
+ PrintUsage();
+ exit(1);
+ }
+ } else {
+ const char* startupFeatures = getenv("MOZ_PROFILER_STARTUP_FEATURES");
+ if (startupFeatures) {
+ // Interpret startupFeatures as a list of feature strings, separated by
+ // commas.
+ UniquePtr<char[]> featureStringStorage;
+ Vector<const char*> featureStringArray =
+ SplitAtCommas(startupFeatures, featureStringStorage);
+ features = ParseFeaturesFromStringArray(featureStringArray.begin(),
+ featureStringArray.length(),
+ /* aIsStartup */ true);
+ LOG("- MOZ_PROFILER_STARTUP_FEATURES = %d", features);
+ }
+ }
+
+ const char* startupFilters = getenv("MOZ_PROFILER_STARTUP_FILTERS");
+ if (startupFilters && startupFilters[0] != '\0') {
+ filters = SplitAtCommas(startupFilters, filterStorage);
+ LOG("- MOZ_PROFILER_STARTUP_FILTERS = %s", startupFilters);
+
+ if (mozilla::profiler::detail::FiltersExcludePid(filters)) {
+ LOG(" -> This process is excluded and won't be profiled");
+ return;
+ }
+ }
+
+ locked_profiler_start(lock, capacity, interval, features, filters.begin(),
+ filters.length(), duration);
+ }
+
+ // TODO: Install memory counter if it is possible from mozglue.
+ // #if defined(MOZ_REPLACE_MALLOC) && defined(MOZ_PROFILER_MEMORY)
+ // // start counting memory allocations (outside of lock because this may
+ // call
+ // // profiler_add_sampled_counter which would attempt to take the lock.)
+ // mozilla::profiler::install_memory_counter(true);
+ // #endif
+}
+
+static void locked_profiler_save_profile_to_file(PSLockRef aLock,
+ const char* aFilename,
+ bool aIsShuttingDown);
+
+static SamplerThread* locked_profiler_stop(PSLockRef aLock);
+
+void profiler_shutdown() {
+ LOG("profiler_shutdown");
+
+ VTUNE_SHUTDOWN();
+
+ MOZ_RELEASE_ASSERT(profiler_is_main_thread());
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ // If the profiler is active we must get a handle to the SamplerThread before
+ // ActivePS is destroyed, in order to delete it.
+ SamplerThread* samplerThread = nullptr;
+ {
+ PSAutoLock lock;
+
+ // Save the profile on shutdown if requested.
+ if (ActivePS::Exists(lock)) {
+ const char* filename = getenv("MOZ_PROFILER_SHUTDOWN");
+ if (filename && filename[0] != '\0') {
+ locked_profiler_save_profile_to_file(lock, filename,
+ /* aIsShuttingDown */ true);
+ }
+
+ samplerThread = locked_profiler_stop(lock);
+ }
+
+ CorePS::Destroy(lock);
+
+ // We just destroyed CorePS and the ThreadInfos it contains, so we can
+ // clear this thread's TLSRegisteredThread.
+ TLSRegisteredThread::SetRegisteredThread(lock, nullptr);
+ }
+
+ // We do these operations with gPSMutex unlocked. The comments in
+ // profiler_stop() explain why.
+ if (samplerThread) {
+ delete samplerThread;
+ }
+}
+
+static bool WriteProfileToJSONWriter(SpliceableChunkedJSONWriter& aWriter,
+ double aSinceTime, bool aIsShuttingDown,
+ bool aOnlyThreads = false) {
+ LOG("WriteProfileToJSONWriter");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ if (!aOnlyThreads) {
+ aWriter.Start();
+ {
+ if (!profiler_stream_json_for_this_process(
+ aWriter, aSinceTime, aIsShuttingDown, aOnlyThreads)) {
+ return false;
+ }
+
+ // Don't include profiles from other processes because this is a
+ // synchronous function.
+ aWriter.StartArrayProperty("processes");
+ aWriter.EndArray();
+ }
+ aWriter.End();
+ } else {
+ aWriter.StartBareList();
+ if (!profiler_stream_json_for_this_process(aWriter, aSinceTime,
+ aIsShuttingDown, aOnlyThreads)) {
+ return false;
+ }
+ aWriter.EndBareList();
+ }
+ return true;
+}
+
+void profiler_set_process_name(const std::string& aProcessName,
+ const std::string* aETLDplus1) {
+ LOG("profiler_set_process_name(\"%s\", \"%s\")", aProcessName.c_str(),
+ aETLDplus1 ? aETLDplus1->c_str() : "<none>");
+ PSAutoLock lock;
+ CorePS::SetProcessName(lock, aProcessName);
+ if (aETLDplus1) {
+ CorePS::SetETLDplus1(lock, *aETLDplus1);
+ }
+}
+
+UniquePtr<char[]> profiler_get_profile(double aSinceTime, bool aIsShuttingDown,
+ bool aOnlyThreads) {
+ LOG("profiler_get_profile");
+
+ SpliceableChunkedJSONWriter b{FailureLatchInfallibleSource::Singleton()};
+ if (!WriteProfileToJSONWriter(b, aSinceTime, aIsShuttingDown, aOnlyThreads)) {
+ return nullptr;
+ }
+ return b.ChunkedWriteFunc().CopyData();
+}
+
+void profiler_get_start_params(int* aCapacity, Maybe<double>* aDuration,
+ double* aInterval, uint32_t* aFeatures,
+ Vector<const char*>* aFilters) {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ if (!aCapacity || !aDuration || !aInterval || !aFeatures || !aFilters) {
+ return;
+ }
+
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ *aCapacity = 0;
+ *aDuration = Nothing();
+ *aInterval = 0;
+ *aFeatures = 0;
+ aFilters->clear();
+ return;
+ }
+
+ *aCapacity = ActivePS::Capacity(lock).Value();
+ *aDuration = ActivePS::Duration(lock);
+ *aInterval = ActivePS::Interval(lock);
+ *aFeatures = ActivePS::Features(lock);
+
+ const Vector<std::string>& filters = ActivePS::Filters(lock);
+ MOZ_ALWAYS_TRUE(aFilters->resize(filters.length()));
+ for (uint32_t i = 0; i < filters.length(); ++i) {
+ (*aFilters)[i] = filters[i].c_str();
+ }
+}
+
+void GetProfilerEnvVarsForChildProcess(
+ std::function<void(const char* key, const char* value)>&& aSetEnv) {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ aSetEnv("MOZ_PROFILER_STARTUP", "");
+ return;
+ }
+
+ aSetEnv("MOZ_PROFILER_STARTUP", "1");
+ auto capacityString =
+ Smprintf("%u", unsigned(ActivePS::Capacity(lock).Value()));
+ aSetEnv("MOZ_PROFILER_STARTUP_ENTRIES", capacityString.get());
+
+ // Use AppendFloat instead of Smprintf with %f because the decimal
+ // separator used by %f is locale-dependent. But the string we produce needs
+ // to be parseable by strtod, which only accepts the period character as a
+ // decimal separator. AppendFloat always uses the period character.
+ std::string intervalString = std::to_string(ActivePS::Interval(lock));
+ aSetEnv("MOZ_PROFILER_STARTUP_INTERVAL", intervalString.c_str());
+
+ auto featuresString = Smprintf("%d", ActivePS::Features(lock));
+ aSetEnv("MOZ_PROFILER_STARTUP_FEATURES_BITFIELD", featuresString.get());
+
+ std::string filtersString;
+ const Vector<std::string>& filters = ActivePS::Filters(lock);
+ for (uint32_t i = 0; i < filters.length(); ++i) {
+ filtersString += filters[i];
+ if (i != filters.length() - 1) {
+ filtersString += ",";
+ }
+ }
+ aSetEnv("MOZ_PROFILER_STARTUP_FILTERS", filtersString.c_str());
+}
+
+void profiler_received_exit_profile(const std::string& aExitProfile) {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+ PSAutoLock lock;
+ if (!ActivePS::Exists(lock)) {
+ return;
+ }
+ ActivePS::AddExitProfile(lock, aExitProfile);
+}
+
+Vector<std::string> profiler_move_exit_profiles() {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+ PSAutoLock lock;
+ Vector<std::string> profiles;
+ if (ActivePS::Exists(lock)) {
+ profiles = ActivePS::MoveExitProfiles(lock);
+ }
+ return profiles;
+}
+
+static void locked_profiler_save_profile_to_file(PSLockRef aLock,
+ const char* aFilename,
+ bool aIsShuttingDown = false) {
+ LOG("locked_profiler_save_profile_to_file(%s)", aFilename);
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists() && ActivePS::Exists(aLock));
+
+ std::ofstream stream;
+ stream.open(aFilename);
+ if (stream.is_open()) {
+ OStreamJSONWriteFunc jw(stream);
+ SpliceableJSONWriter w(jw, FailureLatchInfallibleSource::Singleton());
+ w.Start();
+ {
+ locked_profiler_stream_json_for_this_process(aLock, w, /* sinceTime */ 0,
+ aIsShuttingDown);
+
+ w.StartArrayProperty("processes");
+ Vector<std::string> exitProfiles = ActivePS::MoveExitProfiles(aLock);
+ for (auto& exitProfile : exitProfiles) {
+ if (!exitProfile.empty()) {
+ w.Splice(exitProfile);
+ }
+ }
+ w.EndArray();
+ }
+ w.End();
+
+ stream.close();
+ }
+}
+
+void baseprofiler_save_profile_to_file(const char* aFilename) {
+ LOG("baseprofiler_save_profile_to_file(%s)", aFilename);
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return;
+ }
+
+ locked_profiler_save_profile_to_file(lock, aFilename);
+}
+
+uint32_t profiler_get_available_features() {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+ return AvailableFeatures();
+}
+
+Maybe<ProfilerBufferInfo> profiler_get_buffer_info() {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return Nothing();
+ }
+
+ return Some(ActivePS::Buffer(lock).GetProfilerBufferInfo());
+}
+
+// This basically duplicates AutoProfilerLabel's constructor.
+static void* MozGlueBaseLabelEnter(const char* aLabel,
+ const char* aDynamicString, void* aSp) {
+ ProfilingStack* profilingStack = AutoProfilerLabel::sProfilingStack.get();
+ if (profilingStack) {
+ profilingStack->pushLabelFrame(aLabel, aDynamicString, aSp,
+ ProfilingCategoryPair::OTHER);
+ }
+ return profilingStack;
+}
+
+// This basically duplicates AutoProfilerLabel's destructor.
+static void MozGlueBaseLabelExit(void* sProfilingStack) {
+ if (sProfilingStack) {
+ reinterpret_cast<ProfilingStack*>(sProfilingStack)->pop();
+ }
+}
+
+static void locked_profiler_start(PSLockRef aLock, PowerOfTwo32 aCapacity,
+ double aInterval, uint32_t aFeatures,
+ const char** aFilters, uint32_t aFilterCount,
+ const Maybe<double>& aDuration) {
+ const TimeStamp profilingStartTime = TimeStamp::Now();
+
+ if (LOG_TEST) {
+ LOG("locked_profiler_start");
+ LOG("- capacity = %d", int(aCapacity.Value()));
+ LOG("- duration = %.2f", aDuration ? *aDuration : -1);
+ LOG("- interval = %.2f", aInterval);
+
+#define LOG_FEATURE(n_, str_, Name_, desc_) \
+ if (ProfilerFeature::Has##Name_(aFeatures)) { \
+ LOG("- feature = %s", str_); \
+ }
+
+ BASE_PROFILER_FOR_EACH_FEATURE(LOG_FEATURE)
+
+#undef LOG_FEATURE
+
+ for (uint32_t i = 0; i < aFilterCount; i++) {
+ LOG("- threads = %s", aFilters[i]);
+ }
+ }
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists() && !ActivePS::Exists(aLock));
+
+ mozilla::base_profiler_markers_detail::EnsureBufferForMainThreadAddMarker();
+
+#if defined(GP_PLAT_amd64_windows)
+ InitializeWin64ProfilerHooks();
+#endif
+
+ // Fall back to the default values if the passed-in values are unreasonable.
+ // We want to be able to store at least one full stack.
+ // TODO: Review magic numbers.
+ PowerOfTwo32 capacity =
+ (aCapacity.Value() >=
+ ProfileBufferChunkManager::scExpectedMaximumStackSize / scBytesPerEntry)
+ ? aCapacity
+ : BASE_PROFILER_DEFAULT_ENTRIES;
+ Maybe<double> duration = aDuration;
+
+ if (aDuration && *aDuration <= 0) {
+ duration = Nothing();
+ }
+ double interval = aInterval > 0 ? aInterval : BASE_PROFILER_DEFAULT_INTERVAL;
+
+ ActivePS::Create(aLock, profilingStartTime, capacity, interval, aFeatures,
+ aFilters, aFilterCount, duration);
+
+ // Set up profiling for each registered thread, if appropriate.
+ const Vector<UniquePtr<RegisteredThread>>& registeredThreads =
+ CorePS::RegisteredThreads(aLock);
+ for (auto& registeredThread : registeredThreads) {
+ RefPtr<ThreadInfo> info = registeredThread->Info();
+
+ if (ActivePS::ShouldProfileThread(aLock, info)) {
+ registeredThread->RacyRegisteredThread().SetIsBeingProfiled(true);
+ ActivePS::AddLiveProfiledThread(aLock, registeredThread.get(),
+ MakeUnique<ProfiledThreadData>(info));
+ registeredThread->RacyRegisteredThread().ReinitializeOnResume();
+ }
+ }
+
+ // Setup support for pushing/popping labels in mozglue.
+ RegisterProfilerLabelEnterExit(MozGlueBaseLabelEnter, MozGlueBaseLabelExit);
+
+ // At the very end, set up RacyFeatures.
+ RacyFeatures::SetActive(ActivePS::Features(aLock));
+}
+
+void profiler_start(PowerOfTwo32 aCapacity, double aInterval,
+ uint32_t aFeatures, const char** aFilters,
+ uint32_t aFilterCount, const Maybe<double>& aDuration) {
+ LOG("profiler_start");
+
+ SamplerThread* samplerThread = nullptr;
+ {
+ PSAutoLock lock;
+
+ // Initialize if necessary.
+ if (!CorePS::Exists()) {
+ profiler_init(nullptr);
+ }
+
+ // Reset the current state if the profiler is running.
+ if (ActivePS::Exists(lock)) {
+ samplerThread = locked_profiler_stop(lock);
+ }
+
+ locked_profiler_start(lock, aCapacity, aInterval, aFeatures, aFilters,
+ aFilterCount, aDuration);
+ }
+
+ // TODO: Install memory counter if it is possible from mozglue.
+ // #if defined(MOZ_REPLACE_MALLOC) && defined(MOZ_PROFILER_MEMORY)
+ // // start counting memory allocations (outside of lock because this may
+ // call
+ // // profiler_add_sampled_counter which would attempt to take the lock.)
+ // mozilla::profiler::install_memory_counter(true);
+ // #endif
+
+ // We do these operations with gPSMutex unlocked. The comments in
+ // profiler_stop() explain why.
+ if (samplerThread) {
+ delete samplerThread;
+ }
+}
+
+void profiler_ensure_started(PowerOfTwo32 aCapacity, double aInterval,
+ uint32_t aFeatures, const char** aFilters,
+ uint32_t aFilterCount,
+ const Maybe<double>& aDuration) {
+ LOG("profiler_ensure_started");
+
+ // bool startedProfiler = false; (See TODO below)
+ SamplerThread* samplerThread = nullptr;
+ {
+ PSAutoLock lock;
+
+ // Initialize if necessary.
+ if (!CorePS::Exists()) {
+ profiler_init(nullptr);
+ }
+
+ if (ActivePS::Exists(lock)) {
+ // The profiler is active.
+ if (!ActivePS::Equals(lock, aCapacity, aDuration, aInterval, aFeatures,
+ aFilters, aFilterCount)) {
+ // Stop and restart with different settings.
+ samplerThread = locked_profiler_stop(lock);
+ locked_profiler_start(lock, aCapacity, aInterval, aFeatures, aFilters,
+ aFilterCount, aDuration);
+ // startedProfiler = true; (See TODO below)
+ }
+ } else {
+ // The profiler is stopped.
+ locked_profiler_start(lock, aCapacity, aInterval, aFeatures, aFilters,
+ aFilterCount, aDuration);
+ // startedProfiler = true; (See TODO below)
+ }
+ }
+
+ // TODO: Install memory counter if it is possible from mozglue.
+ // #if defined(MOZ_REPLACE_MALLOC) && defined(MOZ_PROFILER_MEMORY)
+ // // start counting memory allocations (outside of lock because this may
+ // // call profiler_add_sampled_counter which would attempt to take the
+ // // lock.)
+ // mozilla::profiler::install_memory_counter(true);
+ // #endif
+
+ // We do these operations with gPSMutex unlocked. The comments in
+ // profiler_stop() explain why.
+ if (samplerThread) {
+ delete samplerThread;
+ }
+}
+
+[[nodiscard]] static SamplerThread* locked_profiler_stop(PSLockRef aLock) {
+ LOG("locked_profiler_stop");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists() && ActivePS::Exists(aLock));
+
+ // At the very start, clear RacyFeatures.
+ RacyFeatures::SetInactive();
+
+ // TODO: Uninstall memory counter if it is possible from mozglue.
+ // #if defined(MOZ_REPLACE_MALLOC) && defined(MOZ_PROFILER_MEMORY)
+ // mozilla::profiler::install_memory_counter(false);
+ // #endif
+
+ // Remove support for pushing/popping labels in mozglue.
+ RegisterProfilerLabelEnterExit(nullptr, nullptr);
+
+ // Stop sampling live threads.
+ const Vector<LiveProfiledThreadData>& liveProfiledThreads =
+ ActivePS::LiveProfiledThreads(aLock);
+ for (auto& thread : liveProfiledThreads) {
+ RegisteredThread* registeredThread = thread.mRegisteredThread;
+ registeredThread->RacyRegisteredThread().SetIsBeingProfiled(false);
+ }
+
+ // The Stop() call doesn't actually stop Run(); that happens in this
+ // function's caller when the sampler thread is destroyed. Stop() just gives
+ // the SamplerThread a chance to do some cleanup with gPSMutex locked.
+ SamplerThread* samplerThread = ActivePS::Destroy(aLock);
+ samplerThread->Stop(aLock);
+
+ mozilla::base_profiler_markers_detail::ReleaseBufferForMainThreadAddMarker();
+
+ return samplerThread;
+}
+
+void profiler_stop() {
+ LOG("profiler_stop");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ SamplerThread* samplerThread;
+ {
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return;
+ }
+
+ samplerThread = locked_profiler_stop(lock);
+ }
+
+ // We delete with gPSMutex unlocked. Otherwise we would get a deadlock: we
+ // would be waiting here with gPSMutex locked for SamplerThread::Run() to
+ // return so the join operation within the destructor can complete, but Run()
+ // needs to lock gPSMutex to return.
+ //
+ // Because this call occurs with gPSMutex unlocked, it -- including the final
+ // iteration of Run()'s loop -- must be able detect deactivation and return
+ // in a way that's safe with respect to other gPSMutex-locking operations
+ // that may have occurred in the meantime.
+ delete samplerThread;
+}
+
+bool profiler_is_paused() {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return false;
+ }
+
+ return ActivePS::IsPaused(lock);
+}
+
+void profiler_pause() {
+ LOG("profiler_pause");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ {
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return;
+ }
+
+ RacyFeatures::SetPaused();
+ ActivePS::SetIsPaused(lock, true);
+ ActivePS::Buffer(lock).AddEntry(ProfileBufferEntry::Pause(profiler_time()));
+ }
+}
+
+void profiler_resume() {
+ LOG("profiler_resume");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ {
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return;
+ }
+
+ ActivePS::Buffer(lock).AddEntry(
+ ProfileBufferEntry::Resume(profiler_time()));
+ ActivePS::SetIsPaused(lock, false);
+ RacyFeatures::SetUnpaused();
+ }
+}
+
+bool profiler_is_sampling_paused() {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return false;
+ }
+
+ return ActivePS::IsSamplingPaused(lock);
+}
+
+void profiler_pause_sampling() {
+ LOG("profiler_pause_sampling");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ {
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return;
+ }
+
+ RacyFeatures::SetSamplingPaused();
+ ActivePS::SetIsSamplingPaused(lock, true);
+ ActivePS::Buffer(lock).AddEntry(
+ ProfileBufferEntry::PauseSampling(profiler_time()));
+ }
+}
+
+void profiler_resume_sampling() {
+ LOG("profiler_resume_sampling");
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ {
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock)) {
+ return;
+ }
+
+ ActivePS::Buffer(lock).AddEntry(
+ ProfileBufferEntry::ResumeSampling(profiler_time()));
+ ActivePS::SetIsSamplingPaused(lock, false);
+ RacyFeatures::SetSamplingUnpaused();
+ }
+}
+
+bool profiler_feature_active(uint32_t aFeature) {
+ // This function runs both on and off the main thread.
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ // This function is hot enough that we use RacyFeatures, not ActivePS.
+ return RacyFeatures::IsActiveWithFeature(aFeature);
+}
+
+bool profiler_active_without_feature(uint32_t aFeature) {
+ // This function runs both on and off the main thread.
+
+ // This function is hot enough that we use RacyFeatures, not ActivePS.
+ return RacyFeatures::IsActiveWithoutFeature(aFeature);
+}
+
+void profiler_add_sampled_counter(BaseProfilerCount* aCounter) {
+ DEBUG_LOG("profiler_add_sampled_counter(%s)", aCounter->mLabel);
+ PSAutoLock lock;
+ CorePS::AppendCounter(lock, aCounter);
+}
+
+void profiler_remove_sampled_counter(BaseProfilerCount* aCounter) {
+ DEBUG_LOG("profiler_remove_sampled_counter(%s)", aCounter->mLabel);
+ PSAutoLock lock;
+ // Note: we don't enforce a final sample, though we could do so if the
+ // profiler was active
+ CorePS::RemoveCounter(lock, aCounter);
+}
+
+ProfilingStack* profiler_register_thread(const char* aName,
+ void* aGuessStackTop) {
+ DEBUG_LOG("profiler_register_thread(%s)", aName);
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ if (RegisteredThread* thread = FindCurrentThreadRegisteredThread(lock);
+ thread) {
+ LOG("profiler_register_thread(%s) - thread %" PRIu64
+ " already registered as %s",
+ aName, uint64_t(profiler_current_thread_id().ToNumber()),
+ thread->Info()->Name());
+ // TODO: Use new name. This is currently not possible because the
+ // RegisteredThread's ThreadInfo cannot be changed.
+ // In the meantime, we record a marker that could be used in the frontend.
+ std::string text("Thread ");
+ text += std::to_string(profiler_current_thread_id().ToNumber());
+ text += " \"";
+ text += thread->Info()->Name();
+ text += "\" attempted to re-register as \"";
+ text += aName;
+ text += "\"";
+ BASE_PROFILER_MARKER_TEXT("profiler_register_thread again", OTHER_Profiling,
+ MarkerThreadId::MainThread(), text);
+
+ return &thread->RacyRegisteredThread().ProfilingStack();
+ }
+
+ void* stackTop = GetStackTop(aGuessStackTop);
+ return locked_register_thread(lock, aName, stackTop);
+}
+
+void profiler_unregister_thread() {
+ if (!CorePS::Exists()) {
+ // This function can be called after the main thread has already shut down.
+ return;
+ }
+
+ PSAutoLock lock;
+
+ RegisteredThread* registeredThread = FindCurrentThreadRegisteredThread(lock);
+ MOZ_RELEASE_ASSERT(registeredThread ==
+ TLSRegisteredThread::RegisteredThread(lock));
+ if (registeredThread) {
+ RefPtr<ThreadInfo> info = registeredThread->Info();
+
+ DEBUG_LOG("profiler_unregister_thread: %s", info->Name());
+
+ if (ActivePS::Exists(lock)) {
+ ActivePS::UnregisterThread(lock, registeredThread);
+ }
+
+ // Clear the pointer to the RegisteredThread object that we're about to
+ // destroy.
+ TLSRegisteredThread::SetRegisteredThread(lock, nullptr);
+
+ // Remove the thread from the list of registered threads. This deletes the
+ // registeredThread object.
+ CorePS::RemoveRegisteredThread(lock, registeredThread);
+ } else {
+ LOG("profiler_unregister_thread() - thread %" PRIu64
+ " already unregistered",
+ uint64_t(profiler_current_thread_id().ToNumber()));
+ // We cannot record a marker on this thread because it was already
+ // unregistered. Send it to the main thread (unless this *is* already the
+ // main thread, which has been unregistered); this may be useful to catch
+ // mismatched register/unregister pairs in Firefox.
+ if (BaseProfilerThreadId tid = profiler_current_thread_id();
+ tid != profiler_main_thread_id()) {
+ BASE_PROFILER_MARKER_TEXT(
+ "profiler_unregister_thread again", OTHER_Profiling,
+ MarkerThreadId::MainThread(),
+ std::to_string(profiler_current_thread_id().ToNumber()));
+ }
+ // There are two ways FindCurrentThreadRegisteredThread() might have failed.
+ //
+ // - TLSRegisteredThread::Init() failed in locked_register_thread().
+ //
+ // - We've already called profiler_unregister_thread() for this thread.
+ // (Whether or not it should, this does happen in practice.)
+ //
+ // Either way, TLSRegisteredThread should be empty.
+ MOZ_RELEASE_ASSERT(!TLSRegisteredThread::RegisteredThread(lock));
+ }
+}
+
+void profiler_register_page(uint64_t aTabID, uint64_t aInnerWindowID,
+ const std::string& aUrl,
+ uint64_t aEmbedderInnerWindowID) {
+ DEBUG_LOG("profiler_register_page(%" PRIu64 ", %" PRIu64 ", %s, %" PRIu64 ")",
+ aTabID, aInnerWindowID, aUrl.c_str(), aEmbedderInnerWindowID);
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ // When a Browsing context is first loaded, the first url loaded in it will be
+ // about:blank. Because of that, this call keeps the first non-about:blank
+ // registration of window and discards the previous one.
+ RefPtr<PageInformation> pageInfo =
+ new PageInformation(aTabID, aInnerWindowID, aUrl, aEmbedderInnerWindowID);
+ CorePS::AppendRegisteredPage(lock, std::move(pageInfo));
+
+ // After appending the given page to CorePS, look for the expired
+ // pages and remove them if there are any.
+ if (ActivePS::Exists(lock)) {
+ ActivePS::DiscardExpiredPages(lock);
+ }
+}
+
+void profiler_unregister_page(uint64_t aRegisteredInnerWindowID) {
+ if (!CorePS::Exists()) {
+ // This function can be called after the main thread has already shut down.
+ return;
+ }
+
+ PSAutoLock lock;
+
+ // During unregistration, if the profiler is active, we have to keep the
+ // page information since there may be some markers associated with the given
+ // page. But if profiler is not active. we have no reason to keep the
+ // page information here because there can't be any marker associated with it.
+ if (ActivePS::Exists(lock)) {
+ ActivePS::UnregisterPage(lock, aRegisteredInnerWindowID);
+ } else {
+ CorePS::RemoveRegisteredPage(lock, aRegisteredInnerWindowID);
+ }
+}
+
+void profiler_clear_all_pages() {
+ if (!CorePS::Exists()) {
+ // This function can be called after the main thread has already shut down.
+ return;
+ }
+
+ {
+ PSAutoLock lock;
+ CorePS::ClearRegisteredPages(lock);
+ if (ActivePS::Exists(lock)) {
+ ActivePS::ClearUnregisteredPages(lock);
+ }
+ }
+}
+
+void profiler_thread_sleep() {
+ // This function runs both on and off the main thread.
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ RacyRegisteredThread* racyRegisteredThread =
+ TLSRegisteredThread::RacyRegisteredThread();
+ if (!racyRegisteredThread) {
+ return;
+ }
+
+ racyRegisteredThread->SetSleeping();
+}
+
+void profiler_thread_wake() {
+ // This function runs both on and off the main thread.
+
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ RacyRegisteredThread* racyRegisteredThread =
+ TLSRegisteredThread::RacyRegisteredThread();
+ if (!racyRegisteredThread) {
+ return;
+ }
+
+ racyRegisteredThread->SetAwake();
+}
+
+bool detail::IsThreadBeingProfiled() {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ const RacyRegisteredThread* racyRegisteredThread =
+ TLSRegisteredThread::RacyRegisteredThread();
+ return racyRegisteredThread && racyRegisteredThread->IsBeingProfiled();
+}
+
+bool profiler_thread_is_sleeping() {
+ MOZ_RELEASE_ASSERT(profiler_is_main_thread());
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ RacyRegisteredThread* racyRegisteredThread =
+ TLSRegisteredThread::RacyRegisteredThread();
+ if (!racyRegisteredThread) {
+ return false;
+ }
+ return racyRegisteredThread->IsSleeping();
+}
+
+double profiler_time() {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ TimeDuration delta = TimeStamp::Now() - CorePS::ProcessStartTime();
+ return delta.ToMilliseconds();
+}
+
+bool profiler_capture_backtrace_into(ProfileChunkedBuffer& aChunkedBuffer,
+ StackCaptureOptions aCaptureOptions) {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+
+ PSAutoLock lock;
+
+ if (!ActivePS::Exists(lock) ||
+ aCaptureOptions == StackCaptureOptions::NoStack) {
+ return false;
+ }
+
+ RegisteredThread* registeredThread =
+ TLSRegisteredThread::RegisteredThread(lock);
+ if (!registeredThread) {
+ MOZ_ASSERT(registeredThread);
+ return false;
+ }
+
+ ProfileBuffer profileBuffer(aChunkedBuffer);
+
+ Registers regs;
+#if defined(HAVE_NATIVE_UNWIND)
+ REGISTERS_SYNC_POPULATE(regs);
+#else
+ regs.Clear();
+#endif
+
+ DoSyncSample(lock, *registeredThread, TimeStamp::Now(), regs, profileBuffer,
+ aCaptureOptions);
+
+ return true;
+}
+
+UniquePtr<ProfileChunkedBuffer> profiler_capture_backtrace() {
+ MOZ_RELEASE_ASSERT(CorePS::Exists());
+ AUTO_BASE_PROFILER_LABEL("baseprofiler::profiler_capture_backtrace",
+ PROFILER);
+
+ // Quick is-active check before allocating a buffer.
+ // If NoMarkerStacks is set, we don't want to capture a backtrace.
+ if (!profiler_active_without_feature(ProfilerFeature::NoMarkerStacks)) {
+ return nullptr;
+ }
+
+ auto buffer = MakeUnique<ProfileChunkedBuffer>(
+ ProfileChunkedBuffer::ThreadSafety::WithoutMutex,
+ MakeUnique<ProfileBufferChunkManagerSingle>(
+ ProfileBufferChunkManager::scExpectedMaximumStackSize));
+
+ if (!profiler_capture_backtrace_into(*buffer, StackCaptureOptions::Full)) {
+ return nullptr;
+ }
+
+ return buffer;
+}
+
+UniqueProfilerBacktrace profiler_get_backtrace() {
+ UniquePtr<ProfileChunkedBuffer> buffer = profiler_capture_backtrace();
+
+ if (!buffer) {
+ return nullptr;
+ }
+
+ return UniqueProfilerBacktrace(
+ new ProfilerBacktrace("SyncProfile", std::move(buffer)));
+}
+
+void ProfilerBacktraceDestructor::operator()(ProfilerBacktrace* aBacktrace) {
+ delete aBacktrace;
+}
+
+bool profiler_is_locked_on_current_thread() {
+ // This function is used to help users avoid calling `profiler_...` functions
+ // when the profiler may already have a lock in place, which would prevent a
+ // 2nd recursive lock (resulting in a crash or a never-ending wait).
+ // So we must return `true` for any of:
+ // - The main profiler mutex, used by most functions, and/or
+ // - The buffer mutex, used directly in some functions without locking the
+ // main mutex, e.g., marker-related functions.
+ return PSAutoLock::IsLockedOnCurrentThread() ||
+ profiler_get_core_buffer().IsThreadSafeAndLockedOnCurrentThread();
+}
+
+// This is a simplified version of profiler_add_marker that can be easily passed
+// into the JS engine.
+void profiler_add_js_marker(const char* aMarkerName, const char* aMarkerText) {
+ BASE_PROFILER_MARKER_TEXT(
+ ProfilerString8View::WrapNullTerminatedString(aMarkerName), JS, {},
+ ProfilerString8View::WrapNullTerminatedString(aMarkerText));
+}
+
+// NOTE: aCollector's methods will be called while the target thread is paused.
+// Doing things in those methods like allocating -- which may try to claim
+// locks -- is a surefire way to deadlock.
+void profiler_suspend_and_sample_thread(BaseProfilerThreadId aThreadId,
+ uint32_t aFeatures,
+ ProfilerStackCollector& aCollector,
+ bool aSampleNative /* = true */) {
+ const bool isSynchronous = [&aThreadId]() {
+ const BaseProfilerThreadId currentThreadId = profiler_current_thread_id();
+ if (!aThreadId.IsSpecified()) {
+ aThreadId = currentThreadId;
+ return true;
+ }
+ return aThreadId == currentThreadId;
+ }();
+
+ // Lock the profiler mutex
+ PSAutoLock lock;
+
+ const Vector<UniquePtr<RegisteredThread>>& registeredThreads =
+ CorePS::RegisteredThreads(lock);
+ for (auto& thread : registeredThreads) {
+ RefPtr<ThreadInfo> info = thread->Info();
+ RegisteredThread& registeredThread = *thread.get();
+
+ if (info->ThreadId() == aThreadId) {
+ if (info->IsMainThread()) {
+ aCollector.SetIsMainThread();
+ }
+
+ // Allocate the space for the native stack
+ NativeStack nativeStack;
+
+ auto collectStack = [&](const Registers& aRegs, const TimeStamp& aNow) {
+ // The target thread is now suspended. Collect a native
+ // backtrace, and call the callback.
+#if defined(HAVE_FASTINIT_NATIVE_UNWIND)
+ if (aSampleNative) {
+ // We can only use FramePointerStackWalk or MozStackWalk from
+ // suspend_and_sample_thread as other stackwalking methods may not be
+ // initialized.
+# if defined(USE_FRAME_POINTER_STACK_WALK)
+ DoFramePointerBacktrace(lock, registeredThread, aRegs, nativeStack);
+# elif defined(USE_MOZ_STACK_WALK)
+ DoMozStackWalkBacktrace(lock, registeredThread, aRegs, nativeStack);
+# else
+# error "Invalid configuration"
+# endif
+
+ MergeStacks(aFeatures, isSynchronous, registeredThread, aRegs,
+ nativeStack, aCollector);
+ } else
+#endif
+ {
+ MergeStacks(aFeatures, isSynchronous, registeredThread, aRegs,
+ nativeStack, aCollector);
+
+ aCollector.CollectNativeLeafAddr((void*)aRegs.mPC);
+ }
+ };
+
+ if (isSynchronous) {
+ // Sampling the current thread, do NOT suspend it!
+ Registers regs;
+#if defined(HAVE_NATIVE_UNWIND)
+ REGISTERS_SYNC_POPULATE(regs);
+#else
+ regs.Clear();
+#endif
+ collectStack(regs, TimeStamp::Now());
+ } else {
+ // Suspend, sample, and then resume the target thread.
+ Sampler sampler(lock);
+ TimeStamp now = TimeStamp::Now();
+ sampler.SuspendAndSampleAndResumeThread(lock, registeredThread, now,
+ collectStack);
+
+ // NOTE: Make sure to disable the sampler before it is destroyed, in
+ // case the profiler is running at the same time.
+ sampler.Disable(lock);
+ }
+ break;
+ }
+ }
+}
+
+// END externally visible functions
+////////////////////////////////////////////////////////////////////////
+
+} // namespace baseprofiler
+} // namespace mozilla
diff --git a/mozglue/baseprofiler/core/platform.h b/mozglue/baseprofiler/core/platform.h
new file mode 100644
index 0000000000..f77fc12726
--- /dev/null
+++ b/mozglue/baseprofiler/core/platform.h
@@ -0,0 +1,149 @@
+// Copyright (c) 2006-2011 The Chromium 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.
+// * Neither the name of Google, Inc. nor the names of its contributors
+// may be used to endorse or promote products derived from this
+// software without specific prior written permission.
+//
+// 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 OWNER 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.
+
+#ifndef TOOLS_PLATFORM_H_
+#define TOOLS_PLATFORM_H_
+
+#include "PlatformMacros.h"
+
+#include "BaseProfiler.h"
+
+#include "mozilla/Atomics.h"
+#include "mozilla/Logging.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Vector.h"
+
+#include <functional>
+#include <stdint.h>
+#include <string>
+
+namespace mozilla {
+namespace baseprofiler {
+bool LogTest(int aLevelToTest);
+void PrintToConsole(const char* aFmt, ...) MOZ_FORMAT_PRINTF(1, 2);
+} // namespace baseprofiler
+} // namespace mozilla
+
+// These are for MOZ_BASE_PROFILER_LOGGING and above. It's the default logging
+// level for the profiler, and should be used sparingly.
+#define LOG_TEST ::mozilla::baseprofiler::LogTest(3)
+#define LOG(arg, ...) \
+ do { \
+ if (LOG_TEST) { \
+ ::mozilla::baseprofiler::PrintToConsole( \
+ "[I %d/%d] " arg "\n", \
+ int(::mozilla::baseprofiler::profiler_current_process_id() \
+ .ToNumber()), \
+ int(::mozilla::baseprofiler::profiler_current_thread_id() \
+ .ToNumber()), \
+ ##__VA_ARGS__); \
+ } \
+ } while (0)
+
+// These are for MOZ_BASE_PROFILER_DEBUG_LOGGING. It should be used for logging
+// that is somewhat more verbose than LOG.
+#define DEBUG_LOG_TEST ::mozilla::baseprofiler::LogTest(4)
+#define DEBUG_LOG(arg, ...) \
+ do { \
+ if (DEBUG_LOG_TEST) { \
+ ::mozilla::baseprofiler::PrintToConsole( \
+ "[D %d/%d] " arg "\n", \
+ int(::mozilla::baseprofiler::profiler_current_process_id() \
+ .ToNumber()), \
+ int(::mozilla::baseprofiler::profiler_current_thread_id() \
+ .ToNumber()), \
+ ##__VA_ARGS__); \
+ } \
+ } while (0)
+
+// These are for MOZ_BASE_PROFILER_VERBOSE_LOGGING. It should be used for
+// logging that is somewhat more verbose than DEBUG_LOG.
+#define VERBOSE_LOG_TEST ::mozilla::baseprofiler::LogTest(5)
+#define VERBOSE_LOG(arg, ...) \
+ do { \
+ if (VERBOSE_LOG_TEST) { \
+ ::mozilla::baseprofiler::PrintToConsole( \
+ "[V %d/%d] " arg "\n", \
+ int(::mozilla::baseprofiler::profiler_current_process_id() \
+ .ToNumber()), \
+ int(::mozilla::baseprofiler::profiler_current_thread_id() \
+ .ToNumber()), \
+ ##__VA_ARGS__); \
+ } \
+ } while (0)
+
+namespace mozilla {
+
+class JSONWriter;
+
+namespace baseprofiler {
+
+// If positive, skip stack-sampling in the sampler thread loop.
+// Users should increment it atomically when samplings should be avoided, and
+// later decrement it back. Multiple uses can overlap.
+// There could be a sampling in progress when this is first incremented, so if
+// it is critical to prevent any sampling, lock the profiler mutex instead.
+// Relaxed ordering, because it's used to request that the profiler pause
+// future sampling; this is not time critical, nor dependent on anything else.
+extern mozilla::Atomic<int, mozilla::MemoryOrdering::Relaxed> gSkipSampling;
+
+typedef uint8_t* Address;
+
+class PlatformData;
+
+// We can't new/delete the type safely without defining it
+// (-Wdelete-incomplete). Use these to hide the details from clients.
+struct PlatformDataDestructor {
+ void operator()(PlatformData*);
+};
+
+typedef UniquePtr<PlatformData, PlatformDataDestructor> UniquePlatformData;
+UniquePlatformData AllocPlatformData(BaseProfilerThreadId aThreadId);
+
+// Convert the array of strings to a bitfield.
+uint32_t ParseFeaturesFromStringArray(const char** aFeatures,
+ uint32_t aFeatureCount,
+ bool aIsStartup = false);
+
+// Flags to conveniently track various JS instrumentations.
+enum class JSInstrumentationFlags {
+ StackSampling = 0x1,
+ Allocations = 0x2,
+};
+
+// Record an exit profile from a child process.
+void profiler_received_exit_profile(const std::string& aExitProfile);
+
+// Extract all received exit profiles that have not yet expired (i.e., they
+// still intersect with this process' buffer range).
+Vector<std::string> profiler_move_exit_profiles();
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif /* ndef TOOLS_PLATFORM_H_ */
diff --git a/mozglue/baseprofiler/core/shared-libraries-linux.cc b/mozglue/baseprofiler/core/shared-libraries-linux.cc
new file mode 100644
index 0000000000..a12d60cf73
--- /dev/null
+++ b/mozglue/baseprofiler/core/shared-libraries-linux.cc
@@ -0,0 +1,854 @@
+/* -*- 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/. */
+
+#include "BaseProfilerSharedLibraries.h"
+
+#define PATH_MAX_TOSTRING(x) #x
+#define PATH_MAX_STRING(x) PATH_MAX_TOSTRING(x)
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <unistd.h>
+#include <fstream>
+#include "platform.h"
+#include "mozilla/Sprintf.h"
+
+#include <algorithm>
+#include <arpa/inet.h>
+#include <elf.h>
+#include <fcntl.h>
+#if defined(GP_OS_linux) || defined(GP_OS_android)
+# include <features.h>
+#endif
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <vector>
+
+#if defined(GP_OS_linux) || defined(GP_OS_android) || defined(GP_OS_freebsd)
+# include <link.h> // dl_phdr_info, ElfW()
+#else
+# error "Unexpected configuration"
+#endif
+
+#if defined(GP_OS_android)
+extern "C" MOZ_EXPORT __attribute__((weak)) int dl_iterate_phdr(
+ int (*callback)(struct dl_phdr_info* info, size_t size, void* data),
+ void* data);
+#endif
+
+#if defined(GP_OS_freebsd) && !defined(ElfW)
+# define ElfW(type) Elf_##type
+#endif
+
+// ----------------------------------------------------------------------------
+// Starting imports from toolkit/crashreporter/google-breakpad/, as needed by
+// this file when moved to mozglue.
+
+// Imported from
+// toolkit/crashreporter/google-breakpad/src/common/memory_range.h.
+// A lightweight wrapper with a pointer and a length to encapsulate a contiguous
+// range of memory. It provides helper methods for checked access of a subrange
+// of the memory. Its implemementation does not allocate memory or call into
+// libc functions, and is thus safer to use in a crashed environment.
+class MemoryRange {
+ public:
+ MemoryRange() : data_(NULL), length_(0) {}
+
+ MemoryRange(const void* data, size_t length) { Set(data, length); }
+
+ // Returns true if this memory range contains no data.
+ bool IsEmpty() const {
+ // Set() guarantees that |length_| is zero if |data_| is NULL.
+ return length_ == 0;
+ }
+
+ // Resets to an empty range.
+ void Reset() {
+ data_ = NULL;
+ length_ = 0;
+ }
+
+ // Sets this memory range to point to |data| and its length to |length|.
+ void Set(const void* data, size_t length) {
+ data_ = reinterpret_cast<const uint8_t*>(data);
+ // Always set |length_| to zero if |data_| is NULL.
+ length_ = data ? length : 0;
+ }
+
+ // Returns true if this range covers a subrange of |sub_length| bytes
+ // at |sub_offset| bytes of this memory range, or false otherwise.
+ bool Covers(size_t sub_offset, size_t sub_length) const {
+ // The following checks verify that:
+ // 1. sub_offset is within [ 0 .. length_ - 1 ]
+ // 2. sub_offset + sub_length is within
+ // [ sub_offset .. length_ ]
+ return sub_offset < length_ && sub_offset + sub_length >= sub_offset &&
+ sub_offset + sub_length <= length_;
+ }
+
+ // Returns a raw data pointer to a subrange of |sub_length| bytes at
+ // |sub_offset| bytes of this memory range, or NULL if the subrange
+ // is out of bounds.
+ const void* GetData(size_t sub_offset, size_t sub_length) const {
+ return Covers(sub_offset, sub_length) ? (data_ + sub_offset) : NULL;
+ }
+
+ // Same as the two-argument version of GetData() but uses sizeof(DataType)
+ // as the subrange length and returns an |DataType| pointer for convenience.
+ template <typename DataType>
+ const DataType* GetData(size_t sub_offset) const {
+ return reinterpret_cast<const DataType*>(
+ GetData(sub_offset, sizeof(DataType)));
+ }
+
+ // Returns a raw pointer to the |element_index|-th element of an array
+ // of elements of length |element_size| starting at |sub_offset| bytes
+ // of this memory range, or NULL if the element is out of bounds.
+ const void* GetArrayElement(size_t element_offset, size_t element_size,
+ unsigned element_index) const {
+ size_t sub_offset = element_offset + element_index * element_size;
+ return GetData(sub_offset, element_size);
+ }
+
+ // Same as the three-argument version of GetArrayElement() but deduces
+ // the element size using sizeof(ElementType) and returns an |ElementType|
+ // pointer for convenience.
+ template <typename ElementType>
+ const ElementType* GetArrayElement(size_t element_offset,
+ unsigned element_index) const {
+ return reinterpret_cast<const ElementType*>(
+ GetArrayElement(element_offset, sizeof(ElementType), element_index));
+ }
+
+ // Returns a subrange of |sub_length| bytes at |sub_offset| bytes of
+ // this memory range, or an empty range if the subrange is out of bounds.
+ MemoryRange Subrange(size_t sub_offset, size_t sub_length) const {
+ return Covers(sub_offset, sub_length)
+ ? MemoryRange(data_ + sub_offset, sub_length)
+ : MemoryRange();
+ }
+
+ // Returns a pointer to the beginning of this memory range.
+ const uint8_t* data() const { return data_; }
+
+ // Returns the length, in bytes, of this memory range.
+ size_t length() const { return length_; }
+
+ private:
+ // Pointer to the beginning of this memory range.
+ const uint8_t* data_;
+
+ // Length, in bytes, of this memory range.
+ size_t length_;
+};
+
+// Imported from
+// toolkit/crashreporter/google-breakpad/src/common/linux/memory_mapped_file.h
+// and inlined .cc.
+// A utility class for mapping a file into memory for read-only access of the
+// file content. Its implementation avoids calling into libc functions by
+// directly making system calls for open, close, mmap, and munmap.
+class MemoryMappedFile {
+ public:
+ MemoryMappedFile() {}
+
+ // Constructor that calls Map() to map a file at |path| into memory.
+ // If Map() fails, the object behaves as if it is default constructed.
+ MemoryMappedFile(const char* path, size_t offset) { Map(path, offset); }
+
+ MemoryMappedFile(const MemoryMappedFile&) = delete;
+ MemoryMappedFile& operator=(const MemoryMappedFile&) = delete;
+
+ ~MemoryMappedFile() {}
+
+ // Maps a file at |path| into memory, which can then be accessed via
+ // content() as a MemoryRange object or via data(), and returns true on
+ // success. Mapping an empty file will succeed but with data() and size()
+ // returning NULL and 0, respectively. An existing mapping is unmapped
+ // before a new mapping is created.
+ bool Map(const char* path, size_t offset) {
+ Unmap();
+
+ int fd = open(path, O_RDONLY, 0);
+ if (fd == -1) {
+ return false;
+ }
+
+#if defined(__x86_64__) || defined(__aarch64__) || \
+ (defined(__mips__) && _MIPS_SIM == _ABI64) || \
+ !(defined(GP_OS_linux) || defined(GP_OS_android))
+
+ struct stat st;
+ if (fstat(fd, &st) == -1 || st.st_size < 0) {
+#else
+ struct stat64 st;
+ if (fstat64(fd, &st) == -1 || st.st_size < 0) {
+#endif
+ close(fd);
+ return false;
+ }
+
+ // Strangely file size can be negative, but we check above that it is not.
+ size_t file_len = static_cast<size_t>(st.st_size);
+ // If the file does not extend beyond the offset, simply use an empty
+ // MemoryRange and return true. Don't bother to call mmap()
+ // even though mmap() can handle an empty file on some platforms.
+ if (offset >= file_len) {
+ close(fd);
+ return true;
+ }
+
+ void* data = mmap(NULL, file_len, PROT_READ, MAP_PRIVATE, fd, offset);
+ close(fd);
+ if (data == MAP_FAILED) {
+ return false;
+ }
+
+ content_.Set(data, file_len - offset);
+ return true;
+ }
+
+ // Unmaps the memory for the mapped file. It's a no-op if no file is
+ // mapped.
+ void Unmap() {
+ if (content_.data()) {
+ munmap(const_cast<uint8_t*>(content_.data()), content_.length());
+ content_.Set(NULL, 0);
+ }
+ }
+
+ // Returns a MemoryRange object that covers the memory for the mapped
+ // file. The MemoryRange object is empty if no file is mapped.
+ const MemoryRange& content() const { return content_; }
+
+ // Returns a pointer to the beginning of the memory for the mapped file.
+ // or NULL if no file is mapped or the mapped file is empty.
+ const void* data() const { return content_.data(); }
+
+ // Returns the size in bytes of the mapped file, or zero if no file
+ // is mapped.
+ size_t size() const { return content_.length(); }
+
+ private:
+ // Mapped file content as a MemoryRange object.
+ MemoryRange content_;
+};
+
+// Imported from
+// toolkit/crashreporter/google-breakpad/src/common/linux/file_id.h and inlined
+// .cc.
+// GNU binutils' ld defaults to 'sha1', which is 160 bits == 20 bytes,
+// so this is enough to fit that, which most binaries will use.
+// This is just a sensible default for vectors so most callers can get away with
+// stack allocation.
+static const size_t kDefaultBuildIdSize = 20;
+
+// Used in a few places for backwards-compatibility.
+typedef struct {
+ uint32_t data1;
+ uint16_t data2;
+ uint16_t data3;
+ uint8_t data4[8];
+} MDGUID; /* GUID */
+
+const size_t kMDGUIDSize = sizeof(MDGUID);
+
+class FileID {
+ public:
+ explicit FileID(const char* path) : path_(path) {}
+ ~FileID() {}
+
+ // Load the identifier for the elf file path specified in the constructor into
+ // |identifier|.
+ //
+ // The current implementation will look for a .note.gnu.build-id
+ // section and use that as the file id, otherwise it falls back to
+ // XORing the first 4096 bytes of the .text section to generate an identifier.
+ bool ElfFileIdentifier(std::vector<uint8_t>& identifier) {
+ MemoryMappedFile mapped_file(path_.c_str(), 0);
+ if (!mapped_file.data()) // Should probably check if size >= ElfW(Ehdr)?
+ return false;
+
+ return ElfFileIdentifierFromMappedFile(mapped_file.data(), identifier);
+ }
+
+ // Traits classes so consumers can write templatized code to deal
+ // with specific ELF bits.
+ struct ElfClass32 {
+ typedef Elf32_Addr Addr;
+ typedef Elf32_Ehdr Ehdr;
+ typedef Elf32_Nhdr Nhdr;
+ typedef Elf32_Phdr Phdr;
+ typedef Elf32_Shdr Shdr;
+ typedef Elf32_Half Half;
+ typedef Elf32_Off Off;
+ typedef Elf32_Sym Sym;
+ typedef Elf32_Word Word;
+
+ static const int kClass = ELFCLASS32;
+ static const uint16_t kMachine = EM_386;
+ static const size_t kAddrSize = sizeof(Elf32_Addr);
+ static constexpr const char* kMachineName = "x86";
+ };
+
+ struct ElfClass64 {
+ typedef Elf64_Addr Addr;
+ typedef Elf64_Ehdr Ehdr;
+ typedef Elf64_Nhdr Nhdr;
+ typedef Elf64_Phdr Phdr;
+ typedef Elf64_Shdr Shdr;
+ typedef Elf64_Half Half;
+ typedef Elf64_Off Off;
+ typedef Elf64_Sym Sym;
+ typedef Elf64_Word Word;
+
+ static const int kClass = ELFCLASS64;
+ static const uint16_t kMachine = EM_X86_64;
+ static const size_t kAddrSize = sizeof(Elf64_Addr);
+ static constexpr const char* kMachineName = "x86_64";
+ };
+
+ // Internal helper method, exposed for convenience for callers
+ // that already have more info.
+ template <typename ElfClass>
+ static const typename ElfClass::Shdr* FindElfSectionByName(
+ const char* name, typename ElfClass::Word section_type,
+ const typename ElfClass::Shdr* sections, const char* section_names,
+ const char* names_end, int nsection) {
+ if (!name || !sections || nsection == 0) {
+ return NULL;
+ }
+
+ int name_len = strlen(name);
+ if (name_len == 0) return NULL;
+
+ for (int i = 0; i < nsection; ++i) {
+ const char* section_name = section_names + sections[i].sh_name;
+ if (sections[i].sh_type == section_type &&
+ names_end - section_name >= name_len + 1 &&
+ strcmp(name, section_name) == 0) {
+ return sections + i;
+ }
+ }
+ return NULL;
+ }
+
+ struct ElfSegment {
+ const void* start;
+ size_t size;
+ };
+
+ // Convert an offset from an Elf header into a pointer to the mapped
+ // address in the current process. Takes an extra template parameter
+ // to specify the return type to avoid having to dynamic_cast the
+ // result.
+ template <typename ElfClass, typename T>
+ static const T* GetOffset(const typename ElfClass::Ehdr* elf_header,
+ typename ElfClass::Off offset) {
+ return reinterpret_cast<const T*>(reinterpret_cast<uintptr_t>(elf_header) +
+ offset);
+ }
+
+// ELF note name and desc are 32-bits word padded.
+#define NOTE_PADDING(a) ((a + 3) & ~3)
+
+ static bool ElfClassBuildIDNoteIdentifier(const void* section, size_t length,
+ std::vector<uint8_t>& identifier) {
+ static_assert(sizeof(ElfClass32::Nhdr) == sizeof(ElfClass64::Nhdr),
+ "Elf32_Nhdr and Elf64_Nhdr should be the same");
+ typedef typename ElfClass32::Nhdr Nhdr;
+
+ const void* section_end = reinterpret_cast<const char*>(section) + length;
+ const Nhdr* note_header = reinterpret_cast<const Nhdr*>(section);
+ while (reinterpret_cast<const void*>(note_header) < section_end) {
+ if (note_header->n_type == NT_GNU_BUILD_ID) break;
+ note_header = reinterpret_cast<const Nhdr*>(
+ reinterpret_cast<const char*>(note_header) + sizeof(Nhdr) +
+ NOTE_PADDING(note_header->n_namesz) +
+ NOTE_PADDING(note_header->n_descsz));
+ }
+ if (reinterpret_cast<const void*>(note_header) >= section_end ||
+ note_header->n_descsz == 0) {
+ return false;
+ }
+
+ const uint8_t* build_id = reinterpret_cast<const uint8_t*>(note_header) +
+ sizeof(Nhdr) +
+ NOTE_PADDING(note_header->n_namesz);
+ identifier.insert(identifier.end(), build_id,
+ build_id + note_header->n_descsz);
+
+ return true;
+ }
+
+ template <typename ElfClass>
+ static bool FindElfClassSection(const char* elf_base,
+ const char* section_name,
+ typename ElfClass::Word section_type,
+ const void** section_start,
+ size_t* section_size) {
+ typedef typename ElfClass::Ehdr Ehdr;
+ typedef typename ElfClass::Shdr Shdr;
+
+ if (!elf_base || !section_start || !section_size) {
+ return false;
+ }
+
+ if (strncmp(elf_base, ELFMAG, SELFMAG) != 0) {
+ return false;
+ }
+
+ const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base);
+ if (elf_header->e_ident[EI_CLASS] != ElfClass::kClass) {
+ return false;
+ }
+
+ const Shdr* sections =
+ GetOffset<ElfClass, Shdr>(elf_header, elf_header->e_shoff);
+ const Shdr* section_names = sections + elf_header->e_shstrndx;
+ const char* names =
+ GetOffset<ElfClass, char>(elf_header, section_names->sh_offset);
+ const char* names_end = names + section_names->sh_size;
+
+ const Shdr* section =
+ FindElfSectionByName<ElfClass>(section_name, section_type, sections,
+ names, names_end, elf_header->e_shnum);
+
+ if (section != NULL && section->sh_size > 0) {
+ *section_start = elf_base + section->sh_offset;
+ *section_size = section->sh_size;
+ }
+
+ return true;
+ }
+
+ template <typename ElfClass>
+ static bool FindElfClassSegment(const char* elf_base,
+ typename ElfClass::Word segment_type,
+ std::vector<ElfSegment>* segments) {
+ typedef typename ElfClass::Ehdr Ehdr;
+ typedef typename ElfClass::Phdr Phdr;
+
+ if (!elf_base || !segments) {
+ return false;
+ }
+
+ if (strncmp(elf_base, ELFMAG, SELFMAG) != 0) {
+ return false;
+ }
+
+ const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base);
+ if (elf_header->e_ident[EI_CLASS] != ElfClass::kClass) {
+ return false;
+ }
+
+ const Phdr* phdrs =
+ GetOffset<ElfClass, Phdr>(elf_header, elf_header->e_phoff);
+
+ for (int i = 0; i < elf_header->e_phnum; ++i) {
+ if (phdrs[i].p_type == segment_type) {
+ ElfSegment seg = {};
+ seg.start = elf_base + phdrs[i].p_offset;
+ seg.size = phdrs[i].p_filesz;
+ segments->push_back(seg);
+ }
+ }
+
+ return true;
+ }
+
+ static bool IsValidElf(const void* elf_base) {
+ return strncmp(reinterpret_cast<const char*>(elf_base), ELFMAG, SELFMAG) ==
+ 0;
+ }
+
+ static int ElfClass(const void* elf_base) {
+ const ElfW(Ehdr)* elf_header =
+ reinterpret_cast<const ElfW(Ehdr)*>(elf_base);
+
+ return elf_header->e_ident[EI_CLASS];
+ }
+
+ static bool FindElfSection(const void* elf_mapped_base,
+ const char* section_name, uint32_t section_type,
+ const void** section_start, size_t* section_size) {
+ if (!elf_mapped_base || !section_start || !section_size) {
+ return false;
+ }
+
+ *section_start = NULL;
+ *section_size = 0;
+
+ if (!IsValidElf(elf_mapped_base)) return false;
+
+ int cls = ElfClass(elf_mapped_base);
+ const char* elf_base = static_cast<const char*>(elf_mapped_base);
+
+ if (cls == ELFCLASS32) {
+ return FindElfClassSection<ElfClass32>(elf_base, section_name,
+ section_type, section_start,
+ section_size) &&
+ *section_start != NULL;
+ } else if (cls == ELFCLASS64) {
+ return FindElfClassSection<ElfClass64>(elf_base, section_name,
+ section_type, section_start,
+ section_size) &&
+ *section_start != NULL;
+ }
+
+ return false;
+ }
+
+ static bool FindElfSegments(const void* elf_mapped_base,
+ uint32_t segment_type,
+ std::vector<ElfSegment>* segments) {
+ if (!elf_mapped_base || !segments) {
+ return false;
+ }
+
+ if (!IsValidElf(elf_mapped_base)) return false;
+
+ int cls = ElfClass(elf_mapped_base);
+ const char* elf_base = static_cast<const char*>(elf_mapped_base);
+
+ if (cls == ELFCLASS32) {
+ return FindElfClassSegment<ElfClass32>(elf_base, segment_type, segments);
+ } else if (cls == ELFCLASS64) {
+ return FindElfClassSegment<ElfClass64>(elf_base, segment_type, segments);
+ }
+
+ return false;
+ }
+
+ // Attempt to locate a .note.gnu.build-id section in an ELF binary
+ // and copy it into |identifier|.
+ static bool FindElfBuildIDNote(const void* elf_mapped_base,
+ std::vector<uint8_t>& identifier) {
+ // lld normally creates 2 PT_NOTEs, gold normally creates 1.
+ std::vector<ElfSegment> segs;
+ if (FindElfSegments(elf_mapped_base, PT_NOTE, &segs)) {
+ for (ElfSegment& seg : segs) {
+ if (ElfClassBuildIDNoteIdentifier(seg.start, seg.size, identifier)) {
+ return true;
+ }
+ }
+ }
+
+ void* note_section;
+ size_t note_size;
+ if (FindElfSection(elf_mapped_base, ".note.gnu.build-id", SHT_NOTE,
+ (const void**)&note_section, &note_size)) {
+ return ElfClassBuildIDNoteIdentifier(note_section, note_size, identifier);
+ }
+
+ return false;
+ }
+
+ // Attempt to locate the .text section of an ELF binary and generate
+ // a simple hash by XORing the first page worth of bytes into |identifier|.
+ static bool HashElfTextSection(const void* elf_mapped_base,
+ std::vector<uint8_t>& identifier) {
+ identifier.resize(kMDGUIDSize);
+
+ void* text_section;
+ size_t text_size;
+ if (!FindElfSection(elf_mapped_base, ".text", SHT_PROGBITS,
+ (const void**)&text_section, &text_size) ||
+ text_size == 0) {
+ return false;
+ }
+
+ // Only provide |kMDGUIDSize| bytes to keep identifiers produced by this
+ // function backwards-compatible.
+ memset(&identifier[0], 0, kMDGUIDSize);
+ const uint8_t* ptr = reinterpret_cast<const uint8_t*>(text_section);
+ const uint8_t* ptr_end =
+ ptr + std::min(text_size, static_cast<size_t>(4096));
+ while (ptr < ptr_end) {
+ for (unsigned i = 0; i < kMDGUIDSize; i++) identifier[i] ^= ptr[i];
+ ptr += kMDGUIDSize;
+ }
+ return true;
+ }
+
+ // Load the identifier for the elf file mapped into memory at |base| into
+ // |identifier|. Return false if the identifier could not be created for this
+ // file.
+ static bool ElfFileIdentifierFromMappedFile(
+ const void* base, std::vector<uint8_t>& identifier) {
+ // Look for a build id note first.
+ if (FindElfBuildIDNote(base, identifier)) return true;
+
+ // Fall back on hashing the first page of the text section.
+ return HashElfTextSection(base, identifier);
+ }
+
+ // These three functions are not ever called in an unsafe context, so it's OK
+ // to allocate memory and use libc.
+ static std::string bytes_to_hex_string(const uint8_t* bytes, size_t count,
+ bool lowercase = false) {
+ std::string result;
+ for (unsigned int idx = 0; idx < count; ++idx) {
+ char buf[3];
+ SprintfLiteral(buf, lowercase ? "%02x" : "%02X", bytes[idx]);
+ result.append(buf);
+ }
+ return result;
+ }
+
+ // Convert the |identifier| data to a string. The string will
+ // be formatted as a UUID in all uppercase without dashes.
+ // (e.g., 22F065BBFC9C49F780FE26A7CEBD7BCE).
+ static std::string ConvertIdentifierToUUIDString(
+ const std::vector<uint8_t>& identifier) {
+ uint8_t identifier_swapped[kMDGUIDSize] = {0};
+
+ // Endian-ness swap to match dump processor expectation.
+ memcpy(identifier_swapped, &identifier[0],
+ std::min(kMDGUIDSize, identifier.size()));
+ uint32_t* data1 = reinterpret_cast<uint32_t*>(identifier_swapped);
+ *data1 = htonl(*data1);
+ uint16_t* data2 = reinterpret_cast<uint16_t*>(identifier_swapped + 4);
+ *data2 = htons(*data2);
+ uint16_t* data3 = reinterpret_cast<uint16_t*>(identifier_swapped + 6);
+ *data3 = htons(*data3);
+
+ return bytes_to_hex_string(identifier_swapped, kMDGUIDSize);
+ }
+
+ // Convert the entire |identifier| data to a lowercase hex string.
+ static std::string ConvertIdentifierToString(
+ const std::vector<uint8_t>& identifier) {
+ return bytes_to_hex_string(&identifier[0], identifier.size(),
+ /* lowercase */ true);
+ }
+
+ private:
+ // Storage for the path specified
+ std::string path_;
+};
+
+// End of imports from toolkit/crashreporter/google-breakpad/.
+// ----------------------------------------------------------------------------
+
+struct LoadedLibraryInfo {
+ LoadedLibraryInfo(const char* aName, unsigned long aBaseAddress,
+ unsigned long aFirstMappingStart,
+ unsigned long aLastMappingEnd)
+ : mName(aName),
+ mBaseAddress(aBaseAddress),
+ mFirstMappingStart(aFirstMappingStart),
+ mLastMappingEnd(aLastMappingEnd) {}
+
+ std::string mName;
+ unsigned long mBaseAddress;
+ unsigned long mFirstMappingStart;
+ unsigned long mLastMappingEnd;
+};
+
+static std::string IDtoUUIDString(const std::vector<uint8_t>& aIdentifier) {
+ std::string uuid = FileID::ConvertIdentifierToUUIDString(aIdentifier);
+ // This is '0', not '\0', since it represents the breakpad id age.
+ uuid += '0';
+ return uuid;
+}
+
+// Return raw Build ID in hex.
+static std::string IDtoString(const std::vector<uint8_t>& aIdentifier) {
+ std::string uuid = FileID::ConvertIdentifierToString(aIdentifier);
+ return uuid;
+}
+
+// Get the breakpad Id for the binary file pointed by bin_name
+static std::string getBreakpadId(const char* bin_name) {
+ std::vector<uint8_t> identifier;
+ identifier.reserve(kDefaultBuildIdSize);
+
+ FileID file_id(bin_name);
+ if (file_id.ElfFileIdentifier(identifier)) {
+ return IDtoUUIDString(identifier);
+ }
+
+ return {};
+}
+
+// Get the code Id for the binary file pointed by bin_name
+static std::string getCodeId(const char* bin_name) {
+ std::vector<uint8_t> identifier;
+ identifier.reserve(kDefaultBuildIdSize);
+
+ FileID file_id(bin_name);
+ if (file_id.ElfFileIdentifier(identifier)) {
+ return IDtoString(identifier);
+ }
+
+ return {};
+}
+
+static SharedLibrary SharedLibraryAtPath(const char* path,
+ unsigned long libStart,
+ unsigned long libEnd,
+ unsigned long offset = 0) {
+ std::string pathStr = path;
+
+ size_t pos = pathStr.rfind('\\');
+ std::string nameStr =
+ (pos != std::string::npos) ? pathStr.substr(pos + 1) : pathStr;
+
+ return SharedLibrary(libStart, libEnd, offset, getBreakpadId(path),
+ getCodeId(path), nameStr, pathStr, nameStr, pathStr,
+ std::string{}, "");
+}
+
+static int dl_iterate_callback(struct dl_phdr_info* dl_info, size_t size,
+ void* data) {
+ auto libInfoList = reinterpret_cast<std::vector<LoadedLibraryInfo>*>(data);
+
+ if (dl_info->dlpi_phnum <= 0) return 0;
+
+ unsigned long baseAddress = dl_info->dlpi_addr;
+ unsigned long firstMappingStart = -1;
+ unsigned long lastMappingEnd = 0;
+
+ for (size_t i = 0; i < dl_info->dlpi_phnum; i++) {
+ if (dl_info->dlpi_phdr[i].p_type != PT_LOAD) {
+ continue;
+ }
+ unsigned long start = dl_info->dlpi_addr + dl_info->dlpi_phdr[i].p_vaddr;
+ unsigned long end = start + dl_info->dlpi_phdr[i].p_memsz;
+ if (start < firstMappingStart) {
+ firstMappingStart = start;
+ }
+ if (end > lastMappingEnd) {
+ lastMappingEnd = end;
+ }
+ }
+
+ libInfoList->push_back(LoadedLibraryInfo(dl_info->dlpi_name, baseAddress,
+ firstMappingStart, lastMappingEnd));
+
+ return 0;
+}
+
+SharedLibraryInfo SharedLibraryInfo::GetInfoForSelf() {
+ SharedLibraryInfo info;
+
+#if defined(GP_OS_linux)
+ // We need to find the name of the executable (exeName, exeNameLen) and the
+ // address of its executable section (exeExeAddr) in the running image.
+ char exeName[PATH_MAX];
+ memset(exeName, 0, sizeof(exeName));
+
+ ssize_t exeNameLen = readlink("/proc/self/exe", exeName, sizeof(exeName) - 1);
+ if (exeNameLen == -1) {
+ // readlink failed for whatever reason. Note this, but keep going.
+ exeName[0] = '\0';
+ exeNameLen = 0;
+ // LOG("SharedLibraryInfo::GetInfoForSelf(): readlink failed");
+ } else {
+ // Assert no buffer overflow.
+ MOZ_RELEASE_ASSERT(exeNameLen >= 0 &&
+ exeNameLen < static_cast<ssize_t>(sizeof(exeName)));
+ }
+
+ unsigned long exeExeAddr = 0;
+#endif
+
+#if defined(GP_OS_android)
+ // If dl_iterate_phdr doesn't exist, we give up immediately.
+ if (!dl_iterate_phdr) {
+ // On ARM Android, dl_iterate_phdr is provided by the custom linker.
+ // So if libxul was loaded by the system linker (e.g. as part of
+ // xpcshell when running tests), it won't be available and we should
+ // not call it.
+ return info;
+ }
+#endif
+
+#if defined(GP_OS_linux) || defined(GP_OS_android)
+ // Read info from /proc/self/maps. We ignore most of it.
+ pid_t pid = mozilla::baseprofiler::profiler_current_process_id().ToNumber();
+ char path[PATH_MAX];
+ SprintfLiteral(path, "/proc/%d/maps", pid);
+ std::ifstream maps(path);
+ std::string line;
+ while (std::getline(maps, line)) {
+ int ret;
+ unsigned long start;
+ unsigned long end;
+ char perm[6 + 1] = "";
+ unsigned long offset;
+ char modulePath[PATH_MAX + 1] = "";
+ ret = sscanf(line.c_str(),
+ "%lx-%lx %6s %lx %*s %*x %" PATH_MAX_STRING(PATH_MAX) "s\n",
+ &start, &end, perm, &offset, modulePath);
+ if (!strchr(perm, 'x')) {
+ // Ignore non executable entries
+ continue;
+ }
+ if (ret != 5 && ret != 4) {
+ // LOG("SharedLibraryInfo::GetInfoForSelf(): "
+ // "reading /proc/self/maps failed");
+ continue;
+ }
+
+# if defined(GP_OS_linux)
+ // Try to establish the main executable's load address.
+ if (exeNameLen > 0 && strcmp(modulePath, exeName) == 0) {
+ exeExeAddr = start;
+ }
+# elif defined(GP_OS_android)
+ // Use /proc/pid/maps to get the dalvik-jit section since it has no
+ // associated phdrs.
+ if (0 == strcmp(modulePath, "/dev/ashmem/dalvik-jit-code-cache")) {
+ info.AddSharedLibrary(
+ SharedLibraryAtPath(modulePath, start, end, offset));
+ if (info.GetSize() > 10000) {
+ // LOG("SharedLibraryInfo::GetInfoForSelf(): "
+ // "implausibly large number of mappings acquired");
+ break;
+ }
+ }
+# endif
+ }
+#endif
+
+ std::vector<LoadedLibraryInfo> libInfoList;
+
+ // We collect the bulk of the library info using dl_iterate_phdr.
+ dl_iterate_phdr(dl_iterate_callback, &libInfoList);
+
+ for (const auto& libInfo : libInfoList) {
+ info.AddSharedLibrary(
+ SharedLibraryAtPath(libInfo.mName.c_str(), libInfo.mFirstMappingStart,
+ libInfo.mLastMappingEnd,
+ libInfo.mFirstMappingStart - libInfo.mBaseAddress));
+ }
+
+#if defined(GP_OS_linux)
+ // Make another pass over the information we just harvested from
+ // dl_iterate_phdr. If we see a nameless object mapped at what we earlier
+ // established to be the main executable's load address, attach the
+ // executable's name to that entry.
+ for (size_t i = 0; i < info.GetSize(); i++) {
+ SharedLibrary& lib = info.GetMutableEntry(i);
+ if (lib.GetStart() <= exeExeAddr && exeExeAddr <= lib.GetEnd() &&
+ lib.GetDebugPath().empty()) {
+ lib = SharedLibraryAtPath(exeName, lib.GetStart(), lib.GetEnd(),
+ lib.GetOffset());
+
+ // We only expect to see one such entry.
+ break;
+ }
+ }
+#endif
+
+ return info;
+}
+
+void SharedLibraryInfo::Initialize() { /* do nothing */
+}
diff --git a/mozglue/baseprofiler/core/shared-libraries-macos.cc b/mozglue/baseprofiler/core/shared-libraries-macos.cc
new file mode 100644
index 0000000000..f995581001
--- /dev/null
+++ b/mozglue/baseprofiler/core/shared-libraries-macos.cc
@@ -0,0 +1,206 @@
+/* -*- 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 "BaseProfilerSharedLibraries.h"
+
+#include "platform.h"
+
+#include "mozilla/Unused.h"
+#include <AvailabilityMacros.h>
+
+#include <dlfcn.h>
+#include <mach-o/arch.h>
+#include <mach-o/dyld_images.h>
+#include <mach-o/dyld.h>
+#include <mach-o/loader.h>
+#include <mach/mach_init.h>
+#include <mach/mach_traps.h>
+#include <mach/task_info.h>
+#include <mach/task.h>
+#include <sstream>
+#include <stdlib.h>
+#include <string.h>
+#include <vector>
+
+// Architecture specific abstraction.
+#if defined(GP_ARCH_x86)
+typedef mach_header platform_mach_header;
+typedef segment_command mach_segment_command_type;
+# define MACHO_MAGIC_NUMBER MH_MAGIC
+# define CMD_SEGMENT LC_SEGMENT
+# define seg_size uint32_t
+#else
+typedef mach_header_64 platform_mach_header;
+typedef segment_command_64 mach_segment_command_type;
+# define MACHO_MAGIC_NUMBER MH_MAGIC_64
+# define CMD_SEGMENT LC_SEGMENT_64
+# define seg_size uint64_t
+#endif
+
+struct NativeSharedLibrary {
+ const platform_mach_header* header;
+ std::string path;
+};
+static std::vector<NativeSharedLibrary>* sSharedLibrariesList = nullptr;
+
+class MOZ_RAII SharedLibrariesLock {
+ public:
+ SharedLibrariesLock() { sSharedLibrariesMutex.Lock(); }
+
+ ~SharedLibrariesLock() { sSharedLibrariesMutex.Unlock(); }
+
+ SharedLibrariesLock(const SharedLibrariesLock&) = delete;
+ void operator=(const SharedLibrariesLock&) = delete;
+
+ private:
+ static mozilla::baseprofiler::detail::BaseProfilerMutex sSharedLibrariesMutex;
+};
+
+mozilla::baseprofiler::detail::BaseProfilerMutex
+ SharedLibrariesLock::sSharedLibrariesMutex;
+
+static void SharedLibraryAddImage(const struct mach_header* mh,
+ intptr_t vmaddr_slide) {
+ // NOTE: Presumably for backwards-compatibility reasons, this function accepts
+ // a mach_header even on 64-bit where it ought to be a mach_header_64. We cast
+ // it to the right type here.
+ auto header = reinterpret_cast<const platform_mach_header*>(mh);
+
+ Dl_info info;
+ if (!dladdr(header, &info)) {
+ return;
+ }
+
+ SharedLibrariesLock lock;
+ if (!sSharedLibrariesList) {
+ return;
+ }
+
+ NativeSharedLibrary lib = {header, info.dli_fname};
+ sSharedLibrariesList->push_back(lib);
+}
+
+static void SharedLibraryRemoveImage(const struct mach_header* mh,
+ intptr_t vmaddr_slide) {
+ // NOTE: Presumably for backwards-compatibility reasons, this function accepts
+ // a mach_header even on 64-bit where it ought to be a mach_header_64. We cast
+ // it to the right type here.
+ auto header = reinterpret_cast<const platform_mach_header*>(mh);
+
+ SharedLibrariesLock lock;
+ if (!sSharedLibrariesList) {
+ return;
+ }
+
+ uint32_t count = sSharedLibrariesList->size();
+ for (uint32_t i = 0; i < count; ++i) {
+ if ((*sSharedLibrariesList)[i].header == header) {
+ sSharedLibrariesList->erase(sSharedLibrariesList->begin() + i);
+ return;
+ }
+ }
+}
+
+void SharedLibraryInfo::Initialize() {
+ // NOTE: We intentionally leak this memory here. We're allocating dynamically
+ // in order to avoid static initializers.
+ sSharedLibrariesList = new std::vector<NativeSharedLibrary>();
+
+ _dyld_register_func_for_add_image(SharedLibraryAddImage);
+ _dyld_register_func_for_remove_image(SharedLibraryRemoveImage);
+}
+
+static void addSharedLibrary(const platform_mach_header* header,
+ const char* path, SharedLibraryInfo& info) {
+ const struct load_command* cmd =
+ reinterpret_cast<const struct load_command*>(header + 1);
+
+ seg_size size = 0;
+ unsigned long long start = reinterpret_cast<unsigned long long>(header);
+ // Find the cmd segment in the macho image. It will contain the offset we care
+ // about.
+ const uint8_t* uuid_bytes = nullptr;
+ for (unsigned int i = 0;
+ cmd && (i < header->ncmds) && (uuid_bytes == nullptr || size == 0);
+ ++i) {
+ if (cmd->cmd == CMD_SEGMENT) {
+ const mach_segment_command_type* seg =
+ reinterpret_cast<const mach_segment_command_type*>(cmd);
+
+ if (!strcmp(seg->segname, "__TEXT")) {
+ size = seg->vmsize;
+ }
+ } else if (cmd->cmd == LC_UUID) {
+ const uuid_command* ucmd = reinterpret_cast<const uuid_command*>(cmd);
+ uuid_bytes = ucmd->uuid;
+ }
+
+ cmd = reinterpret_cast<const struct load_command*>(
+ reinterpret_cast<const char*>(cmd) + cmd->cmdsize);
+ }
+
+ std::string uuid;
+ std::string breakpadId;
+ if (uuid_bytes != nullptr) {
+ static constexpr char digits[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+ for (int i = 0; i < 16; ++i) {
+ uint8_t byte = uuid_bytes[i];
+ uuid += digits[byte >> 4];
+ uuid += digits[byte & 0xFu];
+ }
+
+ // Breakpad id is the same as the uuid but with the additional trailing 0
+ // for the breakpad id age.
+ breakpadId = uuid;
+ // breakpad id age.
+ breakpadId += '0';
+ }
+
+ std::string pathStr = path;
+
+ size_t pos = pathStr.rfind('\\');
+ std::string nameStr =
+ (pos != std::string::npos) ? pathStr.substr(pos + 1) : pathStr;
+
+ const NXArchInfo* archInfo =
+ NXGetArchInfoFromCpuType(header->cputype, header->cpusubtype);
+
+ info.AddSharedLibrary(SharedLibrary(
+ start, start + size, 0, breakpadId, uuid, nameStr, pathStr, nameStr,
+ pathStr, std::string{}, archInfo ? archInfo->name : ""));
+}
+
+// Translate the statically stored sSharedLibrariesList information into a
+// SharedLibraryInfo object.
+SharedLibraryInfo SharedLibraryInfo::GetInfoForSelf() {
+ SharedLibrariesLock lock;
+ SharedLibraryInfo sharedLibraryInfo;
+
+ for (auto& info : *sSharedLibrariesList) {
+ addSharedLibrary(info.header, info.path.c_str(), sharedLibraryInfo);
+ }
+
+ // Add the entry for dyld itself.
+ // We only support macOS 10.12+, which corresponds to dyld version 15+.
+ // dyld version 15 added the dyldPath property.
+ task_dyld_info_data_t task_dyld_info;
+ mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
+ if (task_info(mach_task_self(), TASK_DYLD_INFO, (task_info_t)&task_dyld_info,
+ &count) != KERN_SUCCESS) {
+ return sharedLibraryInfo;
+ }
+
+ struct dyld_all_image_infos* aii =
+ (struct dyld_all_image_infos*)task_dyld_info.all_image_info_addr;
+ if (aii->version >= 15) {
+ const platform_mach_header* header =
+ reinterpret_cast<const platform_mach_header*>(
+ aii->dyldImageLoadAddress);
+ addSharedLibrary(header, aii->dyldPath, sharedLibraryInfo);
+ }
+
+ return sharedLibraryInfo;
+}
diff --git a/mozglue/baseprofiler/core/shared-libraries-win32.cc b/mozglue/baseprofiler/core/shared-libraries-win32.cc
new file mode 100644
index 0000000000..eb6ca3572a
--- /dev/null
+++ b/mozglue/baseprofiler/core/shared-libraries-win32.cc
@@ -0,0 +1,222 @@
+/* -*- 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 <windows.h>
+
+#include "BaseProfilerSharedLibraries.h"
+
+#include "mozilla/glue/WindowsUnicode.h"
+#include "mozilla/NativeNt.h"
+#include "mozilla/WindowsEnumProcessModules.h"
+#include "mozilla/WindowsVersion.h"
+
+#include <cctype>
+#include <string>
+
+static constexpr char uppercaseDigits[16] = {'0', '1', '2', '3', '4', '5',
+ '6', '7', '8', '9', 'A', 'B',
+ 'C', 'D', 'E', 'F'};
+static constexpr char lowercaseDigits[16] = {'0', '1', '2', '3', '4', '5',
+ '6', '7', '8', '9', 'a', 'b',
+ 'c', 'd', 'e', 'f'};
+
+static void AppendHex(const unsigned char* aBegin, const unsigned char* aEnd,
+ std::string& aOut) {
+ for (const unsigned char* p = aBegin; p < aEnd; ++p) {
+ unsigned char c = *p;
+ aOut += uppercaseDigits[c >> 4];
+ aOut += uppercaseDigits[c & 0xFu];
+ }
+}
+
+static constexpr bool WITH_PADDING = true;
+static constexpr bool WITHOUT_PADDING = false;
+static constexpr bool LOWERCASE = true;
+static constexpr bool UPPERCASE = false;
+template <typename T>
+static void AppendHex(T aValue, std::string& aOut, bool aWithPadding,
+ bool aLowercase = UPPERCASE) {
+ for (int i = sizeof(T) * 2 - 1; i >= 0; --i) {
+ unsigned nibble = (aValue >> (i * 4)) & 0xFu;
+ // If no-padding requested, skip starting zeroes -- unless we're on the very
+ // last nibble (so we don't output a blank).
+ if (!aWithPadding && i != 0) {
+ if (nibble == 0) {
+ // Requested no padding, skip zeroes.
+ continue;
+ }
+ // Requested no padding, got first non-zero, pretend we now want padding
+ // so we don't skip zeroes anymore.
+ aWithPadding = true;
+ }
+ aOut += aLowercase ? lowercaseDigits[nibble] : uppercaseDigits[nibble];
+ }
+}
+
+static bool IsModuleUnsafeToLoad(const std::string& aModuleName) {
+ auto LowerCaseEqualsLiteral = [](char aModuleChar, char aDetouredChar) {
+ return std::tolower(aModuleChar) == aDetouredChar;
+ };
+
+#if defined(_M_AMD64) || defined(_M_IX86)
+ // Hackaround for Bug 1607574. Nvidia's shim driver nvd3d9wrap[x].dll detours
+ // LoadLibraryExW and it causes AV when the following conditions are met.
+ // 1. LoadLibraryExW was called for "detoured.dll"
+ // 2. nvinit[x].dll was unloaded
+ // 3. OS version is older than 6.2
+# if defined(_M_AMD64)
+ LPCWSTR kNvidiaShimDriver = L"nvd3d9wrapx.dll";
+ LPCWSTR kNvidiaInitDriver = L"nvinitx.dll";
+# elif defined(_M_IX86)
+ LPCWSTR kNvidiaShimDriver = L"nvd3d9wrap.dll";
+ LPCWSTR kNvidiaInitDriver = L"nvinit.dll";
+# endif
+ constexpr std::string_view detoured_dll = "detoured.dll";
+ if (std::equal(aModuleName.cbegin(), aModuleName.cend(),
+ detoured_dll.cbegin(), detoured_dll.cend(),
+ LowerCaseEqualsLiteral) &&
+ !mozilla::IsWin8OrLater() && ::GetModuleHandleW(kNvidiaShimDriver) &&
+ !::GetModuleHandleW(kNvidiaInitDriver)) {
+ return true;
+ }
+#endif // defined(_M_AMD64) || defined(_M_IX86)
+
+ // Hackaround for Bug 1723868. There is no safe way to prevent the module
+ // Microsoft's VP9 Video Decoder from being unloaded because mfplat.dll may
+ // have posted more than one task to unload the module in the work queue
+ // without calling LoadLibrary.
+ constexpr std::string_view vp9_decoder_dll = "msvp9dec_store.dll";
+ if (std::equal(aModuleName.cbegin(), aModuleName.cend(),
+ vp9_decoder_dll.cbegin(), vp9_decoder_dll.cend(),
+ LowerCaseEqualsLiteral)) {
+ return true;
+ }
+
+ return false;
+}
+
+void SharedLibraryInfo::AddSharedLibraryFromModuleInfo(
+ const wchar_t* aModulePath, mozilla::Maybe<HMODULE> aModule) {
+ mozilla::UniquePtr<char[]> utf8ModulePath(
+ mozilla::glue::WideToUTF8(aModulePath));
+ if (!utf8ModulePath) {
+ return;
+ }
+
+ std::string modulePathStr(utf8ModulePath.get());
+ size_t pos = modulePathStr.find_last_of("\\/");
+ std::string moduleNameStr = (pos != std::string::npos)
+ ? modulePathStr.substr(pos + 1)
+ : modulePathStr;
+
+ // If the module is unsafe to call LoadLibraryEx for, we skip.
+ if (IsModuleUnsafeToLoad(moduleNameStr)) {
+ return;
+ }
+
+ // Load the module again - to make sure that its handle will remain valid as
+ // we attempt to read the PDB information from it - or for the first time if
+ // we only have a path. We want to load the DLL without running the newly
+ // loaded module's DllMain function, but not as a data file because we want
+ // to be able to do RVA computations easily. Hence, we use the flag
+ // LOAD_LIBRARY_AS_IMAGE_RESOURCE which ensures that the sections (not PE
+ // headers) will be relocated by the loader. Otherwise GetPdbInfo() and/or
+ // GetVersionInfo() can cause a crash. If the original handle |aModule| is
+ // valid, LoadLibraryEx just increments its refcount.
+ nsModuleHandle handleLock(
+ ::LoadLibraryExW(aModulePath, NULL, LOAD_LIBRARY_AS_IMAGE_RESOURCE));
+ if (!handleLock) {
+ return;
+ }
+
+ mozilla::nt::PEHeaders headers(handleLock.get());
+ if (!headers) {
+ return;
+ }
+
+ mozilla::Maybe<mozilla::Range<const uint8_t>> bounds = headers.GetBounds();
+ if (!bounds) {
+ return;
+ }
+
+ // Put the original |aModule| into SharedLibrary, but we get debug info
+ // from |handleLock| as |aModule| might be inaccessible.
+ const uintptr_t modStart =
+ aModule.isSome() ? reinterpret_cast<uintptr_t>(*aModule)
+ : reinterpret_cast<uintptr_t>(handleLock.get());
+ const uintptr_t modEnd = modStart + bounds->length();
+
+ std::string breakpadId;
+ std::string pdbPathStr;
+ std::string pdbNameStr;
+ if (const auto* debugInfo = headers.GetPdbInfo()) {
+ MOZ_ASSERT(breakpadId.empty());
+ const GUID& pdbSig = debugInfo->pdbSignature;
+ AppendHex(pdbSig.Data1, breakpadId, WITH_PADDING);
+ AppendHex(pdbSig.Data2, breakpadId, WITH_PADDING);
+ AppendHex(pdbSig.Data3, breakpadId, WITH_PADDING);
+ AppendHex(reinterpret_cast<const unsigned char*>(&pdbSig.Data4),
+ reinterpret_cast<const unsigned char*>(&pdbSig.Data4) +
+ sizeof(pdbSig.Data4),
+ breakpadId);
+ AppendHex(debugInfo->pdbAge, breakpadId, WITHOUT_PADDING);
+
+ // The PDB file name could be different from module filename,
+ // so report both
+ // e.g. The PDB for C:\Windows\SysWOW64\ntdll.dll is wntdll.pdb
+ pdbPathStr = debugInfo->pdbFileName;
+ size_t pos = pdbPathStr.find_last_of("\\/");
+ pdbNameStr =
+ (pos != std::string::npos) ? pdbPathStr.substr(pos + 1) : pdbPathStr;
+ }
+
+ std::string codeId;
+ DWORD timestamp;
+ DWORD imageSize;
+ if (headers.GetTimeStamp(timestamp) && headers.GetImageSize(imageSize)) {
+ AppendHex(timestamp, codeId, WITH_PADDING);
+ AppendHex(imageSize, codeId, WITHOUT_PADDING, LOWERCASE);
+ }
+
+ std::string versionStr;
+ uint64_t version;
+ if (headers.GetVersionInfo(version)) {
+ versionStr += std::to_string((version >> 48) & 0xFFFF);
+ versionStr += '.';
+ versionStr += std::to_string((version >> 32) & 0xFFFF);
+ versionStr += '.';
+ versionStr += std::to_string((version >> 16) & 0xFFFF);
+ versionStr += '.';
+ versionStr += std::to_string(version & 0xFFFF);
+ }
+
+ SharedLibrary shlib(modStart, modEnd,
+ 0, // DLLs are always mapped at offset 0 on Windows
+ breakpadId, codeId, moduleNameStr, modulePathStr,
+ pdbNameStr, pdbPathStr, versionStr, "");
+ AddSharedLibrary(shlib);
+}
+
+SharedLibraryInfo SharedLibraryInfo::GetInfoForSelf() {
+ SharedLibraryInfo sharedLibraryInfo;
+
+ auto addSharedLibraryFromModuleInfo =
+ [&sharedLibraryInfo](const wchar_t* aModulePath, HMODULE aModule) {
+ sharedLibraryInfo.AddSharedLibraryFromModuleInfo(
+ aModulePath, mozilla::Some(aModule));
+ };
+
+ mozilla::EnumerateProcessModules(addSharedLibraryFromModuleInfo);
+ return sharedLibraryInfo;
+}
+
+SharedLibraryInfo SharedLibraryInfo::GetInfoFromPath(const wchar_t* aPath) {
+ SharedLibraryInfo sharedLibraryInfo;
+ sharedLibraryInfo.AddSharedLibraryFromModuleInfo(aPath, mozilla::Nothing());
+ return sharedLibraryInfo;
+}
+
+void SharedLibraryInfo::Initialize() { /* do nothing */
+}
diff --git a/mozglue/baseprofiler/core/vtune/ittnotify.h b/mozglue/baseprofiler/core/vtune/ittnotify.h
new file mode 100644
index 0000000000..04adf9eb5e
--- /dev/null
+++ b/mozglue/baseprofiler/core/vtune/ittnotify.h
@@ -0,0 +1,4127 @@
+// clang-format off
+
+/* <copyright>
+ This file is provided under a dual BSD/GPLv2 license. When using or
+ redistributing this file, you may do so under either license.
+
+ GPL LICENSE SUMMARY
+
+ Copyright (c) 2005-2014 Intel Corporation. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of version 2 of the GNU General Public License as
+ published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ The full GNU General Public License is included in this distribution
+ in the file called LICENSE.GPL.
+
+ Contact Information:
+ http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/
+
+ BSD LICENSE
+
+ Copyright (c) 2005-2014 Intel Corporation. All rights reserved.
+ 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.
+ * Neither the name of Intel Corporation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ 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
+ OWNER 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.
+</copyright> */
+#ifndef _ITTNOTIFY_H_
+# define _ITTNOTIFY_H_
+
+/**
+@file
+@brief Public User API functions and types
+@mainpage
+
+The ITT API is used to annotate a user's program with additional information
+that can be used by correctness and performance tools. The user inserts
+calls in their program. Those calls generate information that is collected
+at runtime, and used by Intel(R) Threading Tools.
+
+@section API Concepts
+The following general concepts are used throughout the API.
+
+@subsection Unicode Support
+Many API functions take character string arguments. On Windows, there
+are two versions of each such function. The function name is suffixed
+by W if Unicode support is enabled, and by A otherwise. Any API function
+that takes a character string argument adheres to this convention.
+
+@subsection Conditional Compilation
+Many users prefer having an option to modify ITT API code when linking it
+inside their runtimes. ITT API header file provides a mechanism to replace
+ITT API function names inside your code with empty strings. To do this,
+define the macros INTEL_NO_ITTNOTIFY_API during compilation and remove the
+static library from the linker script.
+
+@subsection Domains
+[see domains]
+Domains provide a way to separate notification for different modules or
+libraries in a program. Domains are specified by dotted character strings,
+e.g. TBB.Internal.Control.
+
+A mechanism (to be specified) is provided to enable and disable
+domains. By default, all domains are enabled.
+@subsection Named Entities and Instances
+Named entities (frames, regions, tasks, and markers) communicate
+information about the program to the analysis tools. A named entity often
+refers to a section of program code, or to some set of logical concepts
+that the programmer wants to group together.
+
+Named entities relate to the programmer's static view of the program. When
+the program actually executes, many instances of a given named entity
+may be created.
+
+The API annotations denote instances of named entities. The actual
+named entities are displayed using the analysis tools. In other words,
+the named entities come into existence when instances are created.
+
+Instances of named entities may have instance identifiers (IDs). Some
+API calls use instance identifiers to create relationships between
+different instances of named entities. Other API calls associate data
+with instances of named entities.
+
+Some named entities must always have instance IDs. In particular, regions
+and frames always have IDs. Task and markers need IDs only if the ID is
+needed in another API call (such as adding a relation or metadata).
+
+The lifetime of instance IDs is distinct from the lifetime of
+instances. This allows various relationships to be specified separate
+from the actual execution of instances. This flexibility comes at the
+expense of extra API calls.
+
+The same ID may not be reused for different instances, unless a previous
+[ref] __itt_id_destroy call for that ID has been issued.
+*/
+
+/** @cond exclude_from_documentation */
+#ifndef ITT_OS_WIN
+# define ITT_OS_WIN 1
+#endif /* ITT_OS_WIN */
+
+#ifndef ITT_OS_LINUX
+# define ITT_OS_LINUX 2
+#endif /* ITT_OS_LINUX */
+
+#ifndef ITT_OS_MAC
+# define ITT_OS_MAC 3
+#endif /* ITT_OS_MAC */
+
+#ifndef ITT_OS_FREEBSD
+# define ITT_OS_FREEBSD 4
+#endif /* ITT_OS_FREEBSD */
+
+#ifndef ITT_OS
+# if defined WIN32 || defined _WIN32
+# define ITT_OS ITT_OS_WIN
+# elif defined( __APPLE__ ) && defined( __MACH__ )
+# define ITT_OS ITT_OS_MAC
+# elif defined( __FreeBSD__ )
+# define ITT_OS ITT_OS_FREEBSD
+# else
+# define ITT_OS ITT_OS_LINUX
+# endif
+#endif /* ITT_OS */
+
+#ifndef ITT_PLATFORM_WIN
+# define ITT_PLATFORM_WIN 1
+#endif /* ITT_PLATFORM_WIN */
+
+#ifndef ITT_PLATFORM_POSIX
+# define ITT_PLATFORM_POSIX 2
+#endif /* ITT_PLATFORM_POSIX */
+
+#ifndef ITT_PLATFORM_MAC
+# define ITT_PLATFORM_MAC 3
+#endif /* ITT_PLATFORM_MAC */
+
+#ifndef ITT_PLATFORM_FREEBSD
+# define ITT_PLATFORM_FREEBSD 4
+#endif /* ITT_PLATFORM_FREEBSD */
+
+#ifndef ITT_PLATFORM
+# if ITT_OS==ITT_OS_WIN
+# define ITT_PLATFORM ITT_PLATFORM_WIN
+# elif ITT_OS==ITT_OS_MAC
+# define ITT_PLATFORM ITT_PLATFORM_MAC
+# elif ITT_OS==ITT_OS_FREEBSD
+# define ITT_PLATFORM ITT_PLATFORM_FREEBSD
+# else
+# define ITT_PLATFORM ITT_PLATFORM_POSIX
+# endif
+#endif /* ITT_PLATFORM */
+
+#if defined(_UNICODE) && !defined(UNICODE)
+#define UNICODE
+#endif
+
+#include <stddef.h>
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#include <tchar.h>
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#include <stdint.h>
+#if defined(UNICODE) || defined(_UNICODE)
+#include <wchar.h>
+#endif /* UNICODE || _UNICODE */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#ifndef ITTAPI_CDECL
+# if ITT_PLATFORM==ITT_PLATFORM_WIN
+# define ITTAPI_CDECL __cdecl
+# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+# if defined _M_IX86 || defined __i386__
+# define ITTAPI_CDECL __attribute__ ((cdecl))
+# else /* _M_IX86 || __i386__ */
+# define ITTAPI_CDECL /* actual only on x86 platform */
+# endif /* _M_IX86 || __i386__ */
+# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* ITTAPI_CDECL */
+
+#ifndef STDCALL
+# if ITT_PLATFORM==ITT_PLATFORM_WIN
+# define STDCALL __stdcall
+# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+# if defined _M_IX86 || defined __i386__
+# define STDCALL __attribute__ ((stdcall))
+# else /* _M_IX86 || __i386__ */
+# define STDCALL /* supported only on x86 platform */
+# endif /* _M_IX86 || __i386__ */
+# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* STDCALL */
+
+#define ITTAPI ITTAPI_CDECL
+#define LIBITTAPI ITTAPI_CDECL
+
+/* TODO: Temporary for compatibility! */
+#define ITTAPI_CALL ITTAPI_CDECL
+#define LIBITTAPI_CALL ITTAPI_CDECL
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+/* use __forceinline (VC++ specific) */
+#define ITT_INLINE __forceinline
+#define ITT_INLINE_ATTRIBUTE /* nothing */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+/*
+ * Generally, functions are not inlined unless optimization is specified.
+ * For functions declared inline, this attribute inlines the function even
+ * if no optimization level was specified.
+ */
+#ifdef __STRICT_ANSI__
+#define ITT_INLINE static
+#define ITT_INLINE_ATTRIBUTE __attribute__((unused))
+#else /* __STRICT_ANSI__ */
+#define ITT_INLINE static inline
+#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
+#endif /* __STRICT_ANSI__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+/** @endcond */
+
+#ifdef INTEL_ITTNOTIFY_ENABLE_LEGACY
+# if ITT_PLATFORM==ITT_PLATFORM_WIN
+# pragma message("WARNING!!! Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro")
+# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+# warning "Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro"
+# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+# include "vtune/legacy/ittnotify.h"
+#endif /* INTEL_ITTNOTIFY_ENABLE_LEGACY */
+
+/** @cond exclude_from_documentation */
+/* Helper macro for joining tokens */
+#define ITT_JOIN_AUX(p,n) p##n
+#define ITT_JOIN(p,n) ITT_JOIN_AUX(p,n)
+
+#ifdef ITT_MAJOR
+#undef ITT_MAJOR
+#endif
+#ifdef ITT_MINOR
+#undef ITT_MINOR
+#endif
+#define ITT_MAJOR 3
+#define ITT_MINOR 0
+
+/* Standard versioning of a token with major and minor version numbers */
+#define ITT_VERSIONIZE(x) \
+ ITT_JOIN(x, \
+ ITT_JOIN(_, \
+ ITT_JOIN(ITT_MAJOR, \
+ ITT_JOIN(_, ITT_MINOR))))
+
+#ifndef INTEL_ITTNOTIFY_PREFIX
+# define INTEL_ITTNOTIFY_PREFIX __itt_
+#endif /* INTEL_ITTNOTIFY_PREFIX */
+#ifndef INTEL_ITTNOTIFY_POSTFIX
+# define INTEL_ITTNOTIFY_POSTFIX _ptr_
+#endif /* INTEL_ITTNOTIFY_POSTFIX */
+
+#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
+#define ITTNOTIFY_NAME(n) ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n,INTEL_ITTNOTIFY_POSTFIX)))
+
+#define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)
+#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)
+
+#define ITTNOTIFY_VOID_D0(n,d) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d)
+#define ITTNOTIFY_VOID_D1(n,d,x) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x)
+#define ITTNOTIFY_VOID_D2(n,d,x,y) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y)
+#define ITTNOTIFY_VOID_D3(n,d,x,y,z) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z)
+#define ITTNOTIFY_VOID_D4(n,d,x,y,z,a) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
+#define ITTNOTIFY_VOID_D5(n,d,x,y,z,a,b) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
+#define ITTNOTIFY_VOID_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
+#define ITTNOTIFY_DATA_D0(n,d) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d)
+#define ITTNOTIFY_DATA_D1(n,d,x) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x)
+#define ITTNOTIFY_DATA_D2(n,d,x,y) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y)
+#define ITTNOTIFY_DATA_D3(n,d,x,y,z) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z)
+#define ITTNOTIFY_DATA_D4(n,d,x,y,z,a) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
+#define ITTNOTIFY_DATA_D5(n,d,x,y,z,a,b) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
+#define ITTNOTIFY_DATA_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
+
+#ifdef ITT_STUB
+#undef ITT_STUB
+#endif
+#ifdef ITT_STUBV
+#undef ITT_STUBV
+#endif
+#define ITT_STUBV(api,type,name,args) \
+ typedef type (api* ITT_JOIN(ITTNOTIFY_NAME(name),_t)) args; \
+ extern ITT_JOIN(ITTNOTIFY_NAME(name),_t) ITTNOTIFY_NAME(name);
+#define ITT_STUB ITT_STUBV
+/** @endcond */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/** @cond exclude_from_gpa_documentation */
+/**
+ * @defgroup public Public API
+ * @{
+ * @}
+ */
+
+/**
+ * @defgroup control Collection Control
+ * @ingroup public
+ * General behavior: application continues to run, but no profiling information is being collected
+ *
+ * Pausing occurs not only for the current thread but for all process as well as spawned processes
+ * - Intel(R) Parallel Inspector and Intel(R) Inspector XE:
+ * - Does not analyze or report errors that involve memory access.
+ * - Other errors are reported as usual. Pausing data collection in
+ * Intel(R) Parallel Inspector and Intel(R) Inspector XE
+ * only pauses tracing and analyzing memory access.
+ * It does not pause tracing or analyzing threading APIs.
+ * .
+ * - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE:
+ * - Does continue to record when new threads are started.
+ * .
+ * - Other effects:
+ * - Possible reduction of runtime overhead.
+ * .
+ * @{
+ */
+/** @brief Pause collection */
+void ITTAPI __itt_pause(void);
+/** @brief Resume collection */
+void ITTAPI __itt_resume(void);
+/** @brief Detach collection */
+void ITTAPI __itt_detach(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, pause, (void))
+ITT_STUBV(ITTAPI, void, resume, (void))
+ITT_STUBV(ITTAPI, void, detach, (void))
+#define __itt_pause ITTNOTIFY_VOID(pause)
+#define __itt_pause_ptr ITTNOTIFY_NAME(pause)
+#define __itt_resume ITTNOTIFY_VOID(resume)
+#define __itt_resume_ptr ITTNOTIFY_NAME(resume)
+#define __itt_detach ITTNOTIFY_VOID(detach)
+#define __itt_detach_ptr ITTNOTIFY_NAME(detach)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_pause()
+#define __itt_pause_ptr 0
+#define __itt_resume()
+#define __itt_resume_ptr 0
+#define __itt_detach()
+#define __itt_detach_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_pause_ptr 0
+#define __itt_resume_ptr 0
+#define __itt_detach_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} control group */
+/** @endcond */
+
+/**
+ * @defgroup threads Threads
+ * @ingroup public
+ * Give names to threads
+ * @{
+ */
+/**
+ * @brief Sets thread name of calling thread
+ * @param[in] name - name of thread
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_thread_set_nameA(const char *name);
+void ITTAPI __itt_thread_set_nameW(const wchar_t *name);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_thread_set_name __itt_thread_set_nameW
+# define __itt_thread_set_name_ptr __itt_thread_set_nameW_ptr
+#else /* UNICODE */
+# define __itt_thread_set_name __itt_thread_set_nameA
+# define __itt_thread_set_name_ptr __itt_thread_set_nameA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_thread_set_name(const char *name);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name))
+ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_thread_set_nameA ITTNOTIFY_VOID(thread_set_nameA)
+#define __itt_thread_set_nameA_ptr ITTNOTIFY_NAME(thread_set_nameA)
+#define __itt_thread_set_nameW ITTNOTIFY_VOID(thread_set_nameW)
+#define __itt_thread_set_nameW_ptr ITTNOTIFY_NAME(thread_set_nameW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_thread_set_name ITTNOTIFY_VOID(thread_set_name)
+#define __itt_thread_set_name_ptr ITTNOTIFY_NAME(thread_set_name)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_thread_set_nameA(name)
+#define __itt_thread_set_nameA_ptr 0
+#define __itt_thread_set_nameW(name)
+#define __itt_thread_set_nameW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_thread_set_name(name)
+#define __itt_thread_set_name_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_thread_set_nameA_ptr 0
+#define __itt_thread_set_nameW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_thread_set_name_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @cond exclude_from_gpa_documentation */
+
+/**
+ * @brief Mark current thread as ignored from this point on, for the duration of its existence.
+ */
+void ITTAPI __itt_thread_ignore(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, thread_ignore, (void))
+#define __itt_thread_ignore ITTNOTIFY_VOID(thread_ignore)
+#define __itt_thread_ignore_ptr ITTNOTIFY_NAME(thread_ignore)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_thread_ignore()
+#define __itt_thread_ignore_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_thread_ignore_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} threads group */
+
+/**
+ * @defgroup suppress Error suppression
+ * @ingroup public
+ * General behavior: application continues to run, but errors are suppressed
+ *
+ * @{
+ */
+
+/*****************************************************************//**
+ * @name group of functions used for error suppression in correctness tools
+ *********************************************************************/
+/** @{ */
+/**
+ * @hideinitializer
+ * @brief possible value for suppression mask
+ */
+#define __itt_suppress_all_errors 0x7fffffff
+
+/**
+ * @hideinitializer
+ * @brief possible value for suppression mask (suppresses errors from threading analysis)
+ */
+#define __itt_suppress_threading_errors 0x000000ff
+
+/**
+ * @hideinitializer
+ * @brief possible value for suppression mask (suppresses errors from memory analysis)
+ */
+#define __itt_suppress_memory_errors 0x0000ff00
+
+/**
+ * @brief Start suppressing errors identified in mask on this thread
+ */
+void ITTAPI __itt_suppress_push(unsigned int mask);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask))
+#define __itt_suppress_push ITTNOTIFY_VOID(suppress_push)
+#define __itt_suppress_push_ptr ITTNOTIFY_NAME(suppress_push)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_suppress_push(mask)
+#define __itt_suppress_push_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_suppress_push_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Undo the effects of the matching call to __itt_suppress_push
+ */
+void ITTAPI __itt_suppress_pop(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, suppress_pop, (void))
+#define __itt_suppress_pop ITTNOTIFY_VOID(suppress_pop)
+#define __itt_suppress_pop_ptr ITTNOTIFY_NAME(suppress_pop)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_suppress_pop()
+#define __itt_suppress_pop_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_suppress_pop_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @enum __itt_model_disable
+ * @brief Enumerator for the disable methods
+ */
+typedef enum __itt_suppress_mode {
+ __itt_unsuppress_range,
+ __itt_suppress_range
+} __itt_suppress_mode_t;
+
+/**
+ * @brief Mark a range of memory for error suppression or unsuppression for error types included in mask
+ */
+void ITTAPI __itt_suppress_mark_range(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, suppress_mark_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size))
+#define __itt_suppress_mark_range ITTNOTIFY_VOID(suppress_mark_range)
+#define __itt_suppress_mark_range_ptr ITTNOTIFY_NAME(suppress_mark_range)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_suppress_mark_range(mask)
+#define __itt_suppress_mark_range_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_suppress_mark_range_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Undo the effect of a matching call to __itt_suppress_mark_range. If not matching
+ * call is found, nothing is changed.
+ */
+void ITTAPI __itt_suppress_clear_range(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, suppress_clear_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size))
+#define __itt_suppress_clear_range ITTNOTIFY_VOID(suppress_clear_range)
+#define __itt_suppress_clear_range_ptr ITTNOTIFY_NAME(suppress_clear_range)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_suppress_clear_range(mask)
+#define __itt_suppress_clear_range_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_suppress_clear_range_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} */
+/** @} suppress group */
+
+/**
+ * @defgroup sync Synchronization
+ * @ingroup public
+ * Indicate user-written synchronization code
+ * @{
+ */
+/**
+ * @hideinitializer
+ * @brief possible value of attribute argument for sync object type
+ */
+#define __itt_attr_barrier 1
+
+/**
+ * @hideinitializer
+ * @brief possible value of attribute argument for sync object type
+ */
+#define __itt_attr_mutex 2
+
+/**
+@brief Name a synchronization object
+@param[in] addr Handle for the synchronization object. You should
+use a real address to uniquely identify the synchronization object.
+@param[in] objtype null-terminated object type string. If NULL is
+passed, the name will be "User Synchronization".
+@param[in] objname null-terminated object name string. If NULL,
+no name will be assigned to the object.
+@param[in] attribute one of [#__itt_attr_barrier, #__itt_attr_mutex]
+ */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_sync_createA(void *addr, const char *objtype, const char *objname, int attribute);
+void ITTAPI __itt_sync_createW(void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_sync_create __itt_sync_createW
+# define __itt_sync_create_ptr __itt_sync_createW_ptr
+#else /* UNICODE */
+# define __itt_sync_create __itt_sync_createA
+# define __itt_sync_create_ptr __itt_sync_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_sync_create (void *addr, const char *objtype, const char *objname, int attribute);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_createA, (void *addr, const char *objtype, const char *objname, int attribute))
+ITT_STUBV(ITTAPI, void, sync_createW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_create, (void *addr, const char* objtype, const char* objname, int attribute))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_createA ITTNOTIFY_VOID(sync_createA)
+#define __itt_sync_createA_ptr ITTNOTIFY_NAME(sync_createA)
+#define __itt_sync_createW ITTNOTIFY_VOID(sync_createW)
+#define __itt_sync_createW_ptr ITTNOTIFY_NAME(sync_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_create ITTNOTIFY_VOID(sync_create)
+#define __itt_sync_create_ptr ITTNOTIFY_NAME(sync_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_createA(addr, objtype, objname, attribute)
+#define __itt_sync_createA_ptr 0
+#define __itt_sync_createW(addr, objtype, objname, attribute)
+#define __itt_sync_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_create(addr, objtype, objname, attribute)
+#define __itt_sync_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_createA_ptr 0
+#define __itt_sync_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+@brief Rename a synchronization object
+
+You can use the rename call to assign or reassign a name to a given
+synchronization object.
+@param[in] addr handle for the synchronization object.
+@param[in] name null-terminated object name string.
+*/
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_sync_renameA(void *addr, const char *name);
+void ITTAPI __itt_sync_renameW(void *addr, const wchar_t *name);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_sync_rename __itt_sync_renameW
+# define __itt_sync_rename_ptr __itt_sync_renameW_ptr
+#else /* UNICODE */
+# define __itt_sync_rename __itt_sync_renameA
+# define __itt_sync_rename_ptr __itt_sync_renameA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_sync_rename(void *addr, const char *name);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name))
+ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_renameA ITTNOTIFY_VOID(sync_renameA)
+#define __itt_sync_renameA_ptr ITTNOTIFY_NAME(sync_renameA)
+#define __itt_sync_renameW ITTNOTIFY_VOID(sync_renameW)
+#define __itt_sync_renameW_ptr ITTNOTIFY_NAME(sync_renameW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_rename ITTNOTIFY_VOID(sync_rename)
+#define __itt_sync_rename_ptr ITTNOTIFY_NAME(sync_rename)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_renameA(addr, name)
+#define __itt_sync_renameA_ptr 0
+#define __itt_sync_renameW(addr, name)
+#define __itt_sync_renameW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_rename(addr, name)
+#define __itt_sync_rename_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_renameA_ptr 0
+#define __itt_sync_renameW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_rename_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ @brief Destroy a synchronization object.
+ @param addr Handle for the synchronization object.
+ */
+void ITTAPI __itt_sync_destroy(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr))
+#define __itt_sync_destroy ITTNOTIFY_VOID(sync_destroy)
+#define __itt_sync_destroy_ptr ITTNOTIFY_NAME(sync_destroy)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_sync_destroy(addr)
+#define __itt_sync_destroy_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_sync_destroy_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/*****************************************************************//**
+ * @name group of functions is used for performance measurement tools
+ *********************************************************************/
+/** @{ */
+/**
+ * @brief Enter spin loop on user-defined sync object
+ */
+void ITTAPI __itt_sync_prepare(void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, sync_prepare, (void *addr))
+#define __itt_sync_prepare ITTNOTIFY_VOID(sync_prepare)
+#define __itt_sync_prepare_ptr ITTNOTIFY_NAME(sync_prepare)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_sync_prepare(addr)
+#define __itt_sync_prepare_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_sync_prepare_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Quit spin loop without acquiring spin object
+ */
+void ITTAPI __itt_sync_cancel(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr))
+#define __itt_sync_cancel ITTNOTIFY_VOID(sync_cancel)
+#define __itt_sync_cancel_ptr ITTNOTIFY_NAME(sync_cancel)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_sync_cancel(addr)
+#define __itt_sync_cancel_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_sync_cancel_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Successful spin loop completion (sync object acquired)
+ */
+void ITTAPI __itt_sync_acquired(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr))
+#define __itt_sync_acquired ITTNOTIFY_VOID(sync_acquired)
+#define __itt_sync_acquired_ptr ITTNOTIFY_NAME(sync_acquired)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_sync_acquired(addr)
+#define __itt_sync_acquired_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_sync_acquired_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Start sync object releasing code. Is called before the lock release call.
+ */
+void ITTAPI __itt_sync_releasing(void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, sync_releasing, (void *addr))
+#define __itt_sync_releasing ITTNOTIFY_VOID(sync_releasing)
+#define __itt_sync_releasing_ptr ITTNOTIFY_NAME(sync_releasing)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_sync_releasing(addr)
+#define __itt_sync_releasing_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_sync_releasing_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} */
+
+/** @} sync group */
+
+/**************************************************************//**
+ * @name group of functions is used for correctness checking tools
+ ******************************************************************/
+/** @{ */
+/**
+ * @ingroup legacy
+ * @deprecated Legacy API
+ * @brief Fast synchronization which does no require spinning.
+ * - This special function is to be used by TBB and OpenMP libraries only when they know
+ * there is no spin but they need to suppress TC warnings about shared variable modifications.
+ * - It only has corresponding pointers in static library and does not have corresponding function
+ * in dynamic library.
+ * @see void __itt_sync_prepare(void* addr);
+ */
+void ITTAPI __itt_fsync_prepare(void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, fsync_prepare, (void *addr))
+#define __itt_fsync_prepare ITTNOTIFY_VOID(fsync_prepare)
+#define __itt_fsync_prepare_ptr ITTNOTIFY_NAME(fsync_prepare)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_fsync_prepare(addr)
+#define __itt_fsync_prepare_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_fsync_prepare_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup legacy
+ * @deprecated Legacy API
+ * @brief Fast synchronization which does no require spinning.
+ * - This special function is to be used by TBB and OpenMP libraries only when they know
+ * there is no spin but they need to suppress TC warnings about shared variable modifications.
+ * - It only has corresponding pointers in static library and does not have corresponding function
+ * in dynamic library.
+ * @see void __itt_sync_cancel(void *addr);
+ */
+void ITTAPI __itt_fsync_cancel(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr))
+#define __itt_fsync_cancel ITTNOTIFY_VOID(fsync_cancel)
+#define __itt_fsync_cancel_ptr ITTNOTIFY_NAME(fsync_cancel)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_fsync_cancel(addr)
+#define __itt_fsync_cancel_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_fsync_cancel_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup legacy
+ * @deprecated Legacy API
+ * @brief Fast synchronization which does no require spinning.
+ * - This special function is to be used by TBB and OpenMP libraries only when they know
+ * there is no spin but they need to suppress TC warnings about shared variable modifications.
+ * - It only has corresponding pointers in static library and does not have corresponding function
+ * in dynamic library.
+ * @see void __itt_sync_acquired(void *addr);
+ */
+void ITTAPI __itt_fsync_acquired(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr))
+#define __itt_fsync_acquired ITTNOTIFY_VOID(fsync_acquired)
+#define __itt_fsync_acquired_ptr ITTNOTIFY_NAME(fsync_acquired)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_fsync_acquired(addr)
+#define __itt_fsync_acquired_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_fsync_acquired_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup legacy
+ * @deprecated Legacy API
+ * @brief Fast synchronization which does no require spinning.
+ * - This special function is to be used by TBB and OpenMP libraries only when they know
+ * there is no spin but they need to suppress TC warnings about shared variable modifications.
+ * - It only has corresponding pointers in static library and does not have corresponding function
+ * in dynamic library.
+ * @see void __itt_sync_releasing(void* addr);
+ */
+void ITTAPI __itt_fsync_releasing(void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, fsync_releasing, (void *addr))
+#define __itt_fsync_releasing ITTNOTIFY_VOID(fsync_releasing)
+#define __itt_fsync_releasing_ptr ITTNOTIFY_NAME(fsync_releasing)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_fsync_releasing(addr)
+#define __itt_fsync_releasing_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_fsync_releasing_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} */
+
+/**
+ * @defgroup model Modeling by Intel(R) Parallel Advisor
+ * @ingroup public
+ * This is the subset of itt used for modeling by Intel(R) Parallel Advisor.
+ * This API is called ONLY using annotate.h, by "Annotation" macros
+ * the user places in their sources during the parallelism modeling steps.
+ *
+ * site_begin/end and task_begin/end take the address of handle variables,
+ * which are writeable by the API. Handles must be 0 initialized prior
+ * to the first call to begin, or may cause a run-time failure.
+ * The handles are initialized in a multi-thread safe way by the API if
+ * the handle is 0. The commonly expected idiom is one static handle to
+ * identify a site or task. If a site or task of the same name has already
+ * been started during this collection, the same handle MAY be returned,
+ * but is not required to be - it is unspecified if data merging is done
+ * based on name. These routines also take an instance variable. Like
+ * the lexical instance, these must be 0 initialized. Unlike the lexical
+ * instance, this is used to track a single dynamic instance.
+ *
+ * API used by the Intel(R) Parallel Advisor to describe potential concurrency
+ * and related activities. User-added source annotations expand to calls
+ * to these procedures to enable modeling of a hypothetical concurrent
+ * execution serially.
+ * @{
+ */
+#if !defined(_ADVISOR_ANNOTATE_H_) || defined(ANNOTATE_EXPAND_NULL)
+
+typedef void* __itt_model_site; /*!< @brief handle for lexical site */
+typedef void* __itt_model_site_instance; /*!< @brief handle for dynamic instance */
+typedef void* __itt_model_task; /*!< @brief handle for lexical site */
+typedef void* __itt_model_task_instance; /*!< @brief handle for dynamic instance */
+
+/**
+ * @enum __itt_model_disable
+ * @brief Enumerator for the disable methods
+ */
+typedef enum {
+ __itt_model_disable_observation,
+ __itt_model_disable_collection
+} __itt_model_disable;
+
+#endif /* !_ADVISOR_ANNOTATE_H_ || ANNOTATE_EXPAND_NULL */
+
+/**
+ * @brief ANNOTATE_SITE_BEGIN/ANNOTATE_SITE_END support.
+ *
+ * site_begin/end model a potential concurrency site.
+ * site instances may be recursively nested with themselves.
+ * site_end exits the most recently started but unended site for the current
+ * thread. The handle passed to end may be used to validate structure.
+ * Instances of a site encountered on different threads concurrently
+ * are considered completely distinct. If the site name for two different
+ * lexical sites match, it is unspecified whether they are treated as the
+ * same or different for data presentation.
+ */
+void ITTAPI __itt_model_site_begin(__itt_model_site *site, __itt_model_site_instance *instance, const char *name);
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_model_site_beginW(const wchar_t *name);
+#endif
+void ITTAPI __itt_model_site_beginA(const char *name);
+void ITTAPI __itt_model_site_beginAL(const char *name, size_t siteNameLen);
+void ITTAPI __itt_model_site_end (__itt_model_site *site, __itt_model_site_instance *instance);
+void ITTAPI __itt_model_site_end_2(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_site_begin, (__itt_model_site *site, __itt_model_site_instance *instance, const char *name))
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name))
+#endif
+ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name))
+ITT_STUBV(ITTAPI, void, model_site_beginAL, (const char *name, size_t siteNameLen))
+ITT_STUBV(ITTAPI, void, model_site_end, (__itt_model_site *site, __itt_model_site_instance *instance))
+ITT_STUBV(ITTAPI, void, model_site_end_2, (void))
+#define __itt_model_site_begin ITTNOTIFY_VOID(model_site_begin)
+#define __itt_model_site_begin_ptr ITTNOTIFY_NAME(model_site_begin)
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_model_site_beginW ITTNOTIFY_VOID(model_site_beginW)
+#define __itt_model_site_beginW_ptr ITTNOTIFY_NAME(model_site_beginW)
+#endif
+#define __itt_model_site_beginA ITTNOTIFY_VOID(model_site_beginA)
+#define __itt_model_site_beginA_ptr ITTNOTIFY_NAME(model_site_beginA)
+#define __itt_model_site_beginAL ITTNOTIFY_VOID(model_site_beginAL)
+#define __itt_model_site_beginAL_ptr ITTNOTIFY_NAME(model_site_beginAL)
+#define __itt_model_site_end ITTNOTIFY_VOID(model_site_end)
+#define __itt_model_site_end_ptr ITTNOTIFY_NAME(model_site_end)
+#define __itt_model_site_end_2 ITTNOTIFY_VOID(model_site_end_2)
+#define __itt_model_site_end_2_ptr ITTNOTIFY_NAME(model_site_end_2)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_site_begin(site, instance, name)
+#define __itt_model_site_begin_ptr 0
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_model_site_beginW(name)
+#define __itt_model_site_beginW_ptr 0
+#endif
+#define __itt_model_site_beginA(name)
+#define __itt_model_site_beginA_ptr 0
+#define __itt_model_site_beginAL(name, siteNameLen)
+#define __itt_model_site_beginAL_ptr 0
+#define __itt_model_site_end(site, instance)
+#define __itt_model_site_end_ptr 0
+#define __itt_model_site_end_2()
+#define __itt_model_site_end_2_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_site_begin_ptr 0
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_model_site_beginW_ptr 0
+#endif
+#define __itt_model_site_beginA_ptr 0
+#define __itt_model_site_beginAL_ptr 0
+#define __itt_model_site_end_ptr 0
+#define __itt_model_site_end_2_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief ANNOTATE_TASK_BEGIN/ANNOTATE_TASK_END support
+ *
+ * task_begin/end model a potential task, which is contained within the most
+ * closely enclosing dynamic site. task_end exits the most recently started
+ * but unended task. The handle passed to end may be used to validate
+ * structure. It is unspecified if bad dynamic nesting is detected. If it
+ * is, it should be encoded in the resulting data collection. The collector
+ * should not fail due to construct nesting issues, nor attempt to directly
+ * indicate the problem.
+ */
+void ITTAPI __itt_model_task_begin(__itt_model_task *task, __itt_model_task_instance *instance, const char *name);
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_model_task_beginW(const wchar_t *name);
+void ITTAPI __itt_model_iteration_taskW(const wchar_t *name);
+#endif
+void ITTAPI __itt_model_task_beginA(const char *name);
+void ITTAPI __itt_model_task_beginAL(const char *name, size_t taskNameLen);
+void ITTAPI __itt_model_iteration_taskA(const char *name);
+void ITTAPI __itt_model_iteration_taskAL(const char *name, size_t taskNameLen);
+void ITTAPI __itt_model_task_end (__itt_model_task *task, __itt_model_task_instance *instance);
+void ITTAPI __itt_model_task_end_2(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_task_begin, (__itt_model_task *task, __itt_model_task_instance *instance, const char *name))
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name))
+ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name))
+#endif
+ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name))
+ITT_STUBV(ITTAPI, void, model_task_beginAL, (const char *name, size_t taskNameLen))
+ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name))
+ITT_STUBV(ITTAPI, void, model_iteration_taskAL, (const char *name, size_t taskNameLen))
+ITT_STUBV(ITTAPI, void, model_task_end, (__itt_model_task *task, __itt_model_task_instance *instance))
+ITT_STUBV(ITTAPI, void, model_task_end_2, (void))
+#define __itt_model_task_begin ITTNOTIFY_VOID(model_task_begin)
+#define __itt_model_task_begin_ptr ITTNOTIFY_NAME(model_task_begin)
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_model_task_beginW ITTNOTIFY_VOID(model_task_beginW)
+#define __itt_model_task_beginW_ptr ITTNOTIFY_NAME(model_task_beginW)
+#define __itt_model_iteration_taskW ITTNOTIFY_VOID(model_iteration_taskW)
+#define __itt_model_iteration_taskW_ptr ITTNOTIFY_NAME(model_iteration_taskW)
+#endif
+#define __itt_model_task_beginA ITTNOTIFY_VOID(model_task_beginA)
+#define __itt_model_task_beginA_ptr ITTNOTIFY_NAME(model_task_beginA)
+#define __itt_model_task_beginAL ITTNOTIFY_VOID(model_task_beginAL)
+#define __itt_model_task_beginAL_ptr ITTNOTIFY_NAME(model_task_beginAL)
+#define __itt_model_iteration_taskA ITTNOTIFY_VOID(model_iteration_taskA)
+#define __itt_model_iteration_taskA_ptr ITTNOTIFY_NAME(model_iteration_taskA)
+#define __itt_model_iteration_taskAL ITTNOTIFY_VOID(model_iteration_taskAL)
+#define __itt_model_iteration_taskAL_ptr ITTNOTIFY_NAME(model_iteration_taskAL)
+#define __itt_model_task_end ITTNOTIFY_VOID(model_task_end)
+#define __itt_model_task_end_ptr ITTNOTIFY_NAME(model_task_end)
+#define __itt_model_task_end_2 ITTNOTIFY_VOID(model_task_end_2)
+#define __itt_model_task_end_2_ptr ITTNOTIFY_NAME(model_task_end_2)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_task_begin(task, instance, name)
+#define __itt_model_task_begin_ptr 0
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_model_task_beginW(name)
+#define __itt_model_task_beginW_ptr 0
+#endif
+#define __itt_model_task_beginA(name)
+#define __itt_model_task_beginA_ptr 0
+#define __itt_model_task_beginAL(name, siteNameLen)
+#define __itt_model_task_beginAL_ptr 0
+#define __itt_model_iteration_taskA(name)
+#define __itt_model_iteration_taskA_ptr 0
+#define __itt_model_iteration_taskAL(name, siteNameLen)
+#define __itt_model_iteration_taskAL_ptr 0
+#define __itt_model_task_end(task, instance)
+#define __itt_model_task_end_ptr 0
+#define __itt_model_task_end_2()
+#define __itt_model_task_end_2_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_task_begin_ptr 0
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_model_task_beginW_ptr 0
+#endif
+#define __itt_model_task_beginA_ptr 0
+#define __itt_model_task_beginAL_ptr 0
+#define __itt_model_iteration_taskA_ptr 0
+#define __itt_model_iteration_taskAL_ptr 0
+#define __itt_model_task_end_ptr 0
+#define __itt_model_task_end_2_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief ANNOTATE_LOCK_ACQUIRE/ANNOTATE_LOCK_RELEASE support
+ *
+ * lock_acquire/release model a potential lock for both lockset and
+ * performance modeling. Each unique address is modeled as a separate
+ * lock, with invalid addresses being valid lock IDs. Specifically:
+ * no storage is accessed by the API at the specified address - it is only
+ * used for lock identification. Lock acquires may be self-nested and are
+ * unlocked by a corresponding number of releases.
+ * (These closely correspond to __itt_sync_acquired/__itt_sync_releasing,
+ * but may not have identical semantics.)
+ */
+void ITTAPI __itt_model_lock_acquire(void *lock);
+void ITTAPI __itt_model_lock_acquire_2(void *lock);
+void ITTAPI __itt_model_lock_release(void *lock);
+void ITTAPI __itt_model_lock_release_2(void *lock);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock))
+ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock))
+ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock))
+ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock))
+#define __itt_model_lock_acquire ITTNOTIFY_VOID(model_lock_acquire)
+#define __itt_model_lock_acquire_ptr ITTNOTIFY_NAME(model_lock_acquire)
+#define __itt_model_lock_acquire_2 ITTNOTIFY_VOID(model_lock_acquire_2)
+#define __itt_model_lock_acquire_2_ptr ITTNOTIFY_NAME(model_lock_acquire_2)
+#define __itt_model_lock_release ITTNOTIFY_VOID(model_lock_release)
+#define __itt_model_lock_release_ptr ITTNOTIFY_NAME(model_lock_release)
+#define __itt_model_lock_release_2 ITTNOTIFY_VOID(model_lock_release_2)
+#define __itt_model_lock_release_2_ptr ITTNOTIFY_NAME(model_lock_release_2)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_lock_acquire(lock)
+#define __itt_model_lock_acquire_ptr 0
+#define __itt_model_lock_acquire_2(lock)
+#define __itt_model_lock_acquire_2_ptr 0
+#define __itt_model_lock_release(lock)
+#define __itt_model_lock_release_ptr 0
+#define __itt_model_lock_release_2(lock)
+#define __itt_model_lock_release_2_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_lock_acquire_ptr 0
+#define __itt_model_lock_acquire_2_ptr 0
+#define __itt_model_lock_release_ptr 0
+#define __itt_model_lock_release_2_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief ANNOTATE_RECORD_ALLOCATION/ANNOTATE_RECORD_DEALLOCATION support
+ *
+ * record_allocation/deallocation describe user-defined memory allocator
+ * behavior, which may be required for correctness modeling to understand
+ * when storage is not expected to be actually reused across threads.
+ */
+void ITTAPI __itt_model_record_allocation (void *addr, size_t size);
+void ITTAPI __itt_model_record_deallocation(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size))
+ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr))
+#define __itt_model_record_allocation ITTNOTIFY_VOID(model_record_allocation)
+#define __itt_model_record_allocation_ptr ITTNOTIFY_NAME(model_record_allocation)
+#define __itt_model_record_deallocation ITTNOTIFY_VOID(model_record_deallocation)
+#define __itt_model_record_deallocation_ptr ITTNOTIFY_NAME(model_record_deallocation)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_record_allocation(addr, size)
+#define __itt_model_record_allocation_ptr 0
+#define __itt_model_record_deallocation(addr)
+#define __itt_model_record_deallocation_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_record_allocation_ptr 0
+#define __itt_model_record_deallocation_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief ANNOTATE_INDUCTION_USES support
+ *
+ * Note particular storage is inductive through the end of the current site
+ */
+void ITTAPI __itt_model_induction_uses(void* addr, size_t size);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_induction_uses, (void *addr, size_t size))
+#define __itt_model_induction_uses ITTNOTIFY_VOID(model_induction_uses)
+#define __itt_model_induction_uses_ptr ITTNOTIFY_NAME(model_induction_uses)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_induction_uses(addr, size)
+#define __itt_model_induction_uses_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_induction_uses_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief ANNOTATE_REDUCTION_USES support
+ *
+ * Note particular storage is used for reduction through the end
+ * of the current site
+ */
+void ITTAPI __itt_model_reduction_uses(void* addr, size_t size);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_reduction_uses, (void *addr, size_t size))
+#define __itt_model_reduction_uses ITTNOTIFY_VOID(model_reduction_uses)
+#define __itt_model_reduction_uses_ptr ITTNOTIFY_NAME(model_reduction_uses)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_reduction_uses(addr, size)
+#define __itt_model_reduction_uses_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_reduction_uses_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief ANNOTATE_OBSERVE_USES support
+ *
+ * Have correctness modeling record observations about uses of storage
+ * through the end of the current site
+ */
+void ITTAPI __itt_model_observe_uses(void* addr, size_t size);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_observe_uses, (void *addr, size_t size))
+#define __itt_model_observe_uses ITTNOTIFY_VOID(model_observe_uses)
+#define __itt_model_observe_uses_ptr ITTNOTIFY_NAME(model_observe_uses)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_observe_uses(addr, size)
+#define __itt_model_observe_uses_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_observe_uses_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief ANNOTATE_CLEAR_USES support
+ *
+ * Clear the special handling of a piece of storage related to induction,
+ * reduction or observe_uses
+ */
+void ITTAPI __itt_model_clear_uses(void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_clear_uses, (void *addr))
+#define __itt_model_clear_uses ITTNOTIFY_VOID(model_clear_uses)
+#define __itt_model_clear_uses_ptr ITTNOTIFY_NAME(model_clear_uses)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_clear_uses(addr)
+#define __itt_model_clear_uses_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_clear_uses_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief ANNOTATE_DISABLE_*_PUSH/ANNOTATE_DISABLE_*_POP support
+ *
+ * disable_push/disable_pop push and pop disabling based on a parameter.
+ * Disabling observations stops processing of memory references during
+ * correctness modeling, and all annotations that occur in the disabled
+ * region. This allows description of code that is expected to be handled
+ * specially during conversion to parallelism or that is not recognized
+ * by tools (e.g. some kinds of synchronization operations.)
+ * This mechanism causes all annotations in the disabled region, other
+ * than disable_push and disable_pop, to be ignored. (For example, this
+ * might validly be used to disable an entire parallel site and the contained
+ * tasks and locking in it for data collection purposes.)
+ * The disable for collection is a more expensive operation, but reduces
+ * collector overhead significantly. This applies to BOTH correctness data
+ * collection and performance data collection. For example, a site
+ * containing a task might only enable data collection for the first 10
+ * iterations. Both performance and correctness data should reflect this,
+ * and the program should run as close to full speed as possible when
+ * collection is disabled.
+ */
+void ITTAPI __itt_model_disable_push(__itt_model_disable x);
+void ITTAPI __itt_model_disable_pop(void);
+void ITTAPI __itt_model_aggregate_task(size_t x);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x))
+ITT_STUBV(ITTAPI, void, model_disable_pop, (void))
+ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t x))
+#define __itt_model_disable_push ITTNOTIFY_VOID(model_disable_push)
+#define __itt_model_disable_push_ptr ITTNOTIFY_NAME(model_disable_push)
+#define __itt_model_disable_pop ITTNOTIFY_VOID(model_disable_pop)
+#define __itt_model_disable_pop_ptr ITTNOTIFY_NAME(model_disable_pop)
+#define __itt_model_aggregate_task ITTNOTIFY_VOID(model_aggregate_task)
+#define __itt_model_aggregate_task_ptr ITTNOTIFY_NAME(model_aggregate_task)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_disable_push(x)
+#define __itt_model_disable_push_ptr 0
+#define __itt_model_disable_pop()
+#define __itt_model_disable_pop_ptr 0
+#define __itt_model_aggregate_task(x)
+#define __itt_model_aggregate_task_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_disable_push_ptr 0
+#define __itt_model_disable_pop_ptr 0
+#define __itt_model_aggregate_task_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} model group */
+
+/**
+ * @defgroup heap Heap
+ * @ingroup public
+ * Heap group
+ * @{
+ */
+
+typedef void* __itt_heap_function;
+
+/**
+ * @brief Create an identification for heap function
+ * @return non-zero identifier or NULL
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_heap_function ITTAPI __itt_heap_function_createA(const char* name, const char* domain);
+__itt_heap_function ITTAPI __itt_heap_function_createW(const wchar_t* name, const wchar_t* domain);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_heap_function_create __itt_heap_function_createW
+# define __itt_heap_function_create_ptr __itt_heap_function_createW_ptr
+#else
+# define __itt_heap_function_create __itt_heap_function_createA
+# define __itt_heap_function_create_ptr __itt_heap_function_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_heap_function ITTAPI __itt_heap_function_create(const char* name, const char* domain);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA, (const char* name, const char* domain))
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW, (const wchar_t* name, const wchar_t* domain))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create, (const char* name, const char* domain))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_heap_function_createA ITTNOTIFY_DATA(heap_function_createA)
+#define __itt_heap_function_createA_ptr ITTNOTIFY_NAME(heap_function_createA)
+#define __itt_heap_function_createW ITTNOTIFY_DATA(heap_function_createW)
+#define __itt_heap_function_createW_ptr ITTNOTIFY_NAME(heap_function_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_heap_function_create ITTNOTIFY_DATA(heap_function_create)
+#define __itt_heap_function_create_ptr ITTNOTIFY_NAME(heap_function_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_heap_function_createA(name, domain) (__itt_heap_function)0
+#define __itt_heap_function_createA_ptr 0
+#define __itt_heap_function_createW(name, domain) (__itt_heap_function)0
+#define __itt_heap_function_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_heap_function_create(name, domain) (__itt_heap_function)0
+#define __itt_heap_function_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_heap_function_createA_ptr 0
+#define __itt_heap_function_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_heap_function_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an allocation begin occurrence.
+ */
+void ITTAPI __itt_heap_allocate_begin(__itt_heap_function h, size_t size, int initialized);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_allocate_begin, (__itt_heap_function h, size_t size, int initialized))
+#define __itt_heap_allocate_begin ITTNOTIFY_VOID(heap_allocate_begin)
+#define __itt_heap_allocate_begin_ptr ITTNOTIFY_NAME(heap_allocate_begin)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_allocate_begin(h, size, initialized)
+#define __itt_heap_allocate_begin_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_allocate_begin_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an allocation end occurrence.
+ */
+void ITTAPI __itt_heap_allocate_end(__itt_heap_function h, void** addr, size_t size, int initialized);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_allocate_end, (__itt_heap_function h, void** addr, size_t size, int initialized))
+#define __itt_heap_allocate_end ITTNOTIFY_VOID(heap_allocate_end)
+#define __itt_heap_allocate_end_ptr ITTNOTIFY_NAME(heap_allocate_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_allocate_end(h, addr, size, initialized)
+#define __itt_heap_allocate_end_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_allocate_end_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an free begin occurrence.
+ */
+void ITTAPI __itt_heap_free_begin(__itt_heap_function h, void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void* addr))
+#define __itt_heap_free_begin ITTNOTIFY_VOID(heap_free_begin)
+#define __itt_heap_free_begin_ptr ITTNOTIFY_NAME(heap_free_begin)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_free_begin(h, addr)
+#define __itt_heap_free_begin_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_free_begin_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an free end occurrence.
+ */
+void ITTAPI __itt_heap_free_end(__itt_heap_function h, void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void* addr))
+#define __itt_heap_free_end ITTNOTIFY_VOID(heap_free_end)
+#define __itt_heap_free_end_ptr ITTNOTIFY_NAME(heap_free_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_free_end(h, addr)
+#define __itt_heap_free_end_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_free_end_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an reallocation begin occurrence.
+ */
+void ITTAPI __itt_heap_reallocate_begin(__itt_heap_function h, void* addr, size_t new_size, int initialized);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_reallocate_begin, (__itt_heap_function h, void* addr, size_t new_size, int initialized))
+#define __itt_heap_reallocate_begin ITTNOTIFY_VOID(heap_reallocate_begin)
+#define __itt_heap_reallocate_begin_ptr ITTNOTIFY_NAME(heap_reallocate_begin)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_reallocate_begin(h, addr, new_size, initialized)
+#define __itt_heap_reallocate_begin_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_reallocate_begin_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an reallocation end occurrence.
+ */
+void ITTAPI __itt_heap_reallocate_end(__itt_heap_function h, void* addr, void** new_addr, size_t new_size, int initialized);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_reallocate_end, (__itt_heap_function h, void* addr, void** new_addr, size_t new_size, int initialized))
+#define __itt_heap_reallocate_end ITTNOTIFY_VOID(heap_reallocate_end)
+#define __itt_heap_reallocate_end_ptr ITTNOTIFY_NAME(heap_reallocate_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_reallocate_end(h, addr, new_addr, new_size, initialized)
+#define __itt_heap_reallocate_end_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_reallocate_end_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @brief internal access begin */
+void ITTAPI __itt_heap_internal_access_begin(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void))
+#define __itt_heap_internal_access_begin ITTNOTIFY_VOID(heap_internal_access_begin)
+#define __itt_heap_internal_access_begin_ptr ITTNOTIFY_NAME(heap_internal_access_begin)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_internal_access_begin()
+#define __itt_heap_internal_access_begin_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_internal_access_begin_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @brief internal access end */
+void ITTAPI __itt_heap_internal_access_end(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void))
+#define __itt_heap_internal_access_end ITTNOTIFY_VOID(heap_internal_access_end)
+#define __itt_heap_internal_access_end_ptr ITTNOTIFY_NAME(heap_internal_access_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_internal_access_end()
+#define __itt_heap_internal_access_end_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_internal_access_end_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @brief record memory growth begin */
+void ITTAPI __itt_heap_record_memory_growth_begin(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void))
+#define __itt_heap_record_memory_growth_begin ITTNOTIFY_VOID(heap_record_memory_growth_begin)
+#define __itt_heap_record_memory_growth_begin_ptr ITTNOTIFY_NAME(heap_record_memory_growth_begin)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_record_memory_growth_begin()
+#define __itt_heap_record_memory_growth_begin_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_record_memory_growth_begin_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @brief record memory growth end */
+void ITTAPI __itt_heap_record_memory_growth_end(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void))
+#define __itt_heap_record_memory_growth_end ITTNOTIFY_VOID(heap_record_memory_growth_end)
+#define __itt_heap_record_memory_growth_end_ptr ITTNOTIFY_NAME(heap_record_memory_growth_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_record_memory_growth_end()
+#define __itt_heap_record_memory_growth_end_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_record_memory_growth_end_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Specify the type of heap detection/reporting to modify.
+ */
+/**
+ * @hideinitializer
+ * @brief Report on memory leaks.
+ */
+#define __itt_heap_leaks 0x00000001
+
+/**
+ * @hideinitializer
+ * @brief Report on memory growth.
+ */
+#define __itt_heap_growth 0x00000002
+
+
+/** @brief heap reset detection */
+void ITTAPI __itt_heap_reset_detection(unsigned int reset_mask);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask))
+#define __itt_heap_reset_detection ITTNOTIFY_VOID(heap_reset_detection)
+#define __itt_heap_reset_detection_ptr ITTNOTIFY_NAME(heap_reset_detection)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_reset_detection()
+#define __itt_heap_reset_detection_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_reset_detection_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @brief report */
+void ITTAPI __itt_heap_record(unsigned int record_mask);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask))
+#define __itt_heap_record ITTNOTIFY_VOID(heap_record)
+#define __itt_heap_record_ptr ITTNOTIFY_NAME(heap_record)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_record()
+#define __itt_heap_record_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_record_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @} heap group */
+/** @endcond */
+/* ========================================================================== */
+
+/**
+ * @defgroup domains Domains
+ * @ingroup public
+ * Domains group
+ * @{
+ */
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_domain
+{
+ volatile int flags; /*!< Zero if disabled, non-zero if enabled. The meaning of different non-zero values is reserved to the runtime */
+ const char* nameA; /*!< Copy of original name in ASCII. */
+#if defined(UNICODE) || defined(_UNICODE)
+ const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
+#else /* UNICODE || _UNICODE */
+ void* nameW;
+#endif /* UNICODE || _UNICODE */
+ int extra1; /*!< Reserved to the runtime */
+ void* extra2; /*!< Reserved to the runtime */
+ struct ___itt_domain* next;
+} __itt_domain;
+
+#pragma pack(pop)
+/** @endcond */
+
+/**
+ * @ingroup domains
+ * @brief Create a domain.
+ * Create domain using some domain name: the URI naming style is recommended.
+ * Because the set of domains is expected to be static over the application's
+ * execution time, there is no mechanism to destroy a domain.
+ * Any domain can be accessed by any thread in the process, regardless of
+ * which thread created the domain. This call is thread-safe.
+ * @param[in] name name of domain
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_domain* ITTAPI __itt_domain_createA(const char *name);
+__itt_domain* ITTAPI __itt_domain_createW(const wchar_t *name);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_domain_create __itt_domain_createW
+# define __itt_domain_create_ptr __itt_domain_createW_ptr
+#else /* UNICODE */
+# define __itt_domain_create __itt_domain_createA
+# define __itt_domain_create_ptr __itt_domain_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_domain* ITTAPI __itt_domain_create(const char *name);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_domain*, domain_createA, (const char *name))
+ITT_STUB(ITTAPI, __itt_domain*, domain_createW, (const wchar_t *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_domain*, domain_create, (const char *name))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_domain_createA ITTNOTIFY_DATA(domain_createA)
+#define __itt_domain_createA_ptr ITTNOTIFY_NAME(domain_createA)
+#define __itt_domain_createW ITTNOTIFY_DATA(domain_createW)
+#define __itt_domain_createW_ptr ITTNOTIFY_NAME(domain_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_domain_create ITTNOTIFY_DATA(domain_create)
+#define __itt_domain_create_ptr ITTNOTIFY_NAME(domain_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_domain_createA(name) (__itt_domain*)0
+#define __itt_domain_createA_ptr 0
+#define __itt_domain_createW(name) (__itt_domain*)0
+#define __itt_domain_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_domain_create(name) (__itt_domain*)0
+#define __itt_domain_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_domain_createA_ptr 0
+#define __itt_domain_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_domain_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} domains group */
+
+/**
+ * @defgroup ids IDs
+ * @ingroup public
+ * IDs group
+ * @{
+ */
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_id
+{
+ unsigned long long d1, d2, d3;
+} __itt_id;
+
+#pragma pack(pop)
+/** @endcond */
+
+const __itt_id __itt_null = { 0, 0, 0 };
+
+/**
+ * @ingroup ids
+ * @brief A convenience function is provided to create an ID without domain control.
+ * @brief This is a convenience function to initialize an __itt_id structure. This function
+ * does not affect the collector runtime in any way. After you make the ID with this
+ * function, you still must create it with the __itt_id_create function before using the ID
+ * to identify a named entity.
+ * @param[in] addr The address of object; high QWORD of the ID value.
+ * @param[in] extra The extra data to unique identify object; low QWORD of the ID value.
+ */
+
+ITT_INLINE __itt_id ITTAPI __itt_id_make(void* addr, unsigned long long extra) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE __itt_id ITTAPI __itt_id_make(void* addr, unsigned long long extra)
+{
+ __itt_id id = __itt_null;
+ id.d1 = (unsigned long long)((uintptr_t)addr);
+ id.d2 = (unsigned long long)extra;
+ id.d3 = (unsigned long long)0; /* Reserved. Must be zero */
+ return id;
+}
+
+/**
+ * @ingroup ids
+ * @brief Create an instance of identifier.
+ * This establishes the beginning of the lifetime of an instance of
+ * the given ID in the trace. Once this lifetime starts, the ID
+ * can be used to tag named entity instances in calls such as
+ * __itt_task_begin, and to specify relationships among
+ * identified named entity instances, using the \ref relations APIs.
+ * Instance IDs are not domain specific!
+ * @param[in] domain The domain controlling the execution of this call.
+ * @param[in] id The ID to create.
+ */
+void ITTAPI __itt_id_create(const __itt_domain *domain, __itt_id id);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id))
+#define __itt_id_create(d,x) ITTNOTIFY_VOID_D1(id_create,d,x)
+#define __itt_id_create_ptr ITTNOTIFY_NAME(id_create)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_id_create(domain,id)
+#define __itt_id_create_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_id_create_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup ids
+ * @brief Destroy an instance of identifier.
+ * This ends the lifetime of the current instance of the given ID value in the trace.
+ * Any relationships that are established after this lifetime ends are invalid.
+ * This call must be performed before the given ID value can be reused for a different
+ * named entity instance.
+ * @param[in] domain The domain controlling the execution of this call.
+ * @param[in] id The ID to destroy.
+ */
+void ITTAPI __itt_id_destroy(const __itt_domain *domain, __itt_id id);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id))
+#define __itt_id_destroy(d,x) ITTNOTIFY_VOID_D1(id_destroy,d,x)
+#define __itt_id_destroy_ptr ITTNOTIFY_NAME(id_destroy)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_id_destroy(domain,id)
+#define __itt_id_destroy_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_id_destroy_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} ids group */
+
+/**
+ * @defgroup handless String Handles
+ * @ingroup public
+ * String Handles group
+ * @{
+ */
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_string_handle
+{
+ const char* strA; /*!< Copy of original string in ASCII. */
+#if defined(UNICODE) || defined(_UNICODE)
+ const wchar_t* strW; /*!< Copy of original string in UNICODE. */
+#else /* UNICODE || _UNICODE */
+ void* strW;
+#endif /* UNICODE || _UNICODE */
+ int extra1; /*!< Reserved. Must be zero */
+ void* extra2; /*!< Reserved. Must be zero */
+ struct ___itt_string_handle* next;
+} __itt_string_handle;
+
+#pragma pack(pop)
+/** @endcond */
+
+/**
+ * @ingroup handles
+ * @brief Create a string handle.
+ * Create and return handle value that can be associated with a string.
+ * Consecutive calls to __itt_string_handle_create with the same name
+ * return the same value. Because the set of string handles is expected to remain
+ * static during the application's execution time, there is no mechanism to destroy a string handle.
+ * Any string handle can be accessed by any thread in the process, regardless of which thread created
+ * the string handle. This call is thread-safe.
+ * @param[in] name The input string
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_string_handle* ITTAPI __itt_string_handle_createA(const char *name);
+__itt_string_handle* ITTAPI __itt_string_handle_createW(const wchar_t *name);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_string_handle_create __itt_string_handle_createW
+# define __itt_string_handle_create_ptr __itt_string_handle_createW_ptr
+#else /* UNICODE */
+# define __itt_string_handle_create __itt_string_handle_createA
+# define __itt_string_handle_create_ptr __itt_string_handle_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_string_handle* ITTAPI __itt_string_handle_create(const char *name);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createA, (const char *name))
+ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createW, (const wchar_t *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_create, (const char *name))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_string_handle_createA ITTNOTIFY_DATA(string_handle_createA)
+#define __itt_string_handle_createA_ptr ITTNOTIFY_NAME(string_handle_createA)
+#define __itt_string_handle_createW ITTNOTIFY_DATA(string_handle_createW)
+#define __itt_string_handle_createW_ptr ITTNOTIFY_NAME(string_handle_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_string_handle_create ITTNOTIFY_DATA(string_handle_create)
+#define __itt_string_handle_create_ptr ITTNOTIFY_NAME(string_handle_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_string_handle_createA(name) (__itt_string_handle*)0
+#define __itt_string_handle_createA_ptr 0
+#define __itt_string_handle_createW(name) (__itt_string_handle*)0
+#define __itt_string_handle_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_string_handle_create(name) (__itt_string_handle*)0
+#define __itt_string_handle_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_string_handle_createA_ptr 0
+#define __itt_string_handle_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_string_handle_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} handles group */
+
+/** @cond exclude_from_documentation */
+typedef unsigned long long __itt_timestamp;
+/** @endcond */
+
+#define __itt_timestamp_none ((__itt_timestamp)-1LL)
+
+/** @cond exclude_from_gpa_documentation */
+
+/**
+ * @ingroup timestamps
+ * @brief Return timestamp corresponding to the current moment.
+ * This returns the timestamp in the format that is the most relevant for the current
+ * host or platform (RDTSC, QPC, and others). You can use the "<" operator to
+ * compare __itt_timestamp values.
+ */
+__itt_timestamp ITTAPI __itt_get_timestamp(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void))
+#define __itt_get_timestamp ITTNOTIFY_DATA(get_timestamp)
+#define __itt_get_timestamp_ptr ITTNOTIFY_NAME(get_timestamp)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_get_timestamp()
+#define __itt_get_timestamp_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_get_timestamp_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} timestamps */
+/** @endcond */
+
+/** @cond exclude_from_gpa_documentation */
+
+/**
+ * @defgroup regions Regions
+ * @ingroup public
+ * Regions group
+ * @{
+ */
+/**
+ * @ingroup regions
+ * @brief Begin of region instance.
+ * Successive calls to __itt_region_begin with the same ID are ignored
+ * until a call to __itt_region_end with the same ID
+ * @param[in] domain The domain for this region instance
+ * @param[in] id The instance ID for this region instance. Must not be __itt_null
+ * @param[in] parentid The instance ID for the parent of this region instance, or __itt_null
+ * @param[in] name The name of this region
+ */
+void ITTAPI __itt_region_begin(const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name);
+
+/**
+ * @ingroup regions
+ * @brief End of region instance.
+ * The first call to __itt_region_end with a given ID ends the
+ * region. Successive calls with the same ID are ignored, as are
+ * calls that do not have a matching __itt_region_begin call.
+ * @param[in] domain The domain for this region instance
+ * @param[in] id The instance ID for this region instance
+ */
+void ITTAPI __itt_region_end(const __itt_domain *domain, __itt_id id);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, region_begin, (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id))
+#define __itt_region_begin(d,x,y,z) ITTNOTIFY_VOID_D3(region_begin,d,x,y,z)
+#define __itt_region_begin_ptr ITTNOTIFY_NAME(region_begin)
+#define __itt_region_end(d,x) ITTNOTIFY_VOID_D1(region_end,d,x)
+#define __itt_region_end_ptr ITTNOTIFY_NAME(region_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_region_begin(d,x,y,z)
+#define __itt_region_begin_ptr 0
+#define __itt_region_end(d,x)
+#define __itt_region_end_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_region_begin_ptr 0
+#define __itt_region_end_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} regions group */
+
+/**
+ * @defgroup frames Frames
+ * @ingroup public
+ * Frames are similar to regions, but are intended to be easier to use and to implement.
+ * In particular:
+ * - Frames always represent periods of elapsed time
+ * - By default, frames have no nesting relationships
+ * @{
+ */
+
+/**
+ * @ingroup frames
+ * @brief Begin a frame instance.
+ * Successive calls to __itt_frame_begin with the
+ * same ID are ignored until a call to __itt_frame_end with the same ID.
+ * @param[in] domain The domain for this frame instance
+ * @param[in] id The instance ID for this frame instance or NULL
+ */
+void ITTAPI __itt_frame_begin_v3(const __itt_domain *domain, __itt_id *id);
+
+/**
+ * @ingroup frames
+ * @brief End a frame instance.
+ * The first call to __itt_frame_end with a given ID
+ * ends the frame. Successive calls with the same ID are ignored, as are
+ * calls that do not have a matching __itt_frame_begin call.
+ * @param[in] domain The domain for this frame instance
+ * @param[in] id The instance ID for this frame instance or NULL for current
+ */
+void ITTAPI __itt_frame_end_v3(const __itt_domain *domain, __itt_id *id);
+
+/**
+ * @ingroup frames
+ * @brief Submits a frame instance.
+ * Successive calls to __itt_frame_begin or __itt_frame_submit with the
+ * same ID are ignored until a call to __itt_frame_end or __itt_frame_submit
+ * with the same ID.
+ * Passing special __itt_timestamp_none value as "end" argument means
+ * take the current timestamp as the end timestamp.
+ * @param[in] domain The domain for this frame instance
+ * @param[in] id The instance ID for this frame instance or NULL
+ * @param[in] begin Timestamp of the beginning of the frame
+ * @param[in] end Timestamp of the end of the frame
+ */
+void ITTAPI __itt_frame_submit_v3(const __itt_domain *domain, __itt_id *id,
+ __itt_timestamp begin, __itt_timestamp end);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, frame_begin_v3, (const __itt_domain *domain, __itt_id *id))
+ITT_STUBV(ITTAPI, void, frame_end_v3, (const __itt_domain *domain, __itt_id *id))
+ITT_STUBV(ITTAPI, void, frame_submit_v3, (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin, __itt_timestamp end))
+#define __itt_frame_begin_v3(d,x) ITTNOTIFY_VOID_D1(frame_begin_v3,d,x)
+#define __itt_frame_begin_v3_ptr ITTNOTIFY_NAME(frame_begin_v3)
+#define __itt_frame_end_v3(d,x) ITTNOTIFY_VOID_D1(frame_end_v3,d,x)
+#define __itt_frame_end_v3_ptr ITTNOTIFY_NAME(frame_end_v3)
+#define __itt_frame_submit_v3(d,x,b,e) ITTNOTIFY_VOID_D3(frame_submit_v3,d,x,b,e)
+#define __itt_frame_submit_v3_ptr ITTNOTIFY_NAME(frame_submit_v3)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_frame_begin_v3(domain,id)
+#define __itt_frame_begin_v3_ptr 0
+#define __itt_frame_end_v3(domain,id)
+#define __itt_frame_end_v3_ptr 0
+#define __itt_frame_submit_v3(domain,id,begin,end)
+#define __itt_frame_submit_v3_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_frame_begin_v3_ptr 0
+#define __itt_frame_end_v3_ptr 0
+#define __itt_frame_submit_v3_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} frames group */
+/** @endcond */
+
+/**
+ * @defgroup taskgroup Task Group
+ * @ingroup public
+ * Task Group
+ * @{
+ */
+/**
+ * @ingroup task_groups
+ * @brief Denotes a task_group instance.
+ * Successive calls to __itt_task_group with the same ID are ignored.
+ * @param[in] domain The domain for this task_group instance
+ * @param[in] id The instance ID for this task_group instance. Must not be __itt_null.
+ * @param[in] parentid The instance ID for the parent of this task_group instance, or __itt_null.
+ * @param[in] name The name of this task_group
+ */
+void ITTAPI __itt_task_group(const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, task_group, (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name))
+#define __itt_task_group(d,x,y,z) ITTNOTIFY_VOID_D3(task_group,d,x,y,z)
+#define __itt_task_group_ptr ITTNOTIFY_NAME(task_group)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_task_group(d,x,y,z)
+#define __itt_task_group_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_task_group_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} taskgroup group */
+
+/**
+ * @defgroup tasks Tasks
+ * @ingroup public
+ * A task instance represents a piece of work performed by a particular
+ * thread for a period of time. A call to __itt_task_begin creates a
+ * task instance. This becomes the current instance for that task on that
+ * thread. A following call to __itt_task_end on the same thread ends the
+ * instance. There may be multiple simultaneous instances of tasks with the
+ * same name on different threads. If an ID is specified, the task instance
+ * receives that ID. Nested tasks are allowed.
+ *
+ * Note: The task is defined by the bracketing of __itt_task_begin and
+ * __itt_task_end on the same thread. If some scheduling mechanism causes
+ * task switching (the thread executes a different user task) or task
+ * switching (the user task switches to a different thread) then this breaks
+ * the notion of current instance. Additional API calls are required to
+ * deal with that possibility.
+ * @{
+ */
+
+/**
+ * @ingroup tasks
+ * @brief Begin a task instance.
+ * @param[in] domain The domain for this task
+ * @param[in] taskid The instance ID for this task instance, or __itt_null
+ * @param[in] parentid The parent instance to which this task instance belongs, or __itt_null
+ * @param[in] name The name of this task
+ */
+void ITTAPI __itt_task_begin(const __itt_domain *domain, __itt_id taskid, __itt_id parentid, __itt_string_handle *name);
+
+/**
+ * @ingroup tasks
+ * @brief Begin a task instance.
+ * @param[in] domain The domain for this task
+ * @param[in] taskid The identifier for this task instance (may be 0)
+ * @param[in] parentid The parent of this task (may be 0)
+ * @param[in] fn The pointer to the function you are tracing
+ */
+void ITTAPI __itt_task_begin_fn(const __itt_domain *domain, __itt_id taskid, __itt_id parentid, void* fn);
+
+/**
+ * @ingroup tasks
+ * @brief End the current task instance.
+ * @param[in] domain The domain for this task
+ */
+void ITTAPI __itt_task_end(const __itt_domain *domain);
+
+/**
+ * @ingroup tasks
+ * @brief Begin an overlapped task instance.
+ * @param[in] domain The domain for this task.
+ * @param[in] taskid The identifier for this task instance, *cannot* be __itt_null.
+ * @param[in] parentid The parent of this task, or __itt_null.
+ * @param[in] name The name of this task.
+ */
+void ITTAPI __itt_task_begin_overlapped(const __itt_domain* domain, __itt_id taskid, __itt_id parentid, __itt_string_handle* name);
+
+/**
+ * @ingroup tasks
+ * @brief End an overlapped task instance.
+ * @param[in] domain The domain for this task
+ * @param[in] taskid Explicit ID of finished task
+ */
+void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain, __itt_id taskid);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, task_begin, (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, task_begin_fn, (const __itt_domain *domain, __itt_id id, __itt_id parentid, void* fn))
+ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain))
+ITT_STUBV(ITTAPI, void, task_begin_overlapped, (const __itt_domain *domain, __itt_id taskid, __itt_id parentid, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, task_end_overlapped, (const __itt_domain *domain, __itt_id taskid))
+#define __itt_task_begin(d,x,y,z) ITTNOTIFY_VOID_D3(task_begin,d,x,y,z)
+#define __itt_task_begin_ptr ITTNOTIFY_NAME(task_begin)
+#define __itt_task_begin_fn(d,x,y,z) ITTNOTIFY_VOID_D3(task_begin_fn,d,x,y,z)
+#define __itt_task_begin_fn_ptr ITTNOTIFY_NAME(task_begin_fn)
+#define __itt_task_end(d) ITTNOTIFY_VOID_D0(task_end,d)
+#define __itt_task_end_ptr ITTNOTIFY_NAME(task_end)
+#define __itt_task_begin_overlapped(d,x,y,z) ITTNOTIFY_VOID_D3(task_begin_overlapped,d,x,y,z)
+#define __itt_task_begin_overlapped_ptr ITTNOTIFY_NAME(task_begin_overlapped)
+#define __itt_task_end_overlapped(d,x) ITTNOTIFY_VOID_D1(task_end_overlapped,d,x)
+#define __itt_task_end_overlapped_ptr ITTNOTIFY_NAME(task_end_overlapped)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_task_begin(domain,id,parentid,name)
+#define __itt_task_begin_ptr 0
+#define __itt_task_begin_fn(domain,id,parentid,fn)
+#define __itt_task_begin_fn_ptr 0
+#define __itt_task_end(domain)
+#define __itt_task_end_ptr 0
+#define __itt_task_begin_overlapped(domain,taskid,parentid,name)
+#define __itt_task_begin_overlapped_ptr 0
+#define __itt_task_end_overlapped(domain,taskid)
+#define __itt_task_end_overlapped_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_task_begin_ptr 0
+#define __itt_task_begin_fn_ptr 0
+#define __itt_task_end_ptr 0
+#define __itt_task_begin_overlapped_ptr 0
+#define __itt_task_end_overlapped_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} tasks group */
+
+
+/**
+ * @defgroup markers Markers
+ * Markers represent a single discreet event in time. Markers have a scope,
+ * described by an enumerated type __itt_scope. Markers are created by
+ * the API call __itt_marker. A marker instance can be given an ID for use in
+ * adding metadata.
+ * @{
+ */
+
+/**
+ * @brief Describes the scope of an event object in the trace.
+ */
+typedef enum
+{
+ __itt_scope_unknown = 0,
+ __itt_scope_global,
+ __itt_scope_track_group,
+ __itt_scope_track,
+ __itt_scope_task,
+ __itt_scope_marker
+} __itt_scope;
+
+/** @cond exclude_from_documentation */
+#define __itt_marker_scope_unknown __itt_scope_unknown
+#define __itt_marker_scope_global __itt_scope_global
+#define __itt_marker_scope_process __itt_scope_track_group
+#define __itt_marker_scope_thread __itt_scope_track
+#define __itt_marker_scope_task __itt_scope_task
+/** @endcond */
+
+/**
+ * @ingroup markers
+ * @brief Create a marker instance
+ * @param[in] domain The domain for this marker
+ * @param[in] id The instance ID for this marker or __itt_null
+ * @param[in] name The name for this marker
+ * @param[in] scope The scope for this marker
+ */
+void ITTAPI __itt_marker(const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, marker, (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope))
+#define __itt_marker(d,x,y,z) ITTNOTIFY_VOID_D3(marker,d,x,y,z)
+#define __itt_marker_ptr ITTNOTIFY_NAME(marker)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_marker(domain,id,name,scope)
+#define __itt_marker_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_marker_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} markers group */
+
+/**
+ * @defgroup metadata Metadata
+ * The metadata API is used to attach extra information to named
+ * entities. Metadata can be attached to an identified named entity by ID,
+ * or to the current entity (which is always a task).
+ *
+ * Conceptually metadata has a type (what kind of metadata), a key (the
+ * name of the metadata), and a value (the actual data). The encoding of
+ * the value depends on the type of the metadata.
+ *
+ * The type of metadata is specified by an enumerated type __itt_metdata_type.
+ * @{
+ */
+
+/**
+ * @ingroup parameters
+ * @brief describes the type of metadata
+ */
+typedef enum {
+ __itt_metadata_unknown = 0,
+ __itt_metadata_u64, /**< Unsigned 64-bit integer */
+ __itt_metadata_s64, /**< Signed 64-bit integer */
+ __itt_metadata_u32, /**< Unsigned 32-bit integer */
+ __itt_metadata_s32, /**< Signed 32-bit integer */
+ __itt_metadata_u16, /**< Unsigned 16-bit integer */
+ __itt_metadata_s16, /**< Signed 16-bit integer */
+ __itt_metadata_float, /**< Signed 32-bit floating-point */
+ __itt_metadata_double /**< SIgned 64-bit floating-point */
+} __itt_metadata_type;
+
+/**
+ * @ingroup parameters
+ * @brief Add metadata to an instance of a named entity.
+ * @param[in] domain The domain controlling the call
+ * @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task
+ * @param[in] key The name of the metadata
+ * @param[in] type The type of the metadata
+ * @param[in] count The number of elements of the given type. If count == 0, no metadata will be added.
+ * @param[in] data The metadata itself
+*/
+void ITTAPI __itt_metadata_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, metadata_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data))
+#define __itt_metadata_add(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(metadata_add,d,x,y,z,a,b)
+#define __itt_metadata_add_ptr ITTNOTIFY_NAME(metadata_add)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_metadata_add(d,x,y,z,a,b)
+#define __itt_metadata_add_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_metadata_add_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup parameters
+ * @brief Add string metadata to an instance of a named entity.
+ * @param[in] domain The domain controlling the call
+ * @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task
+ * @param[in] key The name of the metadata
+ * @param[in] data The metadata itself
+ * @param[in] length The number of characters in the string, or -1 if the length is unknown but the string is null-terminated
+*/
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length);
+void ITTAPI __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t *data, size_t length);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_metadata_str_add __itt_metadata_str_addW
+# define __itt_metadata_str_add_ptr __itt_metadata_str_addW_ptr
+#else /* UNICODE */
+# define __itt_metadata_str_add __itt_metadata_str_addA
+# define __itt_metadata_str_add_ptr __itt_metadata_str_addA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_metadata_str_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length);
+#endif
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, metadata_str_addA, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length))
+ITT_STUBV(ITTAPI, void, metadata_str_addW, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t *data, size_t length))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, metadata_str_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_metadata_str_addA(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_addA,d,x,y,z,a)
+#define __itt_metadata_str_addA_ptr ITTNOTIFY_NAME(metadata_str_addA)
+#define __itt_metadata_str_addW(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_addW,d,x,y,z,a)
+#define __itt_metadata_str_addW_ptr ITTNOTIFY_NAME(metadata_str_addW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_metadata_str_add(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add,d,x,y,z,a)
+#define __itt_metadata_str_add_ptr ITTNOTIFY_NAME(metadata_str_add)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_metadata_str_addA(d,x,y,z,a)
+#define __itt_metadata_str_addA_ptr 0
+#define __itt_metadata_str_addW(d,x,y,z,a)
+#define __itt_metadata_str_addW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_metadata_str_add(d,x,y,z,a)
+#define __itt_metadata_str_add_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_metadata_str_addA_ptr 0
+#define __itt_metadata_str_addW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_metadata_str_add_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup parameters
+ * @brief Add metadata to an instance of a named entity.
+ * @param[in] domain The domain controlling the call
+ * @param[in] scope The scope of the instance to which the metadata is to be added
+
+ * @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task
+
+ * @param[in] key The name of the metadata
+ * @param[in] type The type of the metadata
+ * @param[in] count The number of elements of the given type. If count == 0, no metadata will be added.
+ * @param[in] data The metadata itself
+*/
+void ITTAPI __itt_metadata_add_with_scope(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, metadata_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data))
+#define __itt_metadata_add_with_scope(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(metadata_add_with_scope,d,x,y,z,a,b)
+#define __itt_metadata_add_with_scope_ptr ITTNOTIFY_NAME(metadata_add_with_scope)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_metadata_add_with_scope(d,x,y,z,a,b)
+#define __itt_metadata_add_with_scope_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_metadata_add_with_scope_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup parameters
+ * @brief Add string metadata to an instance of a named entity.
+ * @param[in] domain The domain controlling the call
+ * @param[in] scope The scope of the instance to which the metadata is to be added
+
+ * @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task
+
+ * @param[in] key The name of the metadata
+ * @param[in] data The metadata itself
+ * @param[in] length The number of characters in the string, or -1 if the length is unknown but the string is null-terminated
+*/
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_metadata_str_add_with_scopeA(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length);
+void ITTAPI __itt_metadata_str_add_with_scopeW(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeW
+# define __itt_metadata_str_add_with_scope_ptr __itt_metadata_str_add_with_scopeW_ptr
+#else /* UNICODE */
+# define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeA
+# define __itt_metadata_str_add_with_scope_ptr __itt_metadata_str_add_with_scopeA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_metadata_str_add_with_scope(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length);
+#endif
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length))
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_metadata_str_add_with_scopeA(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeA,d,x,y,z,a)
+#define __itt_metadata_str_add_with_scopeA_ptr ITTNOTIFY_NAME(metadata_str_add_with_scopeA)
+#define __itt_metadata_str_add_with_scopeW(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeW,d,x,y,z,a)
+#define __itt_metadata_str_add_with_scopeW_ptr ITTNOTIFY_NAME(metadata_str_add_with_scopeW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_metadata_str_add_with_scope(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add_with_scope,d,x,y,z,a)
+#define __itt_metadata_str_add_with_scope_ptr ITTNOTIFY_NAME(metadata_str_add_with_scope)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_metadata_str_add_with_scopeA(d,x,y,z,a)
+#define __itt_metadata_str_add_with_scopeA_ptr 0
+#define __itt_metadata_str_add_with_scopeW(d,x,y,z,a)
+#define __itt_metadata_str_add_with_scopeW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_metadata_str_add_with_scope(d,x,y,z,a)
+#define __itt_metadata_str_add_with_scope_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_metadata_str_add_with_scopeA_ptr 0
+#define __itt_metadata_str_add_with_scopeW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_metadata_str_add_with_scope_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @} metadata group */
+
+/**
+ * @defgroup relations Relations
+ * Instances of named entities can be explicitly associated with other
+ * instances using instance IDs and the relationship API calls.
+ *
+ * @{
+ */
+
+/**
+ * @ingroup relations
+ * @brief The kind of relation between two instances is specified by the enumerated type __itt_relation.
+ * Relations between instances can be added with an API call. The relation
+ * API uses instance IDs. Relations can be added before or after the actual
+ * instances are created and persist independently of the instances. This
+ * is the motivation for having different lifetimes for instance IDs and
+ * the actual instances.
+ */
+typedef enum
+{
+ __itt_relation_is_unknown = 0,
+ __itt_relation_is_dependent_on, /**< "A is dependent on B" means that A cannot start until B completes */
+ __itt_relation_is_sibling_of, /**< "A is sibling of B" means that A and B were created as a group */
+ __itt_relation_is_parent_of, /**< "A is parent of B" means that A created B */
+ __itt_relation_is_continuation_of, /**< "A is continuation of B" means that A assumes the dependencies of B */
+ __itt_relation_is_child_of, /**< "A is child of B" means that A was created by B (inverse of is_parent_of) */
+ __itt_relation_is_continued_by, /**< "A is continued by B" means that B assumes the dependencies of A (inverse of is_continuation_of) */
+ __itt_relation_is_predecessor_to /**< "A is predecessor to B" means that B cannot start until A completes (inverse of is_dependent_on) */
+} __itt_relation;
+
+/**
+ * @ingroup relations
+ * @brief Add a relation to the current task instance.
+ * The current task instance is the head of the relation.
+ * @param[in] domain The domain controlling this call
+ * @param[in] relation The kind of relation
+ * @param[in] tail The ID for the tail of the relation
+ */
+void ITTAPI __itt_relation_add_to_current(const __itt_domain *domain, __itt_relation relation, __itt_id tail);
+
+/**
+ * @ingroup relations
+ * @brief Add a relation between two instance identifiers.
+ * @param[in] domain The domain controlling this call
+ * @param[in] head The ID for the head of the relation
+ * @param[in] relation The kind of relation
+ * @param[in] tail The ID for the tail of the relation
+ */
+void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, relation_add_to_current, (const __itt_domain *domain, __itt_relation relation, __itt_id tail))
+ITT_STUBV(ITTAPI, void, relation_add, (const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail))
+#define __itt_relation_add_to_current(d,x,y) ITTNOTIFY_VOID_D2(relation_add_to_current,d,x,y)
+#define __itt_relation_add_to_current_ptr ITTNOTIFY_NAME(relation_add_to_current)
+#define __itt_relation_add(d,x,y,z) ITTNOTIFY_VOID_D3(relation_add,d,x,y,z)
+#define __itt_relation_add_ptr ITTNOTIFY_NAME(relation_add)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_relation_add_to_current(d,x,y)
+#define __itt_relation_add_to_current_ptr 0
+#define __itt_relation_add(d,x,y,z)
+#define __itt_relation_add_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_relation_add_to_current_ptr 0
+#define __itt_relation_add_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} relations group */
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_clock_info
+{
+ unsigned long long clock_freq; /*!< Clock domain frequency */
+ unsigned long long clock_base; /*!< Clock domain base timestamp */
+} __itt_clock_info;
+
+#pragma pack(pop)
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+typedef void (ITTAPI *__itt_get_clock_info_fn)(__itt_clock_info* clock_info, void* data);
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_clock_domain
+{
+ __itt_clock_info info; /*!< Most recent clock domain info */
+ __itt_get_clock_info_fn fn; /*!< Callback function pointer */
+ void* fn_data; /*!< Input argument for the callback function */
+ int extra1; /*!< Reserved. Must be zero */
+ void* extra2; /*!< Reserved. Must be zero */
+ struct ___itt_clock_domain* next;
+} __itt_clock_domain;
+
+#pragma pack(pop)
+/** @endcond */
+
+/**
+ * @ingroup clockdomains
+ * @brief Create a clock domain.
+ * Certain applications require the capability to trace their application using
+ * a clock domain different than the CPU, for instance the instrumentation of events
+ * that occur on a GPU.
+ * Because the set of domains is expected to be static over the application's execution time,
+ * there is no mechanism to destroy a domain.
+ * Any domain can be accessed by any thread in the process, regardless of which thread created
+ * the domain. This call is thread-safe.
+ * @param[in] fn A pointer to a callback function which retrieves alternative CPU timestamps
+ * @param[in] fn_data Argument for a callback function; may be NULL
+ */
+__itt_clock_domain* ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn, void* fn_data);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_clock_domain*, clock_domain_create, (__itt_get_clock_info_fn fn, void* fn_data))
+#define __itt_clock_domain_create ITTNOTIFY_DATA(clock_domain_create)
+#define __itt_clock_domain_create_ptr ITTNOTIFY_NAME(clock_domain_create)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_clock_domain_create(fn,fn_data) (__itt_clock_domain*)0
+#define __itt_clock_domain_create_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_clock_domain_create_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup clockdomains
+ * @brief Recalculate clock domains frequences and clock base timestamps.
+ */
+void ITTAPI __itt_clock_domain_reset(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, clock_domain_reset, (void))
+#define __itt_clock_domain_reset ITTNOTIFY_VOID(clock_domain_reset)
+#define __itt_clock_domain_reset_ptr ITTNOTIFY_NAME(clock_domain_reset)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_clock_domain_reset()
+#define __itt_clock_domain_reset_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_clock_domain_reset_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup clockdomain
+ * @brief Create an instance of identifier. This establishes the beginning of the lifetime of
+ * an instance of the given ID in the trace. Once this lifetime starts, the ID can be used to
+ * tag named entity instances in calls such as __itt_task_begin, and to specify relationships among
+ * identified named entity instances, using the \ref relations APIs.
+ * @param[in] domain The domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] id The ID to create.
+ */
+void ITTAPI __itt_id_create_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id);
+
+/**
+ * @ingroup clockdomain
+ * @brief Destroy an instance of identifier. This ends the lifetime of the current instance of the
+ * given ID value in the trace. Any relationships that are established after this lifetime ends are
+ * invalid. This call must be performed before the given ID value can be reused for a different
+ * named entity instance.
+ * @param[in] domain The domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] id The ID to destroy.
+ */
+void ITTAPI __itt_id_destroy_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, id_create_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id))
+ITT_STUBV(ITTAPI, void, id_destroy_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id))
+#define __itt_id_create_ex(d,x,y,z) ITTNOTIFY_VOID_D3(id_create_ex,d,x,y,z)
+#define __itt_id_create_ex_ptr ITTNOTIFY_NAME(id_create_ex)
+#define __itt_id_destroy_ex(d,x,y,z) ITTNOTIFY_VOID_D3(id_destroy_ex,d,x,y,z)
+#define __itt_id_destroy_ex_ptr ITTNOTIFY_NAME(id_destroy_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_id_create_ex(domain,clock_domain,timestamp,id)
+#define __itt_id_create_ex_ptr 0
+#define __itt_id_destroy_ex(domain,clock_domain,timestamp,id)
+#define __itt_id_destroy_ex_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_id_create_ex_ptr 0
+#define __itt_id_destroy_ex_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup clockdomain
+ * @brief Begin a task instance.
+ * @param[in] domain The domain for this task
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] taskid The instance ID for this task instance, or __itt_null
+ * @param[in] parentid The parent instance to which this task instance belongs, or __itt_null
+ * @param[in] name The name of this task
+ */
+void ITTAPI __itt_task_begin_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name);
+
+/**
+ * @ingroup clockdomain
+ * @brief Begin a task instance.
+ * @param[in] domain The domain for this task
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] taskid The identifier for this task instance, or __itt_null
+ * @param[in] parentid The parent of this task, or __itt_null
+ * @param[in] fn The pointer to the function you are tracing
+ */
+void ITTAPI __itt_task_begin_fn_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, void* fn);
+
+/**
+ * @ingroup clockdomain
+ * @brief End the current task instance.
+ * @param[in] domain The domain for this task
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ */
+void ITTAPI __itt_task_end_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, task_begin_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, task_begin_fn_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, void* fn))
+ITT_STUBV(ITTAPI, void, task_end_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp))
+#define __itt_task_begin_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(task_begin_ex,d,x,y,z,a,b)
+#define __itt_task_begin_ex_ptr ITTNOTIFY_NAME(task_begin_ex)
+#define __itt_task_begin_fn_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(task_begin_fn_ex,d,x,y,z,a,b)
+#define __itt_task_begin_fn_ex_ptr ITTNOTIFY_NAME(task_begin_fn_ex)
+#define __itt_task_end_ex(d,x,y) ITTNOTIFY_VOID_D2(task_end_ex,d,x,y)
+#define __itt_task_end_ex_ptr ITTNOTIFY_NAME(task_end_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_task_begin_ex(domain,clock_domain,timestamp,id,parentid,name)
+#define __itt_task_begin_ex_ptr 0
+#define __itt_task_begin_fn_ex(domain,clock_domain,timestamp,id,parentid,fn)
+#define __itt_task_begin_fn_ex_ptr 0
+#define __itt_task_end_ex(domain,clock_domain,timestamp)
+#define __itt_task_end_ex_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_task_begin_ex_ptr 0
+#define __itt_task_begin_fn_ex_ptr 0
+#define __itt_task_end_ex_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @defgroup counters Counters
+ * @ingroup public
+ * Counters are user-defined objects with a monotonically increasing
+ * value. Counter values are 64-bit unsigned integers.
+ * Counters have names that can be displayed in
+ * the tools.
+ * @{
+ */
+
+/**
+ * @brief opaque structure for counter identification
+ */
+/** @cond exclude_from_documentation */
+
+typedef struct ___itt_counter* __itt_counter;
+
+/**
+ * @brief Create an unsigned 64 bits integer counter with given name/domain
+ *
+ * After __itt_counter_create() is called, __itt_counter_inc(id), __itt_counter_inc_delta(id, delta),
+ * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
+ * can be used to change the value of the counter, where value_ptr is a pointer to an unsigned 64 bits integer
+ *
+ * The call is equal to __itt_counter_create_typed(name, domain, __itt_metadata_u64)
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_counter ITTAPI __itt_counter_createA(const char *name, const char *domain);
+__itt_counter ITTAPI __itt_counter_createW(const wchar_t *name, const wchar_t *domain);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_counter_create __itt_counter_createW
+# define __itt_counter_create_ptr __itt_counter_createW_ptr
+#else /* UNICODE */
+# define __itt_counter_create __itt_counter_createA
+# define __itt_counter_create_ptr __itt_counter_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_counter ITTAPI __itt_counter_create(const char *name, const char *domain);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char *name, const char *domain))
+ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create, (const char *name, const char *domain))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_createA ITTNOTIFY_DATA(counter_createA)
+#define __itt_counter_createA_ptr ITTNOTIFY_NAME(counter_createA)
+#define __itt_counter_createW ITTNOTIFY_DATA(counter_createW)
+#define __itt_counter_createW_ptr ITTNOTIFY_NAME(counter_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create ITTNOTIFY_DATA(counter_create)
+#define __itt_counter_create_ptr ITTNOTIFY_NAME(counter_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_createA(name, domain)
+#define __itt_counter_createA_ptr 0
+#define __itt_counter_createW(name, domain)
+#define __itt_counter_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create(name, domain)
+#define __itt_counter_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_createA_ptr 0
+#define __itt_counter_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Increment the unsigned 64 bits integer counter value
+ *
+ * Calling this function to non-unsigned 64 bits integer counters has no effect
+ */
+void ITTAPI __itt_counter_inc(__itt_counter id);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id))
+#define __itt_counter_inc ITTNOTIFY_VOID(counter_inc)
+#define __itt_counter_inc_ptr ITTNOTIFY_NAME(counter_inc)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_inc(id)
+#define __itt_counter_inc_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_inc_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/**
+ * @brief Increment the unsigned 64 bits integer counter value with x
+ *
+ * Calling this function to non-unsigned 64 bits integer counters has no effect
+ */
+void ITTAPI __itt_counter_inc_delta(__itt_counter id, unsigned long long value);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_inc_delta, (__itt_counter id, unsigned long long value))
+#define __itt_counter_inc_delta ITTNOTIFY_VOID(counter_inc_delta)
+#define __itt_counter_inc_delta_ptr ITTNOTIFY_NAME(counter_inc_delta)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_inc_delta(id, value)
+#define __itt_counter_inc_delta_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_inc_delta_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Decrement the unsigned 64 bits integer counter value
+ *
+ * Calling this function to non-unsigned 64 bits integer counters has no effect
+ */
+void ITTAPI __itt_counter_dec(__itt_counter id);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id))
+#define __itt_counter_dec ITTNOTIFY_VOID(counter_dec)
+#define __itt_counter_dec_ptr ITTNOTIFY_NAME(counter_dec)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_dec(id)
+#define __itt_counter_dec_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_dec_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/**
+ * @brief Decrement the unsigned 64 bits integer counter value with x
+ *
+ * Calling this function to non-unsigned 64 bits integer counters has no effect
+ */
+void ITTAPI __itt_counter_dec_delta(__itt_counter id, unsigned long long value);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_dec_delta, (__itt_counter id, unsigned long long value))
+#define __itt_counter_dec_delta ITTNOTIFY_VOID(counter_dec_delta)
+#define __itt_counter_dec_delta_ptr ITTNOTIFY_NAME(counter_dec_delta)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_dec_delta(id, value)
+#define __itt_counter_dec_delta_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_dec_delta_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup counters
+ * @brief Increment a counter by one.
+ * The first call with a given name creates a counter by that name and sets its
+ * value to zero. Successive calls increment the counter value.
+ * @param[in] domain The domain controlling the call. Counter names are not domain specific.
+ * The domain argument is used only to enable or disable the API calls.
+ * @param[in] name The name of the counter
+ */
+void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain, __itt_string_handle *name);
+
+/**
+ * @ingroup counters
+ * @brief Increment a counter by the value specified in delta.
+ * @param[in] domain The domain controlling the call. Counter names are not domain specific.
+ * The domain argument is used only to enable or disable the API calls.
+ * @param[in] name The name of the counter
+ * @param[in] delta The amount by which to increment the counter
+ */
+void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_inc_v3, (const __itt_domain *domain, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta))
+#define __itt_counter_inc_v3(d,x) ITTNOTIFY_VOID_D1(counter_inc_v3,d,x)
+#define __itt_counter_inc_v3_ptr ITTNOTIFY_NAME(counter_inc_v3)
+#define __itt_counter_inc_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_inc_delta_v3,d,x,y)
+#define __itt_counter_inc_delta_v3_ptr ITTNOTIFY_NAME(counter_inc_delta_v3)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_inc_v3(domain,name)
+#define __itt_counter_inc_v3_ptr 0
+#define __itt_counter_inc_delta_v3(domain,name,delta)
+#define __itt_counter_inc_delta_v3_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_inc_v3_ptr 0
+#define __itt_counter_inc_delta_v3_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+
+/**
+ * @ingroup counters
+ * @brief Decrement a counter by one.
+ * The first call with a given name creates a counter by that name and sets its
+ * value to zero. Successive calls decrement the counter value.
+ * @param[in] domain The domain controlling the call. Counter names are not domain specific.
+ * The domain argument is used only to enable or disable the API calls.
+ * @param[in] name The name of the counter
+ */
+void ITTAPI __itt_counter_dec_v3(const __itt_domain *domain, __itt_string_handle *name);
+
+/**
+ * @ingroup counters
+ * @brief Decrement a counter by the value specified in delta.
+ * @param[in] domain The domain controlling the call. Counter names are not domain specific.
+ * The domain argument is used only to enable or disable the API calls.
+ * @param[in] name The name of the counter
+ * @param[in] delta The amount by which to decrement the counter
+ */
+void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_dec_v3, (const __itt_domain *domain, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta))
+#define __itt_counter_dec_v3(d,x) ITTNOTIFY_VOID_D1(counter_dec_v3,d,x)
+#define __itt_counter_dec_v3_ptr ITTNOTIFY_NAME(counter_dec_v3)
+#define __itt_counter_dec_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_dec_delta_v3,d,x,y)
+#define __itt_counter_dec_delta_v3_ptr ITTNOTIFY_NAME(counter_dec_delta_v3)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_dec_v3(domain,name)
+#define __itt_counter_dec_v3_ptr 0
+#define __itt_counter_dec_delta_v3(domain,name,delta)
+#define __itt_counter_dec_delta_v3_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_dec_v3_ptr 0
+#define __itt_counter_dec_delta_v3_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @} counters group */
+
+
+/**
+ * @brief Set the counter value
+ */
+void ITTAPI __itt_counter_set_value(__itt_counter id, void *value_ptr);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr))
+#define __itt_counter_set_value ITTNOTIFY_VOID(counter_set_value)
+#define __itt_counter_set_value_ptr ITTNOTIFY_NAME(counter_set_value)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_set_value(id, value_ptr)
+#define __itt_counter_set_value_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_set_value_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Set the counter value
+ */
+void ITTAPI __itt_counter_set_value_ex(__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr))
+#define __itt_counter_set_value_ex ITTNOTIFY_VOID(counter_set_value_ex)
+#define __itt_counter_set_value_ex_ptr ITTNOTIFY_NAME(counter_set_value_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
+#define __itt_counter_set_value_ex_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_set_value_ex_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Create a typed counter with given name/domain
+ *
+ * After __itt_counter_create_typed() is called, __itt_counter_inc(id), __itt_counter_inc_delta(id, delta),
+ * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
+ * can be used to change the value of the counter
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_counter ITTAPI __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type);
+__itt_counter ITTAPI __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_counter_create_typed __itt_counter_create_typedW
+# define __itt_counter_create_typed_ptr __itt_counter_create_typedW_ptr
+#else /* UNICODE */
+# define __itt_counter_create_typed __itt_counter_create_typedA
+# define __itt_counter_create_typed_ptr __itt_counter_create_typedA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_counter ITTAPI __itt_counter_create_typed(const char *name, const char *domain, __itt_metadata_type type);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char *name, const char *domain, __itt_metadata_type type))
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typed, (const char *name, const char *domain, __itt_metadata_type type))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_create_typedA ITTNOTIFY_DATA(counter_create_typedA)
+#define __itt_counter_create_typedA_ptr ITTNOTIFY_NAME(counter_create_typedA)
+#define __itt_counter_create_typedW ITTNOTIFY_DATA(counter_create_typedW)
+#define __itt_counter_create_typedW_ptr ITTNOTIFY_NAME(counter_create_typedW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create_typed ITTNOTIFY_DATA(counter_create_typed)
+#define __itt_counter_create_typed_ptr ITTNOTIFY_NAME(counter_create_typed)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_create_typedA(name, domain, type)
+#define __itt_counter_create_typedA_ptr 0
+#define __itt_counter_create_typedW(name, domain, type)
+#define __itt_counter_create_typedW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create_typed(name, domain, type)
+#define __itt_counter_create_typed_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_counter_create_typedA_ptr 0
+#define __itt_counter_create_typedW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_counter_create_typed_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Destroy the counter identified by the pointer previously returned by __itt_counter_create() or
+ * __itt_counter_create_typed()
+ */
+void ITTAPI __itt_counter_destroy(__itt_counter id);
+
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id))
+#define __itt_counter_destroy ITTNOTIFY_VOID(counter_destroy)
+#define __itt_counter_destroy_ptr ITTNOTIFY_NAME(counter_destroy)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_destroy(id)
+#define __itt_counter_destroy_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_destroy_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} counters group */
+
+/**
+ * @ingroup markers
+ * @brief Create a marker instance.
+ * @param[in] domain The domain for this marker
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] id The instance ID for this marker, or __itt_null
+ * @param[in] name The name for this marker
+ * @param[in] scope The scope for this marker
+ */
+void ITTAPI __itt_marker_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, marker_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope))
+#define __itt_marker_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(marker_ex,d,x,y,z,a,b)
+#define __itt_marker_ex_ptr ITTNOTIFY_NAME(marker_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_marker_ex(domain,clock_domain,timestamp,id,name,scope)
+#define __itt_marker_ex_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_marker_ex_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @ingroup clockdomain
+ * @brief Add a relation to the current task instance.
+ * The current task instance is the head of the relation.
+ * @param[in] domain The domain controlling this call
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] relation The kind of relation
+ * @param[in] tail The ID for the tail of the relation
+ */
+void ITTAPI __itt_relation_add_to_current_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail);
+
+/**
+ * @ingroup clockdomain
+ * @brief Add a relation between two instance identifiers.
+ * @param[in] domain The domain controlling this call
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] head The ID for the head of the relation
+ * @param[in] relation The kind of relation
+ * @param[in] tail The ID for the tail of the relation
+ */
+void ITTAPI __itt_relation_add_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, relation_add_to_current_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail))
+ITT_STUBV(ITTAPI, void, relation_add_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail))
+#define __itt_relation_add_to_current_ex(d,x,y,z,a) ITTNOTIFY_VOID_D4(relation_add_to_current_ex,d,x,y,z,a)
+#define __itt_relation_add_to_current_ex_ptr ITTNOTIFY_NAME(relation_add_to_current_ex)
+#define __itt_relation_add_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(relation_add_ex,d,x,y,z,a,b)
+#define __itt_relation_add_ex_ptr ITTNOTIFY_NAME(relation_add_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_relation_add_to_current_ex(domain,clock_domain,timestame,relation,tail)
+#define __itt_relation_add_to_current_ex_ptr 0
+#define __itt_relation_add_ex(domain,clock_domain,timestamp,head,relation,tail)
+#define __itt_relation_add_ex_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_relation_add_to_current_ex_ptr 0
+#define __itt_relation_add_ex_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+typedef enum ___itt_track_group_type
+{
+ __itt_track_group_type_normal = 0
+} __itt_track_group_type;
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_track_group
+{
+ __itt_string_handle* name; /*!< Name of the track group */
+ struct ___itt_track* track; /*!< List of child tracks */
+ __itt_track_group_type tgtype; /*!< Type of the track group */
+ int extra1; /*!< Reserved. Must be zero */
+ void* extra2; /*!< Reserved. Must be zero */
+ struct ___itt_track_group* next;
+} __itt_track_group;
+
+#pragma pack(pop)
+/** @endcond */
+
+/**
+ * @brief Placeholder for custom track types. Currently, "normal" custom track
+ * is the only available track type.
+ */
+typedef enum ___itt_track_type
+{
+ __itt_track_type_normal = 0
+#ifdef INTEL_ITTNOTIFY_API_PRIVATE
+ , __itt_track_type_queue
+#endif /* INTEL_ITTNOTIFY_API_PRIVATE */
+} __itt_track_type;
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_track
+{
+ __itt_string_handle* name; /*!< Name of the track group */
+ __itt_track_group* group; /*!< Parent group to a track */
+ __itt_track_type ttype; /*!< Type of the track */
+ int extra1; /*!< Reserved. Must be zero */
+ void* extra2; /*!< Reserved. Must be zero */
+ struct ___itt_track* next;
+} __itt_track;
+
+#pragma pack(pop)
+/** @endcond */
+
+/**
+ * @brief Create logical track group.
+ */
+__itt_track_group* ITTAPI __itt_track_group_create(__itt_string_handle* name, __itt_track_group_type track_group_type);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_track_group*, track_group_create, (__itt_string_handle* name, __itt_track_group_type track_group_type))
+#define __itt_track_group_create ITTNOTIFY_DATA(track_group_create)
+#define __itt_track_group_create_ptr ITTNOTIFY_NAME(track_group_create)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_track_group_create(name) (__itt_track_group*)0
+#define __itt_track_group_create_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_track_group_create_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Create logical track.
+ */
+__itt_track* ITTAPI __itt_track_create(__itt_track_group* track_group, __itt_string_handle* name, __itt_track_type track_type);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_track*, track_create, (__itt_track_group* track_group,__itt_string_handle* name, __itt_track_type track_type))
+#define __itt_track_create ITTNOTIFY_DATA(track_create)
+#define __itt_track_create_ptr ITTNOTIFY_NAME(track_create)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_track_create(track_group,name,track_type) (__itt_track*)0
+#define __itt_track_create_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_track_create_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Set the logical track.
+ */
+void ITTAPI __itt_set_track(__itt_track* track);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, set_track, (__itt_track *track))
+#define __itt_set_track ITTNOTIFY_VOID(set_track)
+#define __itt_set_track_ptr ITTNOTIFY_NAME(set_track)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_set_track(track)
+#define __itt_set_track_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_set_track_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/* ========================================================================== */
+/** @cond exclude_from_gpa_documentation */
+/**
+ * @defgroup events Events
+ * @ingroup public
+ * Events group
+ * @{
+ */
+/** @brief user event type */
+typedef int __itt_event;
+
+/**
+ * @brief Create an event notification
+ * @note name or namelen being null/name and namelen not matching, user event feature not enabled
+ * @return non-zero event identifier upon success and __itt_err otherwise
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen);
+__itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_event_create __itt_event_createW
+# define __itt_event_create_ptr __itt_event_createW_ptr
+#else
+# define __itt_event_create __itt_event_createA
+# define __itt_event_create_ptr __itt_event_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_event LIBITTAPI __itt_event_create(const char *name, int namelen);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen))
+ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_event_createA ITTNOTIFY_DATA(event_createA)
+#define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA)
+#define __itt_event_createW ITTNOTIFY_DATA(event_createW)
+#define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_event_create ITTNOTIFY_DATA(event_create)
+#define __itt_event_create_ptr ITTNOTIFY_NAME(event_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_event_createA(name, namelen) (__itt_event)0
+#define __itt_event_createA_ptr 0
+#define __itt_event_createW(name, namelen) (__itt_event)0
+#define __itt_event_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_event_create(name, namelen) (__itt_event)0
+#define __itt_event_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_event_createA_ptr 0
+#define __itt_event_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_event_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an event occurrence.
+ * @return __itt_err upon failure (invalid event id/user event feature not enabled)
+ */
+int LIBITTAPI __itt_event_start(__itt_event event);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event))
+#define __itt_event_start ITTNOTIFY_DATA(event_start)
+#define __itt_event_start_ptr ITTNOTIFY_NAME(event_start)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_event_start(event) (int)0
+#define __itt_event_start_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_event_start_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an event end occurrence.
+ * @note It is optional if events do not have durations.
+ * @return __itt_err upon failure (invalid event id/user event feature not enabled)
+ */
+int LIBITTAPI __itt_event_end(__itt_event event);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event))
+#define __itt_event_end ITTNOTIFY_DATA(event_end)
+#define __itt_event_end_ptr ITTNOTIFY_NAME(event_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_event_end(event) (int)0
+#define __itt_event_end_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_event_end_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} events group */
+
+
+/**
+ * @defgroup arrays Arrays Visualizer
+ * @ingroup public
+ * Visualize arrays
+ * @{
+ */
+
+/**
+ * @enum __itt_av_data_type
+ * @brief Defines types of arrays data (for C/C++ intrinsic types)
+ */
+typedef enum
+{
+ __itt_e_first = 0,
+ __itt_e_char = 0, /* 1-byte integer */
+ __itt_e_uchar, /* 1-byte unsigned integer */
+ __itt_e_int16, /* 2-byte integer */
+ __itt_e_uint16, /* 2-byte unsigned integer */
+ __itt_e_int32, /* 4-byte integer */
+ __itt_e_uint32, /* 4-byte unsigned integer */
+ __itt_e_int64, /* 8-byte integer */
+ __itt_e_uint64, /* 8-byte unsigned integer */
+ __itt_e_float, /* 4-byte floating */
+ __itt_e_double, /* 8-byte floating */
+ __itt_e_last = __itt_e_double
+} __itt_av_data_type;
+
+/**
+ * @brief Save an array data to a file.
+ * Output format is defined by the file extension. The csv and bmp formats are supported (bmp - for 2-dimensional array only).
+ * @param[in] data - pointer to the array data
+ * @param[in] rank - the rank of the array
+ * @param[in] dimensions - pointer to an array of integers, which specifies the array dimensions.
+ * The size of dimensions must be equal to the rank
+ * @param[in] type - the type of the array, specified as one of the __itt_av_data_type values (for intrinsic types)
+ * @param[in] filePath - the file path; the output format is defined by the file extension
+ * @param[in] columnOrder - defines how the array is stored in the linear memory.
+ * It should be 1 for column-major order (e.g. in FORTRAN) or 0 - for row-major order (e.g. in C).
+ */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+int ITTAPI __itt_av_saveA(void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder);
+int ITTAPI __itt_av_saveW(void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_av_save __itt_av_saveW
+# define __itt_av_save_ptr __itt_av_saveW_ptr
+#else /* UNICODE */
+# define __itt_av_save __itt_av_saveA
+# define __itt_av_save_ptr __itt_av_saveA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+int ITTAPI __itt_av_save(void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, av_saveA, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder))
+ITT_STUB(ITTAPI, int, av_saveW, (void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, av_save, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_av_saveA ITTNOTIFY_DATA(av_saveA)
+#define __itt_av_saveA_ptr ITTNOTIFY_NAME(av_saveA)
+#define __itt_av_saveW ITTNOTIFY_DATA(av_saveW)
+#define __itt_av_saveW_ptr ITTNOTIFY_NAME(av_saveW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_av_save ITTNOTIFY_DATA(av_save)
+#define __itt_av_save_ptr ITTNOTIFY_NAME(av_save)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_av_saveA(name)
+#define __itt_av_saveA_ptr 0
+#define __itt_av_saveW(name)
+#define __itt_av_saveW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_av_save(name)
+#define __itt_av_save_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_av_saveA_ptr 0
+#define __itt_av_saveW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_av_save_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+void ITTAPI __itt_enable_attach(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, enable_attach, (void))
+#define __itt_enable_attach ITTNOTIFY_VOID(enable_attach)
+#define __itt_enable_attach_ptr ITTNOTIFY_NAME(enable_attach)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_enable_attach()
+#define __itt_enable_attach_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_enable_attach_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @cond exclude_from_gpa_documentation */
+
+/** @} arrays group */
+
+/** @endcond */
+
+/**
+ * @brief Module load info
+ * This API is used to report necessary information in case of module relocation
+ * @param[in] start_addr - relocated module start address
+ * @param[in] end_addr - relocated module end address
+ * @param[in] path - file system path to the module
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_module_loadA(void *start_addr, void *end_addr, const char *path);
+void ITTAPI __itt_module_loadW(void *start_addr, void *end_addr, const wchar_t *path);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_module_load __itt_module_loadW
+# define __itt_module_load_ptr __itt_module_loadW_ptr
+#else /* UNICODE */
+# define __itt_module_load __itt_module_loadA
+# define __itt_module_load_ptr __itt_module_loadA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_module_load(void *start_addr, void *end_addr, const char *path);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, void, module_loadA, (void *start_addr, void *end_addr, const char *path))
+ITT_STUB(ITTAPI, void, module_loadW, (void *start_addr, void *end_addr, const wchar_t *path))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, void, module_load, (void *start_addr, void *end_addr, const char *path))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_module_loadA ITTNOTIFY_VOID(module_loadA)
+#define __itt_module_loadA_ptr ITTNOTIFY_NAME(module_loadA)
+#define __itt_module_loadW ITTNOTIFY_VOID(module_loadW)
+#define __itt_module_loadW_ptr ITTNOTIFY_NAME(module_loadW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_module_load ITTNOTIFY_VOID(module_load)
+#define __itt_module_load_ptr ITTNOTIFY_NAME(module_load)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_module_loadA(start_addr, end_addr, path)
+#define __itt_module_loadA_ptr 0
+#define __itt_module_loadW(start_addr, end_addr, path)
+#define __itt_module_loadW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_module_load(start_addr, end_addr, path)
+#define __itt_module_load_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_module_loadA_ptr 0
+#define __itt_module_loadW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_module_load_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _ITTNOTIFY_H_ */
+
+#ifdef INTEL_ITTNOTIFY_API_PRIVATE
+
+#ifndef _ITTNOTIFY_PRIVATE_
+#define _ITTNOTIFY_PRIVATE_
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * @ingroup clockdomain
+ * @brief Begin an overlapped task instance.
+ * @param[in] domain The domain for this task
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] taskid The identifier for this task instance, *cannot* be __itt_null.
+ * @param[in] parentid The parent of this task, or __itt_null.
+ * @param[in] name The name of this task.
+ */
+void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name);
+
+/**
+ * @ingroup clockdomain
+ * @brief End an overlapped task instance.
+ * @param[in] domain The domain for this task
+ * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] timestamp The user defined timestamp.
+ * @param[in] taskid Explicit ID of finished task
+ */
+void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex, (const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name))
+ITT_STUBV(ITTAPI, void, task_end_overlapped_ex, (const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid))
+#define __itt_task_begin_overlapped_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(task_begin_overlapped_ex,d,x,y,z,a,b)
+#define __itt_task_begin_overlapped_ex_ptr ITTNOTIFY_NAME(task_begin_overlapped_ex)
+#define __itt_task_end_overlapped_ex(d,x,y,z) ITTNOTIFY_VOID_D3(task_end_overlapped_ex,d,x,y,z)
+#define __itt_task_end_overlapped_ex_ptr ITTNOTIFY_NAME(task_end_overlapped_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_task_begin_overlapped_ex(domain,clock_domain,timestamp,taskid,parentid,name)
+#define __itt_task_begin_overlapped_ex_ptr 0
+#define __itt_task_end_overlapped_ex(domain,clock_domain,timestamp,taskid)
+#define __itt_task_end_overlapped_ex_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_task_begin_overlapped_ex_ptr 0
+#define __itt_task_end_overlapped_ptr 0
+#define __itt_task_end_overlapped_ex_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @defgroup makrs_internal Marks
+ * @ingroup internal
+ * Marks group
+ * @warning Internal API:
+ * - It is not shipped to outside of Intel
+ * - It is delivered to internal Intel teams using e-mail or SVN access only
+ * @{
+ */
+/** @brief user mark type */
+typedef int __itt_mark_type;
+
+/**
+ * @brief Creates a user mark type with the specified name using char or Unicode string.
+ * @param[in] name - name of mark to create
+ * @return Returns a handle to the mark type
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_mark_type ITTAPI __itt_mark_createA(const char *name);
+__itt_mark_type ITTAPI __itt_mark_createW(const wchar_t *name);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_mark_create __itt_mark_createW
+# define __itt_mark_create_ptr __itt_mark_createW_ptr
+#else /* UNICODE */
+# define __itt_mark_create __itt_mark_createA
+# define __itt_mark_create_ptr __itt_mark_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_mark_type ITTAPI __itt_mark_create(const char *name);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name))
+ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_mark_createA ITTNOTIFY_DATA(mark_createA)
+#define __itt_mark_createA_ptr ITTNOTIFY_NAME(mark_createA)
+#define __itt_mark_createW ITTNOTIFY_DATA(mark_createW)
+#define __itt_mark_createW_ptr ITTNOTIFY_NAME(mark_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark_create ITTNOTIFY_DATA(mark_create)
+#define __itt_mark_create_ptr ITTNOTIFY_NAME(mark_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_mark_createA(name) (__itt_mark_type)0
+#define __itt_mark_createA_ptr 0
+#define __itt_mark_createW(name) (__itt_mark_type)0
+#define __itt_mark_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark_create(name) (__itt_mark_type)0
+#define __itt_mark_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_mark_createA_ptr 0
+#define __itt_mark_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Creates a "discrete" user mark type of the specified type and an optional parameter using char or Unicode string.
+ *
+ * - The mark of "discrete" type is placed to collection results in case of success. It appears in overtime view(s) as a special tick sign.
+ * - The call is "synchronous" - function returns after mark is actually added to results.
+ * - This function is useful, for example, to mark different phases of application
+ * (beginning of the next mark automatically meand end of current region).
+ * - Can be used together with "continuous" marks (see below) at the same collection session
+ * @param[in] mt - mark, created by __itt_mark_create(const char* name) function
+ * @param[in] parameter - string parameter of mark
+ * @return Returns zero value in case of success, non-zero value otherwise.
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+int ITTAPI __itt_markA(__itt_mark_type mt, const char *parameter);
+int ITTAPI __itt_markW(__itt_mark_type mt, const wchar_t *parameter);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_mark __itt_markW
+# define __itt_mark_ptr __itt_markW_ptr
+#else /* UNICODE */
+# define __itt_mark __itt_markA
+# define __itt_mark_ptr __itt_markA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+int ITTAPI __itt_mark(__itt_mark_type mt, const char *parameter);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter))
+ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_markA ITTNOTIFY_DATA(markA)
+#define __itt_markA_ptr ITTNOTIFY_NAME(markA)
+#define __itt_markW ITTNOTIFY_DATA(markW)
+#define __itt_markW_ptr ITTNOTIFY_NAME(markW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark ITTNOTIFY_DATA(mark)
+#define __itt_mark_ptr ITTNOTIFY_NAME(mark)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_markA(mt, parameter) (int)0
+#define __itt_markA_ptr 0
+#define __itt_markW(mt, parameter) (int)0
+#define __itt_markW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark(mt, parameter) (int)0
+#define __itt_mark_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_markA_ptr 0
+#define __itt_markW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Use this if necessary to create a "discrete" user event type (mark) for process
+ * rather then for one thread
+ * @see int __itt_mark(__itt_mark_type mt, const char* parameter);
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+int ITTAPI __itt_mark_globalA(__itt_mark_type mt, const char *parameter);
+int ITTAPI __itt_mark_globalW(__itt_mark_type mt, const wchar_t *parameter);
+#if defined(UNICODE) || defined(_UNICODE)
+# define __itt_mark_global __itt_mark_globalW
+# define __itt_mark_global_ptr __itt_mark_globalW_ptr
+#else /* UNICODE */
+# define __itt_mark_global __itt_mark_globalA
+# define __itt_mark_global_ptr __itt_mark_globalA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+int ITTAPI __itt_mark_global(__itt_mark_type mt, const char *parameter);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter))
+ITT_STUB(ITTAPI, int, mark_globalW, (__itt_mark_type mt, const wchar_t *parameter))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_mark_globalA ITTNOTIFY_DATA(mark_globalA)
+#define __itt_mark_globalA_ptr ITTNOTIFY_NAME(mark_globalA)
+#define __itt_mark_globalW ITTNOTIFY_DATA(mark_globalW)
+#define __itt_mark_globalW_ptr ITTNOTIFY_NAME(mark_globalW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark_global ITTNOTIFY_DATA(mark_global)
+#define __itt_mark_global_ptr ITTNOTIFY_NAME(mark_global)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_mark_globalA(mt, parameter) (int)0
+#define __itt_mark_globalA_ptr 0
+#define __itt_mark_globalW(mt, parameter) (int)0
+#define __itt_mark_globalW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark_global(mt, parameter) (int)0
+#define __itt_mark_global_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_mark_globalA_ptr 0
+#define __itt_mark_globalW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_mark_global_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Creates an "end" point for "continuous" mark with specified name.
+ *
+ * - Returns zero value in case of success, non-zero value otherwise.
+ * Also returns non-zero value when preceding "begin" point for the
+ * mark with the same name failed to be created or not created.
+ * - The mark of "continuous" type is placed to collection results in
+ * case of success. It appears in overtime view(s) as a special tick
+ * sign (different from "discrete" mark) together with line from
+ * corresponding "begin" mark to "end" mark.
+ * @note Continuous marks can overlap and be nested inside each other.
+ * Discrete mark can be nested inside marked region
+ * @param[in] mt - mark, created by __itt_mark_create(const char* name) function
+ * @return Returns zero value in case of success, non-zero value otherwise.
+ */
+int ITTAPI __itt_mark_off(__itt_mark_type mt);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt))
+#define __itt_mark_off ITTNOTIFY_DATA(mark_off)
+#define __itt_mark_off_ptr ITTNOTIFY_NAME(mark_off)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_mark_off(mt) (int)0
+#define __itt_mark_off_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_mark_off_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Use this if necessary to create an "end" point for mark of process
+ * @see int __itt_mark_off(__itt_mark_type mt);
+ */
+int ITTAPI __itt_mark_global_off(__itt_mark_type mt);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt))
+#define __itt_mark_global_off ITTNOTIFY_DATA(mark_global_off)
+#define __itt_mark_global_off_ptr ITTNOTIFY_NAME(mark_global_off)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_mark_global_off(mt) (int)0
+#define __itt_mark_global_off_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_mark_global_off_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} marks group */
+
+/**
+ * @defgroup counters_internal Counters
+ * @ingroup internal
+ * Counters group
+ * @{
+ */
+
+
+/**
+ * @defgroup stitch Stack Stitching
+ * @ingroup internal
+ * Stack Stitching group
+ * @{
+ */
+/**
+ * @brief opaque structure for counter identification
+ */
+typedef struct ___itt_caller *__itt_caller;
+
+/**
+ * @brief Create the stitch point e.g. a point in call stack where other stacks should be stitched to.
+ * The function returns a unique identifier which is used to match the cut points with corresponding stitch points.
+ */
+__itt_caller ITTAPI __itt_stack_caller_create(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void))
+#define __itt_stack_caller_create ITTNOTIFY_DATA(stack_caller_create)
+#define __itt_stack_caller_create_ptr ITTNOTIFY_NAME(stack_caller_create)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_stack_caller_create() (__itt_caller)0
+#define __itt_stack_caller_create_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_stack_caller_create_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Destroy the inforamtion about stitch point identified by the pointer previously returned by __itt_stack_caller_create()
+ */
+void ITTAPI __itt_stack_caller_destroy(__itt_caller id);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id))
+#define __itt_stack_caller_destroy ITTNOTIFY_VOID(stack_caller_destroy)
+#define __itt_stack_caller_destroy_ptr ITTNOTIFY_NAME(stack_caller_destroy)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_stack_caller_destroy(id)
+#define __itt_stack_caller_destroy_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_stack_caller_destroy_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Sets the cut point. Stack from each event which occurs after this call will be cut
+ * at the same stack level the function was called and stitched to the corresponding stitch point.
+ */
+void ITTAPI __itt_stack_callee_enter(__itt_caller id);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id))
+#define __itt_stack_callee_enter ITTNOTIFY_VOID(stack_callee_enter)
+#define __itt_stack_callee_enter_ptr ITTNOTIFY_NAME(stack_callee_enter)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_stack_callee_enter(id)
+#define __itt_stack_callee_enter_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_stack_callee_enter_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief This function eliminates the cut point which was set by latest __itt_stack_callee_enter().
+ */
+void ITTAPI __itt_stack_callee_leave(__itt_caller id);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id))
+#define __itt_stack_callee_leave ITTNOTIFY_VOID(stack_callee_leave)
+#define __itt_stack_callee_leave_ptr ITTNOTIFY_NAME(stack_callee_leave)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_stack_callee_leave(id)
+#define __itt_stack_callee_leave_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_stack_callee_leave_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @} stitch group */
+
+/* ***************************************************************************************************************************** */
+
+#include <stdarg.h>
+
+/** @cond exclude_from_documentation */
+typedef enum __itt_error_code
+{
+ __itt_error_success = 0, /*!< no error */
+ __itt_error_no_module = 1, /*!< module can't be loaded */
+ /* %1$s -- library name; win: %2$d -- system error code; unx: %2$s -- system error message. */
+ __itt_error_no_symbol = 2, /*!< symbol not found */
+ /* %1$s -- library name, %2$s -- symbol name. */
+ __itt_error_unknown_group = 3, /*!< unknown group specified */
+ /* %1$s -- env var name, %2$s -- group name. */
+ __itt_error_cant_read_env = 4, /*!< GetEnvironmentVariable() failed */
+ /* %1$s -- env var name, %2$d -- system error. */
+ __itt_error_env_too_long = 5, /*!< variable value too long */
+ /* %1$s -- env var name, %2$d -- actual length of the var, %3$d -- max allowed length. */
+ __itt_error_system = 6 /*!< pthread_mutexattr_init or pthread_mutex_init failed */
+ /* %1$s -- function name, %2$d -- errno. */
+} __itt_error_code;
+
+typedef void (__itt_error_handler_t)(__itt_error_code code, va_list);
+__itt_error_handler_t* __itt_set_error_handler(__itt_error_handler_t*);
+
+const char* ITTAPI __itt_api_version(void);
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#define __itt_error_handler ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, error_handler)
+void __itt_error_handler(__itt_error_code code, va_list args);
+extern const int ITTNOTIFY_NAME(err);
+#define __itt_err ITTNOTIFY_NAME(err)
+ITT_STUB(ITTAPI, const char*, api_version, (void))
+#define __itt_api_version ITTNOTIFY_DATA(api_version)
+#define __itt_api_version_ptr ITTNOTIFY_NAME(api_version)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_api_version() (const char*)0
+#define __itt_api_version_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_api_version_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _ITTNOTIFY_PRIVATE_ */
+
+#endif /* INTEL_ITTNOTIFY_API_PRIVATE */
+
+// clang-format on
diff --git a/mozglue/baseprofiler/lul/AutoObjectMapper.cpp b/mozglue/baseprofiler/lul/AutoObjectMapper.cpp
new file mode 100644
index 0000000000..0037c943aa
--- /dev/null
+++ b/mozglue/baseprofiler/lul/AutoObjectMapper.cpp
@@ -0,0 +1,80 @@
+/* -*- 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/. */
+
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Sprintf.h"
+
+#include "BaseProfiler.h"
+#include "PlatformMacros.h"
+#include "AutoObjectMapper.h"
+
+// A helper function for creating failure error messages in
+// AutoObjectMapper*::Map.
+static void failedToMessage(void (*aLog)(const char*), const char* aHowFailed,
+ std::string aFileName) {
+ char buf[300];
+ SprintfLiteral(buf, "AutoObjectMapper::Map: Failed to %s \'%s\'", aHowFailed,
+ aFileName.c_str());
+ buf[sizeof(buf) - 1] = 0;
+ aLog(buf);
+}
+
+AutoObjectMapperPOSIX::AutoObjectMapperPOSIX(void (*aLog)(const char*))
+ : mImage(nullptr), mSize(0), mLog(aLog), mIsMapped(false) {}
+
+AutoObjectMapperPOSIX::~AutoObjectMapperPOSIX() {
+ if (!mIsMapped) {
+ // There's nothing to do.
+ MOZ_ASSERT(!mImage);
+ MOZ_ASSERT(mSize == 0);
+ return;
+ }
+ MOZ_ASSERT(mSize > 0);
+ // The following assertion doesn't necessarily have to be true,
+ // but we assume (reasonably enough) that no mmap facility would
+ // be crazy enough to map anything at page zero.
+ MOZ_ASSERT(mImage);
+ munmap(mImage, mSize);
+}
+
+bool AutoObjectMapperPOSIX::Map(/*OUT*/ void** start, /*OUT*/ size_t* length,
+ std::string fileName) {
+ MOZ_ASSERT(!mIsMapped);
+
+ int fd = open(fileName.c_str(), O_RDONLY);
+ if (fd == -1) {
+ failedToMessage(mLog, "open", fileName);
+ return false;
+ }
+
+ struct stat st;
+ int err = fstat(fd, &st);
+ size_t sz = (err == 0) ? st.st_size : 0;
+ if (err != 0 || sz == 0) {
+ failedToMessage(mLog, "fstat", fileName);
+ close(fd);
+ return false;
+ }
+
+ void* image = mmap(nullptr, sz, PROT_READ, MAP_SHARED, fd, 0);
+ if (image == MAP_FAILED) {
+ failedToMessage(mLog, "mmap", fileName);
+ close(fd);
+ return false;
+ }
+
+ close(fd);
+ mIsMapped = true;
+ mImage = *start = image;
+ mSize = *length = sz;
+ return true;
+}
diff --git a/mozglue/baseprofiler/lul/AutoObjectMapper.h b/mozglue/baseprofiler/lul/AutoObjectMapper.h
new file mode 100644
index 0000000000..f63aa43e0e
--- /dev/null
+++ b/mozglue/baseprofiler/lul/AutoObjectMapper.h
@@ -0,0 +1,64 @@
+/* -*- 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/. */
+
+#ifndef AutoObjectMapper_h
+#define AutoObjectMapper_h
+
+#include <string>
+
+#include "mozilla/Attributes.h"
+#include "PlatformMacros.h"
+
+// A (nearly-) RAII class that maps an object in and then unmaps it on
+// destruction. This base class version uses the "normal" POSIX
+// functions: open, fstat, close, mmap, munmap.
+
+class MOZ_STACK_CLASS AutoObjectMapperPOSIX {
+ public:
+ // The constructor does not attempt to map the file, because that
+ // might fail. Instead, once the object has been constructed,
+ // call Map() to attempt the mapping. There is no corresponding
+ // Unmap() since the unmapping is done in the destructor. Failure
+ // messages are sent to |aLog|.
+ explicit AutoObjectMapperPOSIX(void (*aLog)(const char*));
+
+ // Unmap the file on destruction of this object.
+ ~AutoObjectMapperPOSIX();
+
+ // Map |fileName| into the address space and return the mapping
+ // extents. If the file is zero sized this will fail. The file is
+ // mapped read-only and private. Returns true iff the mapping
+ // succeeded, in which case *start and *length hold its extent.
+ // Once a call to Map succeeds, all subsequent calls to it will
+ // fail.
+ bool Map(/*OUT*/ void** start, /*OUT*/ size_t* length, std::string fileName);
+
+ protected:
+ // If we are currently holding a mapped object, these record the
+ // mapped address range.
+ void* mImage;
+ size_t mSize;
+
+ // A logging sink, for complaining about mapping failures.
+ void (*mLog)(const char*);
+
+ private:
+ // Are we currently holding a mapped object? This is private to
+ // the base class. Derived classes need to have their own way to
+ // track whether they are holding a mapped object.
+ bool mIsMapped;
+
+ // Disable copying and assignment.
+ AutoObjectMapperPOSIX(const AutoObjectMapperPOSIX&);
+ AutoObjectMapperPOSIX& operator=(const AutoObjectMapperPOSIX&);
+ // Disable heap allocation of this class.
+ void* operator new(size_t);
+ void* operator new[](size_t);
+ void operator delete(void*);
+ void operator delete[](void*);
+};
+
+#endif // AutoObjectMapper_h
diff --git a/mozglue/baseprofiler/lul/LulCommon.cpp b/mozglue/baseprofiler/lul/LulCommon.cpp
new file mode 100644
index 0000000000..f014892a57
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulCommon.cpp
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+// Copyright (c) 2011, 2013 Google Inc.
+// 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.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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
+// OWNER 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.
+
+// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+
+// This file is derived from the following files in
+// toolkit/crashreporter/google-breakpad:
+// src/common/module.cc
+// src/common/unique_string.cc
+
+// There's no internal-only interface for LulCommon. Hence include
+// the external interface directly.
+#include "LulCommonExt.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <string>
+#include <map>
+
+#include "BaseProfiler.h"
+
+namespace lul {
+
+using std::string;
+
+////////////////////////////////////////////////////////////////
+// Module
+//
+Module::Module(const string& name, const string& os, const string& architecture,
+ const string& id)
+ : name_(name), os_(os), architecture_(architecture), id_(id) {}
+
+Module::~Module() {}
+
+////////////////////////////////////////////////////////////////
+// UniqueString
+//
+class UniqueString {
+ public:
+ explicit UniqueString(string str) { str_ = strdup(str.c_str()); }
+ ~UniqueString() { free(reinterpret_cast<void*>(const_cast<char*>(str_))); }
+ const char* str_;
+};
+
+const char* FromUniqueString(const UniqueString* ustr) { return ustr->str_; }
+
+bool IsEmptyUniqueString(const UniqueString* ustr) {
+ return (ustr->str_)[0] == '\0';
+}
+
+////////////////////////////////////////////////////////////////
+// UniqueStringUniverse
+//
+UniqueStringUniverse::~UniqueStringUniverse() {
+ for (std::map<string, UniqueString*>::iterator it = map_.begin();
+ it != map_.end(); it++) {
+ delete it->second;
+ }
+}
+
+const UniqueString* UniqueStringUniverse::ToUniqueString(string str) {
+ std::map<string, UniqueString*>::iterator it = map_.find(str);
+ if (it == map_.end()) {
+ UniqueString* ustr = new UniqueString(str);
+ map_[str] = ustr;
+ return ustr;
+ } else {
+ return it->second;
+ }
+}
+
+} // namespace lul
diff --git a/mozglue/baseprofiler/lul/LulCommonExt.h b/mozglue/baseprofiler/lul/LulCommonExt.h
new file mode 100644
index 0000000000..b20a7321ff
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulCommonExt.h
@@ -0,0 +1,509 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+// Copyright (c) 2006, 2010, 2012, 2013 Google Inc.
+// 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.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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
+// OWNER 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.
+
+// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+
+// module.h: Define google_breakpad::Module. A Module holds debugging
+// information, and can write that information out as a Breakpad
+// symbol file.
+
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// Copyright (c) 2001, 2002 Peter Dimov
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+// See http://www.boost.org/libs/smart_ptr/scoped_ptr.htm for documentation.
+//
+
+// This file is derived from the following files in
+// toolkit/crashreporter/google-breakpad:
+// src/common/unique_string.h
+// src/common/scoped_ptr.h
+// src/common/module.h
+
+// External interface for the "Common" component of LUL.
+
+#ifndef LulCommonExt_h
+#define LulCommonExt_h
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+
+#include <string>
+#include <map>
+#include <vector>
+#include <cstddef> // for std::ptrdiff_t
+
+#include "mozilla/Assertions.h"
+
+namespace lul {
+
+using std::map;
+using std::string;
+
+////////////////////////////////////////////////////////////////
+// UniqueString
+//
+
+// Abstract type
+class UniqueString;
+
+// Get the contained C string (debugging only)
+const char* FromUniqueString(const UniqueString*);
+
+// Is the given string empty (that is, "") ?
+bool IsEmptyUniqueString(const UniqueString*);
+
+////////////////////////////////////////////////////////////////
+// UniqueStringUniverse
+//
+
+// All UniqueStrings live in some specific UniqueStringUniverse.
+class UniqueStringUniverse {
+ public:
+ UniqueStringUniverse() {}
+ ~UniqueStringUniverse();
+ // Convert a |string| to a UniqueString, that lives in this universe.
+ const UniqueString* ToUniqueString(string str);
+
+ private:
+ map<string, UniqueString*> map_;
+};
+
+////////////////////////////////////////////////////////////////
+// GUID
+//
+
+typedef struct {
+ uint32_t data1;
+ uint16_t data2;
+ uint16_t data3;
+ uint8_t data4[8];
+} MDGUID; // GUID
+
+typedef MDGUID GUID;
+
+////////////////////////////////////////////////////////////////
+// scoped_ptr
+//
+
+// scoped_ptr mimics a built-in pointer except that it guarantees deletion
+// of the object pointed to, either on destruction of the scoped_ptr or via
+// an explicit reset(). scoped_ptr is a simple solution for simple needs;
+// use shared_ptr or std::auto_ptr if your needs are more complex.
+
+// *** NOTE ***
+// If your scoped_ptr is a class member of class FOO pointing to a
+// forward declared type BAR (as shown below), then you MUST use a non-inlined
+// version of the destructor. The destructor of a scoped_ptr (called from
+// FOO's destructor) must have a complete definition of BAR in order to
+// destroy it. Example:
+//
+// -- foo.h --
+// class BAR;
+//
+// class FOO {
+// public:
+// FOO();
+// ~FOO(); // Required for sources that instantiate class FOO to compile!
+//
+// private:
+// scoped_ptr<BAR> bar_;
+// };
+//
+// -- foo.cc --
+// #include "foo.h"
+// FOO::~FOO() {} // Empty, but must be non-inlined to FOO's class definition.
+
+// scoped_ptr_malloc added by Google
+// When one of these goes out of scope, instead of doing a delete or
+// delete[], it calls free(). scoped_ptr_malloc<char> is likely to see
+// much more use than any other specializations.
+
+// release() added by Google
+// Use this to conditionally transfer ownership of a heap-allocated object
+// to the caller, usually on method success.
+
+template <typename T>
+class scoped_ptr {
+ private:
+ T* ptr;
+
+ scoped_ptr(scoped_ptr const&);
+ scoped_ptr& operator=(scoped_ptr const&);
+
+ public:
+ typedef T element_type;
+
+ explicit scoped_ptr(T* p = 0) : ptr(p) {}
+
+ ~scoped_ptr() { delete ptr; }
+
+ void reset(T* p = 0) {
+ if (ptr != p) {
+ delete ptr;
+ ptr = p;
+ }
+ }
+
+ T& operator*() const {
+ MOZ_ASSERT(ptr != 0);
+ return *ptr;
+ }
+
+ T* operator->() const {
+ MOZ_ASSERT(ptr != 0);
+ return ptr;
+ }
+
+ bool operator==(T* p) const { return ptr == p; }
+
+ bool operator!=(T* p) const { return ptr != p; }
+
+ T* get() const { return ptr; }
+
+ void swap(scoped_ptr& b) {
+ T* tmp = b.ptr;
+ b.ptr = ptr;
+ ptr = tmp;
+ }
+
+ T* release() {
+ T* tmp = ptr;
+ ptr = 0;
+ return tmp;
+ }
+
+ private:
+ // no reason to use these: each scoped_ptr should have its own object
+ template <typename U>
+ bool operator==(scoped_ptr<U> const& p) const;
+ template <typename U>
+ bool operator!=(scoped_ptr<U> const& p) const;
+};
+
+template <typename T>
+inline void swap(scoped_ptr<T>& a, scoped_ptr<T>& b) {
+ a.swap(b);
+}
+
+template <typename T>
+inline bool operator==(T* p, const scoped_ptr<T>& b) {
+ return p == b.get();
+}
+
+template <typename T>
+inline bool operator!=(T* p, const scoped_ptr<T>& b) {
+ return p != b.get();
+}
+
+// scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
+// is guaranteed, either on destruction of the scoped_array or via an explicit
+// reset(). Use shared_array or std::vector if your needs are more complex.
+
+template <typename T>
+class scoped_array {
+ private:
+ T* ptr;
+
+ scoped_array(scoped_array const&);
+ scoped_array& operator=(scoped_array const&);
+
+ public:
+ typedef T element_type;
+
+ explicit scoped_array(T* p = 0) : ptr(p) {}
+
+ ~scoped_array() { delete[] ptr; }
+
+ void reset(T* p = 0) {
+ if (ptr != p) {
+ delete[] ptr;
+ ptr = p;
+ }
+ }
+
+ T& operator[](std::ptrdiff_t i) const {
+ MOZ_ASSERT(ptr != 0);
+ MOZ_ASSERT(i >= 0);
+ return ptr[i];
+ }
+
+ bool operator==(T* p) const { return ptr == p; }
+
+ bool operator!=(T* p) const { return ptr != p; }
+
+ T* get() const { return ptr; }
+
+ void swap(scoped_array& b) {
+ T* tmp = b.ptr;
+ b.ptr = ptr;
+ ptr = tmp;
+ }
+
+ T* release() {
+ T* tmp = ptr;
+ ptr = 0;
+ return tmp;
+ }
+
+ private:
+ // no reason to use these: each scoped_array should have its own object
+ template <typename U>
+ bool operator==(scoped_array<U> const& p) const;
+ template <typename U>
+ bool operator!=(scoped_array<U> const& p) const;
+};
+
+template <class T>
+inline void swap(scoped_array<T>& a, scoped_array<T>& b) {
+ a.swap(b);
+}
+
+template <typename T>
+inline bool operator==(T* p, const scoped_array<T>& b) {
+ return p == b.get();
+}
+
+template <typename T>
+inline bool operator!=(T* p, const scoped_array<T>& b) {
+ return p != b.get();
+}
+
+// This class wraps the c library function free() in a class that can be
+// passed as a template argument to scoped_ptr_malloc below.
+class ScopedPtrMallocFree {
+ public:
+ inline void operator()(void* x) const { free(x); }
+};
+
+// scoped_ptr_malloc<> is similar to scoped_ptr<>, but it accepts a
+// second template argument, the functor used to free the object.
+
+template <typename T, typename FreeProc = ScopedPtrMallocFree>
+class scoped_ptr_malloc {
+ private:
+ T* ptr;
+
+ scoped_ptr_malloc(scoped_ptr_malloc const&);
+ scoped_ptr_malloc& operator=(scoped_ptr_malloc const&);
+
+ public:
+ typedef T element_type;
+
+ explicit scoped_ptr_malloc(T* p = 0) : ptr(p) {}
+
+ ~scoped_ptr_malloc() { free_((void*)ptr); }
+
+ void reset(T* p = 0) {
+ if (ptr != p) {
+ free_((void*)ptr);
+ ptr = p;
+ }
+ }
+
+ T& operator*() const {
+ MOZ_ASSERT(ptr != 0);
+ return *ptr;
+ }
+
+ T* operator->() const {
+ MOZ_ASSERT(ptr != 0);
+ return ptr;
+ }
+
+ bool operator==(T* p) const { return ptr == p; }
+
+ bool operator!=(T* p) const { return ptr != p; }
+
+ T* get() const { return ptr; }
+
+ void swap(scoped_ptr_malloc& b) {
+ T* tmp = b.ptr;
+ b.ptr = ptr;
+ ptr = tmp;
+ }
+
+ T* release() {
+ T* tmp = ptr;
+ ptr = 0;
+ return tmp;
+ }
+
+ private:
+ // no reason to use these: each scoped_ptr_malloc should have its own object
+ template <typename U, typename GP>
+ bool operator==(scoped_ptr_malloc<U, GP> const& p) const;
+ template <typename U, typename GP>
+ bool operator!=(scoped_ptr_malloc<U, GP> const& p) const;
+
+ static FreeProc const free_;
+};
+
+template <typename T, typename FP>
+FP const scoped_ptr_malloc<T, FP>::free_ = FP();
+
+template <typename T, typename FP>
+inline void swap(scoped_ptr_malloc<T, FP>& a, scoped_ptr_malloc<T, FP>& b) {
+ a.swap(b);
+}
+
+template <typename T, typename FP>
+inline bool operator==(T* p, const scoped_ptr_malloc<T, FP>& b) {
+ return p == b.get();
+}
+
+template <typename T, typename FP>
+inline bool operator!=(T* p, const scoped_ptr_malloc<T, FP>& b) {
+ return p != b.get();
+}
+
+////////////////////////////////////////////////////////////////
+// Module
+//
+
+// A Module represents the contents of a module, and supports methods
+// for adding information produced by parsing STABS or DWARF data
+// --- possibly both from the same file --- and then writing out the
+// unified contents as a Breakpad-format symbol file.
+class Module {
+ public:
+ // The type of addresses and sizes in a symbol table.
+ typedef uint64_t Address;
+
+ // Representation of an expression. This can either be a postfix
+ // expression, in which case it is stored as a string, or a simple
+ // expression of the form (identifier + imm) or *(identifier + imm).
+ // It can also be invalid (denoting "no value").
+ enum ExprHow { kExprInvalid = 1, kExprPostfix, kExprSimple, kExprSimpleMem };
+
+ struct Expr {
+ // Construct a simple-form expression
+ Expr(const UniqueString* ident, long offset, bool deref) {
+ if (IsEmptyUniqueString(ident)) {
+ Expr();
+ } else {
+ postfix_ = "";
+ ident_ = ident;
+ offset_ = offset;
+ how_ = deref ? kExprSimpleMem : kExprSimple;
+ }
+ }
+
+ // Construct an invalid expression
+ Expr() {
+ postfix_ = "";
+ ident_ = nullptr;
+ offset_ = 0;
+ how_ = kExprInvalid;
+ }
+
+ // Return the postfix expression string, either directly,
+ // if this is a postfix expression, or by synthesising it
+ // for a simple expression.
+ std::string getExprPostfix() const {
+ switch (how_) {
+ case kExprPostfix:
+ return postfix_;
+ case kExprSimple:
+ case kExprSimpleMem: {
+ char buf[40];
+ sprintf(buf, " %ld %c%s", labs(offset_), offset_ < 0 ? '-' : '+',
+ how_ == kExprSimple ? "" : " ^");
+ return std::string(FromUniqueString(ident_)) + std::string(buf);
+ }
+ case kExprInvalid:
+ default:
+ MOZ_ASSERT(0 && "getExprPostfix: invalid Module::Expr type");
+ return "Expr::genExprPostfix: kExprInvalid";
+ }
+ }
+
+ // The identifier that gives the starting value for simple expressions.
+ const UniqueString* ident_;
+ // The offset to add for simple expressions.
+ long offset_;
+ // The Postfix expression string to evaluate for non-simple expressions.
+ std::string postfix_;
+ // The operation expressed by this expression.
+ ExprHow how_;
+ };
+
+ // A map from register names to expressions that recover
+ // their values. This can represent a complete set of rules to
+ // follow at some address, or a set of changes to be applied to an
+ // extant set of rules.
+ // NOTE! there are two completely different types called RuleMap. This
+ // is one of them.
+ typedef std::map<const UniqueString*, Expr> RuleMap;
+
+ // A map from addresses to RuleMaps, representing changes that take
+ // effect at given addresses.
+ typedef std::map<Address, RuleMap> RuleChangeMap;
+
+ // A range of 'STACK CFI' stack walking information. An instance of
+ // this structure corresponds to a 'STACK CFI INIT' record and the
+ // subsequent 'STACK CFI' records that fall within its range.
+ struct StackFrameEntry {
+ // The starting address and number of bytes of machine code this
+ // entry covers.
+ Address address, size;
+
+ // The initial register recovery rules, in force at the starting
+ // address.
+ RuleMap initial_rules;
+
+ // A map from addresses to rule changes. To find the rules in
+ // force at a given address, start with initial_rules, and then
+ // apply the changes given in this map for all addresses up to and
+ // including the address you're interested in.
+ RuleChangeMap rule_changes;
+ };
+
+ // Create a new module with the given name, operating system,
+ // architecture, and ID string.
+ Module(const std::string& name, const std::string& os,
+ const std::string& architecture, const std::string& id);
+ ~Module();
+
+ private:
+ // Module header entries.
+ std::string name_, os_, architecture_, id_;
+};
+
+} // namespace lul
+
+#endif // LulCommonExt_h
diff --git a/mozglue/baseprofiler/lul/LulDwarf.cpp b/mozglue/baseprofiler/lul/LulDwarf.cpp
new file mode 100644
index 0000000000..c83296fc62
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulDwarf.cpp
@@ -0,0 +1,2252 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+// Copyright (c) 2010 Google Inc. 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.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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
+// OWNER 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.
+
+// CFI reader author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+
+// Implementation of dwarf2reader::LineInfo, dwarf2reader::CompilationUnit,
+// and dwarf2reader::CallFrameInfo. See dwarf2reader.h for details.
+
+// This file is derived from the following files in
+// toolkit/crashreporter/google-breakpad:
+// src/common/dwarf/bytereader.cc
+// src/common/dwarf/dwarf2reader.cc
+// src/common/dwarf_cfi_to_module.cc
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <map>
+#include <stack>
+#include <string>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Sprintf.h"
+
+#include "LulCommonExt.h"
+#include "LulDwarfInt.h"
+
+// Set this to 1 for verbose logging
+#define DEBUG_DWARF 0
+
+namespace lul {
+
+using std::string;
+
+ByteReader::ByteReader(enum Endianness endian)
+ : offset_reader_(NULL),
+ address_reader_(NULL),
+ endian_(endian),
+ address_size_(0),
+ offset_size_(0),
+ have_section_base_(),
+ have_text_base_(),
+ have_data_base_(),
+ have_function_base_() {}
+
+ByteReader::~ByteReader() {}
+
+void ByteReader::SetOffsetSize(uint8 size) {
+ offset_size_ = size;
+ MOZ_ASSERT(size == 4 || size == 8);
+ if (size == 4) {
+ this->offset_reader_ = &ByteReader::ReadFourBytes;
+ } else {
+ this->offset_reader_ = &ByteReader::ReadEightBytes;
+ }
+}
+
+void ByteReader::SetAddressSize(uint8 size) {
+ address_size_ = size;
+ MOZ_ASSERT(size == 4 || size == 8);
+ if (size == 4) {
+ this->address_reader_ = &ByteReader::ReadFourBytes;
+ } else {
+ this->address_reader_ = &ByteReader::ReadEightBytes;
+ }
+}
+
+uint64 ByteReader::ReadInitialLength(const char* start, size_t* len) {
+ const uint64 initial_length = ReadFourBytes(start);
+ start += 4;
+
+ // In DWARF2/3, if the initial length is all 1 bits, then the offset
+ // size is 8 and we need to read the next 8 bytes for the real length.
+ if (initial_length == 0xffffffff) {
+ SetOffsetSize(8);
+ *len = 12;
+ return ReadOffset(start);
+ } else {
+ SetOffsetSize(4);
+ *len = 4;
+ }
+ return initial_length;
+}
+
+bool ByteReader::ValidEncoding(DwarfPointerEncoding encoding) const {
+ if (encoding == DW_EH_PE_omit) return true;
+ if (encoding == DW_EH_PE_aligned) return true;
+ if ((encoding & 0x7) > DW_EH_PE_udata8) return false;
+ if ((encoding & 0x70) > DW_EH_PE_funcrel) return false;
+ return true;
+}
+
+bool ByteReader::UsableEncoding(DwarfPointerEncoding encoding) const {
+ switch (encoding & 0x70) {
+ case DW_EH_PE_absptr:
+ return true;
+ case DW_EH_PE_pcrel:
+ return have_section_base_;
+ case DW_EH_PE_textrel:
+ return have_text_base_;
+ case DW_EH_PE_datarel:
+ return have_data_base_;
+ case DW_EH_PE_funcrel:
+ return have_function_base_;
+ default:
+ return false;
+ }
+}
+
+uint64 ByteReader::ReadEncodedPointer(const char* buffer,
+ DwarfPointerEncoding encoding,
+ size_t* len) const {
+ // UsableEncoding doesn't approve of DW_EH_PE_omit, so we shouldn't
+ // see it here.
+ MOZ_ASSERT(encoding != DW_EH_PE_omit);
+
+ // The Linux Standards Base 4.0 does not make this clear, but the
+ // GNU tools (gcc/unwind-pe.h; readelf/dwarf.c; gdb/dwarf2-frame.c)
+ // agree that aligned pointers are always absolute, machine-sized,
+ // machine-signed pointers.
+ if (encoding == DW_EH_PE_aligned) {
+ MOZ_ASSERT(have_section_base_);
+
+ // We don't need to align BUFFER in *our* address space. Rather, we
+ // need to find the next position in our buffer that would be aligned
+ // when the .eh_frame section the buffer contains is loaded into the
+ // program's memory. So align assuming that buffer_base_ gets loaded at
+ // address section_base_, where section_base_ itself may or may not be
+ // aligned.
+
+ // First, find the offset to START from the closest prior aligned
+ // address.
+ uint64 skew = section_base_ & (AddressSize() - 1);
+ // Now find the offset from that aligned address to buffer.
+ uint64 offset = skew + (buffer - buffer_base_);
+ // Round up to the next boundary.
+ uint64 aligned = (offset + AddressSize() - 1) & -AddressSize();
+ // Convert back to a pointer.
+ const char* aligned_buffer = buffer_base_ + (aligned - skew);
+ // Finally, store the length and actually fetch the pointer.
+ *len = aligned_buffer - buffer + AddressSize();
+ return ReadAddress(aligned_buffer);
+ }
+
+ // Extract the value first, ignoring whether it's a pointer or an
+ // offset relative to some base.
+ uint64 offset;
+ switch (encoding & 0x0f) {
+ case DW_EH_PE_absptr:
+ // DW_EH_PE_absptr is weird, as it is used as a meaningful value for
+ // both the high and low nybble of encoding bytes. When it appears in
+ // the high nybble, it means that the pointer is absolute, not an
+ // offset from some base address. When it appears in the low nybble,
+ // as here, it means that the pointer is stored as a normal
+ // machine-sized and machine-signed address. A low nybble of
+ // DW_EH_PE_absptr does not imply that the pointer is absolute; it is
+ // correct for us to treat the value as an offset from a base address
+ // if the upper nybble is not DW_EH_PE_absptr.
+ offset = ReadAddress(buffer);
+ *len = AddressSize();
+ break;
+
+ case DW_EH_PE_uleb128:
+ offset = ReadUnsignedLEB128(buffer, len);
+ break;
+
+ case DW_EH_PE_udata2:
+ offset = ReadTwoBytes(buffer);
+ *len = 2;
+ break;
+
+ case DW_EH_PE_udata4:
+ offset = ReadFourBytes(buffer);
+ *len = 4;
+ break;
+
+ case DW_EH_PE_udata8:
+ offset = ReadEightBytes(buffer);
+ *len = 8;
+ break;
+
+ case DW_EH_PE_sleb128:
+ offset = ReadSignedLEB128(buffer, len);
+ break;
+
+ case DW_EH_PE_sdata2:
+ offset = ReadTwoBytes(buffer);
+ // Sign-extend from 16 bits.
+ offset = (offset ^ 0x8000) - 0x8000;
+ *len = 2;
+ break;
+
+ case DW_EH_PE_sdata4:
+ offset = ReadFourBytes(buffer);
+ // Sign-extend from 32 bits.
+ offset = (offset ^ 0x80000000ULL) - 0x80000000ULL;
+ *len = 4;
+ break;
+
+ case DW_EH_PE_sdata8:
+ // No need to sign-extend; this is the full width of our type.
+ offset = ReadEightBytes(buffer);
+ *len = 8;
+ break;
+
+ default:
+ abort();
+ }
+
+ // Find the appropriate base address.
+ uint64 base;
+ switch (encoding & 0x70) {
+ case DW_EH_PE_absptr:
+ base = 0;
+ break;
+
+ case DW_EH_PE_pcrel:
+ MOZ_ASSERT(have_section_base_);
+ base = section_base_ + (buffer - buffer_base_);
+ break;
+
+ case DW_EH_PE_textrel:
+ MOZ_ASSERT(have_text_base_);
+ base = text_base_;
+ break;
+
+ case DW_EH_PE_datarel:
+ MOZ_ASSERT(have_data_base_);
+ base = data_base_;
+ break;
+
+ case DW_EH_PE_funcrel:
+ MOZ_ASSERT(have_function_base_);
+ base = function_base_;
+ break;
+
+ default:
+ abort();
+ }
+
+ uint64 pointer = base + offset;
+
+ // Remove inappropriate upper bits.
+ if (AddressSize() == 4)
+ pointer = pointer & 0xffffffff;
+ else
+ MOZ_ASSERT(AddressSize() == sizeof(uint64));
+
+ return pointer;
+}
+
+// A DWARF rule for recovering the address or value of a register, or
+// computing the canonical frame address. There is one subclass of this for
+// each '*Rule' member function in CallFrameInfo::Handler.
+//
+// It's annoying that we have to handle Rules using pointers (because
+// the concrete instances can have an arbitrary size). They're small,
+// so it would be much nicer if we could just handle them by value
+// instead of fretting about ownership and destruction.
+//
+// It seems like all these could simply be instances of std::tr1::bind,
+// except that we need instances to be EqualityComparable, too.
+//
+// This could logically be nested within State, but then the qualified names
+// get horrendous.
+class CallFrameInfo::Rule {
+ public:
+ virtual ~Rule() {}
+
+ // Tell HANDLER that, at ADDRESS in the program, REG can be
+ // recovered using this rule. If REG is kCFARegister, then this rule
+ // describes how to compute the canonical frame address. Return what the
+ // HANDLER member function returned.
+ virtual bool Handle(Handler* handler, uint64 address, int reg) const = 0;
+
+ // Equality on rules. We use these to decide which rules we need
+ // to report after a DW_CFA_restore_state instruction.
+ virtual bool operator==(const Rule& rhs) const = 0;
+
+ bool operator!=(const Rule& rhs) const { return !(*this == rhs); }
+
+ // Return a pointer to a copy of this rule.
+ virtual Rule* Copy() const = 0;
+
+ // If this is a base+offset rule, change its base register to REG.
+ // Otherwise, do nothing. (Ugly, but required for DW_CFA_def_cfa_register.)
+ virtual void SetBaseRegister(unsigned reg) {}
+
+ // If this is a base+offset rule, change its offset to OFFSET. Otherwise,
+ // do nothing. (Ugly, but required for DW_CFA_def_cfa_offset.)
+ virtual void SetOffset(long long offset) {}
+
+ // A RTTI workaround, to make it possible to implement equality
+ // comparisons on classes derived from this one.
+ enum CFIRTag {
+ CFIR_UNDEFINED_RULE,
+ CFIR_SAME_VALUE_RULE,
+ CFIR_OFFSET_RULE,
+ CFIR_VAL_OFFSET_RULE,
+ CFIR_REGISTER_RULE,
+ CFIR_EXPRESSION_RULE,
+ CFIR_VAL_EXPRESSION_RULE
+ };
+
+ // Produce the tag that identifies the child class of this object.
+ virtual CFIRTag getTag() const = 0;
+};
+
+// Rule: the value the register had in the caller cannot be recovered.
+class CallFrameInfo::UndefinedRule : public CallFrameInfo::Rule {
+ public:
+ UndefinedRule() {}
+ ~UndefinedRule() {}
+ CFIRTag getTag() const override { return CFIR_UNDEFINED_RULE; }
+ bool Handle(Handler* handler, uint64 address, int reg) const override {
+ return handler->UndefinedRule(address, reg);
+ }
+ bool operator==(const Rule& rhs) const override {
+ if (rhs.getTag() != CFIR_UNDEFINED_RULE) return false;
+ return true;
+ }
+ Rule* Copy() const override { return new UndefinedRule(*this); }
+};
+
+// Rule: the register's value is the same as that it had in the caller.
+class CallFrameInfo::SameValueRule : public CallFrameInfo::Rule {
+ public:
+ SameValueRule() {}
+ ~SameValueRule() {}
+ CFIRTag getTag() const override { return CFIR_SAME_VALUE_RULE; }
+ bool Handle(Handler* handler, uint64 address, int reg) const override {
+ return handler->SameValueRule(address, reg);
+ }
+ bool operator==(const Rule& rhs) const override {
+ if (rhs.getTag() != CFIR_SAME_VALUE_RULE) return false;
+ return true;
+ }
+ Rule* Copy() const override { return new SameValueRule(*this); }
+};
+
+// Rule: the register is saved at OFFSET from BASE_REGISTER. BASE_REGISTER
+// may be CallFrameInfo::Handler::kCFARegister.
+class CallFrameInfo::OffsetRule : public CallFrameInfo::Rule {
+ public:
+ OffsetRule(int base_register, long offset)
+ : base_register_(base_register), offset_(offset) {}
+ ~OffsetRule() {}
+ CFIRTag getTag() const override { return CFIR_OFFSET_RULE; }
+ bool Handle(Handler* handler, uint64 address, int reg) const override {
+ return handler->OffsetRule(address, reg, base_register_, offset_);
+ }
+ bool operator==(const Rule& rhs) const override {
+ if (rhs.getTag() != CFIR_OFFSET_RULE) return false;
+ const OffsetRule* our_rhs = static_cast<const OffsetRule*>(&rhs);
+ return (base_register_ == our_rhs->base_register_ &&
+ offset_ == our_rhs->offset_);
+ }
+ Rule* Copy() const override { return new OffsetRule(*this); }
+ // We don't actually need SetBaseRegister or SetOffset here, since they
+ // are only ever applied to CFA rules, for DW_CFA_def_cfa_offset, and it
+ // doesn't make sense to use OffsetRule for computing the CFA: it
+ // computes the address at which a register is saved, not a value.
+ private:
+ int base_register_;
+ long offset_;
+};
+
+// Rule: the value the register had in the caller is the value of
+// BASE_REGISTER plus offset. BASE_REGISTER may be
+// CallFrameInfo::Handler::kCFARegister.
+class CallFrameInfo::ValOffsetRule : public CallFrameInfo::Rule {
+ public:
+ ValOffsetRule(int base_register, long offset)
+ : base_register_(base_register), offset_(offset) {}
+ ~ValOffsetRule() {}
+ CFIRTag getTag() const override { return CFIR_VAL_OFFSET_RULE; }
+ bool Handle(Handler* handler, uint64 address, int reg) const override {
+ return handler->ValOffsetRule(address, reg, base_register_, offset_);
+ }
+ bool operator==(const Rule& rhs) const override {
+ if (rhs.getTag() != CFIR_VAL_OFFSET_RULE) return false;
+ const ValOffsetRule* our_rhs = static_cast<const ValOffsetRule*>(&rhs);
+ return (base_register_ == our_rhs->base_register_ &&
+ offset_ == our_rhs->offset_);
+ }
+ Rule* Copy() const override { return new ValOffsetRule(*this); }
+ void SetBaseRegister(unsigned reg) override { base_register_ = reg; }
+ void SetOffset(long long offset) override { offset_ = offset; }
+
+ private:
+ int base_register_;
+ long offset_;
+};
+
+// Rule: the register has been saved in another register REGISTER_NUMBER_.
+class CallFrameInfo::RegisterRule : public CallFrameInfo::Rule {
+ public:
+ explicit RegisterRule(int register_number)
+ : register_number_(register_number) {}
+ ~RegisterRule() {}
+ CFIRTag getTag() const override { return CFIR_REGISTER_RULE; }
+ bool Handle(Handler* handler, uint64 address, int reg) const override {
+ return handler->RegisterRule(address, reg, register_number_);
+ }
+ bool operator==(const Rule& rhs) const override {
+ if (rhs.getTag() != CFIR_REGISTER_RULE) return false;
+ const RegisterRule* our_rhs = static_cast<const RegisterRule*>(&rhs);
+ return (register_number_ == our_rhs->register_number_);
+ }
+ Rule* Copy() const override { return new RegisterRule(*this); }
+
+ private:
+ int register_number_;
+};
+
+// Rule: EXPRESSION evaluates to the address at which the register is saved.
+class CallFrameInfo::ExpressionRule : public CallFrameInfo::Rule {
+ public:
+ explicit ExpressionRule(const string& expression) : expression_(expression) {}
+ ~ExpressionRule() {}
+ CFIRTag getTag() const override { return CFIR_EXPRESSION_RULE; }
+ bool Handle(Handler* handler, uint64 address, int reg) const override {
+ return handler->ExpressionRule(address, reg, expression_);
+ }
+ bool operator==(const Rule& rhs) const override {
+ if (rhs.getTag() != CFIR_EXPRESSION_RULE) return false;
+ const ExpressionRule* our_rhs = static_cast<const ExpressionRule*>(&rhs);
+ return (expression_ == our_rhs->expression_);
+ }
+ Rule* Copy() const override { return new ExpressionRule(*this); }
+
+ private:
+ string expression_;
+};
+
+// Rule: EXPRESSION evaluates to the previous value of the register.
+class CallFrameInfo::ValExpressionRule : public CallFrameInfo::Rule {
+ public:
+ explicit ValExpressionRule(const string& expression)
+ : expression_(expression) {}
+ ~ValExpressionRule() {}
+ CFIRTag getTag() const override { return CFIR_VAL_EXPRESSION_RULE; }
+ bool Handle(Handler* handler, uint64 address, int reg) const override {
+ return handler->ValExpressionRule(address, reg, expression_);
+ }
+ bool operator==(const Rule& rhs) const override {
+ if (rhs.getTag() != CFIR_VAL_EXPRESSION_RULE) return false;
+ const ValExpressionRule* our_rhs =
+ static_cast<const ValExpressionRule*>(&rhs);
+ return (expression_ == our_rhs->expression_);
+ }
+ Rule* Copy() const override { return new ValExpressionRule(*this); }
+
+ private:
+ string expression_;
+};
+
+// A map from register numbers to rules.
+class CallFrameInfo::RuleMap {
+ public:
+ RuleMap() : cfa_rule_(NULL) {}
+ RuleMap(const RuleMap& rhs) : cfa_rule_(NULL) { *this = rhs; }
+ ~RuleMap() { Clear(); }
+
+ RuleMap& operator=(const RuleMap& rhs);
+
+ // Set the rule for computing the CFA to RULE. Take ownership of RULE.
+ void SetCFARule(Rule* rule) {
+ delete cfa_rule_;
+ cfa_rule_ = rule;
+ }
+
+ // Return the current CFA rule. Unlike RegisterRule, this RuleMap retains
+ // ownership of the rule. We use this for DW_CFA_def_cfa_offset and
+ // DW_CFA_def_cfa_register, and for detecting references to the CFA before
+ // a rule for it has been established.
+ Rule* CFARule() const { return cfa_rule_; }
+
+ // Return the rule for REG, or NULL if there is none. The caller takes
+ // ownership of the result.
+ Rule* RegisterRule(int reg) const;
+
+ // Set the rule for computing REG to RULE. Take ownership of RULE.
+ void SetRegisterRule(int reg, Rule* rule);
+
+ // Make all the appropriate calls to HANDLER as if we were changing from
+ // this RuleMap to NEW_RULES at ADDRESS. We use this to implement
+ // DW_CFA_restore_state, where lots of rules can change simultaneously.
+ // Return true if all handlers returned true; otherwise, return false.
+ bool HandleTransitionTo(Handler* handler, uint64 address,
+ const RuleMap& new_rules) const;
+
+ private:
+ // A map from register numbers to Rules.
+ typedef std::map<int, Rule*> RuleByNumber;
+
+ // Remove all register rules and clear cfa_rule_.
+ void Clear();
+
+ // The rule for computing the canonical frame address. This RuleMap owns
+ // this rule.
+ Rule* cfa_rule_;
+
+ // A map from register numbers to postfix expressions to recover
+ // their values. This RuleMap owns the Rules the map refers to.
+ RuleByNumber registers_;
+};
+
+CallFrameInfo::RuleMap& CallFrameInfo::RuleMap::operator=(const RuleMap& rhs) {
+ Clear();
+ // Since each map owns the rules it refers to, assignment must copy them.
+ if (rhs.cfa_rule_) cfa_rule_ = rhs.cfa_rule_->Copy();
+ for (RuleByNumber::const_iterator it = rhs.registers_.begin();
+ it != rhs.registers_.end(); it++)
+ registers_[it->first] = it->second->Copy();
+ return *this;
+}
+
+CallFrameInfo::Rule* CallFrameInfo::RuleMap::RegisterRule(int reg) const {
+ MOZ_ASSERT(reg != Handler::kCFARegister);
+ RuleByNumber::const_iterator it = registers_.find(reg);
+ if (it != registers_.end())
+ return it->second->Copy();
+ else
+ return NULL;
+}
+
+void CallFrameInfo::RuleMap::SetRegisterRule(int reg, Rule* rule) {
+ MOZ_ASSERT(reg != Handler::kCFARegister);
+ MOZ_ASSERT(rule);
+ Rule** slot = &registers_[reg];
+ delete *slot;
+ *slot = rule;
+}
+
+bool CallFrameInfo::RuleMap::HandleTransitionTo(
+ Handler* handler, uint64 address, const RuleMap& new_rules) const {
+ // Transition from cfa_rule_ to new_rules.cfa_rule_.
+ if (cfa_rule_ && new_rules.cfa_rule_) {
+ if (*cfa_rule_ != *new_rules.cfa_rule_ &&
+ !new_rules.cfa_rule_->Handle(handler, address, Handler::kCFARegister))
+ return false;
+ } else if (cfa_rule_) {
+ // this RuleMap has a CFA rule but new_rules doesn't.
+ // CallFrameInfo::Handler has no way to handle this --- and shouldn't;
+ // it's garbage input. The instruction interpreter should have
+ // detected this and warned, so take no action here.
+ } else if (new_rules.cfa_rule_) {
+ // This shouldn't be possible: NEW_RULES is some prior state, and
+ // there's no way to remove entries.
+ MOZ_ASSERT(0);
+ } else {
+ // Both CFA rules are empty. No action needed.
+ }
+
+ // Traverse the two maps in order by register number, and report
+ // whatever differences we find.
+ RuleByNumber::const_iterator old_it = registers_.begin();
+ RuleByNumber::const_iterator new_it = new_rules.registers_.begin();
+ while (old_it != registers_.end() && new_it != new_rules.registers_.end()) {
+ if (old_it->first < new_it->first) {
+ // This RuleMap has an entry for old_it->first, but NEW_RULES
+ // doesn't.
+ //
+ // This isn't really the right thing to do, but since CFI generally
+ // only mentions callee-saves registers, and GCC's convention for
+ // callee-saves registers is that they are unchanged, it's a good
+ // approximation.
+ if (!handler->SameValueRule(address, old_it->first)) return false;
+ old_it++;
+ } else if (old_it->first > new_it->first) {
+ // NEW_RULES has entry for new_it->first, but this RuleMap
+ // doesn't. This shouldn't be possible: NEW_RULES is some prior
+ // state, and there's no way to remove entries.
+ MOZ_ASSERT(0);
+ } else {
+ // Both maps have an entry for this register. Report the new
+ // rule if it is different.
+ if (*old_it->second != *new_it->second &&
+ !new_it->second->Handle(handler, address, new_it->first))
+ return false;
+ new_it++;
+ old_it++;
+ }
+ }
+ // Finish off entries from this RuleMap with no counterparts in new_rules.
+ while (old_it != registers_.end()) {
+ if (!handler->SameValueRule(address, old_it->first)) return false;
+ old_it++;
+ }
+ // Since we only make transitions from a rule set to some previously
+ // saved rule set, and we can only add rules to the map, NEW_RULES
+ // must have fewer rules than *this.
+ MOZ_ASSERT(new_it == new_rules.registers_.end());
+
+ return true;
+}
+
+// Remove all register rules and clear cfa_rule_.
+void CallFrameInfo::RuleMap::Clear() {
+ delete cfa_rule_;
+ cfa_rule_ = NULL;
+ for (RuleByNumber::iterator it = registers_.begin(); it != registers_.end();
+ it++)
+ delete it->second;
+ registers_.clear();
+}
+
+// The state of the call frame information interpreter as it processes
+// instructions from a CIE and FDE.
+class CallFrameInfo::State {
+ public:
+ // Create a call frame information interpreter state with the given
+ // reporter, reader, handler, and initial call frame info address.
+ State(ByteReader* reader, Handler* handler, Reporter* reporter,
+ uint64 address)
+ : reader_(reader),
+ handler_(handler),
+ reporter_(reporter),
+ address_(address),
+ entry_(NULL),
+ cursor_(NULL),
+ saved_rules_(NULL) {}
+
+ ~State() {
+ if (saved_rules_) delete saved_rules_;
+ }
+
+ // Interpret instructions from CIE, save the resulting rule set for
+ // DW_CFA_restore instructions, and return true. On error, report
+ // the problem to reporter_ and return false.
+ bool InterpretCIE(const CIE& cie);
+
+ // Interpret instructions from FDE, and return true. On error,
+ // report the problem to reporter_ and return false.
+ bool InterpretFDE(const FDE& fde);
+
+ private:
+ // The operands of a CFI instruction, for ParseOperands.
+ struct Operands {
+ unsigned register_number; // A register number.
+ uint64 offset; // An offset or address.
+ long signed_offset; // A signed offset.
+ string expression; // A DWARF expression.
+ };
+
+ // Parse CFI instruction operands from STATE's instruction stream as
+ // described by FORMAT. On success, populate OPERANDS with the
+ // results, and return true. On failure, report the problem and
+ // return false.
+ //
+ // Each character of FORMAT should be one of the following:
+ //
+ // 'r' unsigned LEB128 register number (OPERANDS->register_number)
+ // 'o' unsigned LEB128 offset (OPERANDS->offset)
+ // 's' signed LEB128 offset (OPERANDS->signed_offset)
+ // 'a' machine-size address (OPERANDS->offset)
+ // (If the CIE has a 'z' augmentation string, 'a' uses the
+ // encoding specified by the 'R' argument.)
+ // '1' a one-byte offset (OPERANDS->offset)
+ // '2' a two-byte offset (OPERANDS->offset)
+ // '4' a four-byte offset (OPERANDS->offset)
+ // '8' an eight-byte offset (OPERANDS->offset)
+ // 'e' a DW_FORM_block holding a (OPERANDS->expression)
+ // DWARF expression
+ bool ParseOperands(const char* format, Operands* operands);
+
+ // Interpret one CFI instruction from STATE's instruction stream, update
+ // STATE, report any rule changes to handler_, and return true. On
+ // failure, report the problem and return false.
+ bool DoInstruction();
+
+ // The following Do* member functions are subroutines of DoInstruction,
+ // factoring out the actual work of operations that have several
+ // different encodings.
+
+ // Set the CFA rule to be the value of BASE_REGISTER plus OFFSET, and
+ // return true. On failure, report and return false. (Used for
+ // DW_CFA_def_cfa and DW_CFA_def_cfa_sf.)
+ bool DoDefCFA(unsigned base_register, long offset);
+
+ // Change the offset of the CFA rule to OFFSET, and return true. On
+ // failure, report and return false. (Subroutine for
+ // DW_CFA_def_cfa_offset and DW_CFA_def_cfa_offset_sf.)
+ bool DoDefCFAOffset(long offset);
+
+ // Specify that REG can be recovered using RULE, and return true. On
+ // failure, report and return false.
+ bool DoRule(unsigned reg, Rule* rule);
+
+ // Specify that REG can be found at OFFSET from the CFA, and return true.
+ // On failure, report and return false. (Subroutine for DW_CFA_offset,
+ // DW_CFA_offset_extended, and DW_CFA_offset_extended_sf.)
+ bool DoOffset(unsigned reg, long offset);
+
+ // Specify that the caller's value for REG is the CFA plus OFFSET,
+ // and return true. On failure, report and return false. (Subroutine
+ // for DW_CFA_val_offset and DW_CFA_val_offset_sf.)
+ bool DoValOffset(unsigned reg, long offset);
+
+ // Restore REG to the rule established in the CIE, and return true. On
+ // failure, report and return false. (Subroutine for DW_CFA_restore and
+ // DW_CFA_restore_extended.)
+ bool DoRestore(unsigned reg);
+
+ // Return the section offset of the instruction at cursor. For use
+ // in error messages.
+ uint64 CursorOffset() { return entry_->offset + (cursor_ - entry_->start); }
+
+ // Report that entry_ is incomplete, and return false. For brevity.
+ bool ReportIncomplete() {
+ reporter_->Incomplete(entry_->offset, entry_->kind);
+ return false;
+ }
+
+ // For reading multi-byte values with the appropriate endianness.
+ ByteReader* reader_;
+
+ // The handler to which we should report the data we find.
+ Handler* handler_;
+
+ // For reporting problems in the info we're parsing.
+ Reporter* reporter_;
+
+ // The code address to which the next instruction in the stream applies.
+ uint64 address_;
+
+ // The entry whose instructions we are currently processing. This is
+ // first a CIE, and then an FDE.
+ const Entry* entry_;
+
+ // The next instruction to process.
+ const char* cursor_;
+
+ // The current set of rules.
+ RuleMap rules_;
+
+ // The set of rules established by the CIE, used by DW_CFA_restore
+ // and DW_CFA_restore_extended. We set this after interpreting the
+ // CIE's instructions.
+ RuleMap cie_rules_;
+
+ // A stack of saved states, for DW_CFA_remember_state and
+ // DW_CFA_restore_state.
+ std::stack<RuleMap>* saved_rules_;
+};
+
+bool CallFrameInfo::State::InterpretCIE(const CIE& cie) {
+ entry_ = &cie;
+ cursor_ = entry_->instructions;
+ while (cursor_ < entry_->end)
+ if (!DoInstruction()) return false;
+ // Note the rules established by the CIE, for use by DW_CFA_restore
+ // and DW_CFA_restore_extended.
+ cie_rules_ = rules_;
+ return true;
+}
+
+bool CallFrameInfo::State::InterpretFDE(const FDE& fde) {
+ entry_ = &fde;
+ cursor_ = entry_->instructions;
+ while (cursor_ < entry_->end)
+ if (!DoInstruction()) return false;
+ return true;
+}
+
+bool CallFrameInfo::State::ParseOperands(const char* format,
+ Operands* operands) {
+ size_t len;
+ const char* operand;
+
+ for (operand = format; *operand; operand++) {
+ size_t bytes_left = entry_->end - cursor_;
+ switch (*operand) {
+ case 'r':
+ operands->register_number = reader_->ReadUnsignedLEB128(cursor_, &len);
+ if (len > bytes_left) return ReportIncomplete();
+ cursor_ += len;
+ break;
+
+ case 'o':
+ operands->offset = reader_->ReadUnsignedLEB128(cursor_, &len);
+ if (len > bytes_left) return ReportIncomplete();
+ cursor_ += len;
+ break;
+
+ case 's':
+ operands->signed_offset = reader_->ReadSignedLEB128(cursor_, &len);
+ if (len > bytes_left) return ReportIncomplete();
+ cursor_ += len;
+ break;
+
+ case 'a':
+ operands->offset = reader_->ReadEncodedPointer(
+ cursor_, entry_->cie->pointer_encoding, &len);
+ if (len > bytes_left) return ReportIncomplete();
+ cursor_ += len;
+ break;
+
+ case '1':
+ if (1 > bytes_left) return ReportIncomplete();
+ operands->offset = static_cast<unsigned char>(*cursor_++);
+ break;
+
+ case '2':
+ if (2 > bytes_left) return ReportIncomplete();
+ operands->offset = reader_->ReadTwoBytes(cursor_);
+ cursor_ += 2;
+ break;
+
+ case '4':
+ if (4 > bytes_left) return ReportIncomplete();
+ operands->offset = reader_->ReadFourBytes(cursor_);
+ cursor_ += 4;
+ break;
+
+ case '8':
+ if (8 > bytes_left) return ReportIncomplete();
+ operands->offset = reader_->ReadEightBytes(cursor_);
+ cursor_ += 8;
+ break;
+
+ case 'e': {
+ size_t expression_length = reader_->ReadUnsignedLEB128(cursor_, &len);
+ if (len > bytes_left || expression_length > bytes_left - len)
+ return ReportIncomplete();
+ cursor_ += len;
+ operands->expression = string(cursor_, expression_length);
+ cursor_ += expression_length;
+ break;
+ }
+
+ default:
+ MOZ_ASSERT(0);
+ }
+ }
+
+ return true;
+}
+
+bool CallFrameInfo::State::DoInstruction() {
+ CIE* cie = entry_->cie;
+ Operands ops;
+
+ // Our entry's kind should have been set by now.
+ MOZ_ASSERT(entry_->kind != kUnknown);
+
+ // We shouldn't have been invoked unless there were more
+ // instructions to parse.
+ MOZ_ASSERT(cursor_ < entry_->end);
+
+ unsigned opcode = *cursor_++;
+ if ((opcode & 0xc0) != 0) {
+ switch (opcode & 0xc0) {
+ // Advance the address.
+ case DW_CFA_advance_loc: {
+ size_t code_offset = opcode & 0x3f;
+ address_ += code_offset * cie->code_alignment_factor;
+ break;
+ }
+
+ // Find a register at an offset from the CFA.
+ case DW_CFA_offset:
+ if (!ParseOperands("o", &ops) ||
+ !DoOffset(opcode & 0x3f, ops.offset * cie->data_alignment_factor))
+ return false;
+ break;
+
+ // Restore the rule established for a register by the CIE.
+ case DW_CFA_restore:
+ if (!DoRestore(opcode & 0x3f)) return false;
+ break;
+
+ // The 'if' above should have excluded this possibility.
+ default:
+ MOZ_ASSERT(0);
+ }
+
+ // Return here, so the big switch below won't be indented.
+ return true;
+ }
+
+ switch (opcode) {
+ // Set the address.
+ case DW_CFA_set_loc:
+ if (!ParseOperands("a", &ops)) return false;
+ address_ = ops.offset;
+ break;
+
+ // Advance the address.
+ case DW_CFA_advance_loc1:
+ if (!ParseOperands("1", &ops)) return false;
+ address_ += ops.offset * cie->code_alignment_factor;
+ break;
+
+ // Advance the address.
+ case DW_CFA_advance_loc2:
+ if (!ParseOperands("2", &ops)) return false;
+ address_ += ops.offset * cie->code_alignment_factor;
+ break;
+
+ // Advance the address.
+ case DW_CFA_advance_loc4:
+ if (!ParseOperands("4", &ops)) return false;
+ address_ += ops.offset * cie->code_alignment_factor;
+ break;
+
+ // Advance the address.
+ case DW_CFA_MIPS_advance_loc8:
+ if (!ParseOperands("8", &ops)) return false;
+ address_ += ops.offset * cie->code_alignment_factor;
+ break;
+
+ // Compute the CFA by adding an offset to a register.
+ case DW_CFA_def_cfa:
+ if (!ParseOperands("ro", &ops) ||
+ !DoDefCFA(ops.register_number, ops.offset))
+ return false;
+ break;
+
+ // Compute the CFA by adding an offset to a register.
+ case DW_CFA_def_cfa_sf:
+ if (!ParseOperands("rs", &ops) ||
+ !DoDefCFA(ops.register_number,
+ ops.signed_offset * cie->data_alignment_factor))
+ return false;
+ break;
+
+ // Change the base register used to compute the CFA.
+ case DW_CFA_def_cfa_register: {
+ Rule* cfa_rule = rules_.CFARule();
+ if (!cfa_rule) {
+ reporter_->NoCFARule(entry_->offset, entry_->kind, CursorOffset());
+ return false;
+ }
+ if (!ParseOperands("r", &ops)) return false;
+ cfa_rule->SetBaseRegister(ops.register_number);
+ if (!cfa_rule->Handle(handler_, address_, Handler::kCFARegister))
+ return false;
+ break;
+ }
+
+ // Change the offset used to compute the CFA.
+ case DW_CFA_def_cfa_offset:
+ if (!ParseOperands("o", &ops) || !DoDefCFAOffset(ops.offset))
+ return false;
+ break;
+
+ // Change the offset used to compute the CFA.
+ case DW_CFA_def_cfa_offset_sf:
+ if (!ParseOperands("s", &ops) ||
+ !DoDefCFAOffset(ops.signed_offset * cie->data_alignment_factor))
+ return false;
+ break;
+
+ // Specify an expression whose value is the CFA.
+ case DW_CFA_def_cfa_expression: {
+ if (!ParseOperands("e", &ops)) return false;
+ Rule* rule = new ValExpressionRule(ops.expression);
+ rules_.SetCFARule(rule);
+ if (!rule->Handle(handler_, address_, Handler::kCFARegister))
+ return false;
+ break;
+ }
+
+ // The register's value cannot be recovered.
+ case DW_CFA_undefined: {
+ if (!ParseOperands("r", &ops) ||
+ !DoRule(ops.register_number, new UndefinedRule()))
+ return false;
+ break;
+ }
+
+ // The register's value is unchanged from its value in the caller.
+ case DW_CFA_same_value: {
+ if (!ParseOperands("r", &ops) ||
+ !DoRule(ops.register_number, new SameValueRule()))
+ return false;
+ break;
+ }
+
+ // Find a register at an offset from the CFA.
+ case DW_CFA_offset_extended:
+ if (!ParseOperands("ro", &ops) ||
+ !DoOffset(ops.register_number,
+ ops.offset * cie->data_alignment_factor))
+ return false;
+ break;
+
+ // The register is saved at an offset from the CFA.
+ case DW_CFA_offset_extended_sf:
+ if (!ParseOperands("rs", &ops) ||
+ !DoOffset(ops.register_number,
+ ops.signed_offset * cie->data_alignment_factor))
+ return false;
+ break;
+
+ // The register is saved at an offset from the CFA.
+ case DW_CFA_GNU_negative_offset_extended:
+ if (!ParseOperands("ro", &ops) ||
+ !DoOffset(ops.register_number,
+ -ops.offset * cie->data_alignment_factor))
+ return false;
+ break;
+
+ // The register's value is the sum of the CFA plus an offset.
+ case DW_CFA_val_offset:
+ if (!ParseOperands("ro", &ops) ||
+ !DoValOffset(ops.register_number,
+ ops.offset * cie->data_alignment_factor))
+ return false;
+ break;
+
+ // The register's value is the sum of the CFA plus an offset.
+ case DW_CFA_val_offset_sf:
+ if (!ParseOperands("rs", &ops) ||
+ !DoValOffset(ops.register_number,
+ ops.signed_offset * cie->data_alignment_factor))
+ return false;
+ break;
+
+ // The register has been saved in another register.
+ case DW_CFA_register: {
+ if (!ParseOperands("ro", &ops) ||
+ !DoRule(ops.register_number, new RegisterRule(ops.offset)))
+ return false;
+ break;
+ }
+
+ // An expression yields the address at which the register is saved.
+ case DW_CFA_expression: {
+ if (!ParseOperands("re", &ops) ||
+ !DoRule(ops.register_number, new ExpressionRule(ops.expression)))
+ return false;
+ break;
+ }
+
+ // An expression yields the caller's value for the register.
+ case DW_CFA_val_expression: {
+ if (!ParseOperands("re", &ops) ||
+ !DoRule(ops.register_number, new ValExpressionRule(ops.expression)))
+ return false;
+ break;
+ }
+
+ // Restore the rule established for a register by the CIE.
+ case DW_CFA_restore_extended:
+ if (!ParseOperands("r", &ops) || !DoRestore(ops.register_number))
+ return false;
+ break;
+
+ // Save the current set of rules on a stack.
+ case DW_CFA_remember_state:
+ if (!saved_rules_) {
+ saved_rules_ = new std::stack<RuleMap>();
+ }
+ saved_rules_->push(rules_);
+ break;
+
+ // Pop the current set of rules off the stack.
+ case DW_CFA_restore_state: {
+ if (!saved_rules_ || saved_rules_->empty()) {
+ reporter_->EmptyStateStack(entry_->offset, entry_->kind,
+ CursorOffset());
+ return false;
+ }
+ const RuleMap& new_rules = saved_rules_->top();
+ if (rules_.CFARule() && !new_rules.CFARule()) {
+ reporter_->ClearingCFARule(entry_->offset, entry_->kind,
+ CursorOffset());
+ return false;
+ }
+ rules_.HandleTransitionTo(handler_, address_, new_rules);
+ rules_ = new_rules;
+ saved_rules_->pop();
+ break;
+ }
+
+ // No operation. (Padding instruction.)
+ case DW_CFA_nop:
+ break;
+
+ // A SPARC register window save: Registers 8 through 15 (%o0-%o7)
+ // are saved in registers 24 through 31 (%i0-%i7), and registers
+ // 16 through 31 (%l0-%l7 and %i0-%i7) are saved at CFA offsets
+ // (0-15 * the register size). The register numbers must be
+ // hard-coded. A GNU extension, and not a pretty one.
+ case DW_CFA_GNU_window_save: {
+ // Save %o0-%o7 in %i0-%i7.
+ for (int i = 8; i < 16; i++)
+ if (!DoRule(i, new RegisterRule(i + 16))) return false;
+ // Save %l0-%l7 and %i0-%i7 at the CFA.
+ for (int i = 16; i < 32; i++)
+ // Assume that the byte reader's address size is the same as
+ // the architecture's register size. !@#%*^ hilarious.
+ if (!DoRule(i, new OffsetRule(Handler::kCFARegister,
+ (i - 16) * reader_->AddressSize())))
+ return false;
+ break;
+ }
+
+ // I'm not sure what this is. GDB doesn't use it for unwinding.
+ case DW_CFA_GNU_args_size:
+ if (!ParseOperands("o", &ops)) return false;
+ break;
+
+ // An opcode we don't recognize.
+ default: {
+ reporter_->BadInstruction(entry_->offset, entry_->kind, CursorOffset());
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool CallFrameInfo::State::DoDefCFA(unsigned base_register, long offset) {
+ Rule* rule = new ValOffsetRule(base_register, offset);
+ rules_.SetCFARule(rule);
+ return rule->Handle(handler_, address_, Handler::kCFARegister);
+}
+
+bool CallFrameInfo::State::DoDefCFAOffset(long offset) {
+ Rule* cfa_rule = rules_.CFARule();
+ if (!cfa_rule) {
+ reporter_->NoCFARule(entry_->offset, entry_->kind, CursorOffset());
+ return false;
+ }
+ cfa_rule->SetOffset(offset);
+ return cfa_rule->Handle(handler_, address_, Handler::kCFARegister);
+}
+
+bool CallFrameInfo::State::DoRule(unsigned reg, Rule* rule) {
+ rules_.SetRegisterRule(reg, rule);
+ return rule->Handle(handler_, address_, reg);
+}
+
+bool CallFrameInfo::State::DoOffset(unsigned reg, long offset) {
+ if (!rules_.CFARule()) {
+ reporter_->NoCFARule(entry_->offset, entry_->kind, CursorOffset());
+ return false;
+ }
+ return DoRule(reg, new OffsetRule(Handler::kCFARegister, offset));
+}
+
+bool CallFrameInfo::State::DoValOffset(unsigned reg, long offset) {
+ if (!rules_.CFARule()) {
+ reporter_->NoCFARule(entry_->offset, entry_->kind, CursorOffset());
+ return false;
+ }
+ return DoRule(reg, new ValOffsetRule(Handler::kCFARegister, offset));
+}
+
+bool CallFrameInfo::State::DoRestore(unsigned reg) {
+ // DW_CFA_restore and DW_CFA_restore_extended don't make sense in a CIE.
+ if (entry_->kind == kCIE) {
+ reporter_->RestoreInCIE(entry_->offset, CursorOffset());
+ return false;
+ }
+ Rule* rule = cie_rules_.RegisterRule(reg);
+ if (!rule) {
+ // This isn't really the right thing to do, but since CFI generally
+ // only mentions callee-saves registers, and GCC's convention for
+ // callee-saves registers is that they are unchanged, it's a good
+ // approximation.
+ rule = new SameValueRule();
+ }
+ return DoRule(reg, rule);
+}
+
+bool CallFrameInfo::ReadEntryPrologue(const char* cursor, Entry* entry) {
+ const char* buffer_end = buffer_ + buffer_length_;
+
+ // Initialize enough of ENTRY for use in error reporting.
+ entry->offset = cursor - buffer_;
+ entry->start = cursor;
+ entry->kind = kUnknown;
+ entry->end = NULL;
+
+ // Read the initial length. This sets reader_'s offset size.
+ size_t length_size;
+ uint64 length = reader_->ReadInitialLength(cursor, &length_size);
+ if (length_size > size_t(buffer_end - cursor)) return ReportIncomplete(entry);
+ cursor += length_size;
+
+ // In a .eh_frame section, a length of zero marks the end of the series
+ // of entries.
+ if (length == 0 && eh_frame_) {
+ entry->kind = kTerminator;
+ entry->end = cursor;
+ return true;
+ }
+
+ // Validate the length.
+ if (length > size_t(buffer_end - cursor)) return ReportIncomplete(entry);
+
+ // The length is the number of bytes after the initial length field;
+ // we have that position handy at this point, so compute the end
+ // now. (If we're parsing 64-bit-offset DWARF on a 32-bit machine,
+ // and the length didn't fit in a size_t, we would have rejected it
+ // above.)
+ entry->end = cursor + length;
+
+ // Parse the next field: either the offset of a CIE or a CIE id.
+ size_t offset_size = reader_->OffsetSize();
+ if (offset_size > size_t(entry->end - cursor)) return ReportIncomplete(entry);
+ entry->id = reader_->ReadOffset(cursor);
+
+ // Don't advance cursor past id field yet; in .eh_frame data we need
+ // the id's position to compute the section offset of an FDE's CIE.
+
+ // Now we can decide what kind of entry this is.
+ if (eh_frame_) {
+ // In .eh_frame data, an ID of zero marks the entry as a CIE, and
+ // anything else is an offset from the id field of the FDE to the start
+ // of the CIE.
+ if (entry->id == 0) {
+ entry->kind = kCIE;
+ } else {
+ entry->kind = kFDE;
+ // Turn the offset from the id into an offset from the buffer's start.
+ entry->id = (cursor - buffer_) - entry->id;
+ }
+ } else {
+ // In DWARF CFI data, an ID of ~0 (of the appropriate width, given the
+ // offset size for the entry) marks the entry as a CIE, and anything
+ // else is the offset of the CIE from the beginning of the section.
+ if (offset_size == 4)
+ entry->kind = (entry->id == 0xffffffff) ? kCIE : kFDE;
+ else {
+ MOZ_ASSERT(offset_size == 8);
+ entry->kind = (entry->id == 0xffffffffffffffffULL) ? kCIE : kFDE;
+ }
+ }
+
+ // Now advance cursor past the id.
+ cursor += offset_size;
+
+ // The fields specific to this kind of entry start here.
+ entry->fields = cursor;
+
+ entry->cie = NULL;
+
+ return true;
+}
+
+bool CallFrameInfo::ReadCIEFields(CIE* cie) {
+ const char* cursor = cie->fields;
+ size_t len;
+
+ MOZ_ASSERT(cie->kind == kCIE);
+
+ // Prepare for early exit.
+ cie->version = 0;
+ cie->augmentation.clear();
+ cie->code_alignment_factor = 0;
+ cie->data_alignment_factor = 0;
+ cie->return_address_register = 0;
+ cie->has_z_augmentation = false;
+ cie->pointer_encoding = DW_EH_PE_absptr;
+ cie->instructions = 0;
+
+ // Parse the version number.
+ if (cie->end - cursor < 1) return ReportIncomplete(cie);
+ cie->version = reader_->ReadOneByte(cursor);
+ cursor++;
+
+ // If we don't recognize the version, we can't parse any more fields of the
+ // CIE. For DWARF CFI, we handle versions 1 through 4 (there was never a
+ // version 2 of CFI data). For .eh_frame, we handle versions 1 and 4 as well;
+ // the difference between those versions seems to be the same as for
+ // .debug_frame.
+ if (cie->version < 1 || cie->version > 4) {
+ reporter_->UnrecognizedVersion(cie->offset, cie->version);
+ return false;
+ }
+
+ const char* augmentation_start = cursor;
+ const void* augmentation_end =
+ memchr(augmentation_start, '\0', cie->end - augmentation_start);
+ if (!augmentation_end) return ReportIncomplete(cie);
+ cursor = static_cast<const char*>(augmentation_end);
+ cie->augmentation = string(augmentation_start, cursor - augmentation_start);
+ // Skip the terminating '\0'.
+ cursor++;
+
+ // Is this CFI augmented?
+ if (!cie->augmentation.empty()) {
+ // Is it an augmentation we recognize?
+ if (cie->augmentation[0] == DW_Z_augmentation_start) {
+ // Linux C++ ABI 'z' augmentation, used for exception handling data.
+ cie->has_z_augmentation = true;
+ } else {
+ // Not an augmentation we recognize. Augmentations can have arbitrary
+ // effects on the form of rest of the content, so we have to give up.
+ reporter_->UnrecognizedAugmentation(cie->offset, cie->augmentation);
+ return false;
+ }
+ }
+
+ if (cie->version >= 4) {
+ // Check that the address_size and segment_size fields are plausible.
+ if (cie->end - cursor < 2) {
+ return ReportIncomplete(cie);
+ }
+ uint8_t address_size = reader_->ReadOneByte(cursor);
+ cursor++;
+ if (address_size != sizeof(void*)) {
+ // This is not per-se invalid CFI. But we can reasonably expect to
+ // be running on a target of the same word size as the CFI is for,
+ // so we reject this case.
+ reporter_->InvalidDwarf4Artefact(cie->offset, "Invalid address_size");
+ return false;
+ }
+ uint8_t segment_size = reader_->ReadOneByte(cursor);
+ cursor++;
+ if (segment_size != 0) {
+ // This is also not per-se invalid CFI, but we don't currently handle
+ // the case of non-zero |segment_size|.
+ reporter_->InvalidDwarf4Artefact(cie->offset, "Invalid segment_size");
+ return false;
+ }
+ // We only continue parsing if |segment_size| is zero. If this routine
+ // is ever changed to allow non-zero |segment_size|, then
+ // ReadFDEFields() below will have to be changed to match, per comments
+ // there.
+ }
+
+ // Parse the code alignment factor.
+ cie->code_alignment_factor = reader_->ReadUnsignedLEB128(cursor, &len);
+ if (size_t(cie->end - cursor) < len) return ReportIncomplete(cie);
+ cursor += len;
+
+ // Parse the data alignment factor.
+ cie->data_alignment_factor = reader_->ReadSignedLEB128(cursor, &len);
+ if (size_t(cie->end - cursor) < len) return ReportIncomplete(cie);
+ cursor += len;
+
+ // Parse the return address register. This is a ubyte in version 1, and
+ // a ULEB128 in version 3.
+ if (cie->version == 1) {
+ if (cursor >= cie->end) return ReportIncomplete(cie);
+ cie->return_address_register = uint8(*cursor++);
+ } else {
+ cie->return_address_register = reader_->ReadUnsignedLEB128(cursor, &len);
+ if (size_t(cie->end - cursor) < len) return ReportIncomplete(cie);
+ cursor += len;
+ }
+
+ // If we have a 'z' augmentation string, find the augmentation data and
+ // use the augmentation string to parse it.
+ if (cie->has_z_augmentation) {
+ uint64_t data_size = reader_->ReadUnsignedLEB128(cursor, &len);
+ if (size_t(cie->end - cursor) < len + data_size)
+ return ReportIncomplete(cie);
+ cursor += len;
+ const char* data = cursor;
+ cursor += data_size;
+ const char* data_end = cursor;
+
+ cie->has_z_lsda = false;
+ cie->has_z_personality = false;
+ cie->has_z_signal_frame = false;
+
+ // Walk the augmentation string, and extract values from the
+ // augmentation data as the string directs.
+ for (size_t i = 1; i < cie->augmentation.size(); i++) {
+ switch (cie->augmentation[i]) {
+ case DW_Z_has_LSDA:
+ // The CIE's augmentation data holds the language-specific data
+ // area pointer's encoding, and the FDE's augmentation data holds
+ // the pointer itself.
+ cie->has_z_lsda = true;
+ // Fetch the LSDA encoding from the augmentation data.
+ if (data >= data_end) return ReportIncomplete(cie);
+ cie->lsda_encoding = DwarfPointerEncoding(*data++);
+ if (!reader_->ValidEncoding(cie->lsda_encoding)) {
+ reporter_->InvalidPointerEncoding(cie->offset, cie->lsda_encoding);
+ return false;
+ }
+ // Don't check if the encoding is usable here --- we haven't
+ // read the FDE's fields yet, so we're not prepared for
+ // DW_EH_PE_funcrel, although that's a fine encoding for the
+ // LSDA to use, since it appears in the FDE.
+ break;
+
+ case DW_Z_has_personality_routine:
+ // The CIE's augmentation data holds the personality routine
+ // pointer's encoding, followed by the pointer itself.
+ cie->has_z_personality = true;
+ // Fetch the personality routine pointer's encoding from the
+ // augmentation data.
+ if (data >= data_end) return ReportIncomplete(cie);
+ cie->personality_encoding = DwarfPointerEncoding(*data++);
+ if (!reader_->ValidEncoding(cie->personality_encoding)) {
+ reporter_->InvalidPointerEncoding(cie->offset,
+ cie->personality_encoding);
+ return false;
+ }
+ if (!reader_->UsableEncoding(cie->personality_encoding)) {
+ reporter_->UnusablePointerEncoding(cie->offset,
+ cie->personality_encoding);
+ return false;
+ }
+ // Fetch the personality routine's pointer itself from the data.
+ cie->personality_address = reader_->ReadEncodedPointer(
+ data, cie->personality_encoding, &len);
+ if (len > size_t(data_end - data)) return ReportIncomplete(cie);
+ data += len;
+ break;
+
+ case DW_Z_has_FDE_address_encoding:
+ // The CIE's augmentation data holds the pointer encoding to use
+ // for addresses in the FDE.
+ if (data >= data_end) return ReportIncomplete(cie);
+ cie->pointer_encoding = DwarfPointerEncoding(*data++);
+ if (!reader_->ValidEncoding(cie->pointer_encoding)) {
+ reporter_->InvalidPointerEncoding(cie->offset,
+ cie->pointer_encoding);
+ return false;
+ }
+ if (!reader_->UsableEncoding(cie->pointer_encoding)) {
+ reporter_->UnusablePointerEncoding(cie->offset,
+ cie->pointer_encoding);
+ return false;
+ }
+ break;
+
+ case DW_Z_is_signal_trampoline:
+ // Frames using this CIE are signal delivery frames.
+ cie->has_z_signal_frame = true;
+ break;
+
+ default:
+ // An augmentation we don't recognize.
+ reporter_->UnrecognizedAugmentation(cie->offset, cie->augmentation);
+ return false;
+ }
+ }
+ }
+
+ // The CIE's instructions start here.
+ cie->instructions = cursor;
+
+ return true;
+}
+
+bool CallFrameInfo::ReadFDEFields(FDE* fde) {
+ const char* cursor = fde->fields;
+ size_t size;
+
+ // At this point, for Dwarf 4 and above, we are assuming that the
+ // associated CIE has its |segment_size| field equal to zero. This is
+ // checked for in ReadCIEFields() above. If ReadCIEFields() is ever
+ // changed to allow non-zero |segment_size| CIEs then we will have to read
+ // the segment_selector value at this point.
+
+ fde->address =
+ reader_->ReadEncodedPointer(cursor, fde->cie->pointer_encoding, &size);
+ if (size > size_t(fde->end - cursor)) return ReportIncomplete(fde);
+ cursor += size;
+ reader_->SetFunctionBase(fde->address);
+
+ // For the length, we strip off the upper nybble of the encoding used for
+ // the starting address.
+ DwarfPointerEncoding length_encoding =
+ DwarfPointerEncoding(fde->cie->pointer_encoding & 0x0f);
+ fde->size = reader_->ReadEncodedPointer(cursor, length_encoding, &size);
+ if (size > size_t(fde->end - cursor)) return ReportIncomplete(fde);
+ cursor += size;
+
+ // If the CIE has a 'z' augmentation string, then augmentation data
+ // appears here.
+ if (fde->cie->has_z_augmentation) {
+ uint64_t data_size = reader_->ReadUnsignedLEB128(cursor, &size);
+ if (size_t(fde->end - cursor) < size + data_size)
+ return ReportIncomplete(fde);
+ cursor += size;
+
+ // In the abstract, we should walk the augmentation string, and extract
+ // items from the FDE's augmentation data as we encounter augmentation
+ // string characters that specify their presence: the ordering of items
+ // in the augmentation string determines the arrangement of values in
+ // the augmentation data.
+ //
+ // In practice, there's only ever one value in FDE augmentation data
+ // that we support --- the LSDA pointer --- and we have to bail if we
+ // see any unrecognized augmentation string characters. So if there is
+ // anything here at all, we know what it is, and where it starts.
+ if (fde->cie->has_z_lsda) {
+ // Check whether the LSDA's pointer encoding is usable now: only once
+ // we've parsed the FDE's starting address do we call reader_->
+ // SetFunctionBase, so that the DW_EH_PE_funcrel encoding becomes
+ // usable.
+ if (!reader_->UsableEncoding(fde->cie->lsda_encoding)) {
+ reporter_->UnusablePointerEncoding(fde->cie->offset,
+ fde->cie->lsda_encoding);
+ return false;
+ }
+
+ fde->lsda_address =
+ reader_->ReadEncodedPointer(cursor, fde->cie->lsda_encoding, &size);
+ if (size > data_size) return ReportIncomplete(fde);
+ // Ideally, we would also complain here if there were unconsumed
+ // augmentation data.
+ }
+
+ cursor += data_size;
+ }
+
+ // The FDE's instructions start after those.
+ fde->instructions = cursor;
+
+ return true;
+}
+
+bool CallFrameInfo::Start() {
+ const char* buffer_end = buffer_ + buffer_length_;
+ const char* cursor;
+ bool all_ok = true;
+ const char* entry_end;
+ bool ok;
+
+ // Traverse all the entries in buffer_, skipping CIEs and offering
+ // FDEs to the handler.
+ for (cursor = buffer_; cursor < buffer_end;
+ cursor = entry_end, all_ok = all_ok && ok) {
+ FDE fde;
+
+ // Make it easy to skip this entry with 'continue': assume that
+ // things are not okay until we've checked all the data, and
+ // prepare the address of the next entry.
+ ok = false;
+
+ // Read the entry's prologue.
+ if (!ReadEntryPrologue(cursor, &fde)) {
+ if (!fde.end) {
+ // If we couldn't even figure out this entry's extent, then we
+ // must stop processing entries altogether.
+ all_ok = false;
+ break;
+ }
+ entry_end = fde.end;
+ continue;
+ }
+
+ // The next iteration picks up after this entry.
+ entry_end = fde.end;
+
+ // Did we see an .eh_frame terminating mark?
+ if (fde.kind == kTerminator) {
+ // If there appears to be more data left in the section after the
+ // terminating mark, warn the user. But this is just a warning;
+ // we leave all_ok true.
+ if (fde.end < buffer_end) reporter_->EarlyEHTerminator(fde.offset);
+ break;
+ }
+
+ // In this loop, we skip CIEs. We only parse them fully when we
+ // parse an FDE that refers to them. This limits our memory
+ // consumption (beyond the buffer itself) to that needed to
+ // process the largest single entry.
+ if (fde.kind != kFDE) {
+ ok = true;
+ continue;
+ }
+
+ // Validate the CIE pointer.
+ if (fde.id > buffer_length_) {
+ reporter_->CIEPointerOutOfRange(fde.offset, fde.id);
+ continue;
+ }
+
+ CIE cie;
+
+ // Parse this FDE's CIE header.
+ if (!ReadEntryPrologue(buffer_ + fde.id, &cie)) continue;
+ // This had better be an actual CIE.
+ if (cie.kind != kCIE) {
+ reporter_->BadCIEId(fde.offset, fde.id);
+ continue;
+ }
+ if (!ReadCIEFields(&cie)) continue;
+
+ // We now have the values that govern both the CIE and the FDE.
+ cie.cie = &cie;
+ fde.cie = &cie;
+
+ // Parse the FDE's header.
+ if (!ReadFDEFields(&fde)) continue;
+
+ // Call Entry to ask the consumer if they're interested.
+ if (!handler_->Entry(fde.offset, fde.address, fde.size, cie.version,
+ cie.augmentation, cie.return_address_register)) {
+ // The handler isn't interested in this entry. That's not an error.
+ ok = true;
+ continue;
+ }
+
+ if (cie.has_z_augmentation) {
+ // Report the personality routine address, if we have one.
+ if (cie.has_z_personality) {
+ if (!handler_->PersonalityRoutine(
+ cie.personality_address,
+ IsIndirectEncoding(cie.personality_encoding)))
+ continue;
+ }
+
+ // Report the language-specific data area address, if we have one.
+ if (cie.has_z_lsda) {
+ if (!handler_->LanguageSpecificDataArea(
+ fde.lsda_address, IsIndirectEncoding(cie.lsda_encoding)))
+ continue;
+ }
+
+ // If this is a signal-handling frame, report that.
+ if (cie.has_z_signal_frame) {
+ if (!handler_->SignalHandler()) continue;
+ }
+ }
+
+ // Interpret the CIE's instructions, and then the FDE's instructions.
+ State state(reader_, handler_, reporter_, fde.address);
+ ok = state.InterpretCIE(cie) && state.InterpretFDE(fde);
+
+ // Tell the ByteReader that the function start address from the
+ // FDE header is no longer valid.
+ reader_->ClearFunctionBase();
+
+ // Report the end of the entry.
+ handler_->End();
+ }
+
+ return all_ok;
+}
+
+const char* CallFrameInfo::KindName(EntryKind kind) {
+ if (kind == CallFrameInfo::kUnknown)
+ return "entry";
+ else if (kind == CallFrameInfo::kCIE)
+ return "common information entry";
+ else if (kind == CallFrameInfo::kFDE)
+ return "frame description entry";
+ else {
+ MOZ_ASSERT(kind == CallFrameInfo::kTerminator);
+ return ".eh_frame sequence terminator";
+ }
+}
+
+bool CallFrameInfo::ReportIncomplete(Entry* entry) {
+ reporter_->Incomplete(entry->offset, entry->kind);
+ return false;
+}
+
+void CallFrameInfo::Reporter::Incomplete(uint64 offset,
+ CallFrameInfo::EntryKind kind) {
+ char buf[300];
+ SprintfLiteral(buf, "%s: CFI %s at offset 0x%llx in '%s': entry ends early\n",
+ filename_.c_str(), CallFrameInfo::KindName(kind), offset,
+ section_.c_str());
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::EarlyEHTerminator(uint64 offset) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI at offset 0x%llx in '%s': saw end-of-data marker"
+ " before end of section contents\n",
+ filename_.c_str(), offset, section_.c_str());
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::CIEPointerOutOfRange(uint64 offset,
+ uint64 cie_offset) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI frame description entry at offset 0x%llx in '%s':"
+ " CIE pointer is out of range: 0x%llx\n",
+ filename_.c_str(), offset, section_.c_str(), cie_offset);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::BadCIEId(uint64 offset, uint64 cie_offset) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI frame description entry at offset 0x%llx in '%s':"
+ " CIE pointer does not point to a CIE: 0x%llx\n",
+ filename_.c_str(), offset, section_.c_str(), cie_offset);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::UnrecognizedVersion(uint64 offset, int version) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI frame description entry at offset 0x%llx in '%s':"
+ " CIE specifies unrecognized version: %d\n",
+ filename_.c_str(), offset, section_.c_str(), version);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::UnrecognizedAugmentation(uint64 offset,
+ const string& aug) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI frame description entry at offset 0x%llx in '%s':"
+ " CIE specifies unrecognized augmentation: '%s'\n",
+ filename_.c_str(), offset, section_.c_str(), aug.c_str());
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::InvalidDwarf4Artefact(uint64 offset,
+ const char* what) {
+ char* what_safe = strndup(what, 100);
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI frame description entry at offset 0x%llx in '%s':"
+ " CIE specifies invalid Dwarf4 artefact: %s\n",
+ filename_.c_str(), offset, section_.c_str(), what_safe);
+ log_(buf);
+ free(what_safe);
+}
+
+void CallFrameInfo::Reporter::InvalidPointerEncoding(uint64 offset,
+ uint8 encoding) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI common information entry at offset 0x%llx in '%s':"
+ " 'z' augmentation specifies invalid pointer encoding: "
+ "0x%02x\n",
+ filename_.c_str(), offset, section_.c_str(), encoding);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::UnusablePointerEncoding(uint64 offset,
+ uint8 encoding) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI common information entry at offset 0x%llx in '%s':"
+ " 'z' augmentation specifies a pointer encoding for which"
+ " we have no base address: 0x%02x\n",
+ filename_.c_str(), offset, section_.c_str(), encoding);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::RestoreInCIE(uint64 offset, uint64 insn_offset) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI common information entry at offset 0x%llx in '%s':"
+ " the DW_CFA_restore instruction at offset 0x%llx"
+ " cannot be used in a common information entry\n",
+ filename_.c_str(), offset, section_.c_str(), insn_offset);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::BadInstruction(uint64 offset,
+ CallFrameInfo::EntryKind kind,
+ uint64 insn_offset) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI %s at offset 0x%llx in section '%s':"
+ " the instruction at offset 0x%llx is unrecognized\n",
+ filename_.c_str(), CallFrameInfo::KindName(kind), offset,
+ section_.c_str(), insn_offset);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::NoCFARule(uint64 offset,
+ CallFrameInfo::EntryKind kind,
+ uint64 insn_offset) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI %s at offset 0x%llx in section '%s':"
+ " the instruction at offset 0x%llx assumes that a CFA rule "
+ "has been set, but none has been set\n",
+ filename_.c_str(), CallFrameInfo::KindName(kind), offset,
+ section_.c_str(), insn_offset);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::EmptyStateStack(uint64 offset,
+ CallFrameInfo::EntryKind kind,
+ uint64 insn_offset) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI %s at offset 0x%llx in section '%s':"
+ " the DW_CFA_restore_state instruction at offset 0x%llx"
+ " should pop a saved state from the stack, but the stack "
+ "is empty\n",
+ filename_.c_str(), CallFrameInfo::KindName(kind), offset,
+ section_.c_str(), insn_offset);
+ log_(buf);
+}
+
+void CallFrameInfo::Reporter::ClearingCFARule(uint64 offset,
+ CallFrameInfo::EntryKind kind,
+ uint64 insn_offset) {
+ char buf[300];
+ SprintfLiteral(buf,
+ "%s: CFI %s at offset 0x%llx in section '%s':"
+ " the DW_CFA_restore_state instruction at offset 0x%llx"
+ " would clear the CFA rule in effect\n",
+ filename_.c_str(), CallFrameInfo::KindName(kind), offset,
+ section_.c_str(), insn_offset);
+ log_(buf);
+}
+
+unsigned int DwarfCFIToModule::RegisterNames::I386() {
+ /*
+ 8 "$eax", "$ecx", "$edx", "$ebx", "$esp", "$ebp", "$esi", "$edi",
+ 3 "$eip", "$eflags", "$unused1",
+ 8 "$st0", "$st1", "$st2", "$st3", "$st4", "$st5", "$st6", "$st7",
+ 2 "$unused2", "$unused3",
+ 8 "$xmm0", "$xmm1", "$xmm2", "$xmm3", "$xmm4", "$xmm5", "$xmm6", "$xmm7",
+ 8 "$mm0", "$mm1", "$mm2", "$mm3", "$mm4", "$mm5", "$mm6", "$mm7",
+ 3 "$fcw", "$fsw", "$mxcsr",
+ 8 "$es", "$cs", "$ss", "$ds", "$fs", "$gs", "$unused4", "$unused5",
+ 2 "$tr", "$ldtr"
+ */
+ return 8 + 3 + 8 + 2 + 8 + 8 + 3 + 8 + 2;
+}
+
+unsigned int DwarfCFIToModule::RegisterNames::X86_64() {
+ /*
+ 8 "$rax", "$rdx", "$rcx", "$rbx", "$rsi", "$rdi", "$rbp", "$rsp",
+ 8 "$r8", "$r9", "$r10", "$r11", "$r12", "$r13", "$r14", "$r15",
+ 1 "$rip",
+ 8 "$xmm0","$xmm1","$xmm2", "$xmm3", "$xmm4", "$xmm5", "$xmm6", "$xmm7",
+ 8 "$xmm8","$xmm9","$xmm10","$xmm11","$xmm12","$xmm13","$xmm14","$xmm15",
+ 8 "$st0", "$st1", "$st2", "$st3", "$st4", "$st5", "$st6", "$st7",
+ 8 "$mm0", "$mm1", "$mm2", "$mm3", "$mm4", "$mm5", "$mm6", "$mm7",
+ 1 "$rflags",
+ 8 "$es", "$cs", "$ss", "$ds", "$fs", "$gs", "$unused1", "$unused2",
+ 4 "$fs.base", "$gs.base", "$unused3", "$unused4",
+ 2 "$tr", "$ldtr",
+ 3 "$mxcsr", "$fcw", "$fsw"
+ */
+ return 8 + 8 + 1 + 8 + 8 + 8 + 8 + 1 + 8 + 4 + 2 + 3;
+}
+
+// Per ARM IHI 0040A, section 3.1
+unsigned int DwarfCFIToModule::RegisterNames::ARM() {
+ /*
+ 8 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+ 8 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
+ 8 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
+ 8 "fps", "cpsr", "", "", "", "", "", "",
+ 8 "", "", "", "", "", "", "", "",
+ 8 "", "", "", "", "", "", "", "",
+ 8 "", "", "", "", "", "", "", "",
+ 8 "", "", "", "", "", "", "", "",
+ 8 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
+ 8 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
+ 8 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
+ 8 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
+ 8 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7"
+ */
+ return 13 * 8;
+}
+
+// Per ARM IHI 0057A, section 3.1
+unsigned int DwarfCFIToModule::RegisterNames::ARM64() {
+ /*
+ 8 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
+ 8 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
+ 8 "x16" "x17", "x18", "x19", "x20", "x21", "x22", "x23",
+ 8 "x24", "x25", "x26", "x27", "x28", "x29", "x30","sp",
+ 8 "", "", "", "", "", "", "", "",
+ 8 "", "", "", "", "", "", "", "",
+ 8 "", "", "", "", "", "", "", "",
+ 8 "", "", "", "", "", "", "", "",
+ 8 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+ 8 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
+ 8 "v16", "v17", "v18", "v19", "v20", "v21", "v22, "v23",
+ 8 "v24", "x25", "x26, "x27", "v28", "v29", "v30", "v31",
+ */
+ return 12 * 8;
+}
+
+unsigned int DwarfCFIToModule::RegisterNames::MIPS() {
+ /*
+ 8 "$zero", "$at", "$v0", "$v1", "$a0", "$a1", "$a2", "$a3",
+ 8 "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7",
+ 8 "$s0", "$s1", "$s2", "$s3", "$s4", "$s5", "$s6", "$s7",
+ 8 "$t8", "$t9", "$k0", "$k1", "$gp", "$sp", "$fp", "$ra",
+ 9 "$lo", "$hi", "$pc", "$f0", "$f1", "$f2", "$f3", "$f4", "$f5",
+ 8 "$f6", "$f7", "$f8", "$f9", "$f10", "$f11", "$f12", "$f13",
+ 7 "$f14", "$f15", "$f16", "$f17", "$f18", "$f19", "$f20",
+ 7 "$f21", "$f22", "$f23", "$f24", "$f25", "$f26", "$f27",
+ 6 "$f28", "$f29", "$f30", "$f31", "$fcsr", "$fir"
+ */
+ return 8 + 8 + 8 + 8 + 9 + 8 + 7 + 7 + 6;
+}
+
+// See prototype for comments.
+int32_t parseDwarfExpr(Summariser* summ, const ByteReader* reader, string expr,
+ bool debug, bool pushCfaAtStart, bool derefAtEnd) {
+ const char* cursor = expr.c_str();
+ const char* end1 = cursor + expr.length();
+
+ char buf[100];
+ if (debug) {
+ SprintfLiteral(buf, "LUL.DW << DwarfExpr, len is %d\n",
+ (int)(end1 - cursor));
+ summ->Log(buf);
+ }
+
+ // Add a marker for the start of this expression. In it, indicate
+ // whether or not the CFA should be pushed onto the stack prior to
+ // evaluation.
+ int32_t start_ix =
+ summ->AddPfxInstr(PfxInstr(PX_Start, pushCfaAtStart ? 1 : 0));
+ MOZ_ASSERT(start_ix >= 0);
+
+ while (cursor < end1) {
+ uint8 opc = reader->ReadOneByte(cursor);
+ cursor++;
+
+ const char* nm = nullptr;
+ PfxExprOp pxop = PX_End;
+
+ switch (opc) {
+ case DW_OP_lit0 ... DW_OP_lit31: {
+ int32_t simm32 = (int32_t)(opc - DW_OP_lit0);
+ if (debug) {
+ SprintfLiteral(buf, "LUL.DW DW_OP_lit%d\n", (int)simm32);
+ summ->Log(buf);
+ }
+ (void)summ->AddPfxInstr(PfxInstr(PX_SImm32, simm32));
+ break;
+ }
+
+ case DW_OP_breg0 ... DW_OP_breg31: {
+ size_t len;
+ int64_t n = reader->ReadSignedLEB128(cursor, &len);
+ cursor += len;
+ DW_REG_NUMBER reg = (DW_REG_NUMBER)(opc - DW_OP_breg0);
+ if (debug) {
+ SprintfLiteral(buf, "LUL.DW DW_OP_breg%d %lld\n", (int)reg,
+ (long long int)n);
+ summ->Log(buf);
+ }
+ // PfxInstr only allows a 32 bit signed offset. So we
+ // must fail if the immediate is out of range.
+ if (n < INT32_MIN || INT32_MAX < n) goto fail;
+ (void)summ->AddPfxInstr(PfxInstr(PX_DwReg, reg));
+ (void)summ->AddPfxInstr(PfxInstr(PX_SImm32, (int32_t)n));
+ (void)summ->AddPfxInstr(PfxInstr(PX_Add));
+ break;
+ }
+
+ case DW_OP_const4s: {
+ uint64_t u64 = reader->ReadFourBytes(cursor);
+ cursor += 4;
+ // u64 is guaranteed by |ReadFourBytes| to be in the
+ // range 0 .. FFFFFFFF inclusive. But to be safe:
+ uint32_t u32 = (uint32_t)(u64 & 0xFFFFFFFF);
+ int32_t s32 = (int32_t)u32;
+ if (debug) {
+ SprintfLiteral(buf, "LUL.DW DW_OP_const4s %d\n", (int)s32);
+ summ->Log(buf);
+ }
+ (void)summ->AddPfxInstr(PfxInstr(PX_SImm32, s32));
+ break;
+ }
+
+ case DW_OP_deref:
+ nm = "deref";
+ pxop = PX_Deref;
+ goto no_operands;
+ case DW_OP_and:
+ nm = "and";
+ pxop = PX_And;
+ goto no_operands;
+ case DW_OP_plus:
+ nm = "plus";
+ pxop = PX_Add;
+ goto no_operands;
+ case DW_OP_minus:
+ nm = "minus";
+ pxop = PX_Sub;
+ goto no_operands;
+ case DW_OP_shl:
+ nm = "shl";
+ pxop = PX_Shl;
+ goto no_operands;
+ case DW_OP_ge:
+ nm = "ge";
+ pxop = PX_CmpGES;
+ goto no_operands;
+ no_operands:
+ MOZ_ASSERT(nm && pxop != PX_End);
+ if (debug) {
+ SprintfLiteral(buf, "LUL.DW DW_OP_%s\n", nm);
+ summ->Log(buf);
+ }
+ (void)summ->AddPfxInstr(PfxInstr(pxop));
+ break;
+
+ default:
+ if (debug) {
+ SprintfLiteral(buf, "LUL.DW unknown opc %d\n", (int)opc);
+ summ->Log(buf);
+ }
+ goto fail;
+
+ } // switch (opc)
+
+ } // while (cursor < end1)
+
+ MOZ_ASSERT(cursor >= end1);
+
+ if (cursor > end1) {
+ // We overran the Dwarf expression. Give up.
+ goto fail;
+ }
+
+ // For DW_CFA_expression, what the expression denotes is the address
+ // of where the previous value is located. The caller of this routine
+ // may therefore request one last dereference before the end marker is
+ // inserted.
+ if (derefAtEnd) {
+ (void)summ->AddPfxInstr(PfxInstr(PX_Deref));
+ }
+
+ // Insert an end marker, and declare success.
+ (void)summ->AddPfxInstr(PfxInstr(PX_End));
+ if (debug) {
+ SprintfLiteral(buf,
+ "LUL.DW conversion of dwarf expression succeeded, "
+ "ix = %d\n",
+ (int)start_ix);
+ summ->Log(buf);
+ summ->Log("LUL.DW >>\n");
+ }
+ return start_ix;
+
+fail:
+ if (debug) {
+ summ->Log("LUL.DW conversion of dwarf expression failed\n");
+ summ->Log("LUL.DW >>\n");
+ }
+ return -1;
+}
+
+bool DwarfCFIToModule::Entry(size_t offset, uint64 address, uint64 length,
+ uint8 version, const string& augmentation,
+ unsigned return_address) {
+ if (DEBUG_DWARF) {
+ char buf[100];
+ SprintfLiteral(buf, "LUL.DW DwarfCFIToModule::Entry 0x%llx,+%lld\n",
+ address, length);
+ summ_->Log(buf);
+ }
+
+ summ_->Entry(address, length);
+
+ // If dwarf2reader::CallFrameInfo can handle this version and
+ // augmentation, then we should be okay with that, so there's no
+ // need to check them here.
+
+ // Get ready to collect entries.
+ return_address_ = return_address;
+
+ // Breakpad STACK CFI records must provide a .ra rule, but DWARF CFI
+ // may not establish any rule for .ra if the return address column
+ // is an ordinary register, and that register holds the return
+ // address on entry to the function. So establish an initial .ra
+ // rule citing the return address register.
+ if (return_address_ < num_dw_regs_) {
+ summ_->Rule(address, return_address_, NODEREF, return_address, 0);
+ }
+
+ return true;
+}
+
+const UniqueString* DwarfCFIToModule::RegisterName(int i) {
+ if (i < 0) {
+ MOZ_ASSERT(i == kCFARegister);
+ return usu_->ToUniqueString(".cfa");
+ }
+ unsigned reg = i;
+ if (reg == return_address_) return usu_->ToUniqueString(".ra");
+
+ char buf[30];
+ SprintfLiteral(buf, "dwarf_reg_%u", reg);
+ return usu_->ToUniqueString(buf);
+}
+
+bool DwarfCFIToModule::UndefinedRule(uint64 address, int reg) {
+ reporter_->UndefinedNotSupported(entry_offset_, RegisterName(reg));
+ // Treat this as a non-fatal error.
+ return true;
+}
+
+bool DwarfCFIToModule::SameValueRule(uint64 address, int reg) {
+ if (DEBUG_DWARF) {
+ char buf[100];
+ SprintfLiteral(buf, "LUL.DW 0x%llx: old r%d = Same\n", address, reg);
+ summ_->Log(buf);
+ }
+ // reg + 0
+ summ_->Rule(address, reg, NODEREF, reg, 0);
+ return true;
+}
+
+bool DwarfCFIToModule::OffsetRule(uint64 address, int reg, int base_register,
+ long offset) {
+ if (DEBUG_DWARF) {
+ char buf[100];
+ SprintfLiteral(buf, "LUL.DW 0x%llx: old r%d = *(r%d + %ld)\n", address,
+ reg, base_register, offset);
+ summ_->Log(buf);
+ }
+ // *(base_register + offset)
+ summ_->Rule(address, reg, DEREF, base_register, offset);
+ return true;
+}
+
+bool DwarfCFIToModule::ValOffsetRule(uint64 address, int reg, int base_register,
+ long offset) {
+ if (DEBUG_DWARF) {
+ char buf[100];
+ SprintfLiteral(buf, "LUL.DW 0x%llx: old r%d = r%d + %ld\n", address, reg,
+ base_register, offset);
+ summ_->Log(buf);
+ }
+ // base_register + offset
+ summ_->Rule(address, reg, NODEREF, base_register, offset);
+ return true;
+}
+
+bool DwarfCFIToModule::RegisterRule(uint64 address, int reg,
+ int base_register) {
+ if (DEBUG_DWARF) {
+ char buf[100];
+ SprintfLiteral(buf, "LUL.DW 0x%llx: old r%d = r%d\n", address, reg,
+ base_register);
+ summ_->Log(buf);
+ }
+ // base_register + 0
+ summ_->Rule(address, reg, NODEREF, base_register, 0);
+ return true;
+}
+
+bool DwarfCFIToModule::ExpressionRule(uint64 address, int reg,
+ const string& expression) {
+ bool debug = !!DEBUG_DWARF;
+ int32_t start_ix =
+ parseDwarfExpr(summ_, reader_, expression, debug, true /*pushCfaAtStart*/,
+ true /*derefAtEnd*/);
+ if (start_ix >= 0) {
+ summ_->Rule(address, reg, PFXEXPR, 0, start_ix);
+ } else {
+ // Parsing of the Dwarf expression failed. Treat this as a
+ // non-fatal error, hence return |true| even on this path.
+ reporter_->ExpressionCouldNotBeSummarised(entry_offset_, RegisterName(reg));
+ }
+ return true;
+}
+
+bool DwarfCFIToModule::ValExpressionRule(uint64 address, int reg,
+ const string& expression) {
+ bool debug = !!DEBUG_DWARF;
+ int32_t start_ix =
+ parseDwarfExpr(summ_, reader_, expression, debug, true /*pushCfaAtStart*/,
+ false /*!derefAtEnd*/);
+ if (start_ix >= 0) {
+ summ_->Rule(address, reg, PFXEXPR, 0, start_ix);
+ } else {
+ // Parsing of the Dwarf expression failed. Treat this as a
+ // non-fatal error, hence return |true| even on this path.
+ reporter_->ExpressionCouldNotBeSummarised(entry_offset_, RegisterName(reg));
+ }
+ return true;
+}
+
+bool DwarfCFIToModule::End() {
+ // module_->AddStackFrameEntry(entry_);
+ if (DEBUG_DWARF) {
+ summ_->Log("LUL.DW DwarfCFIToModule::End()\n");
+ }
+ summ_->End();
+ return true;
+}
+
+void DwarfCFIToModule::Reporter::UndefinedNotSupported(
+ size_t offset, const UniqueString* reg) {
+ char buf[300];
+ SprintfLiteral(buf, "DwarfCFIToModule::Reporter::UndefinedNotSupported()\n");
+ log_(buf);
+ // BPLOG(INFO) << file_ << ", section '" << section_
+ // << "': the call frame entry at offset 0x"
+ // << std::setbase(16) << offset << std::setbase(10)
+ // << " sets the rule for register '" << FromUniqueString(reg)
+ // << "' to 'undefined', but the Breakpad symbol file format cannot "
+ // << " express this";
+}
+
+// FIXME: move this somewhere sensible
+static bool is_power_of_2(uint64_t n) {
+ int i, nSetBits = 0;
+ for (i = 0; i < 8 * (int)sizeof(n); i++) {
+ if ((n & ((uint64_t)1) << i) != 0) nSetBits++;
+ }
+ return nSetBits <= 1;
+}
+
+void DwarfCFIToModule::Reporter::ExpressionCouldNotBeSummarised(
+ size_t offset, const UniqueString* reg) {
+ static uint64_t n_complaints = 0; // This isn't threadsafe
+ n_complaints++;
+ if (!is_power_of_2(n_complaints)) return;
+ char buf[300];
+ SprintfLiteral(buf,
+ "DwarfCFIToModule::Reporter::"
+ "ExpressionCouldNotBeSummarised(shown %llu times)\n",
+ (unsigned long long int)n_complaints);
+ log_(buf);
+}
+
+} // namespace lul
diff --git a/mozglue/baseprofiler/lul/LulDwarfExt.h b/mozglue/baseprofiler/lul/LulDwarfExt.h
new file mode 100644
index 0000000000..dcd2500e5a
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulDwarfExt.h
@@ -0,0 +1,1289 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+// Copyright 2006, 2010 Google Inc. 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.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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
+// OWNER 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.
+
+// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+
+// This file is derived from the following files in
+// toolkit/crashreporter/google-breakpad:
+// src/common/dwarf/types.h
+// src/common/dwarf/dwarf2enums.h
+// src/common/dwarf/bytereader.h
+// src/common/dwarf_cfi_to_module.h
+// src/common/dwarf/dwarf2reader.h
+
+#ifndef LulDwarfExt_h
+#define LulDwarfExt_h
+
+#include "LulDwarfSummariser.h"
+
+#include "mozilla/Assertions.h"
+
+#include <stdint.h>
+#include <string>
+
+typedef signed char int8;
+typedef short int16;
+typedef int int32;
+typedef long long int64;
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint32;
+typedef unsigned long long uint64;
+
+#ifdef __PTRDIFF_TYPE__
+typedef __PTRDIFF_TYPE__ intptr;
+typedef unsigned __PTRDIFF_TYPE__ uintptr;
+#else
+# error "Can't find pointer-sized integral types."
+#endif
+
+namespace lul {
+
+class UniqueString;
+
+// Exception handling frame description pointer formats, as described
+// by the Linux Standard Base Core Specification 4.0, section 11.5,
+// DWARF Extensions.
+enum DwarfPointerEncoding {
+ DW_EH_PE_absptr = 0x00,
+ DW_EH_PE_omit = 0xff,
+ DW_EH_PE_uleb128 = 0x01,
+ DW_EH_PE_udata2 = 0x02,
+ DW_EH_PE_udata4 = 0x03,
+ DW_EH_PE_udata8 = 0x04,
+ DW_EH_PE_sleb128 = 0x09,
+ DW_EH_PE_sdata2 = 0x0A,
+ DW_EH_PE_sdata4 = 0x0B,
+ DW_EH_PE_sdata8 = 0x0C,
+ DW_EH_PE_pcrel = 0x10,
+ DW_EH_PE_textrel = 0x20,
+ DW_EH_PE_datarel = 0x30,
+ DW_EH_PE_funcrel = 0x40,
+ DW_EH_PE_aligned = 0x50,
+
+ // The GNU toolchain sources define this enum value as well,
+ // simply to help classify the lower nybble values into signed and
+ // unsigned groups.
+ DW_EH_PE_signed = 0x08,
+
+ // This is not documented in LSB 4.0, but it is used in both the
+ // Linux and OS X toolchains. It can be added to any other
+ // encoding (except DW_EH_PE_aligned), and indicates that the
+ // encoded value represents the address at which the true address
+ // is stored, not the true address itself.
+ DW_EH_PE_indirect = 0x80
+};
+
+// We can't use the obvious name of LITTLE_ENDIAN and BIG_ENDIAN
+// because it conflicts with a macro
+enum Endianness { ENDIANNESS_BIG, ENDIANNESS_LITTLE };
+
+// A ByteReader knows how to read single- and multi-byte values of
+// various endiannesses, sizes, and encodings, as used in DWARF
+// debugging information and Linux C++ exception handling data.
+class ByteReader {
+ public:
+ // Construct a ByteReader capable of reading one-, two-, four-, and
+ // eight-byte values according to ENDIANNESS, absolute machine-sized
+ // addresses, DWARF-style "initial length" values, signed and
+ // unsigned LEB128 numbers, and Linux C++ exception handling data's
+ // encoded pointers.
+ explicit ByteReader(enum Endianness endianness);
+ virtual ~ByteReader();
+
+ // Read a single byte from BUFFER and return it as an unsigned 8 bit
+ // number.
+ uint8 ReadOneByte(const char* buffer) const;
+
+ // Read two bytes from BUFFER and return them as an unsigned 16 bit
+ // number, using this ByteReader's endianness.
+ uint16 ReadTwoBytes(const char* buffer) const;
+
+ // Read four bytes from BUFFER and return them as an unsigned 32 bit
+ // number, using this ByteReader's endianness. This function returns
+ // a uint64 so that it is compatible with ReadAddress and
+ // ReadOffset. The number it returns will never be outside the range
+ // of an unsigned 32 bit integer.
+ uint64 ReadFourBytes(const char* buffer) const;
+
+ // Read eight bytes from BUFFER and return them as an unsigned 64
+ // bit number, using this ByteReader's endianness.
+ uint64 ReadEightBytes(const char* buffer) const;
+
+ // Read an unsigned LEB128 (Little Endian Base 128) number from
+ // BUFFER and return it as an unsigned 64 bit integer. Set LEN to
+ // the number of bytes read.
+ //
+ // The unsigned LEB128 representation of an integer N is a variable
+ // number of bytes:
+ //
+ // - If N is between 0 and 0x7f, then its unsigned LEB128
+ // representation is a single byte whose value is N.
+ //
+ // - Otherwise, its unsigned LEB128 representation is (N & 0x7f) |
+ // 0x80, followed by the unsigned LEB128 representation of N /
+ // 128, rounded towards negative infinity.
+ //
+ // In other words, we break VALUE into groups of seven bits, put
+ // them in little-endian order, and then write them as eight-bit
+ // bytes with the high bit on all but the last.
+ uint64 ReadUnsignedLEB128(const char* buffer, size_t* len) const;
+
+ // Read a signed LEB128 number from BUFFER and return it as an
+ // signed 64 bit integer. Set LEN to the number of bytes read.
+ //
+ // The signed LEB128 representation of an integer N is a variable
+ // number of bytes:
+ //
+ // - If N is between -0x40 and 0x3f, then its signed LEB128
+ // representation is a single byte whose value is N in two's
+ // complement.
+ //
+ // - Otherwise, its signed LEB128 representation is (N & 0x7f) |
+ // 0x80, followed by the signed LEB128 representation of N / 128,
+ // rounded towards negative infinity.
+ //
+ // In other words, we break VALUE into groups of seven bits, put
+ // them in little-endian order, and then write them as eight-bit
+ // bytes with the high bit on all but the last.
+ int64 ReadSignedLEB128(const char* buffer, size_t* len) const;
+
+ // Indicate that addresses on this architecture are SIZE bytes long. SIZE
+ // must be either 4 or 8. (DWARF allows addresses to be any number of
+ // bytes in length from 1 to 255, but we only support 32- and 64-bit
+ // addresses at the moment.) You must call this before using the
+ // ReadAddress member function.
+ //
+ // For data in a .debug_info section, or something that .debug_info
+ // refers to like line number or macro data, the compilation unit
+ // header's address_size field indicates the address size to use. Call
+ // frame information doesn't indicate its address size (a shortcoming of
+ // the spec); you must supply the appropriate size based on the
+ // architecture of the target machine.
+ void SetAddressSize(uint8 size);
+
+ // Return the current address size, in bytes. This is either 4,
+ // indicating 32-bit addresses, or 8, indicating 64-bit addresses.
+ uint8 AddressSize() const { return address_size_; }
+
+ // Read an address from BUFFER and return it as an unsigned 64 bit
+ // integer, respecting this ByteReader's endianness and address size. You
+ // must call SetAddressSize before calling this function.
+ uint64 ReadAddress(const char* buffer) const;
+
+ // DWARF actually defines two slightly different formats: 32-bit DWARF
+ // and 64-bit DWARF. This is *not* related to the size of registers or
+ // addresses on the target machine; it refers only to the size of section
+ // offsets and data lengths appearing in the DWARF data. One only needs
+ // 64-bit DWARF when the debugging data itself is larger than 4GiB.
+ // 32-bit DWARF can handle x86_64 or PPC64 code just fine, unless the
+ // debugging data itself is very large.
+ //
+ // DWARF information identifies itself as 32-bit or 64-bit DWARF: each
+ // compilation unit and call frame information entry begins with an
+ // "initial length" field, which, in addition to giving the length of the
+ // data, also indicates the size of section offsets and lengths appearing
+ // in that data. The ReadInitialLength member function, below, reads an
+ // initial length and sets the ByteReader's offset size as a side effect.
+ // Thus, in the normal process of reading DWARF data, the appropriate
+ // offset size is set automatically. So, you should only need to call
+ // SetOffsetSize if you are using the same ByteReader to jump from the
+ // midst of one block of DWARF data into another.
+
+ // Read a DWARF "initial length" field from START, and return it as
+ // an unsigned 64 bit integer, respecting this ByteReader's
+ // endianness. Set *LEN to the length of the initial length in
+ // bytes, either four or twelve. As a side effect, set this
+ // ByteReader's offset size to either 4 (if we see a 32-bit DWARF
+ // initial length) or 8 (if we see a 64-bit DWARF initial length).
+ //
+ // A DWARF initial length is either:
+ //
+ // - a byte count stored as an unsigned 32-bit value less than
+ // 0xffffff00, indicating that the data whose length is being
+ // measured uses the 32-bit DWARF format, or
+ //
+ // - The 32-bit value 0xffffffff, followed by a 64-bit byte count,
+ // indicating that the data whose length is being measured uses
+ // the 64-bit DWARF format.
+ uint64 ReadInitialLength(const char* start, size_t* len);
+
+ // Read an offset from BUFFER and return it as an unsigned 64 bit
+ // integer, respecting the ByteReader's endianness. In 32-bit DWARF, the
+ // offset is 4 bytes long; in 64-bit DWARF, the offset is eight bytes
+ // long. You must call ReadInitialLength or SetOffsetSize before calling
+ // this function; see the comments above for details.
+ uint64 ReadOffset(const char* buffer) const;
+
+ // Return the current offset size, in bytes.
+ // A return value of 4 indicates that we are reading 32-bit DWARF.
+ // A return value of 8 indicates that we are reading 64-bit DWARF.
+ uint8 OffsetSize() const { return offset_size_; }
+
+ // Indicate that section offsets and lengths are SIZE bytes long. SIZE
+ // must be either 4 (meaning 32-bit DWARF) or 8 (meaning 64-bit DWARF).
+ // Usually, you should not call this function yourself; instead, let a
+ // call to ReadInitialLength establish the data's offset size
+ // automatically.
+ void SetOffsetSize(uint8 size);
+
+ // The Linux C++ ABI uses a variant of DWARF call frame information
+ // for exception handling. This data is included in the program's
+ // address space as the ".eh_frame" section, and intepreted at
+ // runtime to walk the stack, find exception handlers, and run
+ // cleanup code. The format is mostly the same as DWARF CFI, with
+ // some adjustments made to provide the additional
+ // exception-handling data, and to make the data easier to work with
+ // in memory --- for example, to allow it to be placed in read-only
+ // memory even when describing position-independent code.
+ //
+ // In particular, exception handling data can select a number of
+ // different encodings for pointers that appear in the data, as
+ // described by the DwarfPointerEncoding enum. There are actually
+ // four axes(!) to the encoding:
+ //
+ // - The pointer size: pointers can be 2, 4, or 8 bytes long, or use
+ // the DWARF LEB128 encoding.
+ //
+ // - The pointer's signedness: pointers can be signed or unsigned.
+ //
+ // - The pointer's base address: the data stored in the exception
+ // handling data can be the actual address (that is, an absolute
+ // pointer), or relative to one of a number of different base
+ // addreses --- including that of the encoded pointer itself, for
+ // a form of "pc-relative" addressing.
+ //
+ // - The pointer may be indirect: it may be the address where the
+ // true pointer is stored. (This is used to refer to things via
+ // global offset table entries, program linkage table entries, or
+ // other tricks used in position-independent code.)
+ //
+ // There are also two options that fall outside that matrix
+ // altogether: the pointer may be omitted, or it may have padding to
+ // align it on an appropriate address boundary. (That last option
+ // may seem like it should be just another axis, but it is not.)
+
+ // Indicate that the exception handling data is loaded starting at
+ // SECTION_BASE, and that the start of its buffer in our own memory
+ // is BUFFER_BASE. This allows us to find the address that a given
+ // byte in our buffer would have when loaded into the program the
+ // data describes. We need this to resolve DW_EH_PE_pcrel pointers.
+ void SetCFIDataBase(uint64 section_base, const char* buffer_base);
+
+ // Indicate that the base address of the program's ".text" section
+ // is TEXT_BASE. We need this to resolve DW_EH_PE_textrel pointers.
+ void SetTextBase(uint64 text_base);
+
+ // Indicate that the base address for DW_EH_PE_datarel pointers is
+ // DATA_BASE. The proper value depends on the ABI; it is usually the
+ // address of the global offset table, held in a designated register in
+ // position-independent code. You will need to look at the startup code
+ // for the target system to be sure. I tried; my eyes bled.
+ void SetDataBase(uint64 data_base);
+
+ // Indicate that the base address for the FDE we are processing is
+ // FUNCTION_BASE. This is the start address of DW_EH_PE_funcrel
+ // pointers. (This encoding does not seem to be used by the GNU
+ // toolchain.)
+ void SetFunctionBase(uint64 function_base);
+
+ // Indicate that we are no longer processing any FDE, so any use of
+ // a DW_EH_PE_funcrel encoding is an error.
+ void ClearFunctionBase();
+
+ // Return true if ENCODING is a valid pointer encoding.
+ bool ValidEncoding(DwarfPointerEncoding encoding) const;
+
+ // Return true if we have all the information we need to read a
+ // pointer that uses ENCODING. This checks that the appropriate
+ // SetFooBase function for ENCODING has been called.
+ bool UsableEncoding(DwarfPointerEncoding encoding) const;
+
+ // Read an encoded pointer from BUFFER using ENCODING; return the
+ // absolute address it represents, and set *LEN to the pointer's
+ // length in bytes, including any padding for aligned pointers.
+ //
+ // This function calls 'abort' if ENCODING is invalid or refers to a
+ // base address this reader hasn't been given, so you should check
+ // with ValidEncoding and UsableEncoding first if you would rather
+ // die in a more helpful way.
+ uint64 ReadEncodedPointer(const char* buffer, DwarfPointerEncoding encoding,
+ size_t* len) const;
+
+ private:
+ // Function pointer type for our address and offset readers.
+ typedef uint64 (ByteReader::*AddressReader)(const char*) const;
+
+ // Read an offset from BUFFER and return it as an unsigned 64 bit
+ // integer. DWARF2/3 define offsets as either 4 or 8 bytes,
+ // generally depending on the amount of DWARF2/3 info present.
+ // This function pointer gets set by SetOffsetSize.
+ AddressReader offset_reader_;
+
+ // Read an address from BUFFER and return it as an unsigned 64 bit
+ // integer. DWARF2/3 allow addresses to be any size from 0-255
+ // bytes currently. Internally we support 4 and 8 byte addresses,
+ // and will CHECK on anything else.
+ // This function pointer gets set by SetAddressSize.
+ AddressReader address_reader_;
+
+ Endianness endian_;
+ uint8 address_size_;
+ uint8 offset_size_;
+
+ // Base addresses for Linux C++ exception handling data's encoded pointers.
+ bool have_section_base_, have_text_base_, have_data_base_;
+ bool have_function_base_;
+ uint64 section_base_;
+ uint64 text_base_, data_base_, function_base_;
+ const char* buffer_base_;
+};
+
+inline uint8 ByteReader::ReadOneByte(const char* buffer) const {
+ return buffer[0];
+}
+
+inline uint16 ByteReader::ReadTwoBytes(const char* signed_buffer) const {
+ const unsigned char* buffer =
+ reinterpret_cast<const unsigned char*>(signed_buffer);
+ const uint16 buffer0 = buffer[0];
+ const uint16 buffer1 = buffer[1];
+ if (endian_ == ENDIANNESS_LITTLE) {
+ return buffer0 | buffer1 << 8;
+ } else {
+ return buffer1 | buffer0 << 8;
+ }
+}
+
+inline uint64 ByteReader::ReadFourBytes(const char* signed_buffer) const {
+ const unsigned char* buffer =
+ reinterpret_cast<const unsigned char*>(signed_buffer);
+ const uint32 buffer0 = buffer[0];
+ const uint32 buffer1 = buffer[1];
+ const uint32 buffer2 = buffer[2];
+ const uint32 buffer3 = buffer[3];
+ if (endian_ == ENDIANNESS_LITTLE) {
+ return buffer0 | buffer1 << 8 | buffer2 << 16 | buffer3 << 24;
+ } else {
+ return buffer3 | buffer2 << 8 | buffer1 << 16 | buffer0 << 24;
+ }
+}
+
+inline uint64 ByteReader::ReadEightBytes(const char* signed_buffer) const {
+ const unsigned char* buffer =
+ reinterpret_cast<const unsigned char*>(signed_buffer);
+ const uint64 buffer0 = buffer[0];
+ const uint64 buffer1 = buffer[1];
+ const uint64 buffer2 = buffer[2];
+ const uint64 buffer3 = buffer[3];
+ const uint64 buffer4 = buffer[4];
+ const uint64 buffer5 = buffer[5];
+ const uint64 buffer6 = buffer[6];
+ const uint64 buffer7 = buffer[7];
+ if (endian_ == ENDIANNESS_LITTLE) {
+ return buffer0 | buffer1 << 8 | buffer2 << 16 | buffer3 << 24 |
+ buffer4 << 32 | buffer5 << 40 | buffer6 << 48 | buffer7 << 56;
+ } else {
+ return buffer7 | buffer6 << 8 | buffer5 << 16 | buffer4 << 24 |
+ buffer3 << 32 | buffer2 << 40 | buffer1 << 48 | buffer0 << 56;
+ }
+}
+
+// Read an unsigned LEB128 number. Each byte contains 7 bits of
+// information, plus one bit saying whether the number continues or
+// not.
+
+inline uint64 ByteReader::ReadUnsignedLEB128(const char* buffer,
+ size_t* len) const {
+ uint64 result = 0;
+ size_t num_read = 0;
+ unsigned int shift = 0;
+ unsigned char byte;
+
+ do {
+ byte = *buffer++;
+ num_read++;
+
+ result |= (static_cast<uint64>(byte & 0x7f)) << shift;
+
+ shift += 7;
+
+ } while (byte & 0x80);
+
+ *len = num_read;
+
+ return result;
+}
+
+// Read a signed LEB128 number. These are like regular LEB128
+// numbers, except the last byte may have a sign bit set.
+
+inline int64 ByteReader::ReadSignedLEB128(const char* buffer,
+ size_t* len) const {
+ int64 result = 0;
+ unsigned int shift = 0;
+ size_t num_read = 0;
+ unsigned char byte;
+
+ do {
+ byte = *buffer++;
+ num_read++;
+ result |= (static_cast<uint64>(byte & 0x7f) << shift);
+ shift += 7;
+ } while (byte & 0x80);
+
+ if ((shift < 8 * sizeof(result)) && (byte & 0x40))
+ result |= -((static_cast<int64>(1)) << shift);
+ *len = num_read;
+ return result;
+}
+
+inline uint64 ByteReader::ReadOffset(const char* buffer) const {
+ MOZ_ASSERT(this->offset_reader_);
+ return (this->*offset_reader_)(buffer);
+}
+
+inline uint64 ByteReader::ReadAddress(const char* buffer) const {
+ MOZ_ASSERT(this->address_reader_);
+ return (this->*address_reader_)(buffer);
+}
+
+inline void ByteReader::SetCFIDataBase(uint64 section_base,
+ const char* buffer_base) {
+ section_base_ = section_base;
+ buffer_base_ = buffer_base;
+ have_section_base_ = true;
+}
+
+inline void ByteReader::SetTextBase(uint64 text_base) {
+ text_base_ = text_base;
+ have_text_base_ = true;
+}
+
+inline void ByteReader::SetDataBase(uint64 data_base) {
+ data_base_ = data_base;
+ have_data_base_ = true;
+}
+
+inline void ByteReader::SetFunctionBase(uint64 function_base) {
+ function_base_ = function_base;
+ have_function_base_ = true;
+}
+
+inline void ByteReader::ClearFunctionBase() { have_function_base_ = false; }
+
+// (derived from)
+// dwarf_cfi_to_module.h: Define the DwarfCFIToModule class, which
+// accepts parsed DWARF call frame info and adds it to a Summariser object.
+
+// This class is a reader for DWARF's Call Frame Information. CFI
+// describes how to unwind stack frames --- even for functions that do
+// not follow fixed conventions for saving registers, whose frame size
+// varies as they execute, etc.
+//
+// CFI describes, at each machine instruction, how to compute the
+// stack frame's base address, how to find the return address, and
+// where to find the saved values of the caller's registers (if the
+// callee has stashed them somewhere to free up the registers for its
+// own use).
+//
+// For example, suppose we have a function whose machine code looks
+// like this (imagine an assembly language that looks like C, for a
+// machine with 32-bit registers, and a stack that grows towards lower
+// addresses):
+//
+// func: ; entry point; return address at sp
+// func+0: sp = sp - 16 ; allocate space for stack frame
+// func+1: sp[12] = r0 ; save r0 at sp+12
+// ... ; other code, not frame-related
+// func+10: sp -= 4; *sp = x ; push some x on the stack
+// ... ; other code, not frame-related
+// func+20: r0 = sp[16] ; restore saved r0
+// func+21: sp += 20 ; pop whole stack frame
+// func+22: pc = *sp; sp += 4 ; pop return address and jump to it
+//
+// DWARF CFI is (a very compressed representation of) a table with a
+// row for each machine instruction address and a column for each
+// register showing how to restore it, if possible.
+//
+// A special column named "CFA", for "Canonical Frame Address", tells how
+// to compute the base address of the frame; registers' entries may
+// refer to the CFA in describing where the registers are saved.
+//
+// Another special column, named "RA", represents the return address.
+//
+// For example, here is a complete (uncompressed) table describing the
+// function above:
+//
+// insn cfa r0 r1 ... ra
+// =======================================
+// func+0: sp cfa[0]
+// func+1: sp+16 cfa[0]
+// func+2: sp+16 cfa[-4] cfa[0]
+// func+11: sp+20 cfa[-4] cfa[0]
+// func+21: sp+20 cfa[0]
+// func+22: sp cfa[0]
+//
+// Some things to note here:
+//
+// - Each row describes the state of affairs *before* executing the
+// instruction at the given address. Thus, the row for func+0
+// describes the state before we allocate the stack frame. In the
+// next row, the formula for computing the CFA has changed,
+// reflecting that allocation.
+//
+// - The other entries are written in terms of the CFA; this allows
+// them to remain unchanged as the stack pointer gets bumped around.
+// For example, the rule for recovering the return address (the "ra"
+// column) remains unchanged throughout the function, even as the
+// stack pointer takes on three different offsets from the return
+// address.
+//
+// - Although we haven't shown it, most calling conventions designate
+// "callee-saves" and "caller-saves" registers. The callee must
+// preserve the values of callee-saves registers; if it uses them,
+// it must save their original values somewhere, and restore them
+// before it returns. In contrast, the callee is free to trash
+// caller-saves registers; if the callee uses these, it will
+// probably not bother to save them anywhere, and the CFI will
+// probably mark their values as "unrecoverable".
+//
+// (However, since the caller cannot assume the callee was going to
+// save them, caller-saves registers are probably dead in the caller
+// anyway, so compilers usually don't generate CFA for caller-saves
+// registers.)
+//
+// - Exactly where the CFA points is a matter of convention that
+// depends on the architecture and ABI in use. In the example, the
+// CFA is the value the stack pointer had upon entry to the
+// function, pointing at the saved return address. But on the x86,
+// the call frame information generated by GCC follows the
+// convention that the CFA is the address *after* the saved return
+// address.
+//
+// But by definition, the CFA remains constant throughout the
+// lifetime of the frame. This makes it a useful value for other
+// columns to refer to. It is also gives debuggers a useful handle
+// for identifying a frame.
+//
+// If you look at the table above, you'll notice that a given entry is
+// often the same as the one immediately above it: most instructions
+// change only one or two aspects of the stack frame, if they affect
+// it at all. The DWARF format takes advantage of this fact, and
+// reduces the size of the data by mentioning only the addresses and
+// columns at which changes take place. So for the above, DWARF CFI
+// data would only actually mention the following:
+//
+// insn cfa r0 r1 ... ra
+// =======================================
+// func+0: sp cfa[0]
+// func+1: sp+16
+// func+2: cfa[-4]
+// func+11: sp+20
+// func+21: r0
+// func+22: sp
+//
+// In fact, this is the way the parser reports CFI to the consumer: as
+// a series of statements of the form, "At address X, column Y changed
+// to Z," and related conventions for describing the initial state.
+//
+// Naturally, it would be impractical to have to scan the entire
+// program's CFI, noting changes as we go, just to recover the
+// unwinding rules in effect at one particular instruction. To avoid
+// this, CFI data is grouped into "entries", each of which covers a
+// specified range of addresses and begins with a complete statement
+// of the rules for all recoverable registers at that starting
+// address. Each entry typically covers a single function.
+//
+// Thus, to compute the contents of a given row of the table --- that
+// is, rules for recovering the CFA, RA, and registers at a given
+// instruction --- the consumer should find the entry that covers that
+// instruction's address, start with the initial state supplied at the
+// beginning of the entry, and work forward until it has processed all
+// the changes up to and including those for the present instruction.
+//
+// There are seven kinds of rules that can appear in an entry of the
+// table:
+//
+// - "undefined": The given register is not preserved by the callee;
+// its value cannot be recovered.
+//
+// - "same value": This register has the same value it did in the callee.
+//
+// - offset(N): The register is saved at offset N from the CFA.
+//
+// - val_offset(N): The value the register had in the caller is the
+// CFA plus offset N. (This is usually only useful for describing
+// the stack pointer.)
+//
+// - register(R): The register's value was saved in another register R.
+//
+// - expression(E): Evaluating the DWARF expression E using the
+// current frame's registers' values yields the address at which the
+// register was saved.
+//
+// - val_expression(E): Evaluating the DWARF expression E using the
+// current frame's registers' values yields the value the register
+// had in the caller.
+
+class CallFrameInfo {
+ public:
+ // The different kinds of entries one finds in CFI. Used internally,
+ // and for error reporting.
+ enum EntryKind { kUnknown, kCIE, kFDE, kTerminator };
+
+ // The handler class to which the parser hands the parsed call frame
+ // information. Defined below.
+ class Handler;
+
+ // A reporter class, which CallFrameInfo uses to report errors
+ // encountered while parsing call frame information. Defined below.
+ class Reporter;
+
+ // Create a DWARF CFI parser. BUFFER points to the contents of the
+ // .debug_frame section to parse; BUFFER_LENGTH is its length in bytes.
+ // REPORTER is an error reporter the parser should use to report
+ // problems. READER is a ByteReader instance that has the endianness and
+ // address size set properly. Report the data we find to HANDLER.
+ //
+ // This class can also parse Linux C++ exception handling data, as found
+ // in '.eh_frame' sections. This data is a variant of DWARF CFI that is
+ // placed in loadable segments so that it is present in the program's
+ // address space, and is interpreted by the C++ runtime to search the
+ // call stack for a handler interested in the exception being thrown,
+ // actually pop the frames, and find cleanup code to run.
+ //
+ // There are two differences between the call frame information described
+ // in the DWARF standard and the exception handling data Linux places in
+ // the .eh_frame section:
+ //
+ // - Exception handling data uses uses a different format for call frame
+ // information entry headers. The distinguished CIE id, the way FDEs
+ // refer to their CIEs, and the way the end of the series of entries is
+ // determined are all slightly different.
+ //
+ // If the constructor's EH_FRAME argument is true, then the
+ // CallFrameInfo parses the entry headers as Linux C++ exception
+ // handling data. If EH_FRAME is false or omitted, the CallFrameInfo
+ // parses standard DWARF call frame information.
+ //
+ // - Linux C++ exception handling data uses CIE augmentation strings
+ // beginning with 'z' to specify the presence of additional data after
+ // the CIE and FDE headers and special encodings used for addresses in
+ // frame description entries.
+ //
+ // CallFrameInfo can handle 'z' augmentations in either DWARF CFI or
+ // exception handling data if you have supplied READER with the base
+ // addresses needed to interpret the pointer encodings that 'z'
+ // augmentations can specify. See the ByteReader interface for details
+ // about the base addresses. See the CallFrameInfo::Handler interface
+ // for details about the additional information one might find in
+ // 'z'-augmented data.
+ //
+ // Thus:
+ //
+ // - If you are parsing standard DWARF CFI, as found in a .debug_frame
+ // section, you should pass false for the EH_FRAME argument, or omit
+ // it, and you need not worry about providing READER with the
+ // additional base addresses.
+ //
+ // - If you want to parse Linux C++ exception handling data from a
+ // .eh_frame section, you should pass EH_FRAME as true, and call
+ // READER's Set*Base member functions before calling our Start method.
+ //
+ // - If you want to parse DWARF CFI that uses the 'z' augmentations
+ // (although I don't think any toolchain ever emits such data), you
+ // could pass false for EH_FRAME, but call READER's Set*Base members.
+ //
+ // The extensions the Linux C++ ABI makes to DWARF for exception
+ // handling are described here, rather poorly:
+ // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.html
+ // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
+ //
+ // The mechanics of C++ exception handling, personality routines,
+ // and language-specific data areas are described here, rather nicely:
+ // http://www.codesourcery.com/public/cxx-abi/abi-eh.html
+
+ CallFrameInfo(const char* buffer, size_t buffer_length, ByteReader* reader,
+ Handler* handler, Reporter* reporter, bool eh_frame = false)
+ : buffer_(buffer),
+ buffer_length_(buffer_length),
+ reader_(reader),
+ handler_(handler),
+ reporter_(reporter),
+ eh_frame_(eh_frame) {}
+
+ ~CallFrameInfo() {}
+
+ // Parse the entries in BUFFER, reporting what we find to HANDLER.
+ // Return true if we reach the end of the section successfully, or
+ // false if we encounter an error.
+ bool Start();
+
+ // Return the textual name of KIND. For error reporting.
+ static const char* KindName(EntryKind kind);
+
+ private:
+ struct CIE;
+
+ // A CFI entry, either an FDE or a CIE.
+ struct Entry {
+ // The starting offset of the entry in the section, for error
+ // reporting.
+ size_t offset;
+
+ // The start of this entry in the buffer.
+ const char* start;
+
+ // Which kind of entry this is.
+ //
+ // We want to be able to use this for error reporting even while we're
+ // in the midst of parsing. Error reporting code may assume that kind,
+ // offset, and start fields are valid, although kind may be kUnknown.
+ EntryKind kind;
+
+ // The end of this entry's common prologue (initial length and id), and
+ // the start of this entry's kind-specific fields.
+ const char* fields;
+
+ // The start of this entry's instructions.
+ const char* instructions;
+
+ // The address past the entry's last byte in the buffer. (Note that
+ // since offset points to the entry's initial length field, and the
+ // length field is the number of bytes after that field, this is not
+ // simply buffer_ + offset + length.)
+ const char* end;
+
+ // For both DWARF CFI and .eh_frame sections, this is the CIE id in a
+ // CIE, and the offset of the associated CIE in an FDE.
+ uint64 id;
+
+ // The CIE that applies to this entry, if we've parsed it. If this is a
+ // CIE, then this field points to this structure.
+ CIE* cie;
+ };
+
+ // A common information entry (CIE).
+ struct CIE : public Entry {
+ uint8 version; // CFI data version number
+ std::string augmentation; // vendor format extension markers
+ uint64 code_alignment_factor; // scale for code address adjustments
+ int data_alignment_factor; // scale for stack pointer adjustments
+ unsigned return_address_register; // which register holds the return addr
+
+ // True if this CIE includes Linux C++ ABI 'z' augmentation data.
+ bool has_z_augmentation;
+
+ // Parsed 'z' augmentation data. These are meaningful only if
+ // has_z_augmentation is true.
+ bool has_z_lsda; // The 'z' augmentation included 'L'.
+ bool has_z_personality; // The 'z' augmentation included 'P'.
+ bool has_z_signal_frame; // The 'z' augmentation included 'S'.
+
+ // If has_z_lsda is true, this is the encoding to be used for language-
+ // specific data area pointers in FDEs.
+ DwarfPointerEncoding lsda_encoding;
+
+ // If has_z_personality is true, this is the encoding used for the
+ // personality routine pointer in the augmentation data.
+ DwarfPointerEncoding personality_encoding;
+
+ // If has_z_personality is true, this is the address of the personality
+ // routine --- or, if personality_encoding & DW_EH_PE_indirect, the
+ // address where the personality routine's address is stored.
+ uint64 personality_address;
+
+ // This is the encoding used for addresses in the FDE header and
+ // in DW_CFA_set_loc instructions. This is always valid, whether
+ // or not we saw a 'z' augmentation string; its default value is
+ // DW_EH_PE_absptr, which is what normal DWARF CFI uses.
+ DwarfPointerEncoding pointer_encoding;
+ };
+
+ // A frame description entry (FDE).
+ struct FDE : public Entry {
+ uint64 address; // start address of described code
+ uint64 size; // size of described code, in bytes
+
+ // If cie->has_z_lsda is true, then this is the language-specific data
+ // area's address --- or its address's address, if cie->lsda_encoding
+ // has the DW_EH_PE_indirect bit set.
+ uint64 lsda_address;
+ };
+
+ // Internal use.
+ class Rule;
+ class UndefinedRule;
+ class SameValueRule;
+ class OffsetRule;
+ class ValOffsetRule;
+ class RegisterRule;
+ class ExpressionRule;
+ class ValExpressionRule;
+ class RuleMap;
+ class State;
+
+ // Parse the initial length and id of a CFI entry, either a CIE, an FDE,
+ // or a .eh_frame end-of-data mark. CURSOR points to the beginning of the
+ // data to parse. On success, populate ENTRY as appropriate, and return
+ // true. On failure, report the problem, and return false. Even if we
+ // return false, set ENTRY->end to the first byte after the entry if we
+ // were able to figure that out, or NULL if we weren't.
+ bool ReadEntryPrologue(const char* cursor, Entry* entry);
+
+ // Parse the fields of a CIE after the entry prologue, including any 'z'
+ // augmentation data. Assume that the 'Entry' fields of CIE are
+ // populated; use CIE->fields and CIE->end as the start and limit for
+ // parsing. On success, populate the rest of *CIE, and return true; on
+ // failure, report the problem and return false.
+ bool ReadCIEFields(CIE* cie);
+
+ // Parse the fields of an FDE after the entry prologue, including any 'z'
+ // augmentation data. Assume that the 'Entry' fields of *FDE are
+ // initialized; use FDE->fields and FDE->end as the start and limit for
+ // parsing. Assume that FDE->cie is fully initialized. On success,
+ // populate the rest of *FDE, and return true; on failure, report the
+ // problem and return false.
+ bool ReadFDEFields(FDE* fde);
+
+ // Report that ENTRY is incomplete, and return false. This is just a
+ // trivial wrapper for invoking reporter_->Incomplete; it provides a
+ // little brevity.
+ bool ReportIncomplete(Entry* entry);
+
+ // Return true if ENCODING has the DW_EH_PE_indirect bit set.
+ static bool IsIndirectEncoding(DwarfPointerEncoding encoding) {
+ return encoding & DW_EH_PE_indirect;
+ }
+
+ // The contents of the DWARF .debug_info section we're parsing.
+ const char* buffer_;
+ size_t buffer_length_;
+
+ // For reading multi-byte values with the appropriate endianness.
+ ByteReader* reader_;
+
+ // The handler to which we should report the data we find.
+ Handler* handler_;
+
+ // For reporting problems in the info we're parsing.
+ Reporter* reporter_;
+
+ // True if we are processing .eh_frame-format data.
+ bool eh_frame_;
+};
+
+// The handler class for CallFrameInfo. The a CFI parser calls the
+// member functions of a handler object to report the data it finds.
+class CallFrameInfo::Handler {
+ public:
+ // The pseudo-register number for the canonical frame address.
+ enum { kCFARegister = DW_REG_CFA };
+
+ Handler() {}
+ virtual ~Handler() {}
+
+ // The parser has found CFI for the machine code at ADDRESS,
+ // extending for LENGTH bytes. OFFSET is the offset of the frame
+ // description entry in the section, for use in error messages.
+ // VERSION is the version number of the CFI format. AUGMENTATION is
+ // a string describing any producer-specific extensions present in
+ // the data. RETURN_ADDRESS is the number of the register that holds
+ // the address to which the function should return.
+ //
+ // Entry should return true to process this CFI, or false to skip to
+ // the next entry.
+ //
+ // The parser invokes Entry for each Frame Description Entry (FDE)
+ // it finds. The parser doesn't report Common Information Entries
+ // to the handler explicitly; instead, if the handler elects to
+ // process a given FDE, the parser reiterates the appropriate CIE's
+ // contents at the beginning of the FDE's rules.
+ virtual bool Entry(size_t offset, uint64 address, uint64 length,
+ uint8 version, const std::string& augmentation,
+ unsigned return_address) = 0;
+
+ // When the Entry function returns true, the parser calls these
+ // handler functions repeatedly to describe the rules for recovering
+ // registers at each instruction in the given range of machine code.
+ // Immediately after a call to Entry, the handler should assume that
+ // the rule for each callee-saves register is "unchanged" --- that
+ // is, that the register still has the value it had in the caller.
+ //
+ // If a *Rule function returns true, we continue processing this entry's
+ // instructions. If a *Rule function returns false, we stop evaluating
+ // instructions, and skip to the next entry. Either way, we call End
+ // before going on to the next entry.
+ //
+ // In all of these functions, if the REG parameter is kCFARegister, then
+ // the rule describes how to find the canonical frame address.
+ // kCFARegister may be passed as a BASE_REGISTER argument, meaning that
+ // the canonical frame address should be used as the base address for the
+ // computation. All other REG values will be positive.
+
+ // At ADDRESS, register REG's value is not recoverable.
+ virtual bool UndefinedRule(uint64 address, int reg) = 0;
+
+ // At ADDRESS, register REG's value is the same as that it had in
+ // the caller.
+ virtual bool SameValueRule(uint64 address, int reg) = 0;
+
+ // At ADDRESS, register REG has been saved at offset OFFSET from
+ // BASE_REGISTER.
+ virtual bool OffsetRule(uint64 address, int reg, int base_register,
+ long offset) = 0;
+
+ // At ADDRESS, the caller's value of register REG is the current
+ // value of BASE_REGISTER plus OFFSET. (This rule doesn't provide an
+ // address at which the register's value is saved.)
+ virtual bool ValOffsetRule(uint64 address, int reg, int base_register,
+ long offset) = 0;
+
+ // At ADDRESS, register REG has been saved in BASE_REGISTER. This differs
+ // from ValOffsetRule(ADDRESS, REG, BASE_REGISTER, 0), in that
+ // BASE_REGISTER is the "home" for REG's saved value: if you want to
+ // assign to a variable whose home is REG in the calling frame, you
+ // should put the value in BASE_REGISTER.
+ virtual bool RegisterRule(uint64 address, int reg, int base_register) = 0;
+
+ // At ADDRESS, the DWARF expression EXPRESSION yields the address at
+ // which REG was saved.
+ virtual bool ExpressionRule(uint64 address, int reg,
+ const std::string& expression) = 0;
+
+ // At ADDRESS, the DWARF expression EXPRESSION yields the caller's
+ // value for REG. (This rule doesn't provide an address at which the
+ // register's value is saved.)
+ virtual bool ValExpressionRule(uint64 address, int reg,
+ const std::string& expression) = 0;
+
+ // Indicate that the rules for the address range reported by the
+ // last call to Entry are complete. End should return true if
+ // everything is okay, or false if an error has occurred and parsing
+ // should stop.
+ virtual bool End() = 0;
+
+ // Handler functions for Linux C++ exception handling data. These are
+ // only called if the data includes 'z' augmentation strings.
+
+ // The Linux C++ ABI uses an extension of the DWARF CFI format to
+ // walk the stack to propagate exceptions from the throw to the
+ // appropriate catch, and do the appropriate cleanups along the way.
+ // CFI entries used for exception handling have two additional data
+ // associated with them:
+ //
+ // - The "language-specific data area" describes which exception
+ // types the function has 'catch' clauses for, and indicates how
+ // to go about re-entering the function at the appropriate catch
+ // clause. If the exception is not caught, it describes the
+ // destructors that must run before the frame is popped.
+ //
+ // - The "personality routine" is responsible for interpreting the
+ // language-specific data area's contents, and deciding whether
+ // the exception should continue to propagate down the stack,
+ // perhaps after doing some cleanup for this frame, or whether the
+ // exception will be caught here.
+ //
+ // In principle, the language-specific data area is opaque to
+ // everybody but the personality routine. In practice, these values
+ // may be useful or interesting to readers with extra context, and
+ // we have to at least skip them anyway, so we might as well report
+ // them to the handler.
+
+ // This entry's exception handling personality routine's address is
+ // ADDRESS. If INDIRECT is true, then ADDRESS is the address at
+ // which the routine's address is stored. The default definition for
+ // this handler function simply returns true, allowing parsing of
+ // the entry to continue.
+ virtual bool PersonalityRoutine(uint64 address, bool indirect) {
+ return true;
+ }
+
+ // This entry's language-specific data area (LSDA) is located at
+ // ADDRESS. If INDIRECT is true, then ADDRESS is the address at
+ // which the area's address is stored. The default definition for
+ // this handler function simply returns true, allowing parsing of
+ // the entry to continue.
+ virtual bool LanguageSpecificDataArea(uint64 address, bool indirect) {
+ return true;
+ }
+
+ // This entry describes a signal trampoline --- this frame is the
+ // caller of a signal handler. The default definition for this
+ // handler function simply returns true, allowing parsing of the
+ // entry to continue.
+ //
+ // The best description of the rationale for and meaning of signal
+ // trampoline CFI entries seems to be in the GCC bug database:
+ // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=26208
+ virtual bool SignalHandler() { return true; }
+};
+
+// The CallFrameInfo class makes calls on an instance of this class to
+// report errors or warn about problems in the data it is parsing.
+// These messages are sent to the message sink |aLog| provided to the
+// constructor.
+class CallFrameInfo::Reporter {
+ public:
+ // Create an error reporter which attributes troubles to the section
+ // named SECTION in FILENAME.
+ //
+ // Normally SECTION would be .debug_frame, but the Mac puts CFI data
+ // in a Mach-O section named __debug_frame. If we support
+ // Linux-style exception handling data, we could be reading an
+ // .eh_frame section.
+ Reporter(void (*aLog)(const char*), const std::string& filename,
+ const std::string& section = ".debug_frame")
+ : log_(aLog), filename_(filename), section_(section) {}
+ virtual ~Reporter() {}
+
+ // The CFI entry at OFFSET ends too early to be well-formed. KIND
+ // indicates what kind of entry it is; KIND can be kUnknown if we
+ // haven't parsed enough of the entry to tell yet.
+ virtual void Incomplete(uint64 offset, CallFrameInfo::EntryKind kind);
+
+ // The .eh_frame data has a four-byte zero at OFFSET where the next
+ // entry's length would be; this is a terminator. However, the buffer
+ // length as given to the CallFrameInfo constructor says there should be
+ // more data.
+ virtual void EarlyEHTerminator(uint64 offset);
+
+ // The FDE at OFFSET refers to the CIE at CIE_OFFSET, but the
+ // section is not that large.
+ virtual void CIEPointerOutOfRange(uint64 offset, uint64 cie_offset);
+
+ // The FDE at OFFSET refers to the CIE at CIE_OFFSET, but the entry
+ // there is not a CIE.
+ virtual void BadCIEId(uint64 offset, uint64 cie_offset);
+
+ // The FDE at OFFSET refers to a CIE with version number VERSION,
+ // which we don't recognize. We cannot parse DWARF CFI if it uses
+ // a version number we don't recognize.
+ virtual void UnrecognizedVersion(uint64 offset, int version);
+
+ // The FDE at OFFSET refers to a CIE with augmentation AUGMENTATION,
+ // which we don't recognize. We cannot parse DWARF CFI if it uses
+ // augmentations we don't recognize.
+ virtual void UnrecognizedAugmentation(uint64 offset,
+ const std::string& augmentation);
+
+ // The FDE at OFFSET contains an invalid or otherwise unusable Dwarf4
+ // specific field (currently, only "address_size" or "segment_size").
+ // Parsing DWARF CFI with unexpected values here seems dubious at best,
+ // so we stop. WHAT gives a little more information about what is wrong.
+ virtual void InvalidDwarf4Artefact(uint64 offset, const char* what);
+
+ // The pointer encoding ENCODING, specified by the CIE at OFFSET, is not
+ // a valid encoding.
+ virtual void InvalidPointerEncoding(uint64 offset, uint8 encoding);
+
+ // The pointer encoding ENCODING, specified by the CIE at OFFSET, depends
+ // on a base address which has not been supplied.
+ virtual void UnusablePointerEncoding(uint64 offset, uint8 encoding);
+
+ // The CIE at OFFSET contains a DW_CFA_restore instruction at
+ // INSN_OFFSET, which may not appear in a CIE.
+ virtual void RestoreInCIE(uint64 offset, uint64 insn_offset);
+
+ // The entry at OFFSET, of kind KIND, has an unrecognized
+ // instruction at INSN_OFFSET.
+ virtual void BadInstruction(uint64 offset, CallFrameInfo::EntryKind kind,
+ uint64 insn_offset);
+
+ // The instruction at INSN_OFFSET in the entry at OFFSET, of kind
+ // KIND, establishes a rule that cites the CFA, but we have not
+ // established a CFA rule yet.
+ virtual void NoCFARule(uint64 offset, CallFrameInfo::EntryKind kind,
+ uint64 insn_offset);
+
+ // The instruction at INSN_OFFSET in the entry at OFFSET, of kind
+ // KIND, is a DW_CFA_restore_state instruction, but the stack of
+ // saved states is empty.
+ virtual void EmptyStateStack(uint64 offset, CallFrameInfo::EntryKind kind,
+ uint64 insn_offset);
+
+ // The DW_CFA_remember_state instruction at INSN_OFFSET in the entry
+ // at OFFSET, of kind KIND, would restore a state that has no CFA
+ // rule, whereas the current state does have a CFA rule. This is
+ // bogus input, which the CallFrameInfo::Handler interface doesn't
+ // (and shouldn't) have any way to report.
+ virtual void ClearingCFARule(uint64 offset, CallFrameInfo::EntryKind kind,
+ uint64 insn_offset);
+
+ private:
+ // A logging sink function, as supplied by LUL's user.
+ void (*log_)(const char*);
+
+ protected:
+ // The name of the file whose CFI we're reading.
+ std::string filename_;
+
+ // The name of the CFI section in that file.
+ std::string section_;
+};
+
+using lul::CallFrameInfo;
+using lul::Summariser;
+
+// A class that accepts parsed call frame information from the DWARF
+// CFI parser and populates a google_breakpad::Module object with the
+// contents.
+class DwarfCFIToModule : public CallFrameInfo::Handler {
+ public:
+ // DwarfCFIToModule uses an instance of this class to report errors
+ // detected while converting DWARF CFI to Breakpad STACK CFI records.
+ class Reporter {
+ public:
+ // Create a reporter that writes messages to the message sink
+ // |aLog|. FILE is the name of the file we're processing, and
+ // SECTION is the name of the section within that file that we're
+ // looking at (.debug_frame, .eh_frame, etc.).
+ Reporter(void (*aLog)(const char*), const std::string& file,
+ const std::string& section)
+ : log_(aLog), file_(file), section_(section) {}
+ virtual ~Reporter() {}
+
+ // The DWARF CFI entry at OFFSET says that REG is undefined, but the
+ // Breakpad symbol file format cannot express this.
+ virtual void UndefinedNotSupported(size_t offset, const UniqueString* reg);
+
+ // The DWARF CFI entry at OFFSET says that REG uses a DWARF
+ // expression to find its value, but parseDwarfExpr could not
+ // convert it to a sequence of PfxInstrs.
+ virtual void ExpressionCouldNotBeSummarised(size_t offset,
+ const UniqueString* reg);
+
+ private:
+ // A logging sink function, as supplied by LUL's user.
+ void (*log_)(const char*);
+
+ protected:
+ std::string file_, section_;
+ };
+
+ // Register name tables. If TABLE is a vector returned by one of these
+ // functions, then TABLE[R] is the name of the register numbered R in
+ // DWARF call frame information.
+ class RegisterNames {
+ public:
+ // Intel's "x86" or IA-32.
+ static unsigned int I386();
+
+ // AMD x86_64, AMD64, Intel EM64T, or Intel 64
+ static unsigned int X86_64();
+
+ // ARM.
+ static unsigned int ARM();
+
+ // AARCH64.
+ static unsigned int ARM64();
+
+ // MIPS.
+ static unsigned int MIPS();
+ };
+
+ // Create a handler for the dwarf2reader::CallFrameInfo parser that
+ // records the stack unwinding information it receives in SUMM.
+ //
+ // Use REGISTER_NAMES[I] as the name of register number I; *this
+ // keeps a reference to the vector, so the vector should remain
+ // alive for as long as the DwarfCFIToModule does.
+ //
+ // Use REPORTER for reporting problems encountered in the conversion
+ // process.
+ DwarfCFIToModule(const unsigned int num_dw_regs, Reporter* reporter,
+ ByteReader* reader,
+ /*MOD*/ UniqueStringUniverse* usu,
+ /*OUT*/ Summariser* summ)
+ : summ_(summ),
+ usu_(usu),
+ num_dw_regs_(num_dw_regs),
+ reporter_(reporter),
+ reader_(reader),
+ return_address_(-1) {}
+ virtual ~DwarfCFIToModule() {}
+
+ virtual bool Entry(size_t offset, uint64 address, uint64 length,
+ uint8 version, const std::string& augmentation,
+ unsigned return_address) override;
+ virtual bool UndefinedRule(uint64 address, int reg) override;
+ virtual bool SameValueRule(uint64 address, int reg) override;
+ virtual bool OffsetRule(uint64 address, int reg, int base_register,
+ long offset) override;
+ virtual bool ValOffsetRule(uint64 address, int reg, int base_register,
+ long offset) override;
+ virtual bool RegisterRule(uint64 address, int reg,
+ int base_register) override;
+ virtual bool ExpressionRule(uint64 address, int reg,
+ const std::string& expression) override;
+ virtual bool ValExpressionRule(uint64 address, int reg,
+ const std::string& expression) override;
+ virtual bool End() override;
+
+ private:
+ // Return the name to use for register I.
+ const UniqueString* RegisterName(int i);
+
+ // The Summariser to which we should give entries
+ Summariser* summ_;
+
+ // Universe for creating UniqueStrings in, should that be necessary.
+ UniqueStringUniverse* usu_;
+
+ // The number of Dwarf-defined register names for this architecture.
+ const unsigned int num_dw_regs_;
+
+ // The reporter to use to report problems.
+ Reporter* reporter_;
+
+ // The ByteReader to use for parsing Dwarf expressions.
+ ByteReader* reader_;
+
+ // The section offset of the current frame description entry, for
+ // use in error messages.
+ size_t entry_offset_;
+
+ // The return address column for that entry.
+ unsigned return_address_;
+};
+
+// Convert the Dwarf expression in |expr| into PfxInstrs stored in the
+// SecMap referred to by |summ|, and return the index of the starting
+// PfxInstr added, which must be >= 0. In case of failure return -1.
+int32_t parseDwarfExpr(Summariser* summ, const ByteReader* reader,
+ std::string expr, bool debug, bool pushCfaAtStart,
+ bool derefAtEnd);
+
+} // namespace lul
+
+#endif // LulDwarfExt_h
diff --git a/mozglue/baseprofiler/lul/LulDwarfInt.h b/mozglue/baseprofiler/lul/LulDwarfInt.h
new file mode 100644
index 0000000000..b72c6e08e3
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulDwarfInt.h
@@ -0,0 +1,193 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+// Copyright (c) 2008, 2010 Google Inc. 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.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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
+// OWNER 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.
+
+// CFI reader author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+
+// This file is derived from the following file in
+// toolkit/crashreporter/google-breakpad:
+// src/common/dwarf/dwarf2enums.h
+
+#ifndef LulDwarfInt_h
+#define LulDwarfInt_h
+
+#include "LulCommonExt.h"
+#include "LulDwarfExt.h"
+
+namespace lul {
+
+// These enums do not follow the google3 style only because they are
+// known universally (specs, other implementations) by the names in
+// exactly this capitalization.
+// Tag names and codes.
+
+// Call Frame Info instructions.
+enum DwarfCFI {
+ DW_CFA_advance_loc = 0x40,
+ DW_CFA_offset = 0x80,
+ DW_CFA_restore = 0xc0,
+ DW_CFA_nop = 0x00,
+ DW_CFA_set_loc = 0x01,
+ DW_CFA_advance_loc1 = 0x02,
+ DW_CFA_advance_loc2 = 0x03,
+ DW_CFA_advance_loc4 = 0x04,
+ DW_CFA_offset_extended = 0x05,
+ DW_CFA_restore_extended = 0x06,
+ DW_CFA_undefined = 0x07,
+ DW_CFA_same_value = 0x08,
+ DW_CFA_register = 0x09,
+ DW_CFA_remember_state = 0x0a,
+ DW_CFA_restore_state = 0x0b,
+ DW_CFA_def_cfa = 0x0c,
+ DW_CFA_def_cfa_register = 0x0d,
+ DW_CFA_def_cfa_offset = 0x0e,
+ DW_CFA_def_cfa_expression = 0x0f,
+ DW_CFA_expression = 0x10,
+ DW_CFA_offset_extended_sf = 0x11,
+ DW_CFA_def_cfa_sf = 0x12,
+ DW_CFA_def_cfa_offset_sf = 0x13,
+ DW_CFA_val_offset = 0x14,
+ DW_CFA_val_offset_sf = 0x15,
+ DW_CFA_val_expression = 0x16,
+
+ // Opcodes in this range are reserved for user extensions.
+ DW_CFA_lo_user = 0x1c,
+ DW_CFA_hi_user = 0x3f,
+
+ // SGI/MIPS specific.
+ DW_CFA_MIPS_advance_loc8 = 0x1d,
+
+ // GNU extensions.
+ DW_CFA_GNU_window_save = 0x2d,
+ DW_CFA_GNU_args_size = 0x2e,
+ DW_CFA_GNU_negative_offset_extended = 0x2f
+};
+
+// Exception handling 'z' augmentation letters.
+enum DwarfZAugmentationCodes {
+ // If the CFI augmentation string begins with 'z', then the CIE and FDE
+ // have an augmentation data area just before the instructions, whose
+ // contents are determined by the subsequent augmentation letters.
+ DW_Z_augmentation_start = 'z',
+
+ // If this letter is present in a 'z' augmentation string, the CIE
+ // augmentation data includes a pointer encoding, and the FDE
+ // augmentation data includes a language-specific data area pointer,
+ // represented using that encoding.
+ DW_Z_has_LSDA = 'L',
+
+ // If this letter is present in a 'z' augmentation string, the CIE
+ // augmentation data includes a pointer encoding, followed by a pointer
+ // to a personality routine, represented using that encoding.
+ DW_Z_has_personality_routine = 'P',
+
+ // If this letter is present in a 'z' augmentation string, the CIE
+ // augmentation data includes a pointer encoding describing how the FDE's
+ // initial location, address range, and DW_CFA_set_loc operands are
+ // encoded.
+ DW_Z_has_FDE_address_encoding = 'R',
+
+ // If this letter is present in a 'z' augmentation string, then code
+ // addresses covered by FDEs that cite this CIE are signal delivery
+ // trampolines. Return addresses of frames in trampolines should not be
+ // adjusted as described in section 6.4.4 of the DWARF 3 spec.
+ DW_Z_is_signal_trampoline = 'S'
+};
+
+// Expression opcodes
+enum DwarfExpressionOpcodes {
+ DW_OP_addr = 0x03,
+ DW_OP_deref = 0x06,
+ DW_OP_const1s = 0x09,
+ DW_OP_const2u = 0x0a,
+ DW_OP_const2s = 0x0b,
+ DW_OP_const4u = 0x0c,
+ DW_OP_const4s = 0x0d,
+ DW_OP_const8u = 0x0e,
+ DW_OP_const8s = 0x0f,
+ DW_OP_constu = 0x10,
+ DW_OP_consts = 0x11,
+ DW_OP_dup = 0x12,
+ DW_OP_drop = 0x13,
+ DW_OP_over = 0x14,
+ DW_OP_pick = 0x15,
+ DW_OP_swap = 0x16,
+ DW_OP_rot = 0x17,
+ DW_OP_xderef = 0x18,
+ DW_OP_abs = 0x19,
+ DW_OP_and = 0x1a,
+ DW_OP_div = 0x1b,
+ DW_OP_minus = 0x1c,
+ DW_OP_mod = 0x1d,
+ DW_OP_mul = 0x1e,
+ DW_OP_neg = 0x1f,
+ DW_OP_not = 0x20,
+ DW_OP_or = 0x21,
+ DW_OP_plus = 0x22,
+ DW_OP_plus_uconst = 0x23,
+ DW_OP_shl = 0x24,
+ DW_OP_shr = 0x25,
+ DW_OP_shra = 0x26,
+ DW_OP_xor = 0x27,
+ DW_OP_skip = 0x2f,
+ DW_OP_bra = 0x28,
+ DW_OP_eq = 0x29,
+ DW_OP_ge = 0x2a,
+ DW_OP_gt = 0x2b,
+ DW_OP_le = 0x2c,
+ DW_OP_lt = 0x2d,
+ DW_OP_ne = 0x2e,
+ DW_OP_lit0 = 0x30,
+ DW_OP_lit31 = 0x4f,
+ DW_OP_reg0 = 0x50,
+ DW_OP_reg31 = 0x6f,
+ DW_OP_breg0 = 0x70,
+ DW_OP_breg31 = 0x8f,
+ DW_OP_regx = 0x90,
+ DW_OP_fbreg = 0x91,
+ DW_OP_bregx = 0x92,
+ DW_OP_piece = 0x93,
+ DW_OP_deref_size = 0x94,
+ DW_OP_xderef_size = 0x95,
+ DW_OP_nop = 0x96,
+ DW_OP_push_object_address = 0x97,
+ DW_OP_call2 = 0x98,
+ DW_OP_call4 = 0x99,
+ DW_OP_call_ref = 0x9a,
+ DW_OP_form_tls_address = 0x9b,
+ DW_OP_call_frame_cfa = 0x9c,
+ DW_OP_bit_piece = 0x9d,
+ DW_OP_lo_user = 0xe0,
+ DW_OP_hi_user = 0xff
+};
+
+} // namespace lul
+
+#endif // LulDwarfInt_h
diff --git a/mozglue/baseprofiler/lul/LulDwarfSummariser.cpp b/mozglue/baseprofiler/lul/LulDwarfSummariser.cpp
new file mode 100644
index 0000000000..ff0f212f6c
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulDwarfSummariser.cpp
@@ -0,0 +1,553 @@
+/* -*- 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/. */
+
+#include "LulDwarfSummariser.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Sprintf.h"
+
+#include "LulDwarfExt.h"
+
+// Set this to 1 for verbose logging
+#define DEBUG_SUMMARISER 0
+
+namespace lul {
+
+// Do |s64|'s lowest 32 bits sign extend back to |s64| itself?
+static inline bool fitsIn32Bits(int64 s64) {
+ return s64 == ((s64 & 0xffffffff) ^ 0x80000000) - 0x80000000;
+}
+
+// Check a LExpr prefix expression, starting at pfxInstrs[start] up to
+// the next PX_End instruction, to ensure that:
+// * It only mentions registers that are tracked on this target
+// * The start point is sane
+// If the expression is ok, return NULL. Else return a pointer
+// a const char* holding a bit of text describing the problem.
+static const char* checkPfxExpr(const vector<PfxInstr>* pfxInstrs,
+ int64_t start) {
+ size_t nInstrs = pfxInstrs->size();
+ if (start < 0 || start >= (ssize_t)nInstrs) {
+ return "bogus start point";
+ }
+ size_t i;
+ for (i = start; i < nInstrs; i++) {
+ PfxInstr pxi = (*pfxInstrs)[i];
+ if (pxi.mOpcode == PX_End) break;
+ if (pxi.mOpcode == PX_DwReg &&
+ !registerIsTracked((DW_REG_NUMBER)pxi.mOperand)) {
+ return "uses untracked reg";
+ }
+ }
+ return nullptr; // success
+}
+
+Summariser::Summariser(SecMap* aSecMap, uintptr_t aTextBias,
+ void (*aLog)(const char*))
+ : mSecMap(aSecMap), mTextBias(aTextBias), mLog(aLog) {
+ mCurrAddr = 0;
+ mMax1Addr = 0; // Gives an empty range.
+
+ // Initialise the running RuleSet to "haven't got a clue" status.
+ new (&mCurrRules) RuleSet();
+}
+
+void Summariser::Entry(uintptr_t aAddress, uintptr_t aLength) {
+ aAddress += mTextBias;
+ if (DEBUG_SUMMARISER) {
+ char buf[100];
+ SprintfLiteral(buf, "LUL Entry(%llx, %llu)\n",
+ (unsigned long long int)aAddress,
+ (unsigned long long int)aLength);
+ mLog(buf);
+ }
+ // This throws away any previous summary, that is, assumes
+ // that the previous summary, if any, has been properly finished
+ // by a call to End().
+ mCurrAddr = aAddress;
+ mMax1Addr = aAddress + aLength;
+ new (&mCurrRules) RuleSet();
+}
+
+void Summariser::Rule(uintptr_t aAddress, int aNewReg, LExprHow how,
+ int16_t oldReg, int64_t offset) {
+ aAddress += mTextBias;
+ if (DEBUG_SUMMARISER) {
+ char buf[100];
+ if (how == NODEREF || how == DEREF) {
+ bool deref = how == DEREF;
+ SprintfLiteral(buf, "LUL 0x%llx old-r%d = %sr%d + %lld%s\n",
+ (unsigned long long int)aAddress, aNewReg,
+ deref ? "*(" : "", (int)oldReg, (long long int)offset,
+ deref ? ")" : "");
+ } else if (how == PFXEXPR) {
+ SprintfLiteral(buf, "LUL 0x%llx old-r%d = pfx-expr-at %lld\n",
+ (unsigned long long int)aAddress, aNewReg,
+ (long long int)offset);
+ } else {
+ SprintfLiteral(buf, "LUL 0x%llx old-r%d = (invalid LExpr!)\n",
+ (unsigned long long int)aAddress, aNewReg);
+ }
+ mLog(buf);
+ }
+
+ if (mCurrAddr < aAddress) {
+ // Flush the existing summary first.
+ mCurrRules.mAddr = mCurrAddr;
+ mCurrRules.mLen = aAddress - mCurrAddr;
+ mSecMap->AddRuleSet(&mCurrRules);
+ if (DEBUG_SUMMARISER) {
+ mLog("LUL ");
+ mCurrRules.Print(mLog);
+ mLog("\n");
+ }
+ mCurrAddr = aAddress;
+ }
+
+ // If for some reason summarisation fails, either or both of these
+ // become non-null and point at constant text describing the
+ // problem. Using two rather than just one avoids complications of
+ // having to concatenate two strings to produce a complete error message.
+ const char* reason1 = nullptr;
+ const char* reason2 = nullptr;
+
+ // |offset| needs to be a 32 bit value that sign extends to 64 bits
+ // on a 64 bit target. We will need to incorporate |offset| into
+ // any LExpr made here. So we may as well check it right now.
+ if (!fitsIn32Bits(offset)) {
+ reason1 = "offset not in signed 32-bit range";
+ goto cant_summarise;
+ }
+
+ // FIXME: factor out common parts of the arch-dependent summarisers.
+
+#if defined(GP_ARCH_arm)
+
+ // ----------------- arm ----------------- //
+
+ // Now, can we add the rule to our summary? This depends on whether
+ // the registers and the overall expression are representable. This
+ // is the heart of the summarisation process.
+ switch (aNewReg) {
+ case DW_REG_CFA:
+ // This is a rule that defines the CFA. The only forms we
+ // choose to represent are: r7/11/12/13 + offset. The offset
+ // must fit into 32 bits since 'uintptr_t' is 32 bit on ARM,
+ // hence there is no need to check it for overflow.
+ if (how != NODEREF) {
+ reason1 = "rule for DW_REG_CFA: invalid |how|";
+ goto cant_summarise;
+ }
+ switch (oldReg) {
+ case DW_REG_ARM_R7:
+ case DW_REG_ARM_R11:
+ case DW_REG_ARM_R12:
+ case DW_REG_ARM_R13:
+ break;
+ default:
+ reason1 = "rule for DW_REG_CFA: invalid |oldReg|";
+ goto cant_summarise;
+ }
+ mCurrRules.mCfaExpr = LExpr(how, oldReg, offset);
+ break;
+
+ case DW_REG_ARM_R7:
+ case DW_REG_ARM_R11:
+ case DW_REG_ARM_R12:
+ case DW_REG_ARM_R13:
+ case DW_REG_ARM_R14:
+ case DW_REG_ARM_R15: {
+ // This is a new rule for R7, R11, R12, R13 (SP), R14 (LR) or
+ // R15 (the return address).
+ switch (how) {
+ case NODEREF:
+ case DEREF:
+ // Check the old register is one we're tracking.
+ if (!registerIsTracked((DW_REG_NUMBER)oldReg) &&
+ oldReg != DW_REG_CFA) {
+ reason1 = "rule for R7/11/12/13/14/15: uses untracked reg";
+ goto cant_summarise;
+ }
+ break;
+ case PFXEXPR: {
+ // Check that the prefix expression only mentions tracked registers.
+ const vector<PfxInstr>* pfxInstrs = mSecMap->GetPfxInstrs();
+ reason2 = checkPfxExpr(pfxInstrs, offset);
+ if (reason2) {
+ reason1 = "rule for R7/11/12/13/14/15: ";
+ goto cant_summarise;
+ }
+ break;
+ }
+ default:
+ goto cant_summarise;
+ }
+ LExpr expr = LExpr(how, oldReg, offset);
+ switch (aNewReg) {
+ case DW_REG_ARM_R7:
+ mCurrRules.mR7expr = expr;
+ break;
+ case DW_REG_ARM_R11:
+ mCurrRules.mR11expr = expr;
+ break;
+ case DW_REG_ARM_R12:
+ mCurrRules.mR12expr = expr;
+ break;
+ case DW_REG_ARM_R13:
+ mCurrRules.mR13expr = expr;
+ break;
+ case DW_REG_ARM_R14:
+ mCurrRules.mR14expr = expr;
+ break;
+ case DW_REG_ARM_R15:
+ mCurrRules.mR15expr = expr;
+ break;
+ default:
+ MOZ_ASSERT(0);
+ }
+ break;
+ }
+
+ default:
+ // Leave |reason1| and |reason2| unset here. This program point
+ // is reached so often that it causes a flood of "Can't
+ // summarise" messages. In any case, we don't really care about
+ // the fact that this summary would produce a new value for a
+ // register that we're not tracking. We do on the other hand
+ // care if the summary's expression *uses* a register that we're
+ // not tracking. But in that case one of the above failures
+ // should tell us which.
+ goto cant_summarise;
+ }
+
+ // Mark callee-saved registers (r4 .. r11) as unchanged, if there is
+ // no other information about them. FIXME: do this just once, at
+ // the point where the ruleset is committed.
+ if (mCurrRules.mR7expr.mHow == UNKNOWN) {
+ mCurrRules.mR7expr = LExpr(NODEREF, DW_REG_ARM_R7, 0);
+ }
+ if (mCurrRules.mR11expr.mHow == UNKNOWN) {
+ mCurrRules.mR11expr = LExpr(NODEREF, DW_REG_ARM_R11, 0);
+ }
+ if (mCurrRules.mR12expr.mHow == UNKNOWN) {
+ mCurrRules.mR12expr = LExpr(NODEREF, DW_REG_ARM_R12, 0);
+ }
+
+ // The old r13 (SP) value before the call is always the same as the
+ // CFA.
+ mCurrRules.mR13expr = LExpr(NODEREF, DW_REG_CFA, 0);
+
+ // If there's no information about R15 (the return address), say
+ // it's a copy of R14 (the link register).
+ if (mCurrRules.mR15expr.mHow == UNKNOWN) {
+ mCurrRules.mR15expr = LExpr(NODEREF, DW_REG_ARM_R14, 0);
+ }
+
+#elif defined(GP_ARCH_arm64)
+
+ // ----------------- arm64 ----------------- //
+
+ switch (aNewReg) {
+ case DW_REG_CFA:
+ if (how != NODEREF) {
+ reason1 = "rule for DW_REG_CFA: invalid |how|";
+ goto cant_summarise;
+ }
+ switch (oldReg) {
+ case DW_REG_AARCH64_X29:
+ case DW_REG_AARCH64_SP:
+ break;
+ default:
+ reason1 = "rule for DW_REG_CFA: invalid |oldReg|";
+ goto cant_summarise;
+ }
+ mCurrRules.mCfaExpr = LExpr(how, oldReg, offset);
+ break;
+
+ case DW_REG_AARCH64_X29:
+ case DW_REG_AARCH64_X30:
+ case DW_REG_AARCH64_SP: {
+ switch (how) {
+ case NODEREF:
+ case DEREF:
+ // Check the old register is one we're tracking.
+ if (!registerIsTracked((DW_REG_NUMBER)oldReg) &&
+ oldReg != DW_REG_CFA) {
+ reason1 = "rule for X29/X30/SP: uses untracked reg";
+ goto cant_summarise;
+ }
+ break;
+ case PFXEXPR: {
+ // Check that the prefix expression only mentions tracked registers.
+ const vector<PfxInstr>* pfxInstrs = mSecMap->GetPfxInstrs();
+ reason2 = checkPfxExpr(pfxInstrs, offset);
+ if (reason2) {
+ reason1 = "rule for X29/X30/SP: ";
+ goto cant_summarise;
+ }
+ break;
+ }
+ default:
+ goto cant_summarise;
+ }
+ LExpr expr = LExpr(how, oldReg, offset);
+ switch (aNewReg) {
+ case DW_REG_AARCH64_X29:
+ mCurrRules.mX29expr = expr;
+ break;
+ case DW_REG_AARCH64_X30:
+ mCurrRules.mX30expr = expr;
+ break;
+ case DW_REG_AARCH64_SP:
+ mCurrRules.mSPexpr = expr;
+ break;
+ default:
+ MOZ_ASSERT(0);
+ }
+ break;
+ }
+ default:
+ // Leave |reason1| and |reason2| unset here, for the reasons explained
+ // in the analogous point
+ goto cant_summarise;
+ }
+
+ if (mCurrRules.mX29expr.mHow == UNKNOWN) {
+ mCurrRules.mX29expr = LExpr(NODEREF, DW_REG_AARCH64_X29, 0);
+ }
+ if (mCurrRules.mX30expr.mHow == UNKNOWN) {
+ mCurrRules.mX30expr = LExpr(NODEREF, DW_REG_AARCH64_X30, 0);
+ }
+ // On aarch64, it seems the old SP value before the call is always the
+ // same as the CFA. Therefore, in the absence of any other way to
+ // recover the SP, specify that the CFA should be copied.
+ if (mCurrRules.mSPexpr.mHow == UNKNOWN) {
+ mCurrRules.mSPexpr = LExpr(NODEREF, DW_REG_CFA, 0);
+ }
+#elif defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+
+ // ---------------- x64/x86 ---------------- //
+
+ // Now, can we add the rule to our summary? This depends on whether
+ // the registers and the overall expression are representable. This
+ // is the heart of the summarisation process.
+ switch (aNewReg) {
+ case DW_REG_CFA: {
+ // This is a rule that defines the CFA. The only forms we choose to
+ // represent are: = SP+offset, = FP+offset, or =prefix-expr.
+ switch (how) {
+ case NODEREF:
+ if (oldReg != DW_REG_INTEL_XSP && oldReg != DW_REG_INTEL_XBP) {
+ reason1 = "rule for DW_REG_CFA: invalid |oldReg|";
+ goto cant_summarise;
+ }
+ break;
+ case DEREF:
+ reason1 = "rule for DW_REG_CFA: invalid |how|";
+ goto cant_summarise;
+ case PFXEXPR: {
+ // Check that the prefix expression only mentions tracked registers.
+ const vector<PfxInstr>* pfxInstrs = mSecMap->GetPfxInstrs();
+ reason2 = checkPfxExpr(pfxInstrs, offset);
+ if (reason2) {
+ reason1 = "rule for CFA: ";
+ goto cant_summarise;
+ }
+ break;
+ }
+ default:
+ goto cant_summarise;
+ }
+ mCurrRules.mCfaExpr = LExpr(how, oldReg, offset);
+ break;
+ }
+
+ case DW_REG_INTEL_XSP:
+ case DW_REG_INTEL_XBP:
+ case DW_REG_INTEL_XIP: {
+ // This is a new rule for XSP, XBP or XIP (the return address).
+ switch (how) {
+ case NODEREF:
+ case DEREF:
+ // Check the old register is one we're tracking.
+ if (!registerIsTracked((DW_REG_NUMBER)oldReg) &&
+ oldReg != DW_REG_CFA) {
+ reason1 = "rule for XSP/XBP/XIP: uses untracked reg";
+ goto cant_summarise;
+ }
+ break;
+ case PFXEXPR: {
+ // Check that the prefix expression only mentions tracked registers.
+ const vector<PfxInstr>* pfxInstrs = mSecMap->GetPfxInstrs();
+ reason2 = checkPfxExpr(pfxInstrs, offset);
+ if (reason2) {
+ reason1 = "rule for XSP/XBP/XIP: ";
+ goto cant_summarise;
+ }
+ break;
+ }
+ default:
+ goto cant_summarise;
+ }
+ LExpr expr = LExpr(how, oldReg, offset);
+ switch (aNewReg) {
+ case DW_REG_INTEL_XBP:
+ mCurrRules.mXbpExpr = expr;
+ break;
+ case DW_REG_INTEL_XSP:
+ mCurrRules.mXspExpr = expr;
+ break;
+ case DW_REG_INTEL_XIP:
+ mCurrRules.mXipExpr = expr;
+ break;
+ default:
+ MOZ_CRASH("impossible value for aNewReg");
+ }
+ break;
+ }
+
+ default:
+ // Leave |reason1| and |reason2| unset here, for the reasons
+ // explained in the analogous point in the ARM case just above.
+ goto cant_summarise;
+ }
+
+ // On Intel, it seems the old SP value before the call is always the
+ // same as the CFA. Therefore, in the absence of any other way to
+ // recover the SP, specify that the CFA should be copied.
+ if (mCurrRules.mXspExpr.mHow == UNKNOWN) {
+ mCurrRules.mXspExpr = LExpr(NODEREF, DW_REG_CFA, 0);
+ }
+
+ // Also, gcc says "Undef" for BP when it is unchanged.
+ if (mCurrRules.mXbpExpr.mHow == UNKNOWN) {
+ mCurrRules.mXbpExpr = LExpr(NODEREF, DW_REG_INTEL_XBP, 0);
+ }
+
+#elif defined(GP_ARCH_mips64)
+ // ---------------- mips ---------------- //
+ //
+ // Now, can we add the rule to our summary? This depends on whether
+ // the registers and the overall expression are representable. This
+ // is the heart of the summarisation process.
+ switch (aNewReg) {
+ case DW_REG_CFA:
+ // This is a rule that defines the CFA. The only forms we can
+ // represent are: = SP+offset or = FP+offset.
+ if (how != NODEREF) {
+ reason1 = "rule for DW_REG_CFA: invalid |how|";
+ goto cant_summarise;
+ }
+ if (oldReg != DW_REG_MIPS_SP && oldReg != DW_REG_MIPS_FP) {
+ reason1 = "rule for DW_REG_CFA: invalid |oldReg|";
+ goto cant_summarise;
+ }
+ mCurrRules.mCfaExpr = LExpr(how, oldReg, offset);
+ break;
+
+ case DW_REG_MIPS_SP:
+ case DW_REG_MIPS_FP:
+ case DW_REG_MIPS_PC: {
+ // This is a new rule for SP, FP or PC (the return address).
+ switch (how) {
+ case NODEREF:
+ case DEREF:
+ // Check the old register is one we're tracking.
+ if (!registerIsTracked((DW_REG_NUMBER)oldReg) &&
+ oldReg != DW_REG_CFA) {
+ reason1 = "rule for SP/FP/PC: uses untracked reg";
+ goto cant_summarise;
+ }
+ break;
+ case PFXEXPR: {
+ // Check that the prefix expression only mentions tracked registers.
+ const vector<PfxInstr>* pfxInstrs = mSecMap->GetPfxInstrs();
+ reason2 = checkPfxExpr(pfxInstrs, offset);
+ if (reason2) {
+ reason1 = "rule for SP/FP/PC: ";
+ goto cant_summarise;
+ }
+ break;
+ }
+ default:
+ goto cant_summarise;
+ }
+ LExpr expr = LExpr(how, oldReg, offset);
+ switch (aNewReg) {
+ case DW_REG_MIPS_FP:
+ mCurrRules.mFPexpr = expr;
+ break;
+ case DW_REG_MIPS_SP:
+ mCurrRules.mSPexpr = expr;
+ break;
+ case DW_REG_MIPS_PC:
+ mCurrRules.mPCexpr = expr;
+ break;
+ default:
+ MOZ_CRASH("impossible value for aNewReg");
+ }
+ break;
+ }
+ default:
+ // Leave |reason1| and |reason2| unset here, for the reasons
+ // explained in the analogous point in the ARM case just above.
+ goto cant_summarise;
+ }
+
+ // On MIPS, it seems the old SP value before the call is always the
+ // same as the CFA. Therefore, in the absence of any other way to
+ // recover the SP, specify that the CFA should be copied.
+ if (mCurrRules.mSPexpr.mHow == UNKNOWN) {
+ mCurrRules.mSPexpr = LExpr(NODEREF, DW_REG_CFA, 0);
+ }
+
+ // Also, gcc says "Undef" for FP when it is unchanged.
+ if (mCurrRules.mFPexpr.mHow == UNKNOWN) {
+ mCurrRules.mFPexpr = LExpr(NODEREF, DW_REG_MIPS_FP, 0);
+ }
+
+#else
+
+# error "Unsupported arch"
+#endif
+
+ return;
+
+cant_summarise:
+ if (reason1 || reason2) {
+ char buf[200];
+ SprintfLiteral(buf,
+ "LUL can't summarise: "
+ "SVMA=0x%llx: %s%s, expr=LExpr(%s,%u,%lld)\n",
+ (unsigned long long int)(aAddress - mTextBias),
+ reason1 ? reason1 : "", reason2 ? reason2 : "",
+ NameOf_LExprHow(how), (unsigned int)oldReg,
+ (long long int)offset);
+ mLog(buf);
+ }
+}
+
+uint32_t Summariser::AddPfxInstr(PfxInstr pfxi) {
+ return mSecMap->AddPfxInstr(pfxi);
+}
+
+void Summariser::End() {
+ if (DEBUG_SUMMARISER) {
+ mLog("LUL End\n");
+ }
+ if (mCurrAddr < mMax1Addr) {
+ mCurrRules.mAddr = mCurrAddr;
+ mCurrRules.mLen = mMax1Addr - mCurrAddr;
+ mSecMap->AddRuleSet(&mCurrRules);
+ if (DEBUG_SUMMARISER) {
+ mLog("LUL ");
+ mCurrRules.Print(mLog);
+ mLog("\n");
+ }
+ }
+}
+
+} // namespace lul
diff --git a/mozglue/baseprofiler/lul/LulDwarfSummariser.h b/mozglue/baseprofiler/lul/LulDwarfSummariser.h
new file mode 100644
index 0000000000..30f1ba23c1
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulDwarfSummariser.h
@@ -0,0 +1,64 @@
+/* -*- 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/. */
+
+#ifndef LulDwarfSummariser_h
+#define LulDwarfSummariser_h
+
+#include "LulMainInt.h"
+
+namespace lul {
+
+class Summariser {
+ public:
+ Summariser(SecMap* aSecMap, uintptr_t aTextBias, void (*aLog)(const char*));
+
+ virtual void Entry(uintptr_t aAddress, uintptr_t aLength);
+ virtual void End();
+
+ // Tell the summariser that the value for |aNewReg| at |aAddress| is
+ // recovered using the LExpr that can be constructed using the
+ // components |how|, |oldReg| and |offset|. The summariser will
+ // inspect the components and may reject them for various reasons,
+ // but the hope is that it will find them acceptable and record this
+ // rule permanently.
+ virtual void Rule(uintptr_t aAddress, int aNewReg, LExprHow how,
+ int16_t oldReg, int64_t offset);
+
+ virtual uint32_t AddPfxInstr(PfxInstr pfxi);
+
+ // Send output to the logging sink, for debugging.
+ virtual void Log(const char* str) { mLog(str); }
+
+ private:
+ // The SecMap in which we park the finished summaries (RuleSets) and
+ // also any PfxInstrs derived from Dwarf expressions.
+ SecMap* mSecMap;
+
+ // Running state for the current summary (RuleSet) under construction.
+ RuleSet mCurrRules;
+
+ // The start of the address range to which the RuleSet under
+ // construction applies.
+ uintptr_t mCurrAddr;
+
+ // The highest address, plus one, for which the RuleSet under
+ // construction could possibly apply. If there are no further
+ // incoming events then mCurrRules will eventually be emitted
+ // as-is, for the range mCurrAddr.. mMax1Addr - 1, if that is
+ // nonempty.
+ uintptr_t mMax1Addr;
+
+ // The bias value (to add to the SVMAs, to get AVMAs) to be used
+ // when adding entries into mSecMap.
+ uintptr_t mTextBias;
+
+ // A logging sink, for debugging.
+ void (*mLog)(const char* aFmt);
+};
+
+} // namespace lul
+
+#endif // LulDwarfSummariser_h
diff --git a/mozglue/baseprofiler/lul/LulElf.cpp b/mozglue/baseprofiler/lul/LulElf.cpp
new file mode 100644
index 0000000000..b5d5e772be
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulElf.cpp
@@ -0,0 +1,873 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+// Copyright (c) 2006, 2011, 2012 Google Inc.
+// 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.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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
+// OWNER 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.
+
+// Restructured in 2009 by: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+
+// (derived from)
+// dump_symbols.cc: implement google_breakpad::WriteSymbolFile:
+// Find all the debugging info in a file and dump it as a Breakpad symbol file.
+//
+// dump_symbols.h: Read debugging information from an ELF file, and write
+// it out as a Breakpad symbol file.
+
+// This file is derived from the following files in
+// toolkit/crashreporter/google-breakpad:
+// src/common/linux/dump_symbols.cc
+// src/common/linux/elfutils.cc
+// src/common/linux/file_id.cc
+
+#include <errno.h>
+#include <fcntl.h>
+#include <libgen.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+
+#include <cstdlib>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Sprintf.h"
+
+#include "PlatformMacros.h"
+#include "LulCommonExt.h"
+#include "LulDwarfExt.h"
+#include "LulElfInt.h"
+#include "LulMainInt.h"
+
+#if defined(GP_PLAT_arm_android) && !defined(SHT_ARM_EXIDX)
+// bionic and older glibsc don't define it
+# define SHT_ARM_EXIDX (SHT_LOPROC + 1)
+#endif
+
+// Old Linux header doesn't define EM_AARCH64
+#ifndef EM_AARCH64
+# define EM_AARCH64 183
+#endif
+
+// This namespace contains helper functions.
+namespace {
+
+using lul::DwarfCFIToModule;
+using lul::FindElfSectionByName;
+using lul::GetOffset;
+using lul::IsValidElf;
+using lul::Module;
+using lul::scoped_ptr;
+using lul::Summariser;
+using lul::UniqueStringUniverse;
+using std::set;
+using std::string;
+using std::vector;
+
+//
+// FDWrapper
+//
+// Wrapper class to make sure opened file is closed.
+//
+class FDWrapper {
+ public:
+ explicit FDWrapper(int fd) : fd_(fd) {}
+ ~FDWrapper() {
+ if (fd_ != -1) close(fd_);
+ }
+ int get() { return fd_; }
+ int release() {
+ int fd = fd_;
+ fd_ = -1;
+ return fd;
+ }
+
+ private:
+ int fd_;
+};
+
+//
+// MmapWrapper
+//
+// Wrapper class to make sure mapped regions are unmapped.
+//
+class MmapWrapper {
+ public:
+ MmapWrapper() : is_set_(false), base_(NULL), size_(0) {}
+ ~MmapWrapper() {
+ if (is_set_ && base_ != NULL) {
+ MOZ_ASSERT(size_ > 0);
+ munmap(base_, size_);
+ }
+ }
+ void set(void* mapped_address, size_t mapped_size) {
+ is_set_ = true;
+ base_ = mapped_address;
+ size_ = mapped_size;
+ }
+ void release() {
+ MOZ_ASSERT(is_set_);
+ is_set_ = false;
+ base_ = NULL;
+ size_ = 0;
+ }
+
+ private:
+ bool is_set_;
+ void* base_;
+ size_t size_;
+};
+
+// Set NUM_DW_REGNAMES to be the number of Dwarf register names
+// appropriate to the machine architecture given in HEADER. Return
+// true on success, or false if HEADER's machine architecture is not
+// supported.
+template <typename ElfClass>
+bool DwarfCFIRegisterNames(const typename ElfClass::Ehdr* elf_header,
+ unsigned int* num_dw_regnames) {
+ switch (elf_header->e_machine) {
+ case EM_386:
+ *num_dw_regnames = DwarfCFIToModule::RegisterNames::I386();
+ return true;
+ case EM_ARM:
+ *num_dw_regnames = DwarfCFIToModule::RegisterNames::ARM();
+ return true;
+ case EM_X86_64:
+ *num_dw_regnames = DwarfCFIToModule::RegisterNames::X86_64();
+ return true;
+ case EM_MIPS:
+ *num_dw_regnames = DwarfCFIToModule::RegisterNames::MIPS();
+ return true;
+ case EM_AARCH64:
+ *num_dw_regnames = DwarfCFIToModule::RegisterNames::ARM64();
+ return true;
+ default:
+ MOZ_ASSERT(0);
+ return false;
+ }
+}
+
+template <typename ElfClass>
+bool LoadDwarfCFI(const string& dwarf_filename,
+ const typename ElfClass::Ehdr* elf_header,
+ const char* section_name,
+ const typename ElfClass::Shdr* section, const bool eh_frame,
+ const typename ElfClass::Shdr* got_section,
+ const typename ElfClass::Shdr* text_section,
+ const bool big_endian, SecMap* smap, uintptr_t text_bias,
+ UniqueStringUniverse* usu, void (*log)(const char*)) {
+ // Find the appropriate set of register names for this file's
+ // architecture.
+ unsigned int num_dw_regs = 0;
+ if (!DwarfCFIRegisterNames<ElfClass>(elf_header, &num_dw_regs)) {
+ fprintf(stderr,
+ "%s: unrecognized ELF machine architecture '%d';"
+ " cannot convert DWARF call frame information\n",
+ dwarf_filename.c_str(), elf_header->e_machine);
+ return false;
+ }
+
+ const lul::Endianness endianness =
+ big_endian ? lul::ENDIANNESS_BIG : lul::ENDIANNESS_LITTLE;
+
+ // Find the call frame information and its size.
+ const char* cfi = GetOffset<ElfClass, char>(elf_header, section->sh_offset);
+ size_t cfi_size = section->sh_size;
+
+ // Plug together the parser, handler, and their entourages.
+
+ // Here's a summariser, which will receive the output of the
+ // parser, create summaries, and add them to |smap|.
+ Summariser summ(smap, text_bias, log);
+
+ lul::ByteReader reader(endianness);
+ reader.SetAddressSize(ElfClass::kAddrSize);
+
+ DwarfCFIToModule::Reporter module_reporter(log, dwarf_filename, section_name);
+ DwarfCFIToModule handler(num_dw_regs, &module_reporter, &reader, usu, &summ);
+
+ // Provide the base addresses for .eh_frame encoded pointers, if
+ // possible.
+ reader.SetCFIDataBase(section->sh_addr, cfi);
+ if (got_section) reader.SetDataBase(got_section->sh_addr);
+ if (text_section) reader.SetTextBase(text_section->sh_addr);
+
+ lul::CallFrameInfo::Reporter dwarf_reporter(log, dwarf_filename,
+ section_name);
+ lul::CallFrameInfo parser(cfi, cfi_size, &reader, &handler, &dwarf_reporter,
+ eh_frame);
+ parser.Start();
+
+ return true;
+}
+
+bool LoadELF(const string& obj_file, MmapWrapper* map_wrapper,
+ void** elf_header) {
+ int obj_fd = open(obj_file.c_str(), O_RDONLY);
+ if (obj_fd < 0) {
+ fprintf(stderr, "Failed to open ELF file '%s': %s\n", obj_file.c_str(),
+ strerror(errno));
+ return false;
+ }
+ FDWrapper obj_fd_wrapper(obj_fd);
+ struct stat st;
+ if (fstat(obj_fd, &st) != 0 && st.st_size <= 0) {
+ fprintf(stderr, "Unable to fstat ELF file '%s': %s\n", obj_file.c_str(),
+ strerror(errno));
+ return false;
+ }
+ // Mapping it read-only is good enough. In any case, mapping it
+ // read-write confuses Valgrind's debuginfo acquire/discard
+ // heuristics, making it hard to profile the profiler.
+ void* obj_base = mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, obj_fd, 0);
+ if (obj_base == MAP_FAILED) {
+ fprintf(stderr, "Failed to mmap ELF file '%s': %s\n", obj_file.c_str(),
+ strerror(errno));
+ return false;
+ }
+ map_wrapper->set(obj_base, st.st_size);
+ *elf_header = obj_base;
+ if (!IsValidElf(*elf_header)) {
+ fprintf(stderr, "Not a valid ELF file: %s\n", obj_file.c_str());
+ return false;
+ }
+ return true;
+}
+
+// Get the endianness of ELF_HEADER. If it's invalid, return false.
+template <typename ElfClass>
+bool ElfEndianness(const typename ElfClass::Ehdr* elf_header,
+ bool* big_endian) {
+ if (elf_header->e_ident[EI_DATA] == ELFDATA2LSB) {
+ *big_endian = false;
+ return true;
+ }
+ if (elf_header->e_ident[EI_DATA] == ELFDATA2MSB) {
+ *big_endian = true;
+ return true;
+ }
+
+ fprintf(stderr, "bad data encoding in ELF header: %d\n",
+ elf_header->e_ident[EI_DATA]);
+ return false;
+}
+
+//
+// LoadSymbolsInfo
+//
+// Holds the state between the two calls to LoadSymbols() in case it's necessary
+// to follow the .gnu_debuglink section and load debug information from a
+// different file.
+//
+template <typename ElfClass>
+class LoadSymbolsInfo {
+ public:
+ typedef typename ElfClass::Addr Addr;
+
+ explicit LoadSymbolsInfo(const vector<string>& dbg_dirs)
+ : debug_dirs_(dbg_dirs), has_loading_addr_(false) {}
+
+ // Keeps track of which sections have been loaded so sections don't
+ // accidentally get loaded twice from two different files.
+ void LoadedSection(const string& section) {
+ if (loaded_sections_.count(section) == 0) {
+ loaded_sections_.insert(section);
+ } else {
+ fprintf(stderr, "Section %s has already been loaded.\n", section.c_str());
+ }
+ }
+
+ string debuglink_file() const { return debuglink_file_; }
+
+ private:
+ const vector<string>& debug_dirs_; // Directories in which to
+ // search for the debug ELF file.
+
+ string debuglink_file_; // Full path to the debug ELF file.
+
+ bool has_loading_addr_; // Indicate if LOADING_ADDR_ is valid.
+
+ set<string> loaded_sections_; // Tracks the Loaded ELF sections
+ // between calls to LoadSymbols().
+};
+
+// Find the preferred loading address of the binary.
+template <typename ElfClass>
+typename ElfClass::Addr GetLoadingAddress(
+ const typename ElfClass::Phdr* program_headers, int nheader) {
+ typedef typename ElfClass::Phdr Phdr;
+
+ // For non-PIC executables (e_type == ET_EXEC), the load address is
+ // the start address of the first PT_LOAD segment. (ELF requires
+ // the segments to be sorted by load address.) For PIC executables
+ // and dynamic libraries (e_type == ET_DYN), this address will
+ // normally be zero.
+ for (int i = 0; i < nheader; ++i) {
+ const Phdr& header = program_headers[i];
+ if (header.p_type == PT_LOAD) return header.p_vaddr;
+ }
+ return 0;
+}
+
+template <typename ElfClass>
+bool LoadSymbols(const string& obj_file, const bool big_endian,
+ const typename ElfClass::Ehdr* elf_header,
+ const bool read_gnu_debug_link,
+ LoadSymbolsInfo<ElfClass>* info, SecMap* smap, void* rx_avma,
+ size_t rx_size, UniqueStringUniverse* usu,
+ void (*log)(const char*)) {
+ typedef typename ElfClass::Phdr Phdr;
+ typedef typename ElfClass::Shdr Shdr;
+
+ char buf[500];
+ SprintfLiteral(buf, "LoadSymbols: BEGIN %s\n", obj_file.c_str());
+ buf[sizeof(buf) - 1] = 0;
+ log(buf);
+
+ // This is how the text bias is calculated.
+ // BEGIN CALCULATE BIAS
+ uintptr_t loading_addr = GetLoadingAddress<ElfClass>(
+ GetOffset<ElfClass, Phdr>(elf_header, elf_header->e_phoff),
+ elf_header->e_phnum);
+ uintptr_t text_bias = ((uintptr_t)rx_avma) - loading_addr;
+ SprintfLiteral(buf, "LoadSymbols: rx_avma=%llx, text_bias=%llx",
+ (unsigned long long int)(uintptr_t)rx_avma,
+ (unsigned long long int)text_bias);
+ buf[sizeof(buf) - 1] = 0;
+ log(buf);
+ // END CALCULATE BIAS
+
+ const Shdr* sections =
+ GetOffset<ElfClass, Shdr>(elf_header, elf_header->e_shoff);
+ const Shdr* section_names = sections + elf_header->e_shstrndx;
+ const char* names =
+ GetOffset<ElfClass, char>(elf_header, section_names->sh_offset);
+ const char* names_end = names + section_names->sh_size;
+ bool found_usable_info = false;
+
+ // Dwarf Call Frame Information (CFI) is actually independent from
+ // the other DWARF debugging information, and can be used alone.
+ const Shdr* dwarf_cfi_section =
+ FindElfSectionByName<ElfClass>(".debug_frame", SHT_PROGBITS, sections,
+ names, names_end, elf_header->e_shnum);
+ if (dwarf_cfi_section) {
+ // Ignore the return value of this function; even without call frame
+ // information, the other debugging information could be perfectly
+ // useful.
+ info->LoadedSection(".debug_frame");
+ bool result = LoadDwarfCFI<ElfClass>(obj_file, elf_header, ".debug_frame",
+ dwarf_cfi_section, false, 0, 0,
+ big_endian, smap, text_bias, usu, log);
+ found_usable_info = found_usable_info || result;
+ if (result) log("LoadSymbols: read CFI from .debug_frame");
+ }
+
+ // Linux C++ exception handling information can also provide
+ // unwinding data.
+ const Shdr* eh_frame_section =
+ FindElfSectionByName<ElfClass>(".eh_frame", SHT_PROGBITS, sections, names,
+ names_end, elf_header->e_shnum);
+ if (eh_frame_section) {
+ // Pointers in .eh_frame data may be relative to the base addresses of
+ // certain sections. Provide those sections if present.
+ const Shdr* got_section = FindElfSectionByName<ElfClass>(
+ ".got", SHT_PROGBITS, sections, names, names_end, elf_header->e_shnum);
+ const Shdr* text_section = FindElfSectionByName<ElfClass>(
+ ".text", SHT_PROGBITS, sections, names, names_end, elf_header->e_shnum);
+ info->LoadedSection(".eh_frame");
+ // As above, ignore the return value of this function.
+ bool result = LoadDwarfCFI<ElfClass>(
+ obj_file, elf_header, ".eh_frame", eh_frame_section, true, got_section,
+ text_section, big_endian, smap, text_bias, usu, log);
+ found_usable_info = found_usable_info || result;
+ if (result) log("LoadSymbols: read CFI from .eh_frame");
+ }
+
+ SprintfLiteral(buf, "LoadSymbols: END %s\n", obj_file.c_str());
+ buf[sizeof(buf) - 1] = 0;
+ log(buf);
+
+ return found_usable_info;
+}
+
+// Return the breakpad symbol file identifier for the architecture of
+// ELF_HEADER.
+template <typename ElfClass>
+const char* ElfArchitecture(const typename ElfClass::Ehdr* elf_header) {
+ typedef typename ElfClass::Half Half;
+ Half arch = elf_header->e_machine;
+ switch (arch) {
+ case EM_386:
+ return "x86";
+ case EM_ARM:
+ return "arm";
+ case EM_AARCH64:
+ return "arm64";
+ case EM_MIPS:
+ return "mips";
+ case EM_PPC64:
+ return "ppc64";
+ case EM_PPC:
+ return "ppc";
+ case EM_S390:
+ return "s390";
+ case EM_SPARC:
+ return "sparc";
+ case EM_SPARCV9:
+ return "sparcv9";
+ case EM_X86_64:
+ return "x86_64";
+ default:
+ return NULL;
+ }
+}
+
+// Format the Elf file identifier in IDENTIFIER as a UUID with the
+// dashes removed.
+string FormatIdentifier(unsigned char identifier[16]) {
+ char identifier_str[40];
+ lul::FileID::ConvertIdentifierToString(identifier, identifier_str,
+ sizeof(identifier_str));
+ string id_no_dash;
+ for (int i = 0; identifier_str[i] != '\0'; ++i)
+ if (identifier_str[i] != '-') id_no_dash += identifier_str[i];
+ // Add an extra "0" by the end. PDB files on Windows have an 'age'
+ // number appended to the end of the file identifier; this isn't
+ // really used or necessary on other platforms, but be consistent.
+ id_no_dash += '0';
+ return id_no_dash;
+}
+
+// Return the non-directory portion of FILENAME: the portion after the
+// last slash, or the whole filename if there are no slashes.
+string BaseFileName(const string& filename) {
+ // Lots of copies! basename's behavior is less than ideal.
+ char* c_filename = strdup(filename.c_str());
+ string base = basename(c_filename);
+ free(c_filename);
+ return base;
+}
+
+template <typename ElfClass>
+bool ReadSymbolDataElfClass(const typename ElfClass::Ehdr* elf_header,
+ const string& obj_filename,
+ const vector<string>& debug_dirs, SecMap* smap,
+ void* rx_avma, size_t rx_size,
+ UniqueStringUniverse* usu,
+ void (*log)(const char*)) {
+ typedef typename ElfClass::Ehdr Ehdr;
+
+ unsigned char identifier[16];
+ if (!lul ::FileID::ElfFileIdentifierFromMappedFile(elf_header, identifier)) {
+ fprintf(stderr, "%s: unable to generate file identifier\n",
+ obj_filename.c_str());
+ return false;
+ }
+
+ const char* architecture = ElfArchitecture<ElfClass>(elf_header);
+ if (!architecture) {
+ fprintf(stderr, "%s: unrecognized ELF machine architecture: %d\n",
+ obj_filename.c_str(), elf_header->e_machine);
+ return false;
+ }
+
+ // Figure out what endianness this file is.
+ bool big_endian;
+ if (!ElfEndianness<ElfClass>(elf_header, &big_endian)) return false;
+
+ string name = BaseFileName(obj_filename);
+ string os = "Linux";
+ string id = FormatIdentifier(identifier);
+
+ LoadSymbolsInfo<ElfClass> info(debug_dirs);
+ if (!LoadSymbols<ElfClass>(obj_filename, big_endian, elf_header,
+ !debug_dirs.empty(), &info, smap, rx_avma, rx_size,
+ usu, log)) {
+ const string debuglink_file = info.debuglink_file();
+ if (debuglink_file.empty()) return false;
+
+ // Load debuglink ELF file.
+ fprintf(stderr, "Found debugging info in %s\n", debuglink_file.c_str());
+ MmapWrapper debug_map_wrapper;
+ Ehdr* debug_elf_header = NULL;
+ if (!LoadELF(debuglink_file, &debug_map_wrapper,
+ reinterpret_cast<void**>(&debug_elf_header)))
+ return false;
+ // Sanity checks to make sure everything matches up.
+ const char* debug_architecture =
+ ElfArchitecture<ElfClass>(debug_elf_header);
+ if (!debug_architecture) {
+ fprintf(stderr, "%s: unrecognized ELF machine architecture: %d\n",
+ debuglink_file.c_str(), debug_elf_header->e_machine);
+ return false;
+ }
+ if (strcmp(architecture, debug_architecture)) {
+ fprintf(stderr,
+ "%s with ELF machine architecture %s does not match "
+ "%s with ELF architecture %s\n",
+ debuglink_file.c_str(), debug_architecture, obj_filename.c_str(),
+ architecture);
+ return false;
+ }
+
+ bool debug_big_endian;
+ if (!ElfEndianness<ElfClass>(debug_elf_header, &debug_big_endian))
+ return false;
+ if (debug_big_endian != big_endian) {
+ fprintf(stderr, "%s and %s does not match in endianness\n",
+ obj_filename.c_str(), debuglink_file.c_str());
+ return false;
+ }
+
+ if (!LoadSymbols<ElfClass>(debuglink_file, debug_big_endian,
+ debug_elf_header, false, &info, smap, rx_avma,
+ rx_size, usu, log)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+} // namespace
+
+namespace lul {
+
+bool ReadSymbolDataInternal(const uint8_t* obj_file, const string& obj_filename,
+ const vector<string>& debug_dirs, SecMap* smap,
+ void* rx_avma, size_t rx_size,
+ UniqueStringUniverse* usu,
+ void (*log)(const char*)) {
+ if (!IsValidElf(obj_file)) {
+ fprintf(stderr, "Not a valid ELF file: %s\n", obj_filename.c_str());
+ return false;
+ }
+
+ int elfclass = ElfClass(obj_file);
+ if (elfclass == ELFCLASS32) {
+ return ReadSymbolDataElfClass<ElfClass32>(
+ reinterpret_cast<const Elf32_Ehdr*>(obj_file), obj_filename, debug_dirs,
+ smap, rx_avma, rx_size, usu, log);
+ }
+ if (elfclass == ELFCLASS64) {
+ return ReadSymbolDataElfClass<ElfClass64>(
+ reinterpret_cast<const Elf64_Ehdr*>(obj_file), obj_filename, debug_dirs,
+ smap, rx_avma, rx_size, usu, log);
+ }
+
+ return false;
+}
+
+bool ReadSymbolData(const string& obj_file, const vector<string>& debug_dirs,
+ SecMap* smap, void* rx_avma, size_t rx_size,
+ UniqueStringUniverse* usu, void (*log)(const char*)) {
+ MmapWrapper map_wrapper;
+ void* elf_header = NULL;
+ if (!LoadELF(obj_file, &map_wrapper, &elf_header)) return false;
+
+ return ReadSymbolDataInternal(reinterpret_cast<uint8_t*>(elf_header),
+ obj_file, debug_dirs, smap, rx_avma, rx_size,
+ usu, log);
+}
+
+namespace {
+
+template <typename ElfClass>
+void FindElfClassSection(const char* elf_base, const char* section_name,
+ typename ElfClass::Word section_type,
+ const void** section_start, int* section_size) {
+ typedef typename ElfClass::Ehdr Ehdr;
+ typedef typename ElfClass::Shdr Shdr;
+
+ MOZ_ASSERT(elf_base);
+ MOZ_ASSERT(section_start);
+ MOZ_ASSERT(section_size);
+
+ MOZ_ASSERT(strncmp(elf_base, ELFMAG, SELFMAG) == 0);
+
+ const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base);
+ MOZ_ASSERT(elf_header->e_ident[EI_CLASS] == ElfClass::kClass);
+
+ const Shdr* sections =
+ GetOffset<ElfClass, Shdr>(elf_header, elf_header->e_shoff);
+ const Shdr* section_names = sections + elf_header->e_shstrndx;
+ const char* names =
+ GetOffset<ElfClass, char>(elf_header, section_names->sh_offset);
+ const char* names_end = names + section_names->sh_size;
+
+ const Shdr* section =
+ FindElfSectionByName<ElfClass>(section_name, section_type, sections,
+ names, names_end, elf_header->e_shnum);
+
+ if (section != NULL && section->sh_size > 0) {
+ *section_start = elf_base + section->sh_offset;
+ *section_size = section->sh_size;
+ }
+}
+
+template <typename ElfClass>
+void FindElfClassSegment(const char* elf_base,
+ typename ElfClass::Word segment_type,
+ const void** segment_start, int* segment_size) {
+ typedef typename ElfClass::Ehdr Ehdr;
+ typedef typename ElfClass::Phdr Phdr;
+
+ MOZ_ASSERT(elf_base);
+ MOZ_ASSERT(segment_start);
+ MOZ_ASSERT(segment_size);
+
+ MOZ_ASSERT(strncmp(elf_base, ELFMAG, SELFMAG) == 0);
+
+ const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base);
+ MOZ_ASSERT(elf_header->e_ident[EI_CLASS] == ElfClass::kClass);
+
+ const Phdr* phdrs =
+ GetOffset<ElfClass, Phdr>(elf_header, elf_header->e_phoff);
+
+ for (int i = 0; i < elf_header->e_phnum; ++i) {
+ if (phdrs[i].p_type == segment_type) {
+ *segment_start = elf_base + phdrs[i].p_offset;
+ *segment_size = phdrs[i].p_filesz;
+ return;
+ }
+ }
+}
+
+} // namespace
+
+bool IsValidElf(const void* elf_base) {
+ return strncmp(reinterpret_cast<const char*>(elf_base), ELFMAG, SELFMAG) == 0;
+}
+
+int ElfClass(const void* elf_base) {
+ const ElfW(Ehdr)* elf_header = reinterpret_cast<const ElfW(Ehdr)*>(elf_base);
+
+ return elf_header->e_ident[EI_CLASS];
+}
+
+bool FindElfSection(const void* elf_mapped_base, const char* section_name,
+ uint32_t section_type, const void** section_start,
+ int* section_size, int* elfclass) {
+ MOZ_ASSERT(elf_mapped_base);
+ MOZ_ASSERT(section_start);
+ MOZ_ASSERT(section_size);
+
+ *section_start = NULL;
+ *section_size = 0;
+
+ if (!IsValidElf(elf_mapped_base)) return false;
+
+ int cls = ElfClass(elf_mapped_base);
+ if (elfclass) {
+ *elfclass = cls;
+ }
+
+ const char* elf_base = static_cast<const char*>(elf_mapped_base);
+
+ if (cls == ELFCLASS32) {
+ FindElfClassSection<ElfClass32>(elf_base, section_name, section_type,
+ section_start, section_size);
+ return *section_start != NULL;
+ } else if (cls == ELFCLASS64) {
+ FindElfClassSection<ElfClass64>(elf_base, section_name, section_type,
+ section_start, section_size);
+ return *section_start != NULL;
+ }
+
+ return false;
+}
+
+bool FindElfSegment(const void* elf_mapped_base, uint32_t segment_type,
+ const void** segment_start, int* segment_size,
+ int* elfclass) {
+ MOZ_ASSERT(elf_mapped_base);
+ MOZ_ASSERT(segment_start);
+ MOZ_ASSERT(segment_size);
+
+ *segment_start = NULL;
+ *segment_size = 0;
+
+ if (!IsValidElf(elf_mapped_base)) return false;
+
+ int cls = ElfClass(elf_mapped_base);
+ if (elfclass) {
+ *elfclass = cls;
+ }
+
+ const char* elf_base = static_cast<const char*>(elf_mapped_base);
+
+ if (cls == ELFCLASS32) {
+ FindElfClassSegment<ElfClass32>(elf_base, segment_type, segment_start,
+ segment_size);
+ return *segment_start != NULL;
+ } else if (cls == ELFCLASS64) {
+ FindElfClassSegment<ElfClass64>(elf_base, segment_type, segment_start,
+ segment_size);
+ return *segment_start != NULL;
+ }
+
+ return false;
+}
+
+// (derived from)
+// file_id.cc: Return a unique identifier for a file
+//
+// See file_id.h for documentation
+//
+
+// ELF note name and desc are 32-bits word padded.
+#define NOTE_PADDING(a) ((a + 3) & ~3)
+
+// These functions are also used inside the crashed process, so be safe
+// and use the syscall/libc wrappers instead of direct syscalls or libc.
+
+template <typename ElfClass>
+static bool ElfClassBuildIDNoteIdentifier(const void* section, int length,
+ uint8_t identifier[kMDGUIDSize]) {
+ typedef typename ElfClass::Nhdr Nhdr;
+
+ const void* section_end = reinterpret_cast<const char*>(section) + length;
+ const Nhdr* note_header = reinterpret_cast<const Nhdr*>(section);
+ while (reinterpret_cast<const void*>(note_header) < section_end) {
+ if (note_header->n_type == NT_GNU_BUILD_ID) break;
+ note_header = reinterpret_cast<const Nhdr*>(
+ reinterpret_cast<const char*>(note_header) + sizeof(Nhdr) +
+ NOTE_PADDING(note_header->n_namesz) +
+ NOTE_PADDING(note_header->n_descsz));
+ }
+ if (reinterpret_cast<const void*>(note_header) >= section_end ||
+ note_header->n_descsz == 0) {
+ return false;
+ }
+
+ const char* build_id = reinterpret_cast<const char*>(note_header) +
+ sizeof(Nhdr) + NOTE_PADDING(note_header->n_namesz);
+ // Copy as many bits of the build ID as will fit
+ // into the GUID space.
+ memset(identifier, 0, kMDGUIDSize);
+ memcpy(identifier, build_id,
+ std::min(kMDGUIDSize, (size_t)note_header->n_descsz));
+
+ return true;
+}
+
+// Attempt to locate a .note.gnu.build-id section in an ELF binary
+// and copy as many bytes of it as will fit into |identifier|.
+static bool FindElfBuildIDNote(const void* elf_mapped_base,
+ uint8_t identifier[kMDGUIDSize]) {
+ void* note_section;
+ int note_size, elfclass;
+ if ((!FindElfSegment(elf_mapped_base, PT_NOTE, (const void**)&note_section,
+ &note_size, &elfclass) ||
+ note_size == 0) &&
+ (!FindElfSection(elf_mapped_base, ".note.gnu.build-id", SHT_NOTE,
+ (const void**)&note_section, &note_size, &elfclass) ||
+ note_size == 0)) {
+ return false;
+ }
+
+ if (elfclass == ELFCLASS32) {
+ return ElfClassBuildIDNoteIdentifier<ElfClass32>(note_section, note_size,
+ identifier);
+ } else if (elfclass == ELFCLASS64) {
+ return ElfClassBuildIDNoteIdentifier<ElfClass64>(note_section, note_size,
+ identifier);
+ }
+
+ return false;
+}
+
+// Attempt to locate the .text section of an ELF binary and generate
+// a simple hash by XORing the first page worth of bytes into |identifier|.
+static bool HashElfTextSection(const void* elf_mapped_base,
+ uint8_t identifier[kMDGUIDSize]) {
+ void* text_section;
+ int text_size;
+ if (!FindElfSection(elf_mapped_base, ".text", SHT_PROGBITS,
+ (const void**)&text_section, &text_size, NULL) ||
+ text_size == 0) {
+ return false;
+ }
+
+ memset(identifier, 0, kMDGUIDSize);
+ const uint8_t* ptr = reinterpret_cast<const uint8_t*>(text_section);
+ const uint8_t* ptr_end = ptr + std::min(text_size, 4096);
+ while (ptr < ptr_end) {
+ for (unsigned i = 0; i < kMDGUIDSize; i++) identifier[i] ^= ptr[i];
+ ptr += kMDGUIDSize;
+ }
+ return true;
+}
+
+// static
+bool FileID::ElfFileIdentifierFromMappedFile(const void* base,
+ uint8_t identifier[kMDGUIDSize]) {
+ // Look for a build id note first.
+ if (FindElfBuildIDNote(base, identifier)) return true;
+
+ // Fall back on hashing the first page of the text section.
+ return HashElfTextSection(base, identifier);
+}
+
+// static
+void FileID::ConvertIdentifierToString(const uint8_t identifier[kMDGUIDSize],
+ char* buffer, int buffer_length) {
+ uint8_t identifier_swapped[kMDGUIDSize];
+
+ // Endian-ness swap to match dump processor expectation.
+ memcpy(identifier_swapped, identifier, kMDGUIDSize);
+ uint32_t* data1 = reinterpret_cast<uint32_t*>(identifier_swapped);
+ *data1 = htonl(*data1);
+ uint16_t* data2 = reinterpret_cast<uint16_t*>(identifier_swapped + 4);
+ *data2 = htons(*data2);
+ uint16_t* data3 = reinterpret_cast<uint16_t*>(identifier_swapped + 6);
+ *data3 = htons(*data3);
+
+ int buffer_idx = 0;
+ for (unsigned int idx = 0;
+ (buffer_idx < buffer_length) && (idx < kMDGUIDSize); ++idx) {
+ int hi = (identifier_swapped[idx] >> 4) & 0x0F;
+ int lo = (identifier_swapped[idx]) & 0x0F;
+
+ if (idx == 4 || idx == 6 || idx == 8 || idx == 10)
+ buffer[buffer_idx++] = '-';
+
+ buffer[buffer_idx++] = (hi >= 10) ? 'A' + hi - 10 : '0' + hi;
+ buffer[buffer_idx++] = (lo >= 10) ? 'A' + lo - 10 : '0' + lo;
+ }
+
+ // NULL terminate
+ buffer[(buffer_idx < buffer_length) ? buffer_idx : buffer_idx - 1] = 0;
+}
+
+} // namespace lul
diff --git a/mozglue/baseprofiler/lul/LulElfExt.h b/mozglue/baseprofiler/lul/LulElfExt.h
new file mode 100644
index 0000000000..73d9ff7f15
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulElfExt.h
@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+// Copyright (c) 2006, 2011, 2012 Google Inc.
+// 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.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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
+// OWNER 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.
+
+// This file is derived from the following files in
+// toolkit/crashreporter/google-breakpad:
+// src/common/linux/dump_symbols.h
+
+#ifndef LulElfExt_h
+#define LulElfExt_h
+
+// These two functions are the external interface to the
+// ELF/Dwarf/EXIDX reader.
+
+#include "LulMainInt.h"
+
+using lul::SecMap;
+
+namespace lul {
+
+class UniqueStringUniverse;
+
+// Find all the unwind information in OBJ_FILE, an ELF executable
+// or shared library, and add it to SMAP.
+bool ReadSymbolData(const std::string& obj_file,
+ const std::vector<std::string>& debug_dirs, SecMap* smap,
+ void* rx_avma, size_t rx_size, UniqueStringUniverse* usu,
+ void (*log)(const char*));
+
+// The same as ReadSymbolData, except that OBJ_FILE is assumed to
+// point to a mapped-in image of OBJ_FILENAME.
+bool ReadSymbolDataInternal(const uint8_t* obj_file,
+ const std::string& obj_filename,
+ const std::vector<std::string>& debug_dirs,
+ SecMap* smap, void* rx_avma, size_t rx_size,
+ UniqueStringUniverse* usu,
+ void (*log)(const char*));
+
+} // namespace lul
+
+#endif // LulElfExt_h
diff --git a/mozglue/baseprofiler/lul/LulElfInt.h b/mozglue/baseprofiler/lul/LulElfInt.h
new file mode 100644
index 0000000000..31ffba8ff0
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulElfInt.h
@@ -0,0 +1,218 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+// Copyright (c) 2006, 2012, Google Inc.
+// 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.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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
+// OWNER 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.
+
+// This file is derived from the following files in
+// toolkit/crashreporter/google-breakpad:
+// src/common/android/include/elf.h
+// src/common/linux/elfutils.h
+// src/common/linux/file_id.h
+// src/common/linux/elfutils-inl.h
+
+#ifndef LulElfInt_h
+#define LulElfInt_h
+
+// This header defines functions etc internal to the ELF reader. It
+// should not be included outside of LulElf.cpp.
+
+#include <elf.h>
+#include <stdlib.h>
+
+#include "mozilla/Assertions.h"
+
+#include "PlatformMacros.h"
+
+// (derived from)
+// elfutils.h: Utilities for dealing with ELF files.
+//
+#include <link.h>
+
+#if defined(GP_OS_android)
+
+// From toolkit/crashreporter/google-breakpad/src/common/android/include/elf.h
+// The Android headers don't always define this constant.
+# ifndef EM_X86_64
+# define EM_X86_64 62
+# endif
+
+# ifndef EM_PPC64
+# define EM_PPC64 21
+# endif
+
+# ifndef EM_S390
+# define EM_S390 22
+# endif
+
+# ifndef NT_GNU_BUILD_ID
+# define NT_GNU_BUILD_ID 3
+# endif
+
+# ifndef ElfW
+# define ElfW(type) _ElfW(Elf, ELFSIZE, type)
+# define _ElfW(e, w, t) _ElfW_1(e, w, _##t)
+# define _ElfW_1(e, w, t) e##w##t
+# endif
+
+#endif
+
+#if defined(GP_OS_freebsd)
+
+# ifndef ElfW
+# define ElfW(type) Elf_##type
+# endif
+
+#endif
+
+namespace lul {
+
+// Traits classes so consumers can write templatized code to deal
+// with specific ELF bits.
+struct ElfClass32 {
+ typedef Elf32_Addr Addr;
+ typedef Elf32_Ehdr Ehdr;
+ typedef Elf32_Nhdr Nhdr;
+ typedef Elf32_Phdr Phdr;
+ typedef Elf32_Shdr Shdr;
+ typedef Elf32_Half Half;
+ typedef Elf32_Off Off;
+ typedef Elf32_Word Word;
+ static const int kClass = ELFCLASS32;
+ static const size_t kAddrSize = sizeof(Elf32_Addr);
+};
+
+struct ElfClass64 {
+ typedef Elf64_Addr Addr;
+ typedef Elf64_Ehdr Ehdr;
+ typedef Elf64_Nhdr Nhdr;
+ typedef Elf64_Phdr Phdr;
+ typedef Elf64_Shdr Shdr;
+ typedef Elf64_Half Half;
+ typedef Elf64_Off Off;
+ typedef Elf64_Word Word;
+ static const int kClass = ELFCLASS64;
+ static const size_t kAddrSize = sizeof(Elf64_Addr);
+};
+
+bool IsValidElf(const void* elf_header);
+int ElfClass(const void* elf_base);
+
+// Attempt to find a section named |section_name| of type |section_type|
+// in the ELF binary data at |elf_mapped_base|. On success, returns true
+// and sets |*section_start| to point to the start of the section data,
+// and |*section_size| to the size of the section's data. If |elfclass|
+// is not NULL, set |*elfclass| to the ELF file class.
+bool FindElfSection(const void* elf_mapped_base, const char* section_name,
+ uint32_t section_type, const void** section_start,
+ int* section_size, int* elfclass);
+
+// Internal helper method, exposed for convenience for callers
+// that already have more info.
+template <typename ElfClass>
+const typename ElfClass::Shdr* FindElfSectionByName(
+ const char* name, typename ElfClass::Word section_type,
+ const typename ElfClass::Shdr* sections, const char* section_names,
+ const char* names_end, int nsection);
+
+// Attempt to find the first segment of type |segment_type| in the ELF
+// binary data at |elf_mapped_base|. On success, returns true and sets
+// |*segment_start| to point to the start of the segment data, and
+// and |*segment_size| to the size of the segment's data. If |elfclass|
+// is not NULL, set |*elfclass| to the ELF file class.
+bool FindElfSegment(const void* elf_mapped_base, uint32_t segment_type,
+ const void** segment_start, int* segment_size,
+ int* elfclass);
+
+// Convert an offset from an Elf header into a pointer to the mapped
+// address in the current process. Takes an extra template parameter
+// to specify the return type to avoid having to dynamic_cast the
+// result.
+template <typename ElfClass, typename T>
+const T* GetOffset(const typename ElfClass::Ehdr* elf_header,
+ typename ElfClass::Off offset);
+
+// (derived from)
+// file_id.h: Return a unique identifier for a file
+//
+
+static const size_t kMDGUIDSize = sizeof(MDGUID);
+
+class FileID {
+ public:
+ // Load the identifier for the elf file mapped into memory at |base| into
+ // |identifier|. Return false if the identifier could not be created for the
+ // file.
+ static bool ElfFileIdentifierFromMappedFile(const void* base,
+ uint8_t identifier[kMDGUIDSize]);
+
+ // Convert the |identifier| data to a NULL terminated string. The string will
+ // be formatted as a UUID (e.g., 22F065BB-FC9C-49F7-80FE-26A7CEBD7BCE).
+ // The |buffer| should be at least 37 bytes long to receive all of the data
+ // and termination. Shorter buffers will contain truncated data.
+ static void ConvertIdentifierToString(const uint8_t identifier[kMDGUIDSize],
+ char* buffer, int buffer_length);
+};
+
+template <typename ElfClass, typename T>
+const T* GetOffset(const typename ElfClass::Ehdr* elf_header,
+ typename ElfClass::Off offset) {
+ return reinterpret_cast<const T*>(reinterpret_cast<uintptr_t>(elf_header) +
+ offset);
+}
+
+template <typename ElfClass>
+const typename ElfClass::Shdr* FindElfSectionByName(
+ const char* name, typename ElfClass::Word section_type,
+ const typename ElfClass::Shdr* sections, const char* section_names,
+ const char* names_end, int nsection) {
+ MOZ_ASSERT(name != NULL);
+ MOZ_ASSERT(sections != NULL);
+ MOZ_ASSERT(nsection > 0);
+
+ int name_len = strlen(name);
+ if (name_len == 0) return NULL;
+
+ for (int i = 0; i < nsection; ++i) {
+ const char* section_name = section_names + sections[i].sh_name;
+ if (sections[i].sh_type == section_type &&
+ names_end - section_name >= name_len + 1 &&
+ strcmp(name, section_name) == 0) {
+ return sections + i;
+ }
+ }
+ return NULL;
+}
+
+} // namespace lul
+
+// And finally, the external interface, offered to LulMain.cpp
+#include "LulElfExt.h"
+
+#endif // LulElfInt_h
diff --git a/mozglue/baseprofiler/lul/LulMain.cpp b/mozglue/baseprofiler/lul/LulMain.cpp
new file mode 100644
index 0000000000..75f205ac3a
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulMain.cpp
@@ -0,0 +1,1958 @@
+/* -*- 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/. */
+
+#include "LulMain.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h> // write(), only for testing LUL
+
+#include <algorithm> // std::sort
+#include <string>
+#include <utility>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/MemoryChecking.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Unused.h"
+
+#include "BaseProfiler.h"
+#include "LulCommonExt.h"
+#include "LulElfExt.h"
+#include "LulMainInt.h"
+
+using mozilla::baseprofiler::profiler_current_process_id;
+using mozilla::baseprofiler::profiler_current_thread_id;
+
+// Set this to 1 for verbose logging
+#define DEBUG_MAIN 0
+
+namespace lul {
+
+using mozilla::CheckedInt;
+using mozilla::DebugOnly;
+using mozilla::MallocSizeOf;
+using mozilla::Unused;
+using std::pair;
+using std::string;
+using std::vector;
+
+// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+//
+// Some functions in this file are marked RUNS IN NO-MALLOC CONTEXT.
+// Any such function -- and, hence, the transitive closure of those
+// reachable from it -- must not do any dynamic memory allocation.
+// Doing so risks deadlock. There is exactly one root function for
+// the transitive closure: Lul::Unwind.
+//
+// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+
+////////////////////////////////////////////////////////////////
+// RuleSet //
+////////////////////////////////////////////////////////////////
+
+static const char* NameOf_DW_REG(int16_t aReg) {
+ switch (aReg) {
+ case DW_REG_CFA:
+ return "cfa";
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ case DW_REG_INTEL_XBP:
+ return "xbp";
+ case DW_REG_INTEL_XSP:
+ return "xsp";
+ case DW_REG_INTEL_XIP:
+ return "xip";
+#elif defined(GP_ARCH_arm)
+ case DW_REG_ARM_R7:
+ return "r7";
+ case DW_REG_ARM_R11:
+ return "r11";
+ case DW_REG_ARM_R12:
+ return "r12";
+ case DW_REG_ARM_R13:
+ return "r13";
+ case DW_REG_ARM_R14:
+ return "r14";
+ case DW_REG_ARM_R15:
+ return "r15";
+#elif defined(GP_ARCH_arm64)
+ case DW_REG_AARCH64_X29:
+ return "x29";
+ case DW_REG_AARCH64_X30:
+ return "x30";
+ case DW_REG_AARCH64_SP:
+ return "sp";
+#elif defined(GP_ARCH_mips64)
+ case DW_REG_MIPS_SP:
+ return "sp";
+ case DW_REG_MIPS_FP:
+ return "fp";
+ case DW_REG_MIPS_PC:
+ return "pc";
+#else
+# error "Unsupported arch"
+#endif
+ default:
+ return "???";
+ }
+}
+
+string LExpr::ShowRule(const char* aNewReg) const {
+ char buf[64];
+ string res = string(aNewReg) + "=";
+ switch (mHow) {
+ case UNKNOWN:
+ res += "Unknown";
+ break;
+ case NODEREF:
+ SprintfLiteral(buf, "%s+%d", NameOf_DW_REG(mReg), (int)mOffset);
+ res += buf;
+ break;
+ case DEREF:
+ SprintfLiteral(buf, "*(%s+%d)", NameOf_DW_REG(mReg), (int)mOffset);
+ res += buf;
+ break;
+ case PFXEXPR:
+ SprintfLiteral(buf, "PfxExpr-at-%d", (int)mOffset);
+ res += buf;
+ break;
+ default:
+ res += "???";
+ break;
+ }
+ return res;
+}
+
+void RuleSet::Print(void (*aLog)(const char*)) const {
+ char buf[96];
+ SprintfLiteral(buf, "[%llx .. %llx]: let ", (unsigned long long int)mAddr,
+ (unsigned long long int)(mAddr + mLen - 1));
+ string res = string(buf);
+ res += mCfaExpr.ShowRule("cfa");
+ res += " in";
+ // For each reg we care about, print the recovery expression.
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ res += mXipExpr.ShowRule(" RA");
+ res += mXspExpr.ShowRule(" SP");
+ res += mXbpExpr.ShowRule(" BP");
+#elif defined(GP_ARCH_arm)
+ res += mR15expr.ShowRule(" R15");
+ res += mR7expr.ShowRule(" R7");
+ res += mR11expr.ShowRule(" R11");
+ res += mR12expr.ShowRule(" R12");
+ res += mR13expr.ShowRule(" R13");
+ res += mR14expr.ShowRule(" R14");
+#elif defined(GP_ARCH_arm64)
+ res += mX29expr.ShowRule(" X29");
+ res += mX30expr.ShowRule(" X30");
+ res += mSPexpr.ShowRule(" SP");
+#elif defined(GP_ARCH_mips64)
+ res += mPCexpr.ShowRule(" PC");
+ res += mSPexpr.ShowRule(" SP");
+ res += mFPexpr.ShowRule(" FP");
+#else
+# error "Unsupported arch"
+#endif
+ aLog(res.c_str());
+}
+
+LExpr* RuleSet::ExprForRegno(DW_REG_NUMBER aRegno) {
+ switch (aRegno) {
+ case DW_REG_CFA:
+ return &mCfaExpr;
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ case DW_REG_INTEL_XIP:
+ return &mXipExpr;
+ case DW_REG_INTEL_XSP:
+ return &mXspExpr;
+ case DW_REG_INTEL_XBP:
+ return &mXbpExpr;
+#elif defined(GP_ARCH_arm)
+ case DW_REG_ARM_R15:
+ return &mR15expr;
+ case DW_REG_ARM_R14:
+ return &mR14expr;
+ case DW_REG_ARM_R13:
+ return &mR13expr;
+ case DW_REG_ARM_R12:
+ return &mR12expr;
+ case DW_REG_ARM_R11:
+ return &mR11expr;
+ case DW_REG_ARM_R7:
+ return &mR7expr;
+#elif defined(GP_ARCH_arm64)
+ case DW_REG_AARCH64_X29:
+ return &mX29expr;
+ case DW_REG_AARCH64_X30:
+ return &mX30expr;
+ case DW_REG_AARCH64_SP:
+ return &mSPexpr;
+#elif defined(GP_ARCH_mips64)
+ case DW_REG_MIPS_SP:
+ return &mSPexpr;
+ case DW_REG_MIPS_FP:
+ return &mFPexpr;
+ case DW_REG_MIPS_PC:
+ return &mPCexpr;
+#else
+# error "Unknown arch"
+#endif
+ default:
+ return nullptr;
+ }
+}
+
+RuleSet::RuleSet() {
+ mAddr = 0;
+ mLen = 0;
+ // The only other fields are of type LExpr and those are initialised
+ // by LExpr::LExpr().
+}
+
+////////////////////////////////////////////////////////////////
+// SecMap //
+////////////////////////////////////////////////////////////////
+
+// See header file LulMainInt.h for comments about invariants.
+
+SecMap::SecMap(void (*aLog)(const char*))
+ : mSummaryMinAddr(1), mSummaryMaxAddr(0), mUsable(true), mLog(aLog) {}
+
+SecMap::~SecMap() { mRuleSets.clear(); }
+
+// RUNS IN NO-MALLOC CONTEXT
+RuleSet* SecMap::FindRuleSet(uintptr_t ia) {
+ // Binary search mRuleSets to find one that brackets |ia|.
+ // lo and hi need to be signed, else the loop termination tests
+ // don't work properly. Note that this works correctly even when
+ // mRuleSets.size() == 0.
+
+ // Can't do this until the array has been sorted and preened.
+ MOZ_ASSERT(mUsable);
+
+ long int lo = 0;
+ long int hi = (long int)mRuleSets.size() - 1;
+ while (true) {
+ // current unsearched space is from lo to hi, inclusive.
+ if (lo > hi) {
+ // not found
+ return nullptr;
+ }
+ long int mid = lo + ((hi - lo) / 2);
+ RuleSet* mid_ruleSet = &mRuleSets[mid];
+ uintptr_t mid_minAddr = mid_ruleSet->mAddr;
+ uintptr_t mid_maxAddr = mid_minAddr + mid_ruleSet->mLen - 1;
+ if (ia < mid_minAddr) {
+ hi = mid - 1;
+ continue;
+ }
+ if (ia > mid_maxAddr) {
+ lo = mid + 1;
+ continue;
+ }
+ MOZ_ASSERT(mid_minAddr <= ia && ia <= mid_maxAddr);
+ return mid_ruleSet;
+ }
+ // NOTREACHED
+}
+
+// Add a RuleSet to the collection. The rule is copied in. Calling
+// this makes the map non-searchable.
+void SecMap::AddRuleSet(const RuleSet* rs) {
+ mUsable = false;
+ mRuleSets.push_back(*rs);
+}
+
+// Add a PfxInstr to the vector of such instrs, and return the index
+// in the vector. Calling this makes the map non-searchable.
+uint32_t SecMap::AddPfxInstr(PfxInstr pfxi) {
+ mUsable = false;
+ mPfxInstrs.push_back(pfxi);
+ return mPfxInstrs.size() - 1;
+}
+
+static bool CmpRuleSetsByAddrLE(const RuleSet& rs1, const RuleSet& rs2) {
+ return rs1.mAddr < rs2.mAddr;
+}
+
+// Prepare the map for searching. Completely remove any which don't
+// fall inside the specified range [start, +len).
+void SecMap::PrepareRuleSets(uintptr_t aStart, size_t aLen) {
+ if (mRuleSets.empty()) {
+ return;
+ }
+
+ MOZ_ASSERT(aLen > 0);
+ if (aLen == 0) {
+ // This should never happen.
+ mRuleSets.clear();
+ return;
+ }
+
+ // Sort by start addresses.
+ std::sort(mRuleSets.begin(), mRuleSets.end(), CmpRuleSetsByAddrLE);
+
+ // Detect any entry not completely contained within [start, +len).
+ // Set its length to zero, so that the next pass will remove it.
+ for (size_t i = 0; i < mRuleSets.size(); ++i) {
+ RuleSet* rs = &mRuleSets[i];
+ if (rs->mLen > 0 &&
+ (rs->mAddr < aStart || rs->mAddr + rs->mLen > aStart + aLen)) {
+ rs->mLen = 0;
+ }
+ }
+
+ // Iteratively truncate any overlaps and remove any zero length
+ // entries that might result, or that may have been present
+ // initially. Unless the input is seriously screwy, this is
+ // expected to iterate only once.
+ while (true) {
+ size_t i;
+ size_t n = mRuleSets.size();
+ size_t nZeroLen = 0;
+
+ if (n == 0) {
+ break;
+ }
+
+ for (i = 1; i < n; ++i) {
+ RuleSet* prev = &mRuleSets[i - 1];
+ RuleSet* here = &mRuleSets[i];
+ MOZ_ASSERT(prev->mAddr <= here->mAddr);
+ if (prev->mAddr + prev->mLen > here->mAddr) {
+ prev->mLen = here->mAddr - prev->mAddr;
+ }
+ if (prev->mLen == 0) nZeroLen++;
+ }
+
+ if (mRuleSets[n - 1].mLen == 0) {
+ nZeroLen++;
+ }
+
+ // At this point, the entries are in-order and non-overlapping.
+ // If none of them are zero-length, we are done.
+ if (nZeroLen == 0) {
+ break;
+ }
+
+ // Slide back the entries to remove the zero length ones.
+ size_t j = 0; // The write-point.
+ for (i = 0; i < n; ++i) {
+ if (mRuleSets[i].mLen == 0) {
+ continue;
+ }
+ if (j != i) mRuleSets[j] = mRuleSets[i];
+ ++j;
+ }
+ MOZ_ASSERT(i == n);
+ MOZ_ASSERT(nZeroLen <= n);
+ MOZ_ASSERT(j == n - nZeroLen);
+ while (nZeroLen > 0) {
+ mRuleSets.pop_back();
+ nZeroLen--;
+ }
+
+ MOZ_ASSERT(mRuleSets.size() == j);
+ }
+
+ size_t n = mRuleSets.size();
+
+#ifdef DEBUG
+ // Do a final check on the rules: their address ranges must be
+ // ascending, non overlapping, non zero sized.
+ if (n > 0) {
+ MOZ_ASSERT(mRuleSets[0].mLen > 0);
+ for (size_t i = 1; i < n; ++i) {
+ RuleSet* prev = &mRuleSets[i - 1];
+ RuleSet* here = &mRuleSets[i];
+ MOZ_ASSERT(prev->mAddr < here->mAddr);
+ MOZ_ASSERT(here->mLen > 0);
+ MOZ_ASSERT(prev->mAddr + prev->mLen <= here->mAddr);
+ }
+ }
+#endif
+
+ // Set the summary min and max address values.
+ if (n == 0) {
+ // Use the values defined in comments in the class declaration.
+ mSummaryMinAddr = 1;
+ mSummaryMaxAddr = 0;
+ } else {
+ mSummaryMinAddr = mRuleSets[0].mAddr;
+ mSummaryMaxAddr = mRuleSets[n - 1].mAddr + mRuleSets[n - 1].mLen - 1;
+ }
+ char buf[150];
+ SprintfLiteral(buf, "PrepareRuleSets: %d entries, smin/smax 0x%llx, 0x%llx\n",
+ (int)n, (unsigned long long int)mSummaryMinAddr,
+ (unsigned long long int)mSummaryMaxAddr);
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+
+ // Is now usable for binary search.
+ mUsable = true;
+
+#if 0
+ mLog("\nRulesets after preening\n");
+ for (size_t i = 0; i < mRuleSets.size(); ++i) {
+ mRuleSets[i].Print(mLog);
+ mLog("\n");
+ }
+ mLog("\n");
+#endif
+}
+
+bool SecMap::IsEmpty() { return mRuleSets.empty(); }
+
+size_t SecMap::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ size_t n = aMallocSizeOf(this);
+
+ // It's conceivable that these calls would be unsafe with some
+ // implementations of std::vector, but it seems to be working for now...
+ n += aMallocSizeOf(mRuleSets.data());
+ n += aMallocSizeOf(mPfxInstrs.data());
+
+ return n;
+}
+
+////////////////////////////////////////////////////////////////
+// SegArray //
+////////////////////////////////////////////////////////////////
+
+// A SegArray holds a set of address ranges that together exactly
+// cover an address range, with no overlaps or holes. Each range has
+// an associated value, which in this case has been specialised to be
+// a simple boolean. The representation is kept to minimal canonical
+// form in which adjacent ranges with the same associated value are
+// merged together. Each range is represented by a |struct Seg|.
+//
+// SegArrays are used to keep track of which parts of the address
+// space are known to contain instructions.
+class SegArray {
+ public:
+ void add(uintptr_t lo, uintptr_t hi, bool val) {
+ if (lo > hi) {
+ return;
+ }
+ split_at(lo);
+ if (hi < UINTPTR_MAX) {
+ split_at(hi + 1);
+ }
+ std::vector<Seg>::size_type iLo, iHi, i;
+ iLo = find(lo);
+ iHi = find(hi);
+ for (i = iLo; i <= iHi; ++i) {
+ mSegs[i].val = val;
+ }
+ preen();
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ bool getBoundingCodeSegment(/*OUT*/ uintptr_t* rx_min,
+ /*OUT*/ uintptr_t* rx_max, uintptr_t addr) {
+ std::vector<Seg>::size_type i = find(addr);
+ if (!mSegs[i].val) {
+ return false;
+ }
+ *rx_min = mSegs[i].lo;
+ *rx_max = mSegs[i].hi;
+ return true;
+ }
+
+ SegArray() {
+ Seg s(0, UINTPTR_MAX, false);
+ mSegs.push_back(s);
+ }
+
+ private:
+ struct Seg {
+ Seg(uintptr_t lo, uintptr_t hi, bool val) : lo(lo), hi(hi), val(val) {}
+ uintptr_t lo;
+ uintptr_t hi;
+ bool val;
+ };
+
+ void preen() {
+ for (std::vector<Seg>::iterator iter = mSegs.begin();
+ iter < mSegs.end() - 1; ++iter) {
+ if (iter[0].val != iter[1].val) {
+ continue;
+ }
+ iter[0].hi = iter[1].hi;
+ mSegs.erase(iter + 1);
+ // Back up one, so as not to miss an opportunity to merge
+ // with the entry after this one.
+ --iter;
+ }
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ std::vector<Seg>::size_type find(uintptr_t a) {
+ long int lo = 0;
+ long int hi = (long int)mSegs.size();
+ while (true) {
+ // The unsearched space is lo .. hi inclusive.
+ if (lo > hi) {
+ // Not found. This can't happen.
+ return (std::vector<Seg>::size_type)(-1);
+ }
+ long int mid = lo + ((hi - lo) / 2);
+ uintptr_t mid_lo = mSegs[mid].lo;
+ uintptr_t mid_hi = mSegs[mid].hi;
+ if (a < mid_lo) {
+ hi = mid - 1;
+ continue;
+ }
+ if (a > mid_hi) {
+ lo = mid + 1;
+ continue;
+ }
+ return (std::vector<Seg>::size_type)mid;
+ }
+ }
+
+ void split_at(uintptr_t a) {
+ std::vector<Seg>::size_type i = find(a);
+ if (mSegs[i].lo == a) {
+ return;
+ }
+ mSegs.insert(mSegs.begin() + i + 1, mSegs[i]);
+ mSegs[i].hi = a - 1;
+ mSegs[i + 1].lo = a;
+ }
+
+ void show() {
+ printf("<< %d entries:\n", (int)mSegs.size());
+ for (std::vector<Seg>::iterator iter = mSegs.begin(); iter < mSegs.end();
+ ++iter) {
+ printf(" %016llx %016llx %s\n", (unsigned long long int)(*iter).lo,
+ (unsigned long long int)(*iter).hi,
+ (*iter).val ? "true" : "false");
+ }
+ printf(">>\n");
+ }
+
+ std::vector<Seg> mSegs;
+};
+
+////////////////////////////////////////////////////////////////
+// PriMap //
+////////////////////////////////////////////////////////////////
+
+class PriMap {
+ public:
+ explicit PriMap(void (*aLog)(const char*)) : mLog(aLog) {}
+
+ // RUNS IN NO-MALLOC CONTEXT
+ pair<const RuleSet*, const vector<PfxInstr>*> Lookup(uintptr_t ia) {
+ SecMap* sm = FindSecMap(ia);
+ return pair<const RuleSet*, const vector<PfxInstr>*>(
+ sm ? sm->FindRuleSet(ia) : nullptr, sm ? sm->GetPfxInstrs() : nullptr);
+ }
+
+ // Add a secondary map. No overlaps allowed w.r.t. existing
+ // secondary maps.
+ void AddSecMap(mozilla::UniquePtr<SecMap>&& aSecMap) {
+ // We can't add an empty SecMap to the PriMap. But that's OK
+ // since we'd never be able to find anything in it anyway.
+ if (aSecMap->IsEmpty()) {
+ return;
+ }
+
+ // Iterate through the SecMaps and find the right place for this
+ // one. At the same time, ensure that the in-order
+ // non-overlapping invariant is preserved (and, generally, holds).
+ // FIXME: this gives a cost that is O(N^2) in the total number of
+ // shared objects in the system. ToDo: better.
+ MOZ_ASSERT(aSecMap->mSummaryMinAddr <= aSecMap->mSummaryMaxAddr);
+
+ size_t num_secMaps = mSecMaps.size();
+ uintptr_t i;
+ for (i = 0; i < num_secMaps; ++i) {
+ mozilla::UniquePtr<SecMap>& sm_i = mSecMaps[i];
+ MOZ_ASSERT(sm_i->mSummaryMinAddr <= sm_i->mSummaryMaxAddr);
+ if (aSecMap->mSummaryMinAddr < sm_i->mSummaryMaxAddr) {
+ // |aSecMap| needs to be inserted immediately before mSecMaps[i].
+ break;
+ }
+ }
+ MOZ_ASSERT(i <= num_secMaps);
+ if (i == num_secMaps) {
+ // It goes at the end.
+ mSecMaps.push_back(std::move(aSecMap));
+ } else {
+ std::vector<mozilla::UniquePtr<SecMap>>::iterator iter =
+ mSecMaps.begin() + i;
+ mSecMaps.insert(iter, std::move(aSecMap));
+ }
+ char buf[100];
+ SprintfLiteral(buf, "AddSecMap: now have %d SecMaps\n",
+ (int)mSecMaps.size());
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+ }
+
+ // Remove and delete any SecMaps in the mapping, that intersect
+ // with the specified address range.
+ void RemoveSecMapsInRange(uintptr_t avma_min, uintptr_t avma_max) {
+ MOZ_ASSERT(avma_min <= avma_max);
+ size_t num_secMaps = mSecMaps.size();
+ if (num_secMaps > 0) {
+ intptr_t i;
+ // Iterate from end to start over the vector, so as to ensure
+ // that the special case where |avma_min| and |avma_max| denote
+ // the entire address space, can be completed in time proportional
+ // to the number of elements in the map.
+ for (i = (intptr_t)num_secMaps - 1; i >= 0; i--) {
+ mozilla::UniquePtr<SecMap>& sm_i = mSecMaps[i];
+ if (sm_i->mSummaryMaxAddr < avma_min ||
+ avma_max < sm_i->mSummaryMinAddr) {
+ // There's no overlap. Move on.
+ continue;
+ }
+ // We need to remove mSecMaps[i] and slide all those above it
+ // downwards to cover the hole.
+ mSecMaps.erase(mSecMaps.begin() + i);
+ }
+ }
+ }
+
+ // Return the number of currently contained SecMaps.
+ size_t CountSecMaps() { return mSecMaps.size(); }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ size_t n = aMallocSizeOf(this);
+
+ // It's conceivable that this call would be unsafe with some
+ // implementations of std::vector, but it seems to be working for now...
+ n += aMallocSizeOf(mSecMaps.data());
+
+ for (size_t i = 0; i < mSecMaps.size(); i++) {
+ n += mSecMaps[i]->SizeOfIncludingThis(aMallocSizeOf);
+ }
+
+ return n;
+ }
+
+ private:
+ // RUNS IN NO-MALLOC CONTEXT
+ SecMap* FindSecMap(uintptr_t ia) {
+ // Binary search mSecMaps to find one that brackets |ia|.
+ // lo and hi need to be signed, else the loop termination tests
+ // don't work properly.
+ long int lo = 0;
+ long int hi = (long int)mSecMaps.size() - 1;
+ while (true) {
+ // current unsearched space is from lo to hi, inclusive.
+ if (lo > hi) {
+ // not found
+ return nullptr;
+ }
+ long int mid = lo + ((hi - lo) / 2);
+ mozilla::UniquePtr<SecMap>& mid_secMap = mSecMaps[mid];
+ uintptr_t mid_minAddr = mid_secMap->mSummaryMinAddr;
+ uintptr_t mid_maxAddr = mid_secMap->mSummaryMaxAddr;
+ if (ia < mid_minAddr) {
+ hi = mid - 1;
+ continue;
+ }
+ if (ia > mid_maxAddr) {
+ lo = mid + 1;
+ continue;
+ }
+ MOZ_ASSERT(mid_minAddr <= ia && ia <= mid_maxAddr);
+ return mid_secMap.get();
+ }
+ // NOTREACHED
+ }
+
+ private:
+ // sorted array of per-object ranges, non overlapping, non empty
+ std::vector<mozilla::UniquePtr<SecMap>> mSecMaps;
+
+ // a logging sink, for debugging.
+ void (*mLog)(const char*);
+};
+
+////////////////////////////////////////////////////////////////
+// LUL //
+////////////////////////////////////////////////////////////////
+
+#define LUL_LOG(_str) \
+ do { \
+ char buf[200]; \
+ SprintfLiteral(buf, "LUL: pid %" PRIu64 " tid %" PRIu64 " lul-obj %p: %s", \
+ uint64_t(profiler_current_process_id().ToNumber()), \
+ uint64_t(profiler_current_thread_id().ToNumber()), this, \
+ (_str)); \
+ buf[sizeof(buf) - 1] = 0; \
+ mLog(buf); \
+ } while (0)
+
+LUL::LUL(void (*aLog)(const char*))
+ : mLog(aLog),
+ mAdminMode(true),
+ mAdminThreadId(profiler_current_thread_id()),
+ mPriMap(new PriMap(aLog)),
+ mSegArray(new SegArray()),
+ mUSU(new UniqueStringUniverse()) {
+ LUL_LOG("LUL::LUL: Created object");
+}
+
+LUL::~LUL() {
+ LUL_LOG("LUL::~LUL: Destroyed object");
+ delete mPriMap;
+ delete mSegArray;
+ mLog = nullptr;
+ delete mUSU;
+}
+
+void LUL::MaybeShowStats() {
+ // This is racey in the sense that it can't guarantee that
+ // n_new == n_new_Context + n_new_CFI + n_new_Scanned
+ // if it should happen that mStats is updated by some other thread
+ // in between computation of n_new and n_new_{Context,CFI,FP}.
+ // But it's just stats printing, so we don't really care.
+ uint32_t n_new = mStats - mStatsPrevious;
+ if (n_new >= 5000) {
+ uint32_t n_new_Context = mStats.mContext - mStatsPrevious.mContext;
+ uint32_t n_new_CFI = mStats.mCFI - mStatsPrevious.mCFI;
+ uint32_t n_new_FP = mStats.mFP - mStatsPrevious.mFP;
+ mStatsPrevious = mStats;
+ char buf[200];
+ SprintfLiteral(buf,
+ "LUL frame stats: TOTAL %5u"
+ " CTX %4u CFI %4u FP %4u",
+ n_new, n_new_Context, n_new_CFI, n_new_FP);
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+ }
+}
+
+size_t LUL::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ size_t n = aMallocSizeOf(this);
+ n += mPriMap->SizeOfIncludingThis(aMallocSizeOf);
+
+ // Measurement of the following members may be added later if DMD finds it
+ // is worthwhile:
+ // - mSegArray
+ // - mUSU
+
+ return n;
+}
+
+void LUL::EnableUnwinding() {
+ LUL_LOG("LUL::EnableUnwinding");
+ // Don't assert for Admin mode here. That is, tolerate a call here
+ // if we are already in Unwinding mode.
+ MOZ_RELEASE_ASSERT(profiler_current_thread_id() == mAdminThreadId);
+
+ mAdminMode = false;
+}
+
+void LUL::NotifyAfterMap(uintptr_t aRXavma, size_t aSize, const char* aFileName,
+ const void* aMappedImage) {
+ MOZ_RELEASE_ASSERT(mAdminMode);
+ MOZ_RELEASE_ASSERT(profiler_current_thread_id() == mAdminThreadId);
+
+ mLog(":\n");
+ char buf[200];
+ SprintfLiteral(buf, "NotifyMap %llx %llu %s\n",
+ (unsigned long long int)aRXavma, (unsigned long long int)aSize,
+ aFileName);
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+
+ // Ignore obviously-stupid notifications.
+ if (aSize > 0) {
+ // Here's a new mapping, for this object.
+ mozilla::UniquePtr<SecMap> smap = mozilla::MakeUnique<SecMap>(mLog);
+
+ // Read CFI or EXIDX unwind data into |smap|.
+ if (!aMappedImage) {
+ (void)lul::ReadSymbolData(string(aFileName), std::vector<string>(),
+ smap.get(), (void*)aRXavma, aSize, mUSU, mLog);
+ } else {
+ (void)lul::ReadSymbolDataInternal(
+ (const uint8_t*)aMappedImage, string(aFileName),
+ std::vector<string>(), smap.get(), (void*)aRXavma, aSize, mUSU, mLog);
+ }
+
+ mLog("NotifyMap .. preparing entries\n");
+
+ smap->PrepareRuleSets(aRXavma, aSize);
+
+ SprintfLiteral(buf, "NotifyMap got %lld entries\n",
+ (long long int)smap->Size());
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+
+ // Add it to the primary map (the top level set of mapped objects).
+ mPriMap->AddSecMap(std::move(smap));
+
+ // Tell the segment array about the mapping, so that the stack
+ // scan and __kernel_syscall mechanisms know where valid code is.
+ mSegArray->add(aRXavma, aRXavma + aSize - 1, true);
+ }
+}
+
+void LUL::NotifyExecutableArea(uintptr_t aRXavma, size_t aSize) {
+ MOZ_RELEASE_ASSERT(mAdminMode);
+ MOZ_RELEASE_ASSERT(profiler_current_thread_id() == mAdminThreadId);
+
+ mLog(":\n");
+ char buf[200];
+ SprintfLiteral(buf, "NotifyExecutableArea %llx %llu\n",
+ (unsigned long long int)aRXavma,
+ (unsigned long long int)aSize);
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+
+ // Ignore obviously-stupid notifications.
+ if (aSize > 0) {
+ // Tell the segment array about the mapping, so that the stack
+ // scan and __kernel_syscall mechanisms know where valid code is.
+ mSegArray->add(aRXavma, aRXavma + aSize - 1, true);
+ }
+}
+
+void LUL::NotifyBeforeUnmap(uintptr_t aRXavmaMin, uintptr_t aRXavmaMax) {
+ MOZ_RELEASE_ASSERT(mAdminMode);
+ MOZ_RELEASE_ASSERT(profiler_current_thread_id() == mAdminThreadId);
+
+ mLog(":\n");
+ char buf[100];
+ SprintfLiteral(buf, "NotifyUnmap %016llx-%016llx\n",
+ (unsigned long long int)aRXavmaMin,
+ (unsigned long long int)aRXavmaMax);
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+
+ MOZ_ASSERT(aRXavmaMin <= aRXavmaMax);
+
+ // Remove from the primary map, any secondary maps that intersect
+ // with the address range. Also delete the secondary maps.
+ mPriMap->RemoveSecMapsInRange(aRXavmaMin, aRXavmaMax);
+
+ // Tell the segment array that the address range no longer
+ // contains valid code.
+ mSegArray->add(aRXavmaMin, aRXavmaMax, false);
+
+ SprintfLiteral(buf, "NotifyUnmap: now have %d SecMaps\n",
+ (int)mPriMap->CountSecMaps());
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+}
+
+size_t LUL::CountMappings() {
+ MOZ_RELEASE_ASSERT(mAdminMode);
+ MOZ_RELEASE_ASSERT(profiler_current_thread_id() == mAdminThreadId);
+
+ return mPriMap->CountSecMaps();
+}
+
+// RUNS IN NO-MALLOC CONTEXT
+static TaggedUWord DerefTUW(TaggedUWord aAddr, const StackImage* aStackImg) {
+ if (!aAddr.Valid()) {
+ return TaggedUWord();
+ }
+
+ // Lower limit check. |aAddr.Value()| is the lowest requested address
+ // and |aStackImg->mStartAvma| is the lowest address we actually have,
+ // so the comparison is straightforward.
+ if (aAddr.Value() < aStackImg->mStartAvma) {
+ return TaggedUWord();
+ }
+
+ // Upper limit check. We must compute the highest requested address
+ // and the highest address we actually have, but being careful to
+ // avoid overflow. In particular if |aAddr| is 0xFFF...FFF or the
+ // 3/7 values below that, then we will get overflow. See bug #1245477.
+ typedef CheckedInt<uintptr_t> CheckedUWord;
+ CheckedUWord highest_requested_plus_one =
+ CheckedUWord(aAddr.Value()) + CheckedUWord(sizeof(uintptr_t));
+ CheckedUWord highest_available_plus_one =
+ CheckedUWord(aStackImg->mStartAvma) + CheckedUWord(aStackImg->mLen);
+ if (!highest_requested_plus_one.isValid() // overflow?
+ || !highest_available_plus_one.isValid() // overflow?
+ || (highest_requested_plus_one.value() >
+ highest_available_plus_one.value())) { // in range?
+ return TaggedUWord();
+ }
+
+ return TaggedUWord(
+ *(uintptr_t*)(&aStackImg
+ ->mContents[aAddr.Value() - aStackImg->mStartAvma]));
+}
+
+// RUNS IN NO-MALLOC CONTEXT
+static TaggedUWord EvaluateReg(int16_t aReg, const UnwindRegs* aOldRegs,
+ TaggedUWord aCFA) {
+ switch (aReg) {
+ case DW_REG_CFA:
+ return aCFA;
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ case DW_REG_INTEL_XBP:
+ return aOldRegs->xbp;
+ case DW_REG_INTEL_XSP:
+ return aOldRegs->xsp;
+ case DW_REG_INTEL_XIP:
+ return aOldRegs->xip;
+#elif defined(GP_ARCH_arm)
+ case DW_REG_ARM_R7:
+ return aOldRegs->r7;
+ case DW_REG_ARM_R11:
+ return aOldRegs->r11;
+ case DW_REG_ARM_R12:
+ return aOldRegs->r12;
+ case DW_REG_ARM_R13:
+ return aOldRegs->r13;
+ case DW_REG_ARM_R14:
+ return aOldRegs->r14;
+ case DW_REG_ARM_R15:
+ return aOldRegs->r15;
+#elif defined(GP_ARCH_arm64)
+ case DW_REG_AARCH64_X29:
+ return aOldRegs->x29;
+ case DW_REG_AARCH64_X30:
+ return aOldRegs->x30;
+ case DW_REG_AARCH64_SP:
+ return aOldRegs->sp;
+#elif defined(GP_ARCH_mips64)
+ case DW_REG_MIPS_SP:
+ return aOldRegs->sp;
+ case DW_REG_MIPS_FP:
+ return aOldRegs->fp;
+ case DW_REG_MIPS_PC:
+ return aOldRegs->pc;
+#else
+# error "Unsupported arch"
+#endif
+ default:
+ MOZ_ASSERT(0);
+ return TaggedUWord();
+ }
+}
+
+// RUNS IN NO-MALLOC CONTEXT
+// See prototype for comment.
+TaggedUWord EvaluatePfxExpr(int32_t start, const UnwindRegs* aOldRegs,
+ TaggedUWord aCFA, const StackImage* aStackImg,
+ const vector<PfxInstr>& aPfxInstrs) {
+ // A small evaluation stack, and a stack pointer, which points to
+ // the highest numbered in-use element.
+ const int N_STACK = 10;
+ TaggedUWord stack[N_STACK];
+ int stackPointer = -1;
+ for (int i = 0; i < N_STACK; i++) stack[i] = TaggedUWord();
+
+#define PUSH(_tuw) \
+ do { \
+ if (stackPointer >= N_STACK - 1) goto fail; /* overflow */ \
+ stack[++stackPointer] = (_tuw); \
+ } while (0)
+
+#define POP(_lval) \
+ do { \
+ if (stackPointer < 0) goto fail; /* underflow */ \
+ _lval = stack[stackPointer--]; \
+ } while (0)
+
+ // Cursor in the instruction sequence.
+ size_t curr = start + 1;
+
+ // Check the start point is sane.
+ size_t nInstrs = aPfxInstrs.size();
+ if (start < 0 || (size_t)start >= nInstrs) goto fail;
+
+ {
+ // The instruction sequence must start with PX_Start. If not,
+ // something is seriously wrong.
+ PfxInstr first = aPfxInstrs[start];
+ if (first.mOpcode != PX_Start) goto fail;
+
+ // Push the CFA on the stack to start with (or not), as required by
+ // the original DW_OP_*expression* CFI.
+ if (first.mOperand != 0) PUSH(aCFA);
+ }
+
+ while (true) {
+ if (curr >= nInstrs) goto fail; // ran off the end of the sequence
+
+ PfxInstr pfxi = aPfxInstrs[curr++];
+ if (pfxi.mOpcode == PX_End) break; // we're done
+
+ switch (pfxi.mOpcode) {
+ case PX_Start:
+ // This should appear only at the start of the sequence.
+ goto fail;
+ case PX_End:
+ // We just took care of that, so we shouldn't see it again.
+ MOZ_ASSERT(0);
+ goto fail;
+ case PX_SImm32:
+ PUSH(TaggedUWord((intptr_t)pfxi.mOperand));
+ break;
+ case PX_DwReg: {
+ DW_REG_NUMBER reg = (DW_REG_NUMBER)pfxi.mOperand;
+ MOZ_ASSERT(reg != DW_REG_CFA);
+ PUSH(EvaluateReg(reg, aOldRegs, aCFA));
+ break;
+ }
+ case PX_Deref: {
+ TaggedUWord addr;
+ POP(addr);
+ PUSH(DerefTUW(addr, aStackImg));
+ break;
+ }
+ case PX_Add: {
+ TaggedUWord x, y;
+ POP(x);
+ POP(y);
+ PUSH(y + x);
+ break;
+ }
+ case PX_Sub: {
+ TaggedUWord x, y;
+ POP(x);
+ POP(y);
+ PUSH(y - x);
+ break;
+ }
+ case PX_And: {
+ TaggedUWord x, y;
+ POP(x);
+ POP(y);
+ PUSH(y & x);
+ break;
+ }
+ case PX_Or: {
+ TaggedUWord x, y;
+ POP(x);
+ POP(y);
+ PUSH(y | x);
+ break;
+ }
+ case PX_CmpGES: {
+ TaggedUWord x, y;
+ POP(x);
+ POP(y);
+ PUSH(y.CmpGEs(x));
+ break;
+ }
+ case PX_Shl: {
+ TaggedUWord x, y;
+ POP(x);
+ POP(y);
+ PUSH(y << x);
+ break;
+ }
+ default:
+ MOZ_ASSERT(0);
+ goto fail;
+ }
+ } // while (true)
+
+ // Evaluation finished. The top value on the stack is the result.
+ if (stackPointer >= 0) {
+ return stack[stackPointer];
+ }
+ // Else fall through
+
+fail:
+ return TaggedUWord();
+
+#undef PUSH
+#undef POP
+}
+
+// RUNS IN NO-MALLOC CONTEXT
+TaggedUWord LExpr::EvaluateExpr(const UnwindRegs* aOldRegs, TaggedUWord aCFA,
+ const StackImage* aStackImg,
+ const vector<PfxInstr>* aPfxInstrs) const {
+ switch (mHow) {
+ case UNKNOWN:
+ return TaggedUWord();
+ case NODEREF: {
+ TaggedUWord tuw = EvaluateReg(mReg, aOldRegs, aCFA);
+ tuw = tuw + TaggedUWord((intptr_t)mOffset);
+ return tuw;
+ }
+ case DEREF: {
+ TaggedUWord tuw = EvaluateReg(mReg, aOldRegs, aCFA);
+ tuw = tuw + TaggedUWord((intptr_t)mOffset);
+ return DerefTUW(tuw, aStackImg);
+ }
+ case PFXEXPR: {
+ MOZ_ASSERT(aPfxInstrs);
+ if (!aPfxInstrs) {
+ return TaggedUWord();
+ }
+ return EvaluatePfxExpr(mOffset, aOldRegs, aCFA, aStackImg, *aPfxInstrs);
+ }
+ default:
+ MOZ_ASSERT(0);
+ return TaggedUWord();
+ }
+}
+
+// RUNS IN NO-MALLOC CONTEXT
+static void UseRuleSet(/*MOD*/ UnwindRegs* aRegs, const StackImage* aStackImg,
+ const RuleSet* aRS, const vector<PfxInstr>* aPfxInstrs) {
+ // Take a copy of regs, since we'll need to refer to the old values
+ // whilst computing the new ones.
+ UnwindRegs old_regs = *aRegs;
+
+ // Mark all the current register values as invalid, so that the
+ // caller can see, on our return, which ones have been computed
+ // anew. If we don't even manage to compute a new PC value, then
+ // the caller will have to abandon the unwind.
+ // FIXME: Create and use instead: aRegs->SetAllInvalid();
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ aRegs->xbp = TaggedUWord();
+ aRegs->xsp = TaggedUWord();
+ aRegs->xip = TaggedUWord();
+#elif defined(GP_ARCH_arm)
+ aRegs->r7 = TaggedUWord();
+ aRegs->r11 = TaggedUWord();
+ aRegs->r12 = TaggedUWord();
+ aRegs->r13 = TaggedUWord();
+ aRegs->r14 = TaggedUWord();
+ aRegs->r15 = TaggedUWord();
+#elif defined(GP_ARCH_arm64)
+ aRegs->x29 = TaggedUWord();
+ aRegs->x30 = TaggedUWord();
+ aRegs->sp = TaggedUWord();
+ aRegs->pc = TaggedUWord();
+#elif defined(GP_ARCH_mips64)
+ aRegs->sp = TaggedUWord();
+ aRegs->fp = TaggedUWord();
+ aRegs->pc = TaggedUWord();
+#else
+# error "Unsupported arch"
+#endif
+
+ // This is generally useful.
+ const TaggedUWord inval = TaggedUWord();
+
+ // First, compute the CFA.
+ TaggedUWord cfa = aRS->mCfaExpr.EvaluateExpr(&old_regs, inval /*old cfa*/,
+ aStackImg, aPfxInstrs);
+
+ // If we didn't manage to compute the CFA, well .. that's ungood,
+ // but keep going anyway. It'll be OK provided none of the register
+ // value rules mention the CFA. In any case, compute the new values
+ // for each register that we're tracking.
+
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ aRegs->xbp =
+ aRS->mXbpExpr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->xsp =
+ aRS->mXspExpr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->xip =
+ aRS->mXipExpr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+#elif defined(GP_ARCH_arm)
+ aRegs->r7 = aRS->mR7expr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->r11 =
+ aRS->mR11expr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->r12 =
+ aRS->mR12expr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->r13 =
+ aRS->mR13expr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->r14 =
+ aRS->mR14expr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->r15 =
+ aRS->mR15expr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+#elif defined(GP_ARCH_arm64)
+ aRegs->x29 =
+ aRS->mX29expr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->x30 =
+ aRS->mX30expr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->sp = aRS->mSPexpr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+#elif defined(GP_ARCH_mips64)
+ aRegs->sp = aRS->mSPexpr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->fp = aRS->mFPexpr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+ aRegs->pc = aRS->mPCexpr.EvaluateExpr(&old_regs, cfa, aStackImg, aPfxInstrs);
+#else
+# error "Unsupported arch"
+#endif
+
+ // We're done. Any regs for which we didn't manage to compute a
+ // new value will now be marked as invalid.
+}
+
+// RUNS IN NO-MALLOC CONTEXT
+void LUL::Unwind(/*OUT*/ uintptr_t* aFramePCs,
+ /*OUT*/ uintptr_t* aFrameSPs,
+ /*OUT*/ size_t* aFramesUsed,
+ /*OUT*/ size_t* aFramePointerFramesAcquired,
+ size_t aFramesAvail, UnwindRegs* aStartRegs,
+ StackImage* aStackImg) {
+ MOZ_RELEASE_ASSERT(!mAdminMode);
+
+ /////////////////////////////////////////////////////////
+ // BEGIN UNWIND
+
+ *aFramesUsed = 0;
+
+ UnwindRegs regs = *aStartRegs;
+ TaggedUWord last_valid_sp = TaggedUWord();
+
+ while (true) {
+ if (DEBUG_MAIN) {
+ char buf[300];
+ mLog("\n");
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ SprintfLiteral(
+ buf, "LoopTop: rip %d/%llx rsp %d/%llx rbp %d/%llx\n",
+ (int)regs.xip.Valid(), (unsigned long long int)regs.xip.Value(),
+ (int)regs.xsp.Valid(), (unsigned long long int)regs.xsp.Value(),
+ (int)regs.xbp.Valid(), (unsigned long long int)regs.xbp.Value());
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+#elif defined(GP_ARCH_arm)
+ SprintfLiteral(
+ buf,
+ "LoopTop: r15 %d/%llx r7 %d/%llx r11 %d/%llx"
+ " r12 %d/%llx r13 %d/%llx r14 %d/%llx\n",
+ (int)regs.r15.Valid(), (unsigned long long int)regs.r15.Value(),
+ (int)regs.r7.Valid(), (unsigned long long int)regs.r7.Value(),
+ (int)regs.r11.Valid(), (unsigned long long int)regs.r11.Value(),
+ (int)regs.r12.Valid(), (unsigned long long int)regs.r12.Value(),
+ (int)regs.r13.Valid(), (unsigned long long int)regs.r13.Value(),
+ (int)regs.r14.Valid(), (unsigned long long int)regs.r14.Value());
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+#elif defined(GP_ARCH_arm64)
+ SprintfLiteral(
+ buf,
+ "LoopTop: pc %d/%llx x29 %d/%llx x30 %d/%llx"
+ " sp %d/%llx\n",
+ (int)regs.pc.Valid(), (unsigned long long int)regs.pc.Value(),
+ (int)regs.x29.Valid(), (unsigned long long int)regs.x29.Value(),
+ (int)regs.x30.Valid(), (unsigned long long int)regs.x30.Value(),
+ (int)regs.sp.Valid(), (unsigned long long int)regs.sp.Value());
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+#elif defined(GP_ARCH_mips64)
+ SprintfLiteral(
+ buf, "LoopTop: pc %d/%llx sp %d/%llx fp %d/%llx\n",
+ (int)regs.pc.Valid(), (unsigned long long int)regs.pc.Value(),
+ (int)regs.sp.Valid(), (unsigned long long int)regs.sp.Value(),
+ (int)regs.fp.Valid(), (unsigned long long int)regs.fp.Value());
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+#else
+# error "Unsupported arch"
+#endif
+ }
+
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ TaggedUWord ia = regs.xip;
+ TaggedUWord sp = regs.xsp;
+#elif defined(GP_ARCH_arm)
+ TaggedUWord ia = (*aFramesUsed == 0 ? regs.r15 : regs.r14);
+ TaggedUWord sp = regs.r13;
+#elif defined(GP_ARCH_arm64)
+ TaggedUWord ia = (*aFramesUsed == 0 ? regs.pc : regs.x30);
+ TaggedUWord sp = regs.sp;
+#elif defined(GP_ARCH_mips64)
+ TaggedUWord ia = regs.pc;
+ TaggedUWord sp = regs.sp;
+#else
+# error "Unsupported arch"
+#endif
+
+ if (*aFramesUsed >= aFramesAvail) {
+ break;
+ }
+
+ // If we don't have a valid value for the PC, give up.
+ if (!ia.Valid()) {
+ break;
+ }
+
+ // If this is the innermost frame, record the SP value, which
+ // presumably is valid. If this isn't the innermost frame, and we
+ // have a valid SP value, check that its SP value isn't less that
+ // the one we've seen so far, so as to catch potential SP value
+ // cycles.
+ if (*aFramesUsed == 0) {
+ last_valid_sp = sp;
+ } else {
+ MOZ_ASSERT(last_valid_sp.Valid());
+ if (sp.Valid()) {
+ if (sp.Value() < last_valid_sp.Value()) {
+ // Hmm, SP going in the wrong direction. Let's stop.
+ break;
+ }
+ // Remember where we got to.
+ last_valid_sp = sp;
+ }
+ }
+
+ // For the innermost frame, the IA value is what we need. For all
+ // other frames, it's actually the return address, so back up one
+ // byte so as to get it into the calling instruction.
+ aFramePCs[*aFramesUsed] = ia.Value() - (*aFramesUsed == 0 ? 0 : 1);
+ aFrameSPs[*aFramesUsed] = sp.Valid() ? sp.Value() : 0;
+ (*aFramesUsed)++;
+
+ // Find the RuleSet for the current IA, if any. This will also
+ // query the backing (secondary) maps if it isn't found in the
+ // thread-local cache.
+
+ // If this isn't the innermost frame, back up into the calling insn.
+ if (*aFramesUsed > 1) {
+ ia = ia + TaggedUWord((uintptr_t)(-1));
+ }
+
+ pair<const RuleSet*, const vector<PfxInstr>*> ruleset_and_pfxinstrs =
+ mPriMap->Lookup(ia.Value());
+ const RuleSet* ruleset = ruleset_and_pfxinstrs.first;
+ const vector<PfxInstr>* pfxinstrs = ruleset_and_pfxinstrs.second;
+
+ if (DEBUG_MAIN) {
+ char buf[100];
+ SprintfLiteral(buf, "ruleset for 0x%llx = %p\n",
+ (unsigned long long int)ia.Value(), ruleset);
+ buf[sizeof(buf) - 1] = 0;
+ mLog(buf);
+ }
+
+#if defined(GP_PLAT_x86_android) || defined(GP_PLAT_x86_linux)
+ /////////////////////////////////////////////
+ ////
+ // On 32 bit x86-linux, syscalls are often done via the VDSO
+ // function __kernel_vsyscall, which doesn't have a corresponding
+ // object that we can read debuginfo from. That effectively kills
+ // off all stack traces for threads blocked in syscalls. Hence
+ // special-case by looking at the code surrounding the program
+ // counter.
+ //
+ // 0xf7757420 <__kernel_vsyscall+0>: push %ecx
+ // 0xf7757421 <__kernel_vsyscall+1>: push %edx
+ // 0xf7757422 <__kernel_vsyscall+2>: push %ebp
+ // 0xf7757423 <__kernel_vsyscall+3>: mov %esp,%ebp
+ // 0xf7757425 <__kernel_vsyscall+5>: sysenter
+ // 0xf7757427 <__kernel_vsyscall+7>: nop
+ // 0xf7757428 <__kernel_vsyscall+8>: nop
+ // 0xf7757429 <__kernel_vsyscall+9>: nop
+ // 0xf775742a <__kernel_vsyscall+10>: nop
+ // 0xf775742b <__kernel_vsyscall+11>: nop
+ // 0xf775742c <__kernel_vsyscall+12>: nop
+ // 0xf775742d <__kernel_vsyscall+13>: nop
+ // 0xf775742e <__kernel_vsyscall+14>: int $0x80
+ // 0xf7757430 <__kernel_vsyscall+16>: pop %ebp
+ // 0xf7757431 <__kernel_vsyscall+17>: pop %edx
+ // 0xf7757432 <__kernel_vsyscall+18>: pop %ecx
+ // 0xf7757433 <__kernel_vsyscall+19>: ret
+ //
+ // In cases where the sampled thread is blocked in a syscall, its
+ // program counter will point at "pop %ebp". Hence we look for
+ // the sequence "int $0x80; pop %ebp; pop %edx; pop %ecx; ret", and
+ // the corresponding register-recovery actions are:
+ // new_ebp = *(old_esp + 0)
+ // new eip = *(old_esp + 12)
+ // new_esp = old_esp + 16
+ //
+ // It may also be the case that the program counter points two
+ // nops before the "int $0x80", viz, is __kernel_vsyscall+12, in
+ // the case where the syscall has been restarted but the thread
+ // hasn't been rescheduled. The code below doesn't handle that;
+ // it could easily be made to.
+ //
+ if (!ruleset && *aFramesUsed == 1 && ia.Valid() && sp.Valid()) {
+ uintptr_t insns_min, insns_max;
+ uintptr_t eip = ia.Value();
+ bool b = mSegArray->getBoundingCodeSegment(&insns_min, &insns_max, eip);
+ if (b && eip - 2 >= insns_min && eip + 3 <= insns_max) {
+ uint8_t* eipC = (uint8_t*)eip;
+ if (eipC[-2] == 0xCD && eipC[-1] == 0x80 && eipC[0] == 0x5D &&
+ eipC[1] == 0x5A && eipC[2] == 0x59 && eipC[3] == 0xC3) {
+ TaggedUWord sp_plus_0 = sp;
+ TaggedUWord sp_plus_12 = sp;
+ TaggedUWord sp_plus_16 = sp;
+ sp_plus_12 = sp_plus_12 + TaggedUWord(12);
+ sp_plus_16 = sp_plus_16 + TaggedUWord(16);
+ TaggedUWord new_ebp = DerefTUW(sp_plus_0, aStackImg);
+ TaggedUWord new_eip = DerefTUW(sp_plus_12, aStackImg);
+ TaggedUWord new_esp = sp_plus_16;
+ if (new_ebp.Valid() && new_eip.Valid() && new_esp.Valid()) {
+ regs.xbp = new_ebp;
+ regs.xip = new_eip;
+ regs.xsp = new_esp;
+ continue;
+ }
+ }
+ }
+ }
+ ////
+ /////////////////////////////////////////////
+#endif // defined(GP_PLAT_x86_android) || defined(GP_PLAT_x86_linux)
+
+ // So, do we have a ruleset for this address? If so, use it now.
+ if (ruleset) {
+ if (DEBUG_MAIN) {
+ ruleset->Print(mLog);
+ mLog("\n");
+ }
+ // Use the RuleSet to compute the registers for the previous
+ // frame. |regs| is modified in-place.
+ UseRuleSet(&regs, aStackImg, ruleset, pfxinstrs);
+ continue;
+ }
+
+#if defined(GP_PLAT_amd64_linux) || defined(GP_PLAT_x86_linux) || \
+ defined(GP_PLAT_amd64_android) || defined(GP_PLAT_x86_android) || \
+ defined(GP_PLAT_amd64_freebsd)
+ // There's no RuleSet for the specified address. On amd64/x86_linux, see if
+ // it's possible to recover the caller's frame by using the frame pointer.
+
+ // We seek to compute (new_IP, new_SP, new_BP) from (old_BP, stack image),
+ // and assume the following layout:
+ //
+ // <--- new_SP
+ // +----------+
+ // | new_IP | (return address)
+ // +----------+
+ // | new_BP | <--- old_BP
+ // +----------+
+ // | .... |
+ // | .... |
+ // | .... |
+ // +----------+ <---- old_SP (arbitrary, but must be <= old_BP)
+
+ const size_t wordSzB = sizeof(uintptr_t);
+ TaggedUWord old_xsp = regs.xsp;
+
+ // points at new_BP ?
+ TaggedUWord old_xbp = regs.xbp;
+ // points at new_IP ?
+ TaggedUWord old_xbp_plus1 = regs.xbp + TaggedUWord(1 * wordSzB);
+ // is the new_SP ?
+ TaggedUWord old_xbp_plus2 = regs.xbp + TaggedUWord(2 * wordSzB);
+
+ if (old_xbp.Valid() && old_xbp.IsAligned() && old_xsp.Valid() &&
+ old_xsp.IsAligned() && old_xsp.Value() <= old_xbp.Value()) {
+ // We don't need to do any range, alignment or validity checks for
+ // addresses passed to DerefTUW, since that performs them itself, and
+ // returns an invalid value on failure. Any such value will poison
+ // subsequent uses, and we do a final check for validity before putting
+ // the computed values into |regs|.
+ TaggedUWord new_xbp = DerefTUW(old_xbp, aStackImg);
+ if (new_xbp.Valid() && new_xbp.IsAligned() &&
+ old_xbp.Value() < new_xbp.Value()) {
+ TaggedUWord new_xip = DerefTUW(old_xbp_plus1, aStackImg);
+ TaggedUWord new_xsp = old_xbp_plus2;
+ if (new_xbp.Valid() && new_xip.Valid() && new_xsp.Valid()) {
+ regs.xbp = new_xbp;
+ regs.xip = new_xip;
+ regs.xsp = new_xsp;
+ (*aFramePointerFramesAcquired)++;
+ continue;
+ }
+ }
+ }
+#elif defined(GP_ARCH_arm64)
+ // Here is an example of generated code for prologue and epilogue..
+ //
+ // stp x29, x30, [sp, #-16]!
+ // mov x29, sp
+ // ...
+ // ldp x29, x30, [sp], #16
+ // ret
+ //
+ // Next is another example of generated code.
+ //
+ // stp x20, x19, [sp, #-32]!
+ // stp x29, x30, [sp, #16]
+ // add x29, sp, #0x10
+ // ...
+ // ldp x29, x30, [sp, #16]
+ // ldp x20, x19, [sp], #32
+ // ret
+ //
+ // Previous x29 and x30 register are stored in the address of x29 register.
+ // But since sp register value depends on local variables, we cannot compute
+ // previous sp register from current sp/fp/lr register and there is no
+ // regular rule for sp register in prologue. But since return address is lr
+ // register, if x29 is valid, we will get return address without sp
+ // register.
+ //
+ // So we assume the following layout that if no rule set. x29 is frame
+ // pointer, so we will be able to compute x29 and x30 .
+ //
+ // +----------+ <--- new_sp (cannot compute)
+ // | .... |
+ // +----------+
+ // | new_lr | (return address)
+ // +----------+
+ // | new_fp | <--- old_fp
+ // +----------+
+ // | .... |
+ // | .... |
+ // +----------+ <---- old_sp (arbitrary, but unused)
+
+ TaggedUWord old_fp = regs.x29;
+ if (old_fp.Valid() && old_fp.IsAligned() && last_valid_sp.Valid() &&
+ last_valid_sp.Value() <= old_fp.Value()) {
+ TaggedUWord new_fp = DerefTUW(old_fp, aStackImg);
+ if (new_fp.Valid() && new_fp.IsAligned() &&
+ old_fp.Value() < new_fp.Value()) {
+ TaggedUWord old_fp_plus1 = old_fp + TaggedUWord(8);
+ TaggedUWord new_lr = DerefTUW(old_fp_plus1, aStackImg);
+ if (new_lr.Valid()) {
+ regs.x29 = new_fp;
+ regs.x30 = new_lr;
+ // When using frame pointer to walk stack, we cannot compute sp
+ // register since we cannot compute sp register from fp/lr/sp
+ // register, and there is no regular rule to compute previous sp
+ // register. So mark as invalid.
+ regs.sp = TaggedUWord();
+ (*aFramePointerFramesAcquired)++;
+ continue;
+ }
+ }
+ }
+#endif // defined(GP_PLAT_amd64_linux) || defined(GP_PLAT_x86_linux) ||
+ // defined(GP_PLAT_amd64_android) || defined(GP_PLAT_x86_android)
+
+ // We failed to recover a frame either using CFI or FP chasing, and we
+ // have no other ways to recover the frame. So we have to give up.
+ break;
+
+ } // top level unwind loop
+
+ // END UNWIND
+ /////////////////////////////////////////////////////////
+}
+
+////////////////////////////////////////////////////////////////
+// LUL Unit Testing //
+////////////////////////////////////////////////////////////////
+
+static const int LUL_UNIT_TEST_STACK_SIZE = 32768;
+
+#if defined(GP_ARCH_mips64)
+static __attribute__((noinline)) unsigned long __getpc(void) {
+ unsigned long rtaddr;
+ __asm__ volatile("move %0, $31" : "=r"(rtaddr));
+ return rtaddr;
+}
+#endif
+
+// This function is innermost in the test call sequence. It uses LUL
+// to unwind, and compares the result with the sequence specified in
+// the director string. These need to agree in order for the test to
+// pass. In order not to screw up the results, this function needs
+// to have a not-very big stack frame, since we're only presenting
+// the innermost LUL_UNIT_TEST_STACK_SIZE bytes of stack to LUL, and
+// that chunk unavoidably includes the frame for this function.
+//
+// This function must not be inlined into its callers. Doing so will
+// cause the expected-vs-actual backtrace consistency checking to
+// fail. Prints summary results to |aLUL|'s logging sink and also
+// returns a boolean indicating whether or not the test failed.
+static __attribute__((noinline)) bool GetAndCheckStackTrace(
+ LUL* aLUL, const char* dstring) {
+ // Get hold of the current unwind-start registers.
+ UnwindRegs startRegs;
+ memset(&startRegs, 0, sizeof(startRegs));
+#if defined(GP_ARCH_amd64)
+ volatile uintptr_t block[3];
+ MOZ_ASSERT(sizeof(block) == 24);
+ __asm__ __volatile__(
+ "leaq 0(%%rip), %%r15"
+ "\n\t"
+ "movq %%r15, 0(%0)"
+ "\n\t"
+ "movq %%rsp, 8(%0)"
+ "\n\t"
+ "movq %%rbp, 16(%0)"
+ "\n"
+ :
+ : "r"(&block[0])
+ : "memory", "r15");
+ startRegs.xip = TaggedUWord(block[0]);
+ startRegs.xsp = TaggedUWord(block[1]);
+ startRegs.xbp = TaggedUWord(block[2]);
+ const uintptr_t REDZONE_SIZE = 128;
+ uintptr_t start = block[1] - REDZONE_SIZE;
+#elif defined(GP_PLAT_x86_linux) || defined(GP_PLAT_x86_android)
+ volatile uintptr_t block[3];
+ MOZ_ASSERT(sizeof(block) == 12);
+ __asm__ __volatile__(
+ ".byte 0xE8,0x00,0x00,0x00,0x00" /*call next insn*/
+ "\n\t"
+ "popl %%edi"
+ "\n\t"
+ "movl %%edi, 0(%0)"
+ "\n\t"
+ "movl %%esp, 4(%0)"
+ "\n\t"
+ "movl %%ebp, 8(%0)"
+ "\n"
+ :
+ : "r"(&block[0])
+ : "memory", "edi");
+ startRegs.xip = TaggedUWord(block[0]);
+ startRegs.xsp = TaggedUWord(block[1]);
+ startRegs.xbp = TaggedUWord(block[2]);
+ const uintptr_t REDZONE_SIZE = 0;
+ uintptr_t start = block[1] - REDZONE_SIZE;
+#elif defined(GP_PLAT_arm_linux) || defined(GP_PLAT_arm_android)
+ volatile uintptr_t block[6];
+ MOZ_ASSERT(sizeof(block) == 24);
+ __asm__ __volatile__(
+ "mov r0, r15"
+ "\n\t"
+ "str r0, [%0, #0]"
+ "\n\t"
+ "str r14, [%0, #4]"
+ "\n\t"
+ "str r13, [%0, #8]"
+ "\n\t"
+ "str r12, [%0, #12]"
+ "\n\t"
+ "str r11, [%0, #16]"
+ "\n\t"
+ "str r7, [%0, #20]"
+ "\n"
+ :
+ : "r"(&block[0])
+ : "memory", "r0");
+ startRegs.r15 = TaggedUWord(block[0]);
+ startRegs.r14 = TaggedUWord(block[1]);
+ startRegs.r13 = TaggedUWord(block[2]);
+ startRegs.r12 = TaggedUWord(block[3]);
+ startRegs.r11 = TaggedUWord(block[4]);
+ startRegs.r7 = TaggedUWord(block[5]);
+ const uintptr_t REDZONE_SIZE = 0;
+ uintptr_t start = block[1] - REDZONE_SIZE;
+#elif defined(GP_ARCH_arm64)
+ volatile uintptr_t block[4];
+ MOZ_ASSERT(sizeof(block) == 32);
+ __asm__ __volatile__(
+ "adr x0, . \n\t"
+ "str x0, [%0, #0] \n\t"
+ "str x29, [%0, #8] \n\t"
+ "str x30, [%0, #16] \n\t"
+ "mov x0, sp \n\t"
+ "str x0, [%0, #24] \n\t"
+ :
+ : "r"(&block[0])
+ : "memory", "x0");
+ startRegs.pc = TaggedUWord(block[0]);
+ startRegs.x29 = TaggedUWord(block[1]);
+ startRegs.x30 = TaggedUWord(block[2]);
+ startRegs.sp = TaggedUWord(block[3]);
+ const uintptr_t REDZONE_SIZE = 0;
+ uintptr_t start = block[1] - REDZONE_SIZE;
+#elif defined(GP_ARCH_mips64)
+ volatile uintptr_t block[3];
+ MOZ_ASSERT(sizeof(block) == 24);
+ __asm__ __volatile__(
+ "sd $29, 8(%0) \n"
+ "sd $30, 16(%0) \n"
+ :
+ : "r"(block)
+ : "memory");
+ block[0] = __getpc();
+ startRegs.pc = TaggedUWord(block[0]);
+ startRegs.sp = TaggedUWord(block[1]);
+ startRegs.fp = TaggedUWord(block[2]);
+ const uintptr_t REDZONE_SIZE = 0;
+ uintptr_t start = block[1] - REDZONE_SIZE;
+#else
+# error "Unsupported platform"
+#endif
+
+ // Get hold of the innermost LUL_UNIT_TEST_STACK_SIZE bytes of the
+ // stack.
+ uintptr_t end = start + LUL_UNIT_TEST_STACK_SIZE;
+ uintptr_t ws = sizeof(void*);
+ start &= ~(ws - 1);
+ end &= ~(ws - 1);
+ uintptr_t nToCopy = end - start;
+ if (nToCopy > lul::N_STACK_BYTES) {
+ nToCopy = lul::N_STACK_BYTES;
+ }
+ MOZ_ASSERT(nToCopy <= lul::N_STACK_BYTES);
+ StackImage* stackImg = new StackImage();
+ stackImg->mLen = nToCopy;
+ stackImg->mStartAvma = start;
+ if (nToCopy > 0) {
+ MOZ_MAKE_MEM_DEFINED((void*)start, nToCopy);
+ memcpy(&stackImg->mContents[0], (void*)start, nToCopy);
+ }
+
+ // Unwind it.
+ const int MAX_TEST_FRAMES = 64;
+ uintptr_t framePCs[MAX_TEST_FRAMES];
+ uintptr_t frameSPs[MAX_TEST_FRAMES];
+ size_t framesAvail = mozilla::ArrayLength(framePCs);
+ size_t framesUsed = 0;
+ size_t framePointerFramesAcquired = 0;
+ aLUL->Unwind(&framePCs[0], &frameSPs[0], &framesUsed,
+ &framePointerFramesAcquired, framesAvail, &startRegs, stackImg);
+
+ delete stackImg;
+
+ // if (0) {
+ // // Show what we have.
+ // fprintf(stderr, "Got %d frames:\n", (int)framesUsed);
+ // for (size_t i = 0; i < framesUsed; i++) {
+ // fprintf(stderr, " [%2d] SP %p PC %p\n",
+ // (int)i, (void*)frameSPs[i], (void*)framePCs[i]);
+ // }
+ // fprintf(stderr, "\n");
+ //}
+
+ // Check to see if there's a consistent binding between digits in
+ // the director string ('1' .. '8') and the PC values acquired by
+ // the unwind. If there isn't, the unwinding has failed somehow.
+ uintptr_t binding[8]; // binding for '1' .. binding for '8'
+ memset((void*)binding, 0, sizeof(binding));
+
+ // The general plan is to work backwards along the director string
+ // and forwards along the framePCs array. Doing so corresponds to
+ // working outwards from the innermost frame of the recursive test set.
+ const char* cursor = dstring;
+
+ // Find the end. This leaves |cursor| two bytes past the first
+ // character we want to look at -- see comment below.
+ while (*cursor) cursor++;
+
+ // Counts the number of consistent frames.
+ size_t nConsistent = 0;
+
+ // Iterate back to the start of the director string. The starting
+ // points are a bit complex. We can't use framePCs[0] because that
+ // contains the PC in this frame (above). We can't use framePCs[1]
+ // because that will contain the PC at return point in the recursive
+ // test group (TestFn[1-8]) for their call "out" to this function,
+ // GetAndCheckStackTrace. Although LUL will compute a correct
+ // return address, that will not be the same return address as for a
+ // recursive call out of the the function to another function in the
+ // group. Hence we can only start consistency checking at
+ // framePCs[2].
+ //
+ // To be consistent, then, we must ignore the last element in the
+ // director string as that corresponds to framePCs[1]. Hence the
+ // start points are: framePCs[2] and the director string 2 bytes
+ // before the terminating zero.
+ //
+ // Also as a result of this, the number of consistent frames counted
+ // will always be one less than the length of the director string
+ // (not including its terminating zero).
+ size_t frameIx;
+ for (cursor = cursor - 2, frameIx = 2;
+ cursor >= dstring && frameIx < framesUsed; cursor--, frameIx++) {
+ char c = *cursor;
+ uintptr_t pc = framePCs[frameIx];
+ // If this doesn't hold, the director string is ill-formed.
+ MOZ_ASSERT(c >= '1' && c <= '8');
+ int n = ((int)c) - ((int)'1');
+ if (binding[n] == 0) {
+ // There's no binding for |c| yet, so install |pc| and carry on.
+ binding[n] = pc;
+ nConsistent++;
+ continue;
+ }
+ // There's a pre-existing binding for |c|. Check it's consistent.
+ if (binding[n] != pc) {
+ // Not consistent. Give up now.
+ break;
+ }
+ // Consistent. Keep going.
+ nConsistent++;
+ }
+
+ // So, did we succeed?
+ bool passed = nConsistent + 1 == strlen(dstring);
+
+ // Show the results.
+ char buf[200];
+ SprintfLiteral(buf, "LULUnitTest: dstring = %s\n", dstring);
+ buf[sizeof(buf) - 1] = 0;
+ aLUL->mLog(buf);
+ SprintfLiteral(buf, "LULUnitTest: %d consistent, %d in dstring: %s\n",
+ (int)nConsistent, (int)strlen(dstring),
+ passed ? "PASS" : "FAIL");
+ buf[sizeof(buf) - 1] = 0;
+ aLUL->mLog(buf);
+
+ return !passed;
+}
+
+// Macro magic to create a set of 8 mutually recursive functions with
+// varying frame sizes. These will recurse amongst themselves as
+// specified by |strP|, the directory string, and call
+// GetAndCheckStackTrace when the string becomes empty, passing it the
+// original value of the string. This checks the result, printing
+// results on |aLUL|'s logging sink, and also returns a boolean
+// indicating whether or not the results are acceptable (correct).
+
+#define DECL_TEST_FN(NAME) \
+ bool NAME(LUL* aLUL, const char* strPorig, const char* strP);
+
+#define GEN_TEST_FN(NAME, FRAMESIZE) \
+ bool NAME(LUL* aLUL, const char* strPorig, const char* strP) { \
+ /* Create a frame of size (at least) FRAMESIZE, so that the */ \
+ /* 8 functions created by this macro offer some variation in frame */ \
+ /* sizes. This isn't as simple as it might seem, since a clever */ \
+ /* optimizing compiler (eg, clang-5) detects that the array is unused */ \
+ /* and removes it. We try to defeat this by passing it to a function */ \
+ /* in a different compilation unit, and hoping that clang does not */ \
+ /* notice that the call is a no-op. */ \
+ char space[FRAMESIZE]; \
+ Unused << write(1, space, 0); /* write zero bytes of |space| to stdout */ \
+ \
+ if (*strP == '\0') { \
+ /* We've come to the end of the director string. */ \
+ /* Take a stack snapshot. */ \
+ /* We purposefully use a negation to avoid tail-call optimization */ \
+ return !GetAndCheckStackTrace(aLUL, strPorig); \
+ } else { \
+ /* Recurse onwards. This is a bit subtle. The obvious */ \
+ /* thing to do here is call onwards directly, from within the */ \
+ /* arms of the case statement. That gives a problem in that */ \
+ /* there will be multiple return points inside each function when */ \
+ /* unwinding, so it will be difficult to check for consistency */ \
+ /* against the director string. Instead, we make an indirect */ \
+ /* call, so as to guarantee that there is only one call site */ \
+ /* within each function. This does assume that the compiler */ \
+ /* won't transform it back to the simple direct-call form. */ \
+ /* To discourage it from doing so, the call is bracketed with */ \
+ /* __asm__ __volatile__ sections so as to make it not-movable. */ \
+ bool (*nextFn)(LUL*, const char*, const char*) = NULL; \
+ switch (*strP) { \
+ case '1': \
+ nextFn = TestFn1; \
+ break; \
+ case '2': \
+ nextFn = TestFn2; \
+ break; \
+ case '3': \
+ nextFn = TestFn3; \
+ break; \
+ case '4': \
+ nextFn = TestFn4; \
+ break; \
+ case '5': \
+ nextFn = TestFn5; \
+ break; \
+ case '6': \
+ nextFn = TestFn6; \
+ break; \
+ case '7': \
+ nextFn = TestFn7; \
+ break; \
+ case '8': \
+ nextFn = TestFn8; \
+ break; \
+ default: \
+ nextFn = TestFn8; \
+ break; \
+ } \
+ /* "use" |space| immediately after the recursive call, */ \
+ /* so as to dissuade clang from deallocating the space while */ \
+ /* the call is active, or otherwise messing with the stack frame. */ \
+ __asm__ __volatile__("" ::: "cc", "memory"); \
+ bool passed = nextFn(aLUL, strPorig, strP + 1); \
+ Unused << write(1, space, 0); \
+ __asm__ __volatile__("" ::: "cc", "memory"); \
+ return passed; \
+ } \
+ }
+
+// The test functions are mutually recursive, so it is necessary to
+// declare them before defining them.
+DECL_TEST_FN(TestFn1)
+DECL_TEST_FN(TestFn2)
+DECL_TEST_FN(TestFn3)
+DECL_TEST_FN(TestFn4)
+DECL_TEST_FN(TestFn5)
+DECL_TEST_FN(TestFn6)
+DECL_TEST_FN(TestFn7)
+DECL_TEST_FN(TestFn8)
+
+GEN_TEST_FN(TestFn1, 123)
+GEN_TEST_FN(TestFn2, 456)
+GEN_TEST_FN(TestFn3, 789)
+GEN_TEST_FN(TestFn4, 23)
+GEN_TEST_FN(TestFn5, 47)
+GEN_TEST_FN(TestFn6, 117)
+GEN_TEST_FN(TestFn7, 1)
+GEN_TEST_FN(TestFn8, 99)
+
+// This starts the test sequence going. Call here to generate a
+// sequence of calls as directed by the string |dstring|. The call
+// sequence will, from its innermost frame, finish by calling
+// GetAndCheckStackTrace() and passing it |dstring|.
+// GetAndCheckStackTrace() will unwind the stack, check consistency
+// of those results against |dstring|, and print a pass/fail message
+// to aLUL's logging sink. It also updates the counters in *aNTests
+// and aNTestsPassed.
+__attribute__((noinline)) void TestUnw(/*OUT*/ int* aNTests,
+ /*OUT*/ int* aNTestsPassed, LUL* aLUL,
+ const char* dstring) {
+ // Ensure that the stack has at least this much space on it. This
+ // makes it safe to saw off the top LUL_UNIT_TEST_STACK_SIZE bytes
+ // and hand it to LUL. Safe in the sense that no segfault can
+ // happen because the stack is at least this big. This is all
+ // somewhat dubious in the sense that a sufficiently clever compiler
+ // (clang, for one) can figure out that space[] is unused and delete
+ // it from the frame. Hence the somewhat elaborate hoop jumping to
+ // fill it up before the call and to at least appear to use the
+ // value afterwards.
+ int i;
+ volatile char space[LUL_UNIT_TEST_STACK_SIZE];
+ for (i = 0; i < LUL_UNIT_TEST_STACK_SIZE; i++) {
+ space[i] = (char)(i & 0x7F);
+ }
+
+ // Really run the test.
+ bool passed = TestFn1(aLUL, dstring, dstring);
+
+ // Appear to use space[], by visiting the value to compute some kind
+ // of checksum, and then (apparently) using the checksum.
+ int sum = 0;
+ for (i = 0; i < LUL_UNIT_TEST_STACK_SIZE; i++) {
+ // If this doesn't fool LLVM, I don't know what will.
+ sum += space[i] - 3 * i;
+ }
+ __asm__ __volatile__("" : : "r"(sum));
+
+ // Update the counters.
+ (*aNTests)++;
+ if (passed) {
+ (*aNTestsPassed)++;
+ }
+}
+
+void RunLulUnitTests(/*OUT*/ int* aNTests, /*OUT*/ int* aNTestsPassed,
+ LUL* aLUL) {
+ aLUL->mLog(":\n");
+ aLUL->mLog("LULUnitTest: BEGIN\n");
+ *aNTests = *aNTestsPassed = 0;
+ TestUnw(aNTests, aNTestsPassed, aLUL, "11111111");
+ TestUnw(aNTests, aNTestsPassed, aLUL, "11222211");
+ TestUnw(aNTests, aNTestsPassed, aLUL, "111222333");
+ TestUnw(aNTests, aNTestsPassed, aLUL, "1212121231212331212121212121212");
+ TestUnw(aNTests, aNTestsPassed, aLUL, "31415827271828325332173258");
+ TestUnw(aNTests, aNTestsPassed, aLUL,
+ "123456781122334455667788777777777777777777777");
+ aLUL->mLog("LULUnitTest: END\n");
+ aLUL->mLog(":\n");
+}
+
+} // namespace lul
diff --git a/mozglue/baseprofiler/lul/LulMain.h b/mozglue/baseprofiler/lul/LulMain.h
new file mode 100644
index 0000000000..987a878c90
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulMain.h
@@ -0,0 +1,378 @@
+/* -*- 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/. */
+
+#ifndef LulMain_h
+#define LulMain_h
+
+#include "PlatformMacros.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/BaseProfilerUtils.h"
+
+// LUL: A Lightweight Unwind Library.
+// This file provides the end-user (external) interface for LUL.
+
+// Some comments about naming in the implementation. These are safe
+// to ignore if you are merely using LUL, but are important if you
+// hack on its internals.
+//
+// Debuginfo readers in general have tended to use the word "address"
+// to mean several different things. This sometimes makes them
+// difficult to understand and maintain. LUL tries hard to avoid
+// using the word "address" and instead uses the following more
+// precise terms:
+//
+// * SVMA ("Stated Virtual Memory Address"): this is an address of a
+// symbol (etc) as it is stated in the symbol table, or other
+// metadata, of an object. Such values are typically small and
+// start from zero or thereabouts, unless the object has been
+// prelinked.
+//
+// * AVMA ("Actual Virtual Memory Address"): this is the address of a
+// symbol (etc) in a running process, that is, once the associated
+// object has been mapped into a process. Such values are typically
+// much larger than SVMAs, since objects can get mapped arbitrarily
+// far along the address space.
+//
+// * "Bias": the difference between AVMA and SVMA for a given symbol
+// (specifically, AVMA - SVMA). The bias is always an integral
+// number of pages. Once we know the bias for a given object's
+// text section (for example), we can compute the AVMAs of all of
+// its text symbols by adding the bias to their SVMAs.
+//
+// * "Image address": typically, to read debuginfo from an object we
+// will temporarily mmap in the file so as to read symbol tables
+// etc. Addresses in this temporary mapping are called "Image
+// addresses". Note that the temporary mapping is entirely
+// unrelated to the mappings of the file that the dynamic linker
+// must perform merely in order to get the program to run. Hence
+// image addresses are unrelated to either SVMAs or AVMAs.
+
+namespace lul {
+
+// A machine word plus validity tag.
+class TaggedUWord {
+ public:
+ // RUNS IN NO-MALLOC CONTEXT
+ // Construct a valid one.
+ explicit TaggedUWord(uintptr_t w) : mValue(w), mValid(true) {}
+
+ // RUNS IN NO-MALLOC CONTEXT
+ // Construct an invalid one.
+ TaggedUWord() : mValue(0), mValid(false) {}
+
+ // RUNS IN NO-MALLOC CONTEXT
+ TaggedUWord operator+(TaggedUWord rhs) const {
+ return (Valid() && rhs.Valid()) ? TaggedUWord(Value() + rhs.Value())
+ : TaggedUWord();
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ TaggedUWord operator-(TaggedUWord rhs) const {
+ return (Valid() && rhs.Valid()) ? TaggedUWord(Value() - rhs.Value())
+ : TaggedUWord();
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ TaggedUWord operator&(TaggedUWord rhs) const {
+ return (Valid() && rhs.Valid()) ? TaggedUWord(Value() & rhs.Value())
+ : TaggedUWord();
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ TaggedUWord operator|(TaggedUWord rhs) const {
+ return (Valid() && rhs.Valid()) ? TaggedUWord(Value() | rhs.Value())
+ : TaggedUWord();
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ TaggedUWord CmpGEs(TaggedUWord rhs) const {
+ if (Valid() && rhs.Valid()) {
+ intptr_t s1 = (intptr_t)Value();
+ intptr_t s2 = (intptr_t)rhs.Value();
+ return TaggedUWord(s1 >= s2 ? 1 : 0);
+ }
+ return TaggedUWord();
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ TaggedUWord operator<<(TaggedUWord rhs) const {
+ if (Valid() && rhs.Valid()) {
+ uintptr_t shift = rhs.Value();
+ if (shift < 8 * sizeof(uintptr_t)) return TaggedUWord(Value() << shift);
+ }
+ return TaggedUWord();
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ // Is equal? Note: non-validity on either side gives non-equality.
+ bool operator==(TaggedUWord other) const {
+ return (mValid && other.Valid()) ? (mValue == other.Value()) : false;
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ // Is it word-aligned?
+ bool IsAligned() const {
+ return mValid && (mValue & (sizeof(uintptr_t) - 1)) == 0;
+ }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ uintptr_t Value() const { return mValue; }
+
+ // RUNS IN NO-MALLOC CONTEXT
+ bool Valid() const { return mValid; }
+
+ private:
+ uintptr_t mValue;
+ bool mValid;
+};
+
+// The registers, with validity tags, that will be unwound.
+
+struct UnwindRegs {
+#if defined(GP_ARCH_arm)
+ TaggedUWord r7;
+ TaggedUWord r11;
+ TaggedUWord r12;
+ TaggedUWord r13;
+ TaggedUWord r14;
+ TaggedUWord r15;
+#elif defined(GP_ARCH_arm64)
+ TaggedUWord x29;
+ TaggedUWord x30;
+ TaggedUWord sp;
+ TaggedUWord pc;
+#elif defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ TaggedUWord xbp;
+ TaggedUWord xsp;
+ TaggedUWord xip;
+#elif defined(GP_ARCH_mips64)
+ TaggedUWord sp;
+ TaggedUWord fp;
+ TaggedUWord pc;
+#else
+# error "Unknown plat"
+#endif
+};
+
+// The maximum number of bytes in a stack snapshot. This value can be increased
+// if necessary, but testing showed that 160k is enough to obtain good
+// backtraces on x86_64 Linux. Most backtraces fit comfortably into 4-8k of
+// stack space, but we do have some very deep stacks occasionally. Please see
+// the comments in DoNativeBacktrace as to why it's OK to have this value be so
+// large.
+static const size_t N_STACK_BYTES = 160 * 1024;
+
+// The stack chunk image that will be unwound.
+struct StackImage {
+ // [start_avma, +len) specify the address range in the buffer.
+ // Obviously we require 0 <= len <= N_STACK_BYTES.
+ uintptr_t mStartAvma;
+ size_t mLen;
+ uint8_t mContents[N_STACK_BYTES];
+};
+
+// Statistics collection for the unwinder.
+template <typename T>
+class LULStats {
+ public:
+ LULStats() : mContext(0), mCFI(0), mFP(0) {}
+
+ template <typename S>
+ explicit LULStats(const LULStats<S>& aOther)
+ : mContext(aOther.mContext), mCFI(aOther.mCFI), mFP(aOther.mFP) {}
+
+ template <typename S>
+ LULStats<T>& operator=(const LULStats<S>& aOther) {
+ mContext = aOther.mContext;
+ mCFI = aOther.mCFI;
+ mFP = aOther.mFP;
+ return *this;
+ }
+
+ template <typename S>
+ uint32_t operator-(const LULStats<S>& aOther) {
+ return (mContext - aOther.mContext) + (mCFI - aOther.mCFI) +
+ (mFP - aOther.mFP);
+ }
+
+ T mContext; // Number of context frames
+ T mCFI; // Number of CFI/EXIDX frames
+ T mFP; // Number of frame-pointer recovered frames
+};
+
+// The core unwinder library class. Just one of these is needed, and
+// it can be shared by multiple unwinder threads.
+//
+// The library operates in one of two modes.
+//
+// * Admin mode. The library is this state after creation. In Admin
+// mode, no unwinding may be performed. It is however allowable to
+// perform administrative tasks -- primarily, loading of unwind info
+// -- in this mode. In particular, it is safe for the library to
+// perform dynamic memory allocation in this mode. Safe in the
+// sense that there is no risk of deadlock against unwinding threads
+// that might -- because of where they have been sampled -- hold the
+// system's malloc lock.
+//
+// * Unwind mode. In this mode, calls to ::Unwind may be made, but
+// nothing else. ::Unwind guarantees not to make any dynamic memory
+// requests, so as to guarantee that the calling thread won't
+// deadlock in the case where it already holds the system's malloc lock.
+//
+// The library is created in Admin mode. After debuginfo is loaded,
+// the caller must switch it into Unwind mode by calling
+// ::EnableUnwinding. There is no way to switch it back to Admin mode
+// after that. To safely switch back to Admin mode would require the
+// caller (or other external agent) to guarantee that there are no
+// pending ::Unwind calls.
+
+class PriMap;
+class SegArray;
+class UniqueStringUniverse;
+
+class LUL {
+ public:
+ // Create; supply a logging sink. Sets the object in Admin mode.
+ explicit LUL(void (*aLog)(const char*));
+
+ // Destroy. Caller is responsible for ensuring that no other
+ // threads are in Unwind calls. All resources are freed and all
+ // registered unwinder threads are deregistered. Can be called
+ // either in Admin or Unwind mode.
+ ~LUL();
+
+ // Notify the library that unwinding is now allowed and so
+ // admin-mode calls are no longer allowed. The object is initially
+ // created in admin mode. The only possible transition is
+ // admin->unwinding, therefore.
+ void EnableUnwinding();
+
+ // Notify of a new r-x mapping, and load the associated unwind info.
+ // The filename is strdup'd and used for debug printing. If
+ // aMappedImage is NULL, this function will mmap/munmap the file
+ // itself, so as to be able to read the unwind info. If
+ // aMappedImage is non-NULL then it is assumed to point to a
+ // called-supplied and caller-managed mapped image of the file.
+ // May only be called in Admin mode.
+ void NotifyAfterMap(uintptr_t aRXavma, size_t aSize, const char* aFileName,
+ const void* aMappedImage);
+
+ // In rare cases we know an executable area exists but don't know
+ // what the associated file is. This call notifies LUL of such
+ // areas. This is important for correct functioning of stack
+ // scanning and of the x86-{linux,android} special-case
+ // __kernel_syscall function handling.
+ // This must be called only after the code area in
+ // question really has been mapped.
+ // May only be called in Admin mode.
+ void NotifyExecutableArea(uintptr_t aRXavma, size_t aSize);
+
+ // Notify that a mapped area has been unmapped; discard any
+ // associated unwind info. Acquires mRWlock for writing. Note that
+ // to avoid segfaulting the stack-scan unwinder, which inspects code
+ // areas, this must be called before the code area in question is
+ // really unmapped. Note that, unlike NotifyAfterMap(), this
+ // function takes the start and end addresses of the range to be
+ // unmapped, rather than a start and a length parameter. This is so
+ // as to make it possible to notify an unmap for the entire address
+ // space using a single call.
+ // May only be called in Admin mode.
+ void NotifyBeforeUnmap(uintptr_t aAvmaMin, uintptr_t aAvmaMax);
+
+ // Apply NotifyBeforeUnmap to the entire address space. This causes
+ // LUL to discard all unwind and executable-area information for the
+ // entire address space.
+ // May only be called in Admin mode.
+ void NotifyBeforeUnmapAll() { NotifyBeforeUnmap(0, UINTPTR_MAX); }
+
+ // Returns the number of mappings currently registered.
+ // May only be called in Admin mode.
+ size_t CountMappings();
+
+ // Unwind |aStackImg| starting with the context in |aStartRegs|.
+ // Write the number of frames recovered in *aFramesUsed. Put
+ // the PC values in aFramePCs[0 .. *aFramesUsed-1] and
+ // the SP values in aFrameSPs[0 .. *aFramesUsed-1].
+ // |aFramesAvail| is the size of the two output arrays and hence the
+ // largest possible value of *aFramesUsed. PC values are always
+ // valid, and the unwind will stop when the PC becomes invalid, but
+ // the SP values might be invalid, in which case the value zero will
+ // be written in the relevant frameSPs[] slot.
+ //
+ // This function assumes that the SP values increase as it unwinds
+ // away from the innermost frame -- that is, that the stack grows
+ // down. It monitors SP values as it unwinds to check they
+ // decrease, so as to avoid looping on corrupted stacks.
+ //
+ // May only be called in Unwind mode. Multiple threads may unwind
+ // at once. LUL user is responsible for ensuring that no thread makes
+ // any Admin calls whilst in Unwind mode.
+ // MOZ_CRASHes if the calling thread is not registered for unwinding.
+ //
+ // The calling thread must previously have been registered via a call to
+ // RegisterSampledThread.
+ void Unwind(/*OUT*/ uintptr_t* aFramePCs,
+ /*OUT*/ uintptr_t* aFrameSPs,
+ /*OUT*/ size_t* aFramesUsed,
+ /*OUT*/ size_t* aFramePointerFramesAcquired, size_t aFramesAvail,
+ UnwindRegs* aStartRegs, StackImage* aStackImg);
+
+ // The logging sink. Call to send debug strings to the caller-
+ // specified destination. Can only be called by the Admin thread.
+ void (*mLog)(const char*);
+
+ // Statistics relating to unwinding. These have to be atomic since
+ // unwinding can occur on different threads simultaneously.
+ LULStats<mozilla::Atomic<uint32_t>> mStats;
+
+ // Possibly show the statistics. This may not be called from any
+ // registered sampling thread, since it involves I/O.
+ void MaybeShowStats();
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const;
+
+ private:
+ // The statistics counters at the point where they were last printed.
+ LULStats<uint32_t> mStatsPrevious;
+
+ // Are we in admin mode? Initially |true| but changes to |false|
+ // once unwinding begins.
+ bool mAdminMode;
+
+ // The thread ID associated with admin mode. This is the only thread
+ // that is allowed do perform non-Unwind calls on this object. Conversely,
+ // no registered Unwinding thread may be the admin thread. This is so
+ // as to clearly partition the one thread that may do dynamic memory
+ // allocation from the threads that are being sampled, since the latter
+ // absolutely may not do dynamic memory allocation.
+ mozilla::baseprofiler::BaseProfilerThreadId mAdminThreadId;
+
+ // The top level mapping from code address ranges to postprocessed
+ // unwind info. Basically a sorted array of (addr, len, info)
+ // records. This field is updated by NotifyAfterMap and NotifyBeforeUnmap.
+ PriMap* mPriMap;
+
+ // An auxiliary structure that records which address ranges are
+ // mapped r-x, for the benefit of the stack scanner.
+ SegArray* mSegArray;
+
+ // A UniqueStringUniverse that holds all the strdup'd strings created
+ // whilst reading unwind information. This is included so as to make
+ // it possible to free them in ~LUL.
+ UniqueStringUniverse* mUSU;
+};
+
+// Run unit tests on an initialised, loaded-up LUL instance, and print
+// summary results on |aLUL|'s logging sink. Also return the number
+// of tests run in *aNTests and the number that passed in
+// *aNTestsPassed.
+void RunLulUnitTests(/*OUT*/ int* aNTests, /*OUT*/ int* aNTestsPassed,
+ LUL* aLUL);
+
+} // namespace lul
+
+#endif // LulMain_h
diff --git a/mozglue/baseprofiler/lul/LulMainInt.h b/mozglue/baseprofiler/lul/LulMainInt.h
new file mode 100644
index 0000000000..c2ee45d73d
--- /dev/null
+++ b/mozglue/baseprofiler/lul/LulMainInt.h
@@ -0,0 +1,420 @@
+/* -*- 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/. */
+
+#ifndef LulMainInt_h
+#define LulMainInt_h
+
+#include "PlatformMacros.h"
+#include "LulMain.h" // for TaggedUWord
+
+#include "mozilla/Assertions.h"
+
+#include <string>
+#include <vector>
+
+// This file is provides internal interface inside LUL. If you are an
+// end-user of LUL, do not include it in your code. The end-user
+// interface is in LulMain.h.
+
+namespace lul {
+
+using std::vector;
+
+////////////////////////////////////////////////////////////////
+// DW_REG_ constants //
+////////////////////////////////////////////////////////////////
+
+// These are the Dwarf CFI register numbers, as (presumably) defined
+// in the ELF ABI supplements for each architecture.
+
+enum DW_REG_NUMBER {
+ // No real register has this number. It's convenient to be able to
+ // treat the CFA (Canonical Frame Address) as "just another
+ // register", though.
+ DW_REG_CFA = -1,
+#if defined(GP_ARCH_arm)
+ // ARM registers
+ DW_REG_ARM_R7 = 7,
+ DW_REG_ARM_R11 = 11,
+ DW_REG_ARM_R12 = 12,
+ DW_REG_ARM_R13 = 13,
+ DW_REG_ARM_R14 = 14,
+ DW_REG_ARM_R15 = 15,
+#elif defined(GP_ARCH_arm64)
+ // aarch64 registers
+ DW_REG_AARCH64_X29 = 29,
+ DW_REG_AARCH64_X30 = 30,
+ DW_REG_AARCH64_SP = 31,
+#elif defined(GP_ARCH_amd64)
+ // Because the X86 (32 bit) and AMD64 (64 bit) summarisers are
+ // combined, a merged set of register constants is needed.
+ DW_REG_INTEL_XBP = 6,
+ DW_REG_INTEL_XSP = 7,
+ DW_REG_INTEL_XIP = 16,
+#elif defined(GP_ARCH_x86)
+ DW_REG_INTEL_XBP = 5,
+ DW_REG_INTEL_XSP = 4,
+ DW_REG_INTEL_XIP = 8,
+#elif defined(GP_ARCH_mips64)
+ DW_REG_MIPS_SP = 29,
+ DW_REG_MIPS_FP = 30,
+ DW_REG_MIPS_PC = 34,
+#else
+# error "Unknown arch"
+#endif
+};
+
+////////////////////////////////////////////////////////////////
+// PfxExpr //
+////////////////////////////////////////////////////////////////
+
+enum PfxExprOp {
+ // meaning of mOperand effect on stack
+ PX_Start, // bool start-with-CFA? start, with CFA on stack, or not
+ PX_End, // none stop; result is at top of stack
+ PX_SImm32, // int32 push signed int32
+ PX_DwReg, // DW_REG_NUMBER push value of the specified reg
+ PX_Deref, // none pop X ; push *X
+ PX_Add, // none pop X ; pop Y ; push Y + X
+ PX_Sub, // none pop X ; pop Y ; push Y - X
+ PX_And, // none pop X ; pop Y ; push Y & X
+ PX_Or, // none pop X ; pop Y ; push Y | X
+ PX_CmpGES, // none pop X ; pop Y ; push (Y >=s X) ? 1 : 0
+ PX_Shl // none pop X ; pop Y ; push Y << X
+};
+
+struct PfxInstr {
+ PfxInstr(PfxExprOp opcode, int32_t operand)
+ : mOpcode(opcode), mOperand(operand) {}
+ explicit PfxInstr(PfxExprOp opcode) : mOpcode(opcode), mOperand(0) {}
+ bool operator==(const PfxInstr& other) const {
+ return mOpcode == other.mOpcode && mOperand == other.mOperand;
+ }
+ PfxExprOp mOpcode;
+ int32_t mOperand;
+};
+
+static_assert(sizeof(PfxInstr) <= 8, "PfxInstr size changed unexpectedly");
+
+// Evaluate the prefix expression whose PfxInstrs start at aPfxInstrs[start].
+// In the case of any mishap (stack over/underflow, running off the end of
+// the instruction vector, obviously malformed sequences),
+// return an invalid TaggedUWord.
+// RUNS IN NO-MALLOC CONTEXT
+TaggedUWord EvaluatePfxExpr(int32_t start, const UnwindRegs* aOldRegs,
+ TaggedUWord aCFA, const StackImage* aStackImg,
+ const vector<PfxInstr>& aPfxInstrs);
+
+////////////////////////////////////////////////////////////////
+// LExpr //
+////////////////////////////////////////////////////////////////
+
+// An expression -- very primitive. Denotes either "register +
+// offset", a dereferenced version of the same, or a reference to a
+// prefix expression stored elsewhere. So as to allow convenient
+// handling of Dwarf-derived unwind info, the register may also denote
+// the CFA. A large number of these need to be stored, so we ensure
+// it fits into 8 bytes. See comment below on RuleSet to see how
+// expressions fit into the bigger picture.
+
+enum LExprHow {
+ UNKNOWN = 0, // This LExpr denotes no value.
+ NODEREF, // Value is (mReg + mOffset).
+ DEREF, // Value is *(mReg + mOffset).
+ PFXEXPR // Value is EvaluatePfxExpr(secMap->mPfxInstrs[mOffset])
+};
+
+inline static const char* NameOf_LExprHow(LExprHow how) {
+ switch (how) {
+ case UNKNOWN:
+ return "UNKNOWN";
+ case NODEREF:
+ return "NODEREF";
+ case DEREF:
+ return "DEREF";
+ case PFXEXPR:
+ return "PFXEXPR";
+ default:
+ return "LExpr-??";
+ }
+}
+
+struct LExpr {
+ // Denotes an expression with no value.
+ LExpr() : mHow(UNKNOWN), mReg(0), mOffset(0) {}
+
+ // Denotes any expressible expression.
+ LExpr(LExprHow how, int16_t reg, int32_t offset)
+ : mHow(how), mReg(reg), mOffset(offset) {
+ switch (how) {
+ case UNKNOWN:
+ MOZ_ASSERT(reg == 0 && offset == 0);
+ break;
+ case NODEREF:
+ break;
+ case DEREF:
+ break;
+ case PFXEXPR:
+ MOZ_ASSERT(reg == 0 && offset >= 0);
+ break;
+ default:
+ MOZ_ASSERT(0, "LExpr::LExpr: invalid how");
+ }
+ }
+
+ // Change the offset for an expression that references memory.
+ LExpr add_delta(long delta) {
+ MOZ_ASSERT(mHow == NODEREF);
+ // If this is a non-debug build and the above assertion would have
+ // failed, at least return LExpr() so that the machinery that uses
+ // the resulting expression fails in a repeatable way.
+ return (mHow == NODEREF) ? LExpr(mHow, mReg, mOffset + delta)
+ : LExpr(); // Gone bad
+ }
+
+ // Dereference an expression that denotes a memory address.
+ LExpr deref() {
+ MOZ_ASSERT(mHow == NODEREF);
+ // Same rationale as for add_delta().
+ return (mHow == NODEREF) ? LExpr(DEREF, mReg, mOffset)
+ : LExpr(); // Gone bad
+ }
+
+ // Print a rule for recovery of |aNewReg| whose recovered value
+ // is this LExpr.
+ std::string ShowRule(const char* aNewReg) const;
+
+ // Evaluate this expression, producing a TaggedUWord. |aOldRegs|
+ // holds register values that may be referred to by the expression.
+ // |aCFA| holds the CFA value, if any, that applies. |aStackImg|
+ // contains a chuck of stack that will be consulted if the expression
+ // references memory. |aPfxInstrs| holds the vector of PfxInstrs
+ // that will be consulted if this is a PFXEXPR.
+ // RUNS IN NO-MALLOC CONTEXT
+ TaggedUWord EvaluateExpr(const UnwindRegs* aOldRegs, TaggedUWord aCFA,
+ const StackImage* aStackImg,
+ const vector<PfxInstr>* aPfxInstrs) const;
+
+ // Representation of expressions. If |mReg| is DW_REG_CFA (-1) then
+ // it denotes the CFA. All other allowed values for |mReg| are
+ // nonnegative and are DW_REG_ values.
+ LExprHow mHow : 8;
+ int16_t mReg; // A DW_REG_ value
+ int32_t mOffset; // 32-bit signed offset should be more than enough.
+};
+
+static_assert(sizeof(LExpr) <= 8, "LExpr size changed unexpectedly");
+
+////////////////////////////////////////////////////////////////
+// RuleSet //
+////////////////////////////////////////////////////////////////
+
+// This is platform-dependent. For some address range, describes how
+// to recover the CFA and then how to recover the registers for the
+// previous frame.
+//
+// The set of LExprs contained in a given RuleSet describe a DAG which
+// says how to compute the caller's registers ("new registers") from
+// the callee's registers ("old registers"). The DAG can contain a
+// single internal node, which is the value of the CFA for the callee.
+// It would be possible to construct a DAG that omits the CFA, but
+// including it makes the summarisers simpler, and the Dwarf CFI spec
+// has the CFA as a central concept.
+//
+// For this to make sense, |mCfaExpr| can't have
+// |mReg| == DW_REG_CFA since we have no previous value for the CFA.
+// All of the other |Expr| fields can -- and usually do -- specify
+// |mReg| == DW_REG_CFA.
+//
+// With that in place, the unwind algorithm proceeds as follows.
+//
+// (0) Initially: we have values for the old registers, and a memory
+// image.
+//
+// (1) Compute the CFA by evaluating |mCfaExpr|. Add the computed
+// value to the set of "old registers".
+//
+// (2) Compute values for the registers by evaluating all of the other
+// |Expr| fields in the RuleSet. These can depend on both the old
+// register values and the just-computed CFA.
+//
+// If we are unwinding without computing a CFA, perhaps because the
+// RuleSets are derived from EXIDX instead of Dwarf, then
+// |mCfaExpr.mHow| will be LExpr::UNKNOWN, so the computed value will
+// be invalid -- that is, TaggedUWord() -- and so any attempt to use
+// that will result in the same value. But that's OK because the
+// RuleSet would make no sense if depended on the CFA but specified no
+// way to compute it.
+//
+// A RuleSet is not allowed to cover zero address range. Having zero
+// length would break binary searching in SecMaps and PriMaps.
+
+class RuleSet {
+ public:
+ RuleSet();
+ void Print(void (*aLog)(const char*)) const;
+
+ // Find the LExpr* for a given DW_REG_ value in this class.
+ LExpr* ExprForRegno(DW_REG_NUMBER aRegno);
+
+ uintptr_t mAddr;
+ uintptr_t mLen;
+ // How to compute the CFA.
+ LExpr mCfaExpr;
+ // How to compute caller register values. These may reference the
+ // value defined by |mCfaExpr|.
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ LExpr mXipExpr; // return address
+ LExpr mXspExpr;
+ LExpr mXbpExpr;
+#elif defined(GP_ARCH_arm)
+ LExpr mR15expr; // return address
+ LExpr mR14expr;
+ LExpr mR13expr;
+ LExpr mR12expr;
+ LExpr mR11expr;
+ LExpr mR7expr;
+#elif defined(GP_ARCH_arm64)
+ LExpr mX29expr; // frame pointer register
+ LExpr mX30expr; // link register
+ LExpr mSPexpr;
+#elif defined(GP_ARCH_mips64)
+ LExpr mPCexpr;
+ LExpr mFPexpr;
+ LExpr mSPexpr;
+#else
+# error "Unknown arch"
+#endif
+};
+
+// Returns |true| for Dwarf register numbers which are members
+// of the set of registers that LUL unwinds on this target.
+static inline bool registerIsTracked(DW_REG_NUMBER reg) {
+ switch (reg) {
+#if defined(GP_ARCH_amd64) || defined(GP_ARCH_x86)
+ case DW_REG_INTEL_XBP:
+ case DW_REG_INTEL_XSP:
+ case DW_REG_INTEL_XIP:
+ return true;
+#elif defined(GP_ARCH_arm)
+ case DW_REG_ARM_R7:
+ case DW_REG_ARM_R11:
+ case DW_REG_ARM_R12:
+ case DW_REG_ARM_R13:
+ case DW_REG_ARM_R14:
+ case DW_REG_ARM_R15:
+ return true;
+#elif defined(GP_ARCH_arm64)
+ case DW_REG_AARCH64_X29:
+ case DW_REG_AARCH64_X30:
+ case DW_REG_AARCH64_SP:
+ return true;
+#elif defined(GP_ARCH_mips64)
+ case DW_REG_MIPS_FP:
+ case DW_REG_MIPS_SP:
+ case DW_REG_MIPS_PC:
+ return true;
+#else
+# error "Unknown arch"
+#endif
+ default:
+ return false;
+ }
+}
+
+////////////////////////////////////////////////////////////////
+// SecMap //
+////////////////////////////////////////////////////////////////
+
+// A SecMap may have zero address range, temporarily, whilst RuleSets
+// are being added to it. But adding a zero-range SecMap to a PriMap
+// will make it impossible to maintain the total order of the PriMap
+// entries, and so that can't be allowed to happen.
+
+class SecMap {
+ public:
+ // These summarise the contained mRuleSets, in that they give
+ // exactly the lowest and highest addresses that any of the entries
+ // in this SecMap cover. Hence invariants:
+ //
+ // mRuleSets is nonempty
+ // <=> mSummaryMinAddr <= mSummaryMaxAddr
+ // && mSummaryMinAddr == mRuleSets[0].mAddr
+ // && mSummaryMaxAddr == mRuleSets[#rulesets-1].mAddr
+ // + mRuleSets[#rulesets-1].mLen - 1;
+ //
+ // This requires that no RuleSet has zero length.
+ //
+ // mRuleSets is empty
+ // <=> mSummaryMinAddr > mSummaryMaxAddr
+ //
+ // This doesn't constrain mSummaryMinAddr and mSummaryMaxAddr uniquely,
+ // so let's use mSummaryMinAddr == 1 and mSummaryMaxAddr == 0 to denote
+ // this case.
+
+ explicit SecMap(void (*aLog)(const char*));
+ ~SecMap();
+
+ // Binary search mRuleSets to find one that brackets |ia|, or nullptr
+ // if none is found. It's not allowable to do this until PrepareRuleSets
+ // has been called first.
+ RuleSet* FindRuleSet(uintptr_t ia);
+
+ // Add a RuleSet to the collection. The rule is copied in. Calling
+ // this makes the map non-searchable.
+ void AddRuleSet(const RuleSet* rs);
+
+ // Add a PfxInstr to the vector of such instrs, and return the index
+ // in the vector. Calling this makes the map non-searchable.
+ uint32_t AddPfxInstr(PfxInstr pfxi);
+
+ // Returns the entire vector of PfxInstrs.
+ const vector<PfxInstr>* GetPfxInstrs() { return &mPfxInstrs; }
+
+ // Prepare the map for searching. Also, remove any rules for code
+ // address ranges which don't fall inside [start, +len). |len| may
+ // not be zero.
+ void PrepareRuleSets(uintptr_t start, size_t len);
+
+ bool IsEmpty();
+
+ size_t Size() { return mRuleSets.size(); }
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ // The min and max addresses of the addresses in the contained
+ // RuleSets. See comment above for invariants.
+ uintptr_t mSummaryMinAddr;
+ uintptr_t mSummaryMaxAddr;
+
+ private:
+ // False whilst adding entries; true once it is safe to call FindRuleSet.
+ // Transition (false->true) is caused by calling PrepareRuleSets().
+ bool mUsable;
+
+ // A vector of RuleSets, sorted, nonoverlapping (post Prepare()).
+ vector<RuleSet> mRuleSets;
+
+ // A vector of PfxInstrs, which are referred to by the RuleSets.
+ // These are provided as a representation of Dwarf expressions
+ // (DW_CFA_val_expression, DW_CFA_expression, DW_CFA_def_cfa_expression),
+ // are relatively expensive to evaluate, and and are therefore
+ // expected to be used only occasionally.
+ //
+ // The vector holds a bunch of separate PfxInstr programs, each one
+ // starting with a PX_Start and terminated by a PX_End, all
+ // concatenated together. When a RuleSet can't recover a value
+ // using a self-contained LExpr, it uses a PFXEXPR whose mOffset is
+ // the index in this vector of start of the necessary PfxInstr program.
+ vector<PfxInstr> mPfxInstrs;
+
+ // A logging sink, for debugging.
+ void (*mLog)(const char*);
+};
+
+} // namespace lul
+
+#endif // ndef LulMainInt_h
diff --git a/mozglue/baseprofiler/lul/platform-linux-lul.cpp b/mozglue/baseprofiler/lul/platform-linux-lul.cpp
new file mode 100644
index 0000000000..a9ee65858d
--- /dev/null
+++ b/mozglue/baseprofiler/lul/platform-linux-lul.cpp
@@ -0,0 +1,76 @@
+/* -*- 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 <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "AutoObjectMapper.h"
+#include "BaseProfiler.h"
+#include "BaseProfilerSharedLibraries.h"
+#include "platform.h"
+#include "PlatformMacros.h"
+#include "LulMain.h"
+
+// Contains miscellaneous helpers that are used to connect the Gecko Profiler
+// and LUL.
+
+// Find out, in a platform-dependent way, where the code modules got
+// mapped in the process' virtual address space, and get |aLUL| to
+// load unwind info for them.
+void read_procmaps(lul::LUL* aLUL) {
+ MOZ_ASSERT(aLUL->CountMappings() == 0);
+
+#if defined(GP_OS_linux) || defined(GP_OS_android) || defined(GP_OS_freebsd)
+ SharedLibraryInfo info = SharedLibraryInfo::GetInfoForSelf();
+
+ for (size_t i = 0; i < info.GetSize(); i++) {
+ const SharedLibrary& lib = info.GetEntry(i);
+
+ std::string nativePath = lib.GetDebugPath();
+
+ // We can use the standard POSIX-based mapper.
+ AutoObjectMapperPOSIX mapper(aLUL->mLog);
+
+ // Ask |mapper| to map the object. Then hand its mapped address
+ // to NotifyAfterMap().
+ void* image = nullptr;
+ size_t size = 0;
+ bool ok = mapper.Map(&image, &size, nativePath);
+ if (ok && image && size > 0) {
+ aLUL->NotifyAfterMap(lib.GetStart(), lib.GetEnd() - lib.GetStart(),
+ nativePath.c_str(), image);
+ } else if (!ok && lib.GetDebugName().empty()) {
+ // The object has no name and (as a consequence) the mapper failed to map
+ // it. This happens on Linux, where GetInfoForSelf() produces such a
+ // mapping for the VDSO. This is a problem on x86-{linux,android} because
+ // lack of knowledge about the mapped area inhibits LUL's special
+ // __kernel_syscall handling. Hence notify |aLUL| at least of the
+ // mapping, even though it can't read any unwind information for the area.
+ aLUL->NotifyExecutableArea(lib.GetStart(), lib.GetEnd() - lib.GetStart());
+ }
+
+ // |mapper| goes out of scope at this point and so its destructor
+ // unmaps the object.
+ }
+
+#else
+# error "Unknown platform"
+#endif
+}
+
+// LUL needs a callback for its logging sink.
+void logging_sink_for_LUL(const char* str) {
+ // These are only printed when Verbose logging is enabled (e.g. with
+ // MOZ_BASE_PROFILER_VERBOSE_LOGGING=1). This is because LUL's logging is much
+ // more verbose than the rest of the profiler's logging, which occurs at the
+ // Info (3) and Debug (4) levels.
+ // FIXME: This causes a build failure in memory/replace/dmd/test/SmokeDMD (!)
+ // and other places, because it doesn't link the implementation in
+ // platform.cpp.
+ // VERBOSE_LOG("[%d] %s", profiler_current_process_id(), str);
+}
diff --git a/mozglue/baseprofiler/lul/platform-linux-lul.h b/mozglue/baseprofiler/lul/platform-linux-lul.h
new file mode 100644
index 0000000000..b54e80edcf
--- /dev/null
+++ b/mozglue/baseprofiler/lul/platform-linux-lul.h
@@ -0,0 +1,21 @@
+/* -*- 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 MOZ_PLATFORM_LINUX_LUL_H
+#define MOZ_PLATFORM_LINUX_LUL_H
+
+#include "platform.h"
+
+#include "BaseProfiler.h"
+
+// Find out, in a platform-dependent way, where the code modules got
+// mapped in the process' virtual address space, and get |aLUL| to
+// load unwind info for them.
+void read_procmaps(lul::LUL* aLUL);
+
+// LUL needs a callback for its logging sink.
+void logging_sink_for_LUL(const char* str);
+
+#endif /* ndef MOZ_PLATFORM_LINUX_LUL_H */
diff --git a/mozglue/baseprofiler/moz.build b/mozglue/baseprofiler/moz.build
new file mode 100644
index 0000000000..bbefe9582e
--- /dev/null
+++ b/mozglue/baseprofiler/moz.build
@@ -0,0 +1,133 @@
+# -*- Mode: python; 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/.
+
+# This is pretty much a copy from tools/profiler, cut down to exclude anything
+# that cannot work in mozglue (because they are totally dependent on libxul-
+# specific code).
+# All exported headers now prefixed with "Base" to avoid #include name clashes.
+
+if CONFIG["MOZ_GECKO_PROFILER"]:
+ DEFINES["IMPL_MFBT"] = True
+ EXPORTS += [
+ "public/BaseProfilerSharedLibraries.h",
+ "public/BaseProfilingStack.h",
+ ]
+ UNIFIED_SOURCES += [
+ "core/PageInformation.cpp",
+ "core/platform.cpp",
+ "core/ProfileBuffer.cpp",
+ "core/ProfileBufferEntry.cpp",
+ "core/ProfiledThreadData.cpp",
+ "core/ProfileJSONWriter.cpp",
+ "core/ProfilerBacktrace.cpp",
+ "core/ProfilerMarkers.cpp",
+ "core/ProfilingCategory.cpp",
+ "core/ProfilingStack.cpp",
+ "core/RegisteredThread.cpp",
+ ]
+
+ if CONFIG["OS_TARGET"] in ("Android", "Linux", "FreeBSD"):
+ if CONFIG["CPU_ARCH"] in ("arm", "aarch64", "x86", "x86_64", "mips64"):
+ UNIFIED_SOURCES += [
+ "lul/AutoObjectMapper.cpp",
+ "lul/LulCommon.cpp",
+ "lul/LulDwarf.cpp",
+ "lul/LulDwarfSummariser.cpp",
+ "lul/LulElf.cpp",
+ "lul/LulMain.cpp",
+ "lul/platform-linux-lul.cpp",
+ ]
+ # These files cannot be built in unified mode because of name clashes with mozglue headers on Android.
+ SOURCES += [
+ "core/shared-libraries-linux.cc",
+ ]
+ if CONFIG["CPU_ARCH"] == "arm" and CONFIG["OS_TARGET"] != "FreeBSD":
+ SOURCES += [
+ "core/EHABIStackWalk.cpp",
+ ]
+ elif CONFIG["OS_TARGET"] == "Darwin":
+ UNIFIED_SOURCES += [
+ "core/shared-libraries-macos.cc",
+ ]
+ elif CONFIG["OS_TARGET"] == "WINNT":
+ SOURCES += [
+ "core/shared-libraries-win32.cc",
+ ]
+
+ LOCAL_INCLUDES += [
+ "/mozglue/baseprofiler/core/",
+ "/mozglue/linker",
+ ]
+
+ if CONFIG["OS_TARGET"] == "Android":
+ DEFINES["ANDROID_NDK_MAJOR_VERSION"] = CONFIG["ANDROID_NDK_MAJOR_VERSION"]
+ DEFINES["ANDROID_NDK_MINOR_VERSION"] = CONFIG["ANDROID_NDK_MINOR_VERSION"]
+
+GeneratedFile(
+ "public/ProfilingCategoryList.h",
+ script="build/generate_profiling_categories.py",
+ entry_point="generate_macro_header",
+ inputs=["build/profiling_categories.yaml"],
+)
+
+EXPORTS += [
+ "!public/ProfilingCategoryList.h",
+ "public/BaseProfiler.h",
+ "public/BaseProfilingCategory.h",
+]
+
+EXPORTS.mozilla += [
+ "public/BaseAndGeckoProfilerDetail.h",
+ "public/BaseProfileJSONWriter.h",
+ "public/BaseProfilerCounts.h",
+ "public/BaseProfilerDetail.h",
+ "public/BaseProfilerLabels.h",
+ "public/BaseProfilerMarkers.h",
+ "public/BaseProfilerMarkersDetail.h",
+ "public/BaseProfilerMarkersPrerequisites.h",
+ "public/BaseProfilerMarkerTypes.h",
+ "public/BaseProfilerRAIIMacro.h",
+ "public/BaseProfilerState.h",
+ "public/BaseProfilerUtils.h",
+ "public/BlocksRingBuffer.h",
+ "public/FailureLatch.h",
+ "public/leb128iterator.h",
+ "public/ModuloBuffer.h",
+ "public/PowerOfTwo.h",
+ "public/ProfileBufferChunk.h",
+ "public/ProfileBufferChunkManager.h",
+ "public/ProfileBufferChunkManagerSingle.h",
+ "public/ProfileBufferChunkManagerWithLocalLimit.h",
+ "public/ProfileBufferControlledChunkManager.h",
+ "public/ProfileBufferEntryKinds.h",
+ "public/ProfileBufferEntrySerialization.h",
+ "public/ProfileBufferIndex.h",
+ "public/ProfileChunkedBuffer.h",
+ "public/ProfileChunkedBufferDetail.h",
+ "public/ProgressLogger.h",
+ "public/ProportionValue.h",
+]
+
+UNIFIED_SOURCES += [
+ "core/BaseAndGeckoProfilerDetail.cpp",
+ "core/ProfilerUtils.cpp",
+]
+
+if CONFIG["MOZ_VTUNE"]:
+ DEFINES["MOZ_VTUNE_INSTRUMENTATION"] = True
+ UNIFIED_SOURCES += [
+ "core/VTuneProfiler.cpp",
+ ]
+
+FINAL_LIBRARY = "mozglue"
+
+if CONFIG["CC_TYPE"] in ("clang", "gcc"):
+ CXXFLAGS += [
+ "-Wno-ignored-qualifiers", # due to use of breakpad headers
+ ]
+
+with Files("**"):
+ BUG_COMPONENT = ("Core", "Gecko Profiler")
diff --git a/mozglue/baseprofiler/public/BaseAndGeckoProfilerDetail.h b/mozglue/baseprofiler/public/BaseAndGeckoProfilerDetail.h
new file mode 100644
index 0000000000..f45170c83f
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseAndGeckoProfilerDetail.h
@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+// Internal Base and Gecko Profiler utilities.
+// It should declare or define things that are used in both profilers, but not
+// needed outside of the profilers.
+// In particular, it is *not* included in popular headers like BaseProfiler.h
+// and GeckoProfiler.h, to avoid rebuilding the world when this is modified.
+
+#ifndef BaseAndGeckoProfilerDetail_h
+#define BaseAndGeckoProfilerDetail_h
+
+#include "mozilla/BaseProfilerUtils.h"
+#include "mozilla/Span.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Types.h"
+#include "mozilla/UniquePtr.h"
+
+namespace mozilla {
+
+class ProfileBufferChunkManagerWithLocalLimit;
+
+namespace baseprofiler::detail {
+
+[[nodiscard]] MFBT_API TimeStamp GetProfilingStartTime();
+
+[[nodiscard]] MFBT_API UniquePtr<ProfileBufferChunkManagerWithLocalLimit>
+ExtractBaseProfilerChunkManager();
+
+// If the current thread is registered, returns its registration time, otherwise
+// a null timestamp.
+[[nodiscard]] MFBT_API TimeStamp GetThreadRegistrationTime();
+
+} // namespace baseprofiler::detail
+
+namespace profiler::detail {
+
+// True if the filter is exactly "pid:<aPid>".
+[[nodiscard]] MFBT_API bool FilterHasPid(
+ const char* aFilter, baseprofiler::BaseProfilerProcessId aPid =
+ baseprofiler::profiler_current_process_id());
+
+// Only true if the filters only contain "pid:..." strings, and *none* of them
+// is exactly "pid:<aPid>". E.g.:
+// - [], 123 -> false (no pids)
+// - ["main"], 123 -> false (not all pids)
+// - ["main", "pid:123"], 123 -> false (not all pids)
+// - ["pid:123"], 123 -> false (all pids, including "pid:123")
+// - ["pid:123", "pid:456"], 123 -> false (all pids, including "pid:123")
+// - ["pid:456"], 123 -> true (all pids, but no "pid:123")
+// - ["pid:456", "pid:789"], 123 -> true (all pids, but no "pid:123")
+[[nodiscard]] MFBT_API bool FiltersExcludePid(
+ Span<const char* const> aFilters,
+ baseprofiler::BaseProfilerProcessId aPid =
+ baseprofiler::profiler_current_process_id());
+
+} // namespace profiler::detail
+
+} // namespace mozilla
+
+#endif // BaseAndGeckoProfilerDetail_h
diff --git a/mozglue/baseprofiler/public/BaseProfileJSONWriter.h b/mozglue/baseprofiler/public/BaseProfileJSONWriter.h
new file mode 100644
index 0000000000..00a2926366
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfileJSONWriter.h
@@ -0,0 +1,600 @@
+/* -*- 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 BASEPROFILEJSONWRITER_H
+#define BASEPROFILEJSONWRITER_H
+
+#include "mozilla/FailureLatch.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/HashTable.h"
+#include "mozilla/JSONWriter.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/ProgressLogger.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtrExtensions.h"
+
+#include <functional>
+#include <ostream>
+#include <string_view>
+
+namespace mozilla {
+namespace baseprofiler {
+
+class SpliceableJSONWriter;
+
+// On average, profile JSONs are large enough such that we want to avoid
+// reallocating its buffer when expanding. Additionally, the contents of the
+// profile are not accessed until the profile is entirely written. For these
+// reasons we use a chunked writer that keeps an array of chunks, which is
+// concatenated together after writing is finished.
+class ChunkedJSONWriteFunc final : public JSONWriteFunc, public FailureLatch {
+ public:
+ friend class SpliceableJSONWriter;
+
+ explicit ChunkedJSONWriteFunc(FailureLatch& aFailureLatch)
+ : mFailureLatch(WrapNotNullUnchecked(&aFailureLatch)) {
+ (void)AllocChunk(kChunkSize);
+ }
+
+ [[nodiscard]] bool IsEmpty() const {
+ MOZ_ASSERT_IF(!mChunkPtr, !mChunkEnd && mChunkList.length() == 0 &&
+ mChunkLengths.length() == 0);
+ return !mChunkPtr;
+ }
+
+ // Length of data written so far, excluding null terminator.
+ [[nodiscard]] size_t Length() const {
+ MOZ_ASSERT(mChunkLengths.length() == mChunkList.length());
+ size_t totalLen = 0;
+ for (size_t i = 0; i < mChunkLengths.length(); i++) {
+ MOZ_ASSERT(strlen(mChunkList[i].get()) == mChunkLengths[i]);
+ totalLen += mChunkLengths[i];
+ }
+ return totalLen;
+ }
+
+ void Write(const Span<const char>& aStr) final {
+ if (Failed()) {
+ return;
+ }
+
+ MOZ_ASSERT(mChunkPtr >= mChunkList.back().get() && mChunkPtr <= mChunkEnd);
+ MOZ_ASSERT(mChunkEnd >= mChunkList.back().get() + mChunkLengths.back());
+ MOZ_ASSERT(*mChunkPtr == '\0');
+
+ // Most strings to be written are small, but subprocess profiles (e.g.,
+ // from the content process in e10s) may be huge. If the string is larger
+ // than a chunk, allocate its own chunk.
+ char* newPtr;
+ if (aStr.size() >= kChunkSize) {
+ if (!AllocChunk(aStr.size() + 1)) {
+ return;
+ }
+ newPtr = mChunkPtr + aStr.size();
+ } else {
+ newPtr = mChunkPtr + aStr.size();
+ if (newPtr >= mChunkEnd) {
+ if (!AllocChunk(kChunkSize)) {
+ return;
+ }
+ newPtr = mChunkPtr + aStr.size();
+ }
+ }
+
+ memcpy(mChunkPtr, aStr.data(), aStr.size());
+ *newPtr = '\0';
+ mChunkPtr = newPtr;
+ mChunkLengths.back() += aStr.size();
+ }
+
+ [[nodiscard]] bool CopyDataIntoLazilyAllocatedBuffer(
+ const std::function<char*(size_t)>& aAllocator) const {
+ // Request a buffer for the full content plus a null terminator.
+ if (Failed()) {
+ return false;
+ }
+
+ char* ptr = aAllocator(Length() + 1);
+
+ if (!ptr) {
+ // Failed to allocate memory.
+ return false;
+ }
+
+ for (size_t i = 0; i < mChunkList.length(); i++) {
+ size_t len = mChunkLengths[i];
+ memcpy(ptr, mChunkList[i].get(), len);
+ ptr += len;
+ }
+ *ptr = '\0';
+ return true;
+ }
+
+ [[nodiscard]] UniquePtr<char[]> CopyData() const {
+ UniquePtr<char[]> c;
+ if (!CopyDataIntoLazilyAllocatedBuffer([&](size_t allocationSize) {
+ c = MakeUnique<char[]>(allocationSize);
+ return c.get();
+ })) {
+ // Something went wrong, make sure the returned pointer is null even if
+ // the allocation happened.
+ c = nullptr;
+ }
+ return c;
+ }
+
+ void Take(ChunkedJSONWriteFunc&& aOther) {
+ SetFailureFrom(aOther);
+ if (Failed()) {
+ return;
+ }
+
+ for (size_t i = 0; i < aOther.mChunkList.length(); i++) {
+ MOZ_ALWAYS_TRUE(mChunkLengths.append(aOther.mChunkLengths[i]));
+ MOZ_ALWAYS_TRUE(mChunkList.append(std::move(aOther.mChunkList[i])));
+ }
+ mChunkPtr = mChunkList.back().get() + mChunkLengths.back();
+ mChunkEnd = mChunkPtr;
+ aOther.Clear();
+ }
+
+ FAILURELATCH_IMPL_PROXY(*mFailureLatch)
+
+ // Change the failure latch to be used here, and if the previous latch was
+ // already in failure state, set that failure in the new latch.
+ // This allows using this WriteFunc in isolation, before attempting to bring
+ // it into another operation group with its own FailureLatch.
+ void ChangeFailureLatchAndForwardState(FailureLatch& aFailureLatch) {
+ aFailureLatch.SetFailureFrom(*this);
+ mFailureLatch = WrapNotNullUnchecked(&aFailureLatch);
+ }
+
+ private:
+ void Clear() {
+ mChunkPtr = nullptr;
+ mChunkEnd = nullptr;
+ mChunkList.clear();
+ mChunkLengths.clear();
+ }
+
+ void ClearAndSetFailure(std::string aFailure) {
+ Clear();
+ SetFailure(std::move(aFailure));
+ }
+
+ [[nodiscard]] bool ClearAndSetFailureAndFalse(std::string aFailure) {
+ ClearAndSetFailure(std::move(aFailure));
+ return false;
+ }
+
+ [[nodiscard]] bool AllocChunk(size_t aChunkSize) {
+ if (Failed()) {
+ if (mChunkPtr) {
+ // FailureLatch is in failed state, but chunks have not been cleared yet
+ // (error must have happened elsewhere).
+ Clear();
+ }
+ return false;
+ }
+
+ MOZ_ASSERT(mChunkLengths.length() == mChunkList.length());
+ UniquePtr<char[]> newChunk = MakeUniqueFallible<char[]>(aChunkSize);
+ if (!newChunk) {
+ return ClearAndSetFailureAndFalse(
+ "OOM in ChunkedJSONWriteFunc::AllocChunk allocating new chunk");
+ }
+ mChunkPtr = newChunk.get();
+ mChunkEnd = mChunkPtr + aChunkSize;
+ *mChunkPtr = '\0';
+ if (!mChunkLengths.append(0)) {
+ return ClearAndSetFailureAndFalse(
+ "OOM in ChunkedJSONWriteFunc::AllocChunk appending length");
+ }
+ if (!mChunkList.append(std::move(newChunk))) {
+ return ClearAndSetFailureAndFalse(
+ "OOM in ChunkedJSONWriteFunc::AllocChunk appending new chunk");
+ }
+ return true;
+ }
+
+ static const size_t kChunkSize = 4096 * 512;
+
+ // Pointer for writing inside the current chunk.
+ //
+ // The current chunk is always at the back of mChunkList, i.e.,
+ // mChunkList.back() <= mChunkPtr <= mChunkEnd.
+ char* mChunkPtr = nullptr;
+
+ // Pointer to the end of the current chunk.
+ //
+ // The current chunk is always at the back of mChunkList, i.e.,
+ // mChunkEnd >= mChunkList.back() + mChunkLengths.back().
+ char* mChunkEnd = nullptr;
+
+ // List of chunks and their lengths.
+ //
+ // For all i, the length of the string in mChunkList[i] is
+ // mChunkLengths[i].
+ Vector<UniquePtr<char[]>> mChunkList;
+ Vector<size_t> mChunkLengths;
+
+ NotNull<FailureLatch*> mFailureLatch;
+};
+
+struct OStreamJSONWriteFunc final : public JSONWriteFunc {
+ explicit OStreamJSONWriteFunc(std::ostream& aStream) : mStream(aStream) {}
+
+ void Write(const Span<const char>& aStr) final {
+ std::string_view sv(aStr.data(), aStr.size());
+ mStream << sv;
+ }
+
+ std::ostream& mStream;
+};
+
+class UniqueJSONStrings;
+
+class SpliceableJSONWriter : public JSONWriter, public FailureLatch {
+ public:
+ SpliceableJSONWriter(JSONWriteFunc& aWriter, FailureLatch& aFailureLatch)
+ : JSONWriter(aWriter, JSONWriter::SingleLineStyle),
+ mFailureLatch(WrapNotNullUnchecked(&aFailureLatch)) {}
+
+ SpliceableJSONWriter(UniquePtr<JSONWriteFunc> aWriter,
+ FailureLatch& aFailureLatch)
+ : JSONWriter(std::move(aWriter), JSONWriter::SingleLineStyle),
+ mFailureLatch(WrapNotNullUnchecked(&aFailureLatch)) {}
+
+ void StartBareList() { StartCollection(scEmptyString, scEmptyString); }
+
+ void EndBareList() { EndCollection(scEmptyString); }
+
+ // Output a time (int64_t given in nanoseconds) in milliseconds. trim zeroes.
+ // E.g.: 1'234'567'890 -> "1234.56789"
+ void TimeI64NsProperty(const Span<const char>& aMaybePropertyName,
+ int64_t aTime_ns) {
+ if (aTime_ns == 0) {
+ Scalar(aMaybePropertyName, MakeStringSpan("0"));
+ return;
+ }
+
+ static constexpr int64_t million = 1'000'000;
+ const int64_t absNanos = std::abs(aTime_ns);
+ const int64_t integerMilliseconds = absNanos / million;
+ auto remainderNanoseconds = static_cast<uint32_t>(absNanos % million);
+
+ // Plenty enough to fit INT64_MIN (-9223372036854775808).
+ static constexpr size_t DIGITS_MAX = 23;
+ char buf[DIGITS_MAX + 1];
+ int len =
+ snprintf(buf, DIGITS_MAX, (aTime_ns >= 0) ? "%" PRIu64 : "-%" PRIu64,
+ integerMilliseconds);
+ if (remainderNanoseconds != 0) {
+ buf[len++] = '.';
+ // Output up to 6 fractional digits. Exit early if the rest would
+ // be trailing zeros.
+ uint32_t powerOfTen = static_cast<uint32_t>(million / 10);
+ for (;;) {
+ auto digit = remainderNanoseconds / powerOfTen;
+ buf[len++] = '0' + static_cast<char>(digit);
+ remainderNanoseconds %= powerOfTen;
+ if (remainderNanoseconds == 0) {
+ break;
+ }
+ powerOfTen /= 10;
+ if (powerOfTen == 0) {
+ break;
+ }
+ }
+ }
+
+ Scalar(aMaybePropertyName, Span<const char>(buf, len));
+ }
+
+ // Output a (double) time in milliseconds, with at best nanosecond precision.
+ void TimeDoubleMsProperty(const Span<const char>& aMaybePropertyName,
+ double aTime_ms) {
+ const double dTime_ns = aTime_ms * 1'000'000.0;
+ // Make sure it's well within int64_t range.
+ // 2^63 nanoseconds is almost 300 years; these times are relative to
+ // firefox startup, this should be enough for most uses.
+ if (dTime_ns >= 0.0) {
+ MOZ_RELEASE_ASSERT(dTime_ns < double(INT64_MAX - 1));
+ } else {
+ MOZ_RELEASE_ASSERT(dTime_ns > double(INT64_MIN + 2));
+ }
+ // Round to nearest integer nanosecond. The conversion to integer truncates
+ // the fractional part, so first we need to push it 0.5 away from zero.
+ const int64_t iTime_ns =
+ (dTime_ns >= 0.0) ? int64_t(dTime_ns + 0.5) : int64_t(dTime_ns - 0.5);
+ TimeI64NsProperty(aMaybePropertyName, iTime_ns);
+ }
+
+ // Output a (double) time in milliseconds, with at best nanosecond precision.
+ void TimeDoubleMsElement(double aTime_ms) {
+ TimeDoubleMsProperty(nullptr, aTime_ms);
+ }
+
+ // This function must be used to correctly stream timestamps in profiles.
+ // Null timestamps don't output anything.
+ void TimeProperty(const Span<const char>& aMaybePropertyName,
+ const TimeStamp& aTime) {
+ if (!aTime.IsNull()) {
+ TimeDoubleMsProperty(
+ aMaybePropertyName,
+ (aTime - TimeStamp::ProcessCreation()).ToMilliseconds());
+ }
+ }
+
+ void NullElements(uint32_t aCount) {
+ for (uint32_t i = 0; i < aCount; i++) {
+ NullElement();
+ }
+ }
+
+ void Splice(const Span<const char>& aStr) {
+ Separator();
+ WriteFunc().Write(aStr);
+ mNeedComma[mDepth] = true;
+ }
+
+ void Splice(const char* aStr, size_t aLen) {
+ Separator();
+ WriteFunc().Write(Span<const char>(aStr, aLen));
+ mNeedComma[mDepth] = true;
+ }
+
+ // Splice the given JSON directly in, without quoting.
+ void SplicedJSONProperty(const Span<const char>& aMaybePropertyName,
+ const Span<const char>& aJsonValue) {
+ Scalar(aMaybePropertyName, aJsonValue);
+ }
+
+ void CopyAndSplice(const ChunkedJSONWriteFunc& aFunc) {
+ Separator();
+ for (size_t i = 0; i < aFunc.mChunkList.length(); i++) {
+ WriteFunc().Write(
+ Span<const char>(aFunc.mChunkList[i].get(), aFunc.mChunkLengths[i]));
+ }
+ mNeedComma[mDepth] = true;
+ }
+
+ // Takes the chunks from aFunc and write them. If move is not possible
+ // (e.g., using OStreamJSONWriteFunc), aFunc's chunks are copied and its
+ // storage cleared.
+ virtual void TakeAndSplice(ChunkedJSONWriteFunc&& aFunc) {
+ Separator();
+ for (size_t i = 0; i < aFunc.mChunkList.length(); i++) {
+ WriteFunc().Write(
+ Span<const char>(aFunc.mChunkList[i].get(), aFunc.mChunkLengths[i]));
+ }
+ aFunc.mChunkPtr = nullptr;
+ aFunc.mChunkEnd = nullptr;
+ aFunc.mChunkList.clear();
+ aFunc.mChunkLengths.clear();
+ mNeedComma[mDepth] = true;
+ }
+
+ // Set (or reset) the pointer to a UniqueJSONStrings.
+ void SetUniqueStrings(UniqueJSONStrings& aUniqueStrings) {
+ MOZ_RELEASE_ASSERT(!mUniqueStrings);
+ mUniqueStrings = &aUniqueStrings;
+ }
+
+ // Set (or reset) the pointer to a UniqueJSONStrings.
+ void ResetUniqueStrings() {
+ MOZ_RELEASE_ASSERT(mUniqueStrings);
+ mUniqueStrings = nullptr;
+ }
+
+ // Add `aStr` to the unique-strings list (if not already there), and write its
+ // index as a named object property.
+ inline void UniqueStringProperty(const Span<const char>& aName,
+ const Span<const char>& aStr);
+
+ // Add `aStr` to the unique-strings list (if not already there), and write its
+ // index as an array element.
+ inline void UniqueStringElement(const Span<const char>& aStr);
+
+ // THe following functions override JSONWriter functions non-virtually. The
+ // goal is to try and prevent calls that specify a style, which would be
+ // ignored anyway because the whole thing is single-lined. It's fine if some
+ // calls still make it through a `JSONWriter&`, no big deal.
+ void Start() { JSONWriter::Start(); }
+ void StartArrayProperty(const Span<const char>& aName) {
+ JSONWriter::StartArrayProperty(aName);
+ }
+ template <size_t N>
+ void StartArrayProperty(const char (&aName)[N]) {
+ JSONWriter::StartArrayProperty(Span<const char>(aName, N));
+ }
+ void StartArrayElement() { JSONWriter::StartArrayElement(); }
+ void StartObjectProperty(const Span<const char>& aName) {
+ JSONWriter::StartObjectProperty(aName);
+ }
+ template <size_t N>
+ void StartObjectProperty(const char (&aName)[N]) {
+ JSONWriter::StartObjectProperty(Span<const char>(aName, N));
+ }
+ void StartObjectElement() { JSONWriter::StartObjectElement(); }
+
+ FAILURELATCH_IMPL_PROXY(*mFailureLatch)
+
+ protected:
+ NotNull<FailureLatch*> mFailureLatch;
+
+ private:
+ UniqueJSONStrings* mUniqueStrings = nullptr;
+};
+
+class SpliceableChunkedJSONWriter final : public SpliceableJSONWriter {
+ public:
+ explicit SpliceableChunkedJSONWriter(FailureLatch& aFailureLatch)
+ : SpliceableJSONWriter(MakeUnique<ChunkedJSONWriteFunc>(aFailureLatch),
+ aFailureLatch) {}
+
+ // Access the ChunkedJSONWriteFunc as reference-to-const, usually to copy data
+ // out.
+ const ChunkedJSONWriteFunc& ChunkedWriteFunc() const {
+ return ChunkedWriteFuncRef();
+ }
+
+ // Access the ChunkedJSONWriteFunc as rvalue-reference, usually to take its
+ // data out. This writer shouldn't be used anymore after this.
+ ChunkedJSONWriteFunc&& TakeChunkedWriteFunc() {
+ ChunkedJSONWriteFunc& ref = ChunkedWriteFuncRef();
+#ifdef DEBUG
+ mTaken = true;
+#endif //
+ return std::move(ref);
+ }
+
+ // Adopts the chunks from aFunc without copying.
+ void TakeAndSplice(ChunkedJSONWriteFunc&& aFunc) override {
+ MOZ_ASSERT(!mTaken);
+ Separator();
+ ChunkedWriteFuncRef().Take(std::move(aFunc));
+ mNeedComma[mDepth] = true;
+ }
+
+ void ChangeFailureLatchAndForwardState(FailureLatch& aFailureLatch) {
+ mFailureLatch = WrapNotNullUnchecked(&aFailureLatch);
+ return ChunkedWriteFuncRef().ChangeFailureLatchAndForwardState(
+ aFailureLatch);
+ }
+
+ private:
+ const ChunkedJSONWriteFunc& ChunkedWriteFuncRef() const {
+ MOZ_ASSERT(!mTaken);
+ // The WriteFunc was non-fallibly allocated as a ChunkedJSONWriteFunc in the
+ // only constructor above, so it's safe to cast to ChunkedJSONWriteFunc&.
+ return static_cast<const ChunkedJSONWriteFunc&>(WriteFunc());
+ }
+
+ ChunkedJSONWriteFunc& ChunkedWriteFuncRef() {
+ MOZ_ASSERT(!mTaken);
+ // The WriteFunc was non-fallibly allocated as a ChunkedJSONWriteFunc in the
+ // only constructor above, so it's safe to cast to ChunkedJSONWriteFunc&.
+ return static_cast<ChunkedJSONWriteFunc&>(WriteFunc());
+ }
+
+#ifdef DEBUG
+ bool mTaken = false;
+#endif
+};
+
+class JSONSchemaWriter {
+ JSONWriter& mWriter;
+ uint32_t mIndex;
+
+ public:
+ explicit JSONSchemaWriter(JSONWriter& aWriter) : mWriter(aWriter), mIndex(0) {
+ aWriter.StartObjectProperty("schema",
+ SpliceableJSONWriter::SingleLineStyle);
+ }
+
+ void WriteField(const Span<const char>& aName) {
+ mWriter.IntProperty(aName, mIndex++);
+ }
+
+ template <size_t Np1>
+ void WriteField(const char (&aName)[Np1]) {
+ WriteField(Span<const char>(aName, Np1 - 1));
+ }
+
+ ~JSONSchemaWriter() { mWriter.EndObject(); }
+};
+
+// This class helps create an indexed list of unique strings, and inserts the
+// index as a JSON value. The collected list of unique strings can later be
+// inserted as a JSON array.
+// This can be useful for elements/properties with many repeated strings.
+//
+// With only JSONWriter w,
+// `w.WriteElement("a"); w.WriteElement("b"); w.WriteElement("a");`
+// when done inside a JSON array, will generate:
+// `["a", "b", "c"]`
+//
+// With UniqueStrings u,
+// `u.WriteElement(w, "a"); u.WriteElement(w, "b"); u.WriteElement(w, "a");`
+// when done inside a JSON array, will generate:
+// `[0, 1, 0]`
+// and later, `u.SpliceStringTableElements(w)` (inside a JSON array), will
+// output the corresponding indexed list of unique strings:
+// `["a", "b"]`
+class UniqueJSONStrings final : public FailureLatch {
+ public:
+ // Start an empty list of unique strings.
+ MFBT_API explicit UniqueJSONStrings(FailureLatch& aFailureLatch);
+
+ // Start with a copy of the strings from another list.
+ MFBT_API UniqueJSONStrings(FailureLatch& aFailureLatch,
+ const UniqueJSONStrings& aOther,
+ ProgressLogger aProgressLogger);
+
+ MFBT_API ~UniqueJSONStrings();
+
+ // Add `aStr` to the list (if not already there), and write its index as a
+ // named object property.
+ void WriteProperty(SpliceableJSONWriter& aWriter,
+ const Span<const char>& aName,
+ const Span<const char>& aStr) {
+ if (const Maybe<uint32_t> maybeIndex = GetOrAddIndex(aStr); maybeIndex) {
+ aWriter.IntProperty(aName, *maybeIndex);
+ } else {
+ aWriter.SetFailureFrom(*this);
+ }
+ }
+
+ // Add `aStr` to the list (if not already there), and write its index as an
+ // array element.
+ void WriteElement(SpliceableJSONWriter& aWriter,
+ const Span<const char>& aStr) {
+ if (const Maybe<uint32_t> maybeIndex = GetOrAddIndex(aStr); maybeIndex) {
+ aWriter.IntElement(*maybeIndex);
+ } else if (!aWriter.Failed()) {
+ aWriter.SetFailureFrom(*this);
+ }
+ }
+
+ // Splice all collected unique strings into an array. This should only be done
+ // once, and then this UniqueStrings shouldn't be used anymore.
+ MFBT_API void SpliceStringTableElements(SpliceableJSONWriter& aWriter);
+
+ FAILURELATCH_IMPL_PROXY(mStringTableWriter)
+
+ void ChangeFailureLatchAndForwardState(FailureLatch& aFailureLatch) {
+ mStringTableWriter.ChangeFailureLatchAndForwardState(aFailureLatch);
+ }
+
+ private:
+ MFBT_API void ClearAndSetFailure(std::string aFailure);
+
+ // If `aStr` is already listed, return its index.
+ // Otherwise add it to the list and return the new index.
+ MFBT_API Maybe<uint32_t> GetOrAddIndex(const Span<const char>& aStr);
+
+ SpliceableChunkedJSONWriter mStringTableWriter;
+ HashMap<HashNumber, uint32_t> mStringHashToIndexMap;
+};
+
+void SpliceableJSONWriter::UniqueStringProperty(const Span<const char>& aName,
+ const Span<const char>& aStr) {
+ MOZ_RELEASE_ASSERT(mUniqueStrings);
+ mUniqueStrings->WriteProperty(*this, aName, aStr);
+}
+
+// Add `aStr` to the list (if not already there), and write its index as an
+// array element.
+void SpliceableJSONWriter::UniqueStringElement(const Span<const char>& aStr) {
+ MOZ_RELEASE_ASSERT(mUniqueStrings);
+ mUniqueStrings->WriteElement(*this, aStr);
+}
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif // BASEPROFILEJSONWRITER_H
diff --git a/mozglue/baseprofiler/public/BaseProfiler.h b/mozglue/baseprofiler/public/BaseProfiler.h
new file mode 100644
index 0000000000..a085eb9774
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfiler.h
@@ -0,0 +1,506 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+// The Gecko Profiler is an always-on profiler that takes fast and low overhead
+// samples of the program execution using only userspace functionality for
+// portability. The goal of this module is to provide performance data in a
+// generic cross-platform way without requiring custom tools or kernel support.
+//
+// Samples are collected to form a timeline with optional timeline event
+// (markers) used for filtering. The samples include both native stacks and
+// platform-independent "label stack" frames.
+
+#ifndef BaseProfiler_h
+#define BaseProfiler_h
+
+// This file is safe to include unconditionally, and only defines
+// empty macros if MOZ_GECKO_PROFILER is not set.
+
+// These headers are also safe to include unconditionally, with empty macros if
+// MOZ_GECKO_PROFILER is not set.
+// If your file only uses particular APIs (e.g., only markers), please consider
+// including only the needed headers instead of this one, to reduce compilation
+// dependencies.
+#include "mozilla/BaseProfilerCounts.h"
+#include "mozilla/BaseProfilerLabels.h"
+#include "mozilla/BaseProfilerMarkers.h"
+#include "mozilla/BaseProfilerState.h"
+
+#ifndef MOZ_GECKO_PROFILER
+
+# include "mozilla/UniquePtr.h"
+
+// This file can be #included unconditionally. However, everything within this
+// file must be guarded by a #ifdef MOZ_GECKO_PROFILER, *except* for the
+// following macros and functions, which encapsulate the most common operations
+// and thus avoid the need for many #ifdefs.
+
+# define AUTO_BASE_PROFILER_INIT \
+ ::mozilla::baseprofiler::profiler_init_main_thread_id()
+
+# define BASE_PROFILER_REGISTER_THREAD(name)
+# define BASE_PROFILER_UNREGISTER_THREAD()
+# define AUTO_BASE_PROFILER_REGISTER_THREAD(name)
+
+# define AUTO_BASE_PROFILER_THREAD_SLEEP
+# define AUTO_BASE_PROFILER_THREAD_WAKE
+
+// Function stubs for when MOZ_GECKO_PROFILER is not defined.
+
+namespace mozilla {
+
+namespace baseprofiler {
+// This won't be used, it's just there to allow the empty definition of
+// `profiler_get_backtrace`.
+struct ProfilerBacktrace {};
+using UniqueProfilerBacktrace = UniquePtr<ProfilerBacktrace>;
+
+// Get/Capture-backtrace functions can return nullptr or false, the result
+// should be fed to another empty macro or stub anyway.
+
+static inline UniqueProfilerBacktrace profiler_get_backtrace() {
+ return nullptr;
+}
+
+static inline bool profiler_capture_backtrace_into(
+ ProfileChunkedBuffer& aChunkedBuffer, StackCaptureOptions aCaptureOptions) {
+ return false;
+}
+
+static inline UniquePtr<ProfileChunkedBuffer> profiler_capture_backtrace() {
+ return nullptr;
+}
+
+static inline void profiler_init(void* stackTop) {}
+
+static inline void profiler_shutdown() {}
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#else // !MOZ_GECKO_PROFILER
+
+# include "BaseProfilingStack.h"
+
+# include "mozilla/Assertions.h"
+# include "mozilla/Atomics.h"
+# include "mozilla/Attributes.h"
+# include "mozilla/BaseProfilerRAIIMacro.h"
+# include "mozilla/Maybe.h"
+# include "mozilla/PowerOfTwo.h"
+# include "mozilla/TimeStamp.h"
+# include "mozilla/UniquePtr.h"
+
+# include <functional>
+# include <stdint.h>
+# include <string>
+
+namespace mozilla {
+
+class MallocAllocPolicy;
+class ProfileChunkedBuffer;
+enum class StackCaptureOptions;
+template <class T, size_t MinInlineCapacity, class AllocPolicy>
+class Vector;
+
+namespace baseprofiler {
+
+class ProfilerBacktrace;
+class SpliceableJSONWriter;
+
+//---------------------------------------------------------------------------
+// Start and stop the profiler
+//---------------------------------------------------------------------------
+
+static constexpr PowerOfTwo32 BASE_PROFILER_DEFAULT_ENTRIES =
+# if !defined(GP_PLAT_arm_android)
+ MakePowerOfTwo32<8 * 1024 * 1024>(); // 8M entries = 64MB
+# else
+ MakePowerOfTwo32<2 * 1024 * 1024>(); // 2M entries = 16MB
+# endif
+
+// Startup profiling usually need to capture more data, especially on slow
+// systems.
+// Note: Keep in sync with GeckoThread.maybeStartGeckoProfiler:
+// https://searchfox.org/mozilla-central/source/mobile/android/geckoview/src/main/java/org/mozilla/gecko/GeckoThread.java
+static constexpr PowerOfTwo32 BASE_PROFILER_DEFAULT_STARTUP_ENTRIES =
+# if !defined(GP_PLAT_arm_android)
+ mozilla::MakePowerOfTwo32<64 * 1024 * 1024>(); // 64M entries = 512MB
+# else
+ mozilla::MakePowerOfTwo32<8 * 1024 * 1024>(); // 8M entries = 64MB
+# endif
+
+// Note: Keep in sync with GeckoThread.maybeStartGeckoProfiler:
+// https://searchfox.org/mozilla-central/source/mobile/android/geckoview/src/main/java/org/mozilla/gecko/GeckoThread.java
+# define BASE_PROFILER_DEFAULT_INTERVAL 1 /* millisecond */
+# define BASE_PROFILER_MAX_INTERVAL 5000 /* milliseconds */
+
+// Initialize the profiler. If MOZ_PROFILER_STARTUP is set the profiler will
+// also be started. This call must happen before any other profiler calls
+// (except profiler_start(), which will call profiler_init() if it hasn't
+// already run).
+MFBT_API void profiler_init(void* stackTop);
+
+# define AUTO_BASE_PROFILER_INIT \
+ ::mozilla::baseprofiler::AutoProfilerInit PROFILER_RAII
+
+// Clean up the profiler module, stopping it if required. This function may
+// also save a shutdown profile if requested. No profiler calls should happen
+// after this point and all profiling stack labels should have been popped.
+MFBT_API void profiler_shutdown();
+
+// Start the profiler -- initializing it first if necessary -- with the
+// selected options. Stops and restarts the profiler if it is already active.
+// After starting the profiler is "active". The samples will be recorded in a
+// circular buffer.
+// "aCapacity" is the maximum number of 8-byte entries in the profiler's
+// circular buffer.
+// "aInterval" the sampling interval, measured in millseconds.
+// "aFeatures" is the feature set. Features unsupported by this
+// platform/configuration are ignored.
+// "aFilters" is the list of thread filters. Threads that do not match any
+// of the filters are not profiled. A filter matches a thread if
+// (a) the thread name contains the filter as a case-insensitive
+// substring, or
+// (b) the filter is of the form "pid:<n>" where n is the process
+// id of the process that the thread is running in.
+// "aDuration" is the duration of entries in the profiler's circular buffer.
+MFBT_API void profiler_start(PowerOfTwo32 aCapacity, double aInterval,
+ uint32_t aFeatures, const char** aFilters,
+ uint32_t aFilterCount,
+ const Maybe<double>& aDuration = Nothing());
+
+// Stop the profiler and discard the profile without saving it. A no-op if the
+// profiler is inactive. After stopping the profiler is "inactive".
+MFBT_API void profiler_stop();
+
+// If the profiler is inactive, start it. If it's already active, restart it if
+// the requested settings differ from the current settings. Both the check and
+// the state change are performed while the profiler state is locked.
+// The only difference to profiler_start is that the current buffer contents are
+// not discarded if the profiler is already running with the requested settings.
+MFBT_API void profiler_ensure_started(
+ PowerOfTwo32 aCapacity, double aInterval, uint32_t aFeatures,
+ const char** aFilters, uint32_t aFilterCount,
+ const Maybe<double>& aDuration = Nothing());
+
+//---------------------------------------------------------------------------
+// Control the profiler
+//---------------------------------------------------------------------------
+
+// Register/unregister threads with the profiler. Both functions operate the
+// same whether the profiler is active or inactive.
+# define BASE_PROFILER_REGISTER_THREAD(name) \
+ do { \
+ char stackTop; \
+ ::mozilla::baseprofiler::profiler_register_thread(name, &stackTop); \
+ } while (0)
+# define BASE_PROFILER_UNREGISTER_THREAD() \
+ ::mozilla::baseprofiler::profiler_unregister_thread()
+MFBT_API ProfilingStack* profiler_register_thread(const char* name,
+ void* guessStackTop);
+MFBT_API void profiler_unregister_thread();
+
+// Registers a DOM Window (the JS global `window`) with the profiler. Each
+// Window _roughly_ corresponds to a single document loaded within a
+// browsing context. Both the Window Id and Browser Id are recorded to allow
+// correlating different Windows loaded within the same tab or frame element.
+//
+// We register pages for each navigations but we do not register
+// history.pushState or history.replaceState since they correspond to the same
+// Inner Window ID. When a browsing context is first loaded, the first url
+// loaded in it will be about:blank. Because of that, this call keeps the first
+// non-about:blank registration of window and discards the previous one.
+//
+// "aTabID" is the BrowserId of that document belongs to.
+// That's used to determine the tab of that page.
+// "aInnerWindowID" is the ID of the `window` global object of that
+// document.
+// "aUrl" is the URL of the page.
+// "aEmbedderInnerWindowID" is the inner window id of embedder. It's used to
+// determine sub documents of a page.
+MFBT_API void profiler_register_page(uint64_t aTabD, uint64_t aInnerWindowID,
+ const std::string& aUrl,
+ uint64_t aEmbedderInnerWindowID);
+
+// Unregister page with the profiler.
+//
+// Take a Inner Window ID and unregister the page entry that has the same ID.
+MFBT_API void profiler_unregister_page(uint64_t aRegisteredInnerWindowID);
+
+// Remove all registered and unregistered pages in the profiler.
+void profiler_clear_all_pages();
+
+class BaseProfilerCount;
+MFBT_API void profiler_add_sampled_counter(BaseProfilerCount* aCounter);
+MFBT_API void profiler_remove_sampled_counter(BaseProfilerCount* aCounter);
+
+// Register and unregister a thread within a scope.
+# define AUTO_BASE_PROFILER_REGISTER_THREAD(name) \
+ ::mozilla::baseprofiler::AutoProfilerRegisterThread PROFILER_RAII(name)
+
+// Pause and resume the profiler. No-ops if the profiler is inactive. While
+// paused the profile will not take any samples and will not record any data
+// into its buffers. The profiler remains fully initialized in this state.
+// This feature will keep JavaScript profiling enabled, thus allowing toggling
+// the profiler without invalidating the JIT.
+MFBT_API void profiler_pause();
+MFBT_API void profiler_resume();
+
+// Only pause and resume the periodic sampling loop, including stack sampling,
+// counters, and profiling overheads.
+MFBT_API void profiler_pause_sampling();
+MFBT_API void profiler_resume_sampling();
+
+// These functions tell the profiler that a thread went to sleep so that we can
+// avoid sampling it while it's sleeping. Calling profiler_thread_sleep()
+// twice without an intervening profiler_thread_wake() is an error. All three
+// functions operate the same whether the profiler is active or inactive.
+MFBT_API void profiler_thread_sleep();
+MFBT_API void profiler_thread_wake();
+
+// Mark a thread as asleep/awake within a scope.
+# define AUTO_BASE_PROFILER_THREAD_SLEEP \
+ ::mozilla::baseprofiler::AutoProfilerThreadSleep PROFILER_RAII
+# define AUTO_BASE_PROFILER_THREAD_WAKE \
+ ::mozilla::baseprofiler::AutoProfilerThreadWake PROFILER_RAII
+
+//---------------------------------------------------------------------------
+// Get information from the profiler
+//---------------------------------------------------------------------------
+
+// Get the params used to start the profiler. Returns 0 and an empty vector
+// (via outparams) if the profile is inactive. It's possible that the features
+// returned may be slightly different to those requested due to required
+// adjustments.
+MFBT_API void profiler_get_start_params(
+ int* aEntrySize, Maybe<double>* aDuration, double* aInterval,
+ uint32_t* aFeatures, Vector<const char*, 0, MallocAllocPolicy>* aFilters);
+
+// The number of milliseconds since the process started. Operates the same
+// whether the profiler is active or inactive.
+MFBT_API double profiler_time();
+
+// An object of this class is passed to profiler_suspend_and_sample_thread().
+// For each stack frame, one of the Collect methods will be called.
+class ProfilerStackCollector {
+ public:
+ // Some collectors need to worry about possibly overwriting previous
+ // generations of data. If that's not an issue, this can return Nothing,
+ // which is the default behaviour.
+ virtual Maybe<uint64_t> SamplePositionInBuffer() { return Nothing(); }
+ virtual Maybe<uint64_t> BufferRangeStart() { return Nothing(); }
+
+ // This method will be called once if the thread being suspended is the main
+ // thread. Default behaviour is to do nothing.
+ virtual void SetIsMainThread() {}
+
+ // WARNING: The target thread is suspended when the Collect methods are
+ // called. Do not try to allocate or acquire any locks, or you could
+ // deadlock. The target thread will have resumed by the time this function
+ // returns.
+
+ virtual void CollectNativeLeafAddr(void* aAddr) = 0;
+
+ virtual void CollectProfilingStackFrame(
+ const ProfilingStackFrame& aFrame) = 0;
+};
+
+// This method suspends the thread identified by aThreadId, samples its
+// profiling stack, JS stack, and (optionally) native stack, passing the
+// collected frames into aCollector. aFeatures dictates which compiler features
+// are used. |Leaf| is the only relevant one.
+// Use `aThreadId`=0 to sample the current thread.
+MFBT_API void profiler_suspend_and_sample_thread(
+ int aThreadId, uint32_t aFeatures, ProfilerStackCollector& aCollector,
+ bool aSampleNative = true);
+
+struct ProfilerBacktraceDestructor {
+ MFBT_API void operator()(ProfilerBacktrace*);
+};
+
+using UniqueProfilerBacktrace =
+ UniquePtr<ProfilerBacktrace, ProfilerBacktraceDestructor>;
+
+// Immediately capture the current thread's call stack, store it in the provided
+// buffer (usually to avoid allocations if you can construct the buffer on the
+// stack). Returns false if unsuccessful, if the profiler is inactive, or if
+// aCaptureOptions is NoStack.
+MFBT_API bool profiler_capture_backtrace_into(
+ ProfileChunkedBuffer& aChunkedBuffer, StackCaptureOptions aCaptureOptions);
+
+// Immediately capture the current thread's call stack, and return it in a
+// ProfileChunkedBuffer (usually for later use in MarkerStack::TakeBacktrace()).
+// May be null if unsuccessful, or if the profiler is inactive.
+MFBT_API UniquePtr<ProfileChunkedBuffer> profiler_capture_backtrace();
+
+// Immediately capture the current thread's call stack, and return it in a
+// ProfilerBacktrace (usually for later use in marker function that take a
+// ProfilerBacktrace). May be null if unsuccessful, or if the profiler is
+// inactive.
+MFBT_API UniqueProfilerBacktrace profiler_get_backtrace();
+
+struct ProfilerStats {
+ unsigned n = 0;
+ double sum = 0;
+ double min = std::numeric_limits<double>::max();
+ double max = 0;
+ void Count(double v) {
+ ++n;
+ sum += v;
+ if (v < min) {
+ min = v;
+ }
+ if (v > max) {
+ max = v;
+ }
+ }
+};
+
+struct ProfilerBufferInfo {
+ // Index of the oldest entry.
+ uint64_t mRangeStart;
+ // Index of the newest entry.
+ uint64_t mRangeEnd;
+ // Buffer capacity in number of 8-byte entries.
+ uint32_t mEntryCount;
+ // Sampling stats: Interval (us) between successive samplings.
+ ProfilerStats mIntervalsUs;
+ // Sampling stats: Total duration (us) of each sampling. (Split detail below.)
+ ProfilerStats mOverheadsUs;
+ // Sampling stats: Time (us) to acquire the lock before sampling.
+ ProfilerStats mLockingsUs;
+ // Sampling stats: Time (us) to discard expired data.
+ ProfilerStats mCleaningsUs;
+ // Sampling stats: Time (us) to collect counter data.
+ ProfilerStats mCountersUs;
+ // Sampling stats: Time (us) to sample thread stacks.
+ ProfilerStats mThreadsUs;
+};
+
+// Get information about the current buffer status.
+// Returns Nothing() if the profiler is inactive.
+//
+// This information may be useful to a user-interface displaying the current
+// status of the profiler, allowing the user to get a sense for how fast the
+// buffer is being written to, and how much data is visible.
+MFBT_API Maybe<ProfilerBufferInfo> profiler_get_buffer_info();
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+namespace mozilla {
+namespace baseprofiler {
+
+//---------------------------------------------------------------------------
+// Put profiling data into the profiler (markers)
+//---------------------------------------------------------------------------
+
+MFBT_API void profiler_add_js_marker(const char* aMarkerName,
+ const char* aMarkerText);
+
+//---------------------------------------------------------------------------
+// Output profiles
+//---------------------------------------------------------------------------
+
+// Set a user-friendly process name, used in JSON stream.
+MFBT_API void profiler_set_process_name(const std::string& aProcessName,
+ const std::string* aETLDplus1);
+
+// Get the profile encoded as a JSON string. A no-op (returning nullptr) if the
+// profiler is inactive.
+// If aIsShuttingDown is true, the current time is included as the process
+// shutdown time in the JSON's "meta" object.
+MFBT_API UniquePtr<char[]> profiler_get_profile(double aSinceTime = 0,
+ bool aIsShuttingDown = false,
+ bool aOnlyThreads = false);
+
+// Write the profile for this process (excluding subprocesses) into aWriter.
+// Returns false if the profiler is inactive.
+MFBT_API bool profiler_stream_json_for_this_process(
+ SpliceableJSONWriter& aWriter, double aSinceTime = 0,
+ bool aIsShuttingDown = false, bool aOnlyThreads = false);
+
+// Get the profile and write it into a file. A no-op if the profile is
+// inactive.
+// Prefixed with "base" to avoid clashing with Gecko Profiler's extern "C"
+// profiler_save_profile_to_file when called from debugger.
+MFBT_API void baseprofiler_save_profile_to_file(const char* aFilename);
+
+//---------------------------------------------------------------------------
+// RAII classes
+//---------------------------------------------------------------------------
+
+class MOZ_RAII AutoProfilerInit {
+ public:
+ explicit AutoProfilerInit() { profiler_init(this); }
+
+ ~AutoProfilerInit() { profiler_shutdown(); }
+
+ private:
+};
+
+// Convenience class to register and unregister a thread with the profiler.
+// Needs to be the first object on the stack of the thread.
+class MOZ_RAII AutoProfilerRegisterThread final {
+ public:
+ explicit AutoProfilerRegisterThread(const char* aName) {
+ profiler_register_thread(aName, this);
+ }
+
+ ~AutoProfilerRegisterThread() { profiler_unregister_thread(); }
+
+ private:
+ AutoProfilerRegisterThread(const AutoProfilerRegisterThread&) = delete;
+ AutoProfilerRegisterThread& operator=(const AutoProfilerRegisterThread&) =
+ delete;
+};
+
+class MOZ_RAII AutoProfilerThreadSleep {
+ public:
+ explicit AutoProfilerThreadSleep() { profiler_thread_sleep(); }
+
+ ~AutoProfilerThreadSleep() { profiler_thread_wake(); }
+
+ private:
+};
+
+// Temporarily wake up the profiling of a thread while servicing events such as
+// Asynchronous Procedure Calls (APCs).
+class MOZ_RAII AutoProfilerThreadWake {
+ public:
+ explicit AutoProfilerThreadWake()
+ : mIssuedWake(profiler_thread_is_sleeping()) {
+ if (mIssuedWake) {
+ profiler_thread_wake();
+ }
+ }
+
+ ~AutoProfilerThreadWake() {
+ if (mIssuedWake) {
+ MOZ_ASSERT(!profiler_thread_is_sleeping());
+ profiler_thread_sleep();
+ }
+ }
+
+ private:
+ bool mIssuedWake;
+};
+
+// Get the MOZ_PROFILER_STARTUP* environment variables that should be
+// supplied to a child process that is about to be launched, in order
+// to make that child process start with the same profiler settings as
+// in the current process. The given function is invoked once for
+// each variable to be set.
+MFBT_API void GetProfilerEnvVarsForChildProcess(
+ std::function<void(const char* key, const char* value)>&& aSetEnv);
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif // !MOZ_GECKO_PROFILER
+
+#endif // BaseProfiler_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerCounts.h b/mozglue/baseprofiler/public/BaseProfilerCounts.h
new file mode 100644
index 0000000000..fbcc713744
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerCounts.h
@@ -0,0 +1,280 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef BaseProfilerCounts_h
+#define BaseProfilerCounts_h
+
+#ifndef MOZ_GECKO_PROFILER
+
+# define BASE_PROFILER_DEFINE_COUNT_TOTAL(label, category, description)
+# define BASE_PROFILER_DEFINE_COUNT(label, category, description)
+# define BASE_PROFILER_DEFINE_STATIC_COUNT_TOTAL(label, category, description)
+# define AUTO_BASE_PROFILER_COUNT_TOTAL(label, count)
+# define AUTO_BASE_PROFILER_COUNT(label)
+# define AUTO_BASE_PROFILER_STATIC_COUNT(label, count)
+# define AUTO_BASE_PROFILER_FORCE_ALLOCATION(label)
+
+#else
+
+# include "mozilla/Atomics.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+class BaseProfilerCount;
+MFBT_API void profiler_add_sampled_counter(BaseProfilerCount* aCounter);
+MFBT_API void profiler_remove_sampled_counter(BaseProfilerCount* aCounter);
+
+typedef Atomic<int64_t, MemoryOrdering::Relaxed> ProfilerAtomicSigned;
+typedef Atomic<uint64_t, MemoryOrdering::Relaxed> ProfilerAtomicUnsigned;
+
+// Counter support
+// There are two types of counters:
+// 1) a simple counter which can be added to or subtracted from. This could
+// track the number of objects of a type, the number of calls to something
+// (reflow, JIT, etc).
+// 2) a combined counter which has the above, plus a number-of-calls counter
+// that is incremented by 1 for each call to modify the count. This provides
+// an optional source for a 'heatmap' of access. This can be used (for
+// example) to track the amount of memory allocated, and provide a heatmap of
+// memory operations (allocs/frees).
+//
+// Counters are sampled by the profiler once per sample-period. At this time,
+// all counters are global to the process. In the future, there might be more
+// versions with per-thread or other discriminators.
+//
+// Typical usage:
+// There are two ways to use counters: With heap-created counter objects,
+// or using macros. Note: the macros use statics, and will be slightly
+// faster/smaller, and you need to care about creating them before using
+// them. They're similar to the use-pattern for the other AUTO_PROFILER*
+// macros, but they do need the PROFILER_DEFINE* to be use to instantiate
+// the statics.
+//
+// PROFILER_DEFINE_COUNT(mything, "JIT", "Some JIT byte count")
+// ...
+// void foo() { ... AUTO_PROFILER_COUNT(mything, number_of_bytes_used); ... }
+//
+// or (to also get a heatmap)
+//
+// PROFILER_DEFINE_COUNT_TOTAL(mything, "JIT", "Some JIT byte count")
+// ...
+// void foo() {
+// ...
+// AUTO_PROFILER_COUNT_TOTAL(mything, number_of_bytes_generated);
+// ...
+// }
+//
+// To use without statics/macros:
+//
+// UniquePtr<ProfilerCounter> myCounter;
+// ...
+// myCounter =
+// MakeUnique<ProfilerCounter>("mything", "JIT", "Some JIT byte count"));
+// ...
+// void foo() { ... myCounter->Add(number_of_bytes_generated0; ... }
+
+class BaseProfilerCount {
+ public:
+ BaseProfilerCount(const char* aLabel, ProfilerAtomicSigned* aCounter,
+ ProfilerAtomicUnsigned* aNumber, const char* aCategory,
+ const char* aDescription)
+ : mLabel(aLabel),
+ mCategory(aCategory),
+ mDescription(aDescription),
+ mCounter(aCounter),
+ mNumber(aNumber) {
+# define COUNTER_CANARY 0xDEADBEEF
+# ifdef DEBUG
+ mCanary = COUNTER_CANARY;
+ mPrevNumber = 0;
+# endif
+ // Can't call profiler_* here since this may be non-xul-library
+ }
+# ifdef DEBUG
+ ~BaseProfilerCount() { mCanary = 0; }
+# endif
+
+ void Sample(int64_t& aCounter, uint64_t& aNumber) {
+ MOZ_ASSERT(mCanary == COUNTER_CANARY);
+
+ aCounter = *mCounter;
+ aNumber = mNumber ? *mNumber : 0;
+# ifdef DEBUG
+ MOZ_ASSERT(aNumber >= mPrevNumber);
+ mPrevNumber = aNumber;
+# endif
+ }
+
+ // We don't define ++ and Add() here, since the static defines directly
+ // increment the atomic counters, and the subclasses implement ++ and
+ // Add() directly.
+
+ // These typically are static strings (for example if you use the macros
+ // below)
+ const char* mLabel;
+ const char* mCategory;
+ const char* mDescription;
+ // We're ok with these being un-ordered in race conditions. These are
+ // pointers because we want to be able to use statics and increment them
+ // directly. Otherwise we could just have them inline, and not need the
+ // constructor args.
+ // These can be static globals (using the macros below), though they
+ // don't have to be - their lifetime must be longer than the use of them
+ // by the profiler (see profiler_add/remove_sampled_counter()). If you're
+ // using a lot of these, they probably should be allocated at runtime (see
+ // class ProfilerCountOnly below).
+ ProfilerAtomicSigned* mCounter;
+ ProfilerAtomicUnsigned* mNumber; // may be null
+
+# ifdef DEBUG
+ uint32_t mCanary;
+ uint64_t mPrevNumber; // value of number from the last Sample()
+# endif
+};
+
+// Designed to be allocated dynamically, and simply incremented with obj++
+// or obj->Add(n)
+class ProfilerCounter final : public BaseProfilerCount {
+ public:
+ ProfilerCounter(const char* aLabel, const char* aCategory,
+ const char* aDescription)
+ : BaseProfilerCount(aLabel, &mCounter, nullptr, aCategory, aDescription) {
+ // Assume we're in libxul
+ profiler_add_sampled_counter(this);
+ }
+
+ virtual ~ProfilerCounter() { profiler_remove_sampled_counter(this); }
+
+ BaseProfilerCount& operator++() {
+ Add(1);
+ return *this;
+ }
+
+ void Add(int64_t aNumber) { mCounter += aNumber; }
+
+ ProfilerAtomicSigned mCounter;
+};
+
+// Also keeps a heatmap (number of calls to ++/Add())
+class ProfilerCounterTotal final : public BaseProfilerCount {
+ public:
+ ProfilerCounterTotal(const char* aLabel, const char* aCategory,
+ const char* aDescription)
+ : BaseProfilerCount(aLabel, &mCounter, &mNumber, aCategory,
+ aDescription) {
+ // Assume we're in libxul
+ profiler_add_sampled_counter(this);
+ }
+
+ virtual ~ProfilerCounterTotal() { profiler_remove_sampled_counter(this); }
+
+ BaseProfilerCount& operator++() {
+ Add(1);
+ return *this;
+ }
+
+ void Add(int64_t aNumber) {
+ mCounter += aNumber;
+ mNumber++;
+ }
+
+ ProfilerAtomicSigned mCounter;
+ ProfilerAtomicUnsigned mNumber;
+};
+
+// Defines a counter that is sampled on each profiler tick, with a running
+// count (signed), and number-of-instances. Note that because these are two
+// independent Atomics, there is a possiblity that count will not include
+// the last call, but number of uses will. I think this is not worth
+// worrying about
+# define BASE_PROFILER_DEFINE_COUNT_TOTAL(label, category, description) \
+ ProfilerAtomicSigned profiler_count_##label(0); \
+ ProfilerAtomicUnsigned profiler_number_##label(0); \
+ const char profiler_category_##label[] = category; \
+ const char profiler_description_##label[] = description; \
+ UniquePtr<::mozilla::baseprofiler::BaseProfilerCount> AutoCount_##label;
+
+// This counts, but doesn't keep track of the number of calls to
+// AUTO_PROFILER_COUNT()
+# define BASE_PROFILER_DEFINE_COUNT(label, category, description) \
+ ProfilerAtomicSigned profiler_count_##label(0); \
+ const char profiler_category_##label[] = category; \
+ const char profiler_description_##label[] = description; \
+ UniquePtr<::mozilla::baseprofiler::BaseProfilerCount> AutoCount_##label;
+
+// This will create a static initializer if used, but avoids a possible
+// allocation.
+# define BASE_PROFILER_DEFINE_STATIC_COUNT_TOTAL(label, category, \
+ description) \
+ ProfilerAtomicSigned profiler_count_##label(0); \
+ ProfilerAtomicUnsigned profiler_number_##label(0); \
+ ::mozilla::baseprofiler::BaseProfilerCount AutoCount_##label( \
+ #label, &profiler_count_##label, &profiler_number_##label, category, \
+ description);
+
+// If we didn't care about static initializers, we could avoid the need for
+// a ptr to the BaseProfilerCount object.
+
+// XXX It would be better to do this without the if() and without the
+// theoretical race to set the UniquePtr (i.e. possible leak).
+# define AUTO_BASE_PROFILER_COUNT_TOTAL(label, count) \
+ do { \
+ profiler_number_##label++; /* do this first*/ \
+ profiler_count_##label += count; \
+ if (!AutoCount_##label) { \
+ /* Ignore that we could call this twice in theory, and that we leak \
+ * them \
+ */ \
+ AutoCount_##label.reset(new BaseProfilerCount( \
+ #label, &profiler_count_##label, &profiler_number_##label, \
+ profiler_category_##label, profiler_description_##label)); \
+ ::mozilla::baseprofiler::profiler_add_sampled_counter( \
+ AutoCount_##label.get()); \
+ } \
+ } while (0)
+
+# define AUTO_BASE_PROFILER_COUNT(label, count) \
+ do { \
+ profiler_count_##label += count; /* do this first*/ \
+ if (!AutoCount_##label) { \
+ /* Ignore that we could call this twice in theory, and that we leak \
+ * them \
+ */ \
+ AutoCount_##label.reset(new BaseProfilerCount( \
+ #label, nullptr, &profiler_number_##label, \
+ profiler_category_##label, profiler_description_##label)); \
+ ::mozilla::baseprofiler::profiler_add_sampled_counter( \
+ AutoCount_##label.get()); \
+ } \
+ } while (0)
+
+# define AUTO_BASE_PROFILER_STATIC_COUNT(label, count) \
+ do { \
+ profiler_number_##label++; /* do this first*/ \
+ profiler_count_##label += count; \
+ } while (0)
+
+// if we need to force the allocation
+# define AUTO_BASE_PROFILER_FORCE_ALLOCATION(label) \
+ do { \
+ if (!AutoCount_##label) { \
+ /* Ignore that we could call this twice in theory, and that we leak \
+ * them \
+ */ \
+ AutoCount_##label.reset( \
+ new ::mozilla::baseprofiler::BaseProfilerCount( \
+ #label, &profiler_count_##label, &profiler_number_##label, \
+ profiler_category_##label, profiler_description_##label)); \
+ } \
+ } while (0)
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif // !MOZ_GECKO_PROFILER
+
+#endif // BaseProfilerCounts_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerDetail.h b/mozglue/baseprofiler/public/BaseProfilerDetail.h
new file mode 100644
index 0000000000..6ecf6e117b
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerDetail.h
@@ -0,0 +1,285 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+// Internal Base Profiler utilities.
+
+#ifndef BaseProfilerDetail_h
+#define BaseProfilerDetail_h
+
+#include "mozilla/Atomics.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/PlatformMutex.h"
+#include "mozilla/PlatformRWLock.h"
+#include "mozilla/BaseProfilerUtils.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+namespace detail {
+
+// Thin shell around mozglue PlatformMutex, for Base Profiler internal use.
+class MOZ_CAPABILITY("mutex") BaseProfilerMutex
+ : private ::mozilla::detail::MutexImpl {
+ public:
+ BaseProfilerMutex() : ::mozilla::detail::MutexImpl() {}
+ explicit BaseProfilerMutex(const char* aName)
+ : ::mozilla::detail::MutexImpl(), mName(aName) {}
+
+ BaseProfilerMutex(const BaseProfilerMutex&) = delete;
+ BaseProfilerMutex& operator=(const BaseProfilerMutex&) = delete;
+ BaseProfilerMutex(BaseProfilerMutex&&) = delete;
+ BaseProfilerMutex& operator=(BaseProfilerMutex&&) = delete;
+
+#ifdef DEBUG
+ ~BaseProfilerMutex() {
+ MOZ_ASSERT(!BaseProfilerThreadId::FromNumber(mOwningThreadId).IsSpecified(),
+ "BaseProfilerMutex should have been unlocked when destroyed");
+ }
+#endif // DEBUG
+
+ [[nodiscard]] bool IsLockedOnCurrentThread() const {
+ return BaseProfilerThreadId::FromNumber(mOwningThreadId) ==
+ baseprofiler::profiler_current_thread_id();
+ }
+
+ void AssertCurrentThreadOwns() const MOZ_ASSERT_CAPABILITY(this) {
+ MOZ_ASSERT(IsLockedOnCurrentThread());
+ }
+
+ void Lock() MOZ_CAPABILITY_ACQUIRE() {
+ const BaseProfilerThreadId tid = baseprofiler::profiler_current_thread_id();
+ MOZ_ASSERT(tid.IsSpecified());
+ MOZ_ASSERT(!IsLockedOnCurrentThread(), "Recursive locking");
+ ::mozilla::detail::MutexImpl::lock();
+ MOZ_ASSERT(!BaseProfilerThreadId::FromNumber(mOwningThreadId).IsSpecified(),
+ "Not unlocked properly");
+ mOwningThreadId = tid.ToNumber();
+ }
+
+ [[nodiscard]] bool TryLock() MOZ_TRY_ACQUIRE(true) {
+ const BaseProfilerThreadId tid = baseprofiler::profiler_current_thread_id();
+ MOZ_ASSERT(tid.IsSpecified());
+ MOZ_ASSERT(!IsLockedOnCurrentThread(), "Recursive locking");
+ if (!::mozilla::detail::MutexImpl::tryLock()) {
+ // Failed to lock, nothing more to do.
+ return false;
+ }
+ MOZ_ASSERT(!BaseProfilerThreadId::FromNumber(mOwningThreadId).IsSpecified(),
+ "Not unlocked properly");
+ mOwningThreadId = tid.ToNumber();
+ return true;
+ }
+
+ void Unlock() MOZ_CAPABILITY_RELEASE() {
+ MOZ_ASSERT(IsLockedOnCurrentThread(), "Unlocking when not locked here");
+ // We're still holding the mutex here, so it's safe to just reset
+ // `mOwningThreadId`.
+ mOwningThreadId = BaseProfilerThreadId{}.ToNumber();
+ ::mozilla::detail::MutexImpl::unlock();
+ }
+
+ const char* GetName() const { return mName; }
+
+ private:
+ // Thread currently owning the lock, or 0.
+ // Atomic because it may be read at any time independent of the mutex.
+ // Relaxed because threads only need to know if they own it already, so:
+ // - If it's their id, only *they* wrote that value with a locked mutex.
+ // - If it's different from their thread id it doesn't matter what other
+ // number it is (0 or another id) and that it can change again at any time.
+ Atomic<typename BaseProfilerThreadId::NumberType, MemoryOrdering::Relaxed>
+ mOwningThreadId;
+
+ const char* mName = nullptr;
+};
+
+// RAII class to lock a mutex.
+class MOZ_RAII BaseProfilerAutoLock {
+ public:
+ explicit BaseProfilerAutoLock(BaseProfilerMutex& aMutex) : mMutex(aMutex) {
+ mMutex.Lock();
+ }
+
+ BaseProfilerAutoLock(const BaseProfilerAutoLock&) = delete;
+ BaseProfilerAutoLock& operator=(const BaseProfilerAutoLock&) = delete;
+ BaseProfilerAutoLock(BaseProfilerAutoLock&&) = delete;
+ BaseProfilerAutoLock& operator=(BaseProfilerAutoLock&&) = delete;
+
+ ~BaseProfilerAutoLock() { mMutex.Unlock(); }
+
+ private:
+ BaseProfilerMutex& mMutex;
+};
+
+// Thin shell around mozglue PlatformMutex, for Base Profiler internal use.
+// Actual mutex may be disabled at construction time.
+class BaseProfilerMaybeMutex : private ::mozilla::detail::MutexImpl {
+ public:
+ explicit BaseProfilerMaybeMutex(bool aActivate) {
+ if (aActivate) {
+ mMaybeMutex.emplace();
+ }
+ }
+
+ BaseProfilerMaybeMutex(const BaseProfilerMaybeMutex&) = delete;
+ BaseProfilerMaybeMutex& operator=(const BaseProfilerMaybeMutex&) = delete;
+ BaseProfilerMaybeMutex(BaseProfilerMaybeMutex&&) = delete;
+ BaseProfilerMaybeMutex& operator=(BaseProfilerMaybeMutex&&) = delete;
+
+ ~BaseProfilerMaybeMutex() = default;
+
+ bool IsActivated() const { return mMaybeMutex.isSome(); }
+
+ [[nodiscard]] bool IsActivatedAndLockedOnCurrentThread() const {
+ if (!IsActivated()) {
+ // Not activated, so we can never be locked.
+ return false;
+ }
+ return mMaybeMutex->IsLockedOnCurrentThread();
+ }
+
+ void AssertCurrentThreadOwns() const {
+#ifdef DEBUG
+ if (IsActivated()) {
+ mMaybeMutex->AssertCurrentThreadOwns();
+ }
+#endif // DEBUG
+ }
+
+ MOZ_PUSH_IGNORE_THREAD_SAFETY
+ void Lock() {
+ if (IsActivated()) {
+ mMaybeMutex->Lock();
+ }
+ }
+
+ void Unlock() {
+ if (IsActivated()) {
+ mMaybeMutex->Unlock();
+ }
+ }
+ MOZ_POP_THREAD_SAFETY
+
+ private:
+ Maybe<BaseProfilerMutex> mMaybeMutex;
+};
+
+// RAII class to lock a mutex.
+class MOZ_RAII BaseProfilerMaybeAutoLock {
+ public:
+ explicit BaseProfilerMaybeAutoLock(BaseProfilerMaybeMutex& aMaybeMutex)
+ : mMaybeMutex(aMaybeMutex) {
+ mMaybeMutex.Lock();
+ }
+
+ BaseProfilerMaybeAutoLock(const BaseProfilerMaybeAutoLock&) = delete;
+ BaseProfilerMaybeAutoLock& operator=(const BaseProfilerMaybeAutoLock&) =
+ delete;
+ BaseProfilerMaybeAutoLock(BaseProfilerMaybeAutoLock&&) = delete;
+ BaseProfilerMaybeAutoLock& operator=(BaseProfilerMaybeAutoLock&&) = delete;
+
+ ~BaseProfilerMaybeAutoLock() { mMaybeMutex.Unlock(); }
+
+ private:
+ BaseProfilerMaybeMutex& mMaybeMutex;
+};
+
+class BaseProfilerSharedMutex : public ::mozilla::detail::RWLockImpl {
+ public:
+#ifdef DEBUG
+ ~BaseProfilerSharedMutex() {
+ MOZ_ASSERT(!BaseProfilerThreadId::FromNumber(mOwningThreadId).IsSpecified(),
+ "BaseProfilerMutex should have been unlocked when destroyed");
+ }
+#endif // DEBUG
+
+ [[nodiscard]] bool IsLockedExclusiveOnCurrentThread() const {
+ return BaseProfilerThreadId::FromNumber(mOwningThreadId) ==
+ baseprofiler::profiler_current_thread_id();
+ }
+
+ void LockExclusive() {
+ const BaseProfilerThreadId tid = baseprofiler::profiler_current_thread_id();
+ MOZ_ASSERT(tid.IsSpecified());
+ MOZ_ASSERT(!IsLockedExclusiveOnCurrentThread(), "Recursive locking");
+ ::mozilla::detail::RWLockImpl::writeLock();
+ MOZ_ASSERT(!BaseProfilerThreadId::FromNumber(mOwningThreadId).IsSpecified(),
+ "Not unlocked properly");
+ mOwningThreadId = tid.ToNumber();
+ }
+
+ void UnlockExclusive() {
+ MOZ_ASSERT(IsLockedExclusiveOnCurrentThread(),
+ "Unlocking when not locked here");
+ // We're still holding the mutex here, so it's safe to just reset
+ // `mOwningThreadId`.
+ mOwningThreadId = BaseProfilerThreadId{}.ToNumber();
+ writeUnlock();
+ }
+
+ void LockShared() { readLock(); }
+
+ void UnlockShared() { readUnlock(); }
+
+ private:
+ // Thread currently owning the exclusive lock, or 0.
+ // Atomic because it may be read at any time independent of the mutex.
+ // Relaxed because threads only need to know if they own it already, so:
+ // - If it's their id, only *they* wrote that value with a locked mutex.
+ // - If it's different from their thread id it doesn't matter what other
+ // number it is (0 or another id) and that it can change again at any time.
+ Atomic<typename BaseProfilerThreadId::NumberType, MemoryOrdering::Relaxed>
+ mOwningThreadId;
+};
+
+// RAII class to lock a shared mutex exclusively.
+class MOZ_RAII BaseProfilerAutoLockExclusive {
+ public:
+ explicit BaseProfilerAutoLockExclusive(BaseProfilerSharedMutex& aSharedMutex)
+ : mSharedMutex(aSharedMutex) {
+ mSharedMutex.LockExclusive();
+ }
+
+ BaseProfilerAutoLockExclusive(const BaseProfilerAutoLockExclusive&) = delete;
+ BaseProfilerAutoLockExclusive& operator=(
+ const BaseProfilerAutoLockExclusive&) = delete;
+ BaseProfilerAutoLockExclusive(BaseProfilerAutoLockExclusive&&) = delete;
+ BaseProfilerAutoLockExclusive& operator=(BaseProfilerAutoLockExclusive&&) =
+ delete;
+
+ ~BaseProfilerAutoLockExclusive() { mSharedMutex.UnlockExclusive(); }
+
+ private:
+ BaseProfilerSharedMutex& mSharedMutex;
+};
+
+// RAII class to lock a shared mutex non-exclusively, other
+// BaseProfilerAutoLockShared's may happen in other threads.
+class MOZ_RAII BaseProfilerAutoLockShared {
+ public:
+ explicit BaseProfilerAutoLockShared(BaseProfilerSharedMutex& aSharedMutex)
+ : mSharedMutex(aSharedMutex) {
+ mSharedMutex.LockShared();
+ }
+
+ BaseProfilerAutoLockShared(const BaseProfilerAutoLockShared&) = delete;
+ BaseProfilerAutoLockShared& operator=(const BaseProfilerAutoLockShared&) =
+ delete;
+ BaseProfilerAutoLockShared(BaseProfilerAutoLockShared&&) = delete;
+ BaseProfilerAutoLockShared& operator=(BaseProfilerAutoLockShared&&) = delete;
+
+ ~BaseProfilerAutoLockShared() { mSharedMutex.UnlockShared(); }
+
+ private:
+ BaseProfilerSharedMutex& mSharedMutex;
+};
+
+} // namespace detail
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif // BaseProfilerDetail_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerLabels.h b/mozglue/baseprofiler/public/BaseProfilerLabels.h
new file mode 100644
index 0000000000..8da596e3ab
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerLabels.h
@@ -0,0 +1,178 @@
+/* -*- Mode: C++; tab-width: 2; 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 header contains all definitions related to Base Profiler labels (outside
+// of XUL).
+// It is safe to include unconditionally, and only defines empty macros if
+// MOZ_GECKO_PROFILER is not set.
+
+#ifndef BaseProfilerLabels_h
+#define BaseProfilerLabels_h
+
+#ifndef MOZ_GECKO_PROFILER
+
+# define AUTO_BASE_PROFILER_LABEL(label, categoryPair)
+# define AUTO_BASE_PROFILER_LABEL_CATEGORY_PAIR(categoryPair)
+# define AUTO_BASE_PROFILER_LABEL_DYNAMIC_CSTR(label, categoryPair, cStr)
+# define AUTO_BASE_PROFILER_LABEL_DYNAMIC_STRING(label, categoryPair, str)
+# define AUTO_BASE_PROFILER_LABEL_FAST(label, categoryPair, ctx)
+# define AUTO_BASE_PROFILER_LABEL_DYNAMIC_FAST(label, dynamicString, \
+ categoryPair, ctx, flags)
+
+#else // !MOZ_GECKO_PROFILER
+
+# include "BaseProfilingStack.h"
+
+# include "mozilla/Attributes.h"
+# include "mozilla/Maybe.h"
+# include "mozilla/BaseProfilerRAIIMacro.h"
+# include "mozilla/BaseProfilerState.h"
+# include "mozilla/ThreadLocal.h"
+
+# include <stdint.h>
+# include <string>
+
+namespace mozilla::baseprofiler {
+
+// Insert an RAII object in this scope to enter a label stack frame. Any
+// samples collected in this scope will contain this label in their stack.
+// The label argument must be a static C string. It is usually of the
+// form "ClassName::FunctionName". (Ideally we'd use the compiler to provide
+// that for us, but __func__ gives us the function name without the class
+// name.) If the label applies to only part of a function, you can qualify it
+// like this: "ClassName::FunctionName:PartName".
+//
+// Use AUTO_BASE_PROFILER_LABEL_DYNAMIC_* if you want to add additional /
+// dynamic information to the label stack frame.
+# define AUTO_BASE_PROFILER_LABEL(label, categoryPair) \
+ ::mozilla::baseprofiler::AutoProfilerLabel PROFILER_RAII( \
+ label, nullptr, \
+ ::mozilla::baseprofiler::ProfilingCategoryPair::categoryPair)
+
+// Similar to AUTO_BASE_PROFILER_LABEL, but with only one argument: the category
+// pair. The label string is taken from the category pair. This is convenient
+// for labels like
+// AUTO_BASE_PROFILER_LABEL_CATEGORY_PAIR(GRAPHICS_LayerBuilding) which would
+// otherwise just repeat the string.
+# define AUTO_BASE_PROFILER_LABEL_CATEGORY_PAIR(categoryPair) \
+ ::mozilla::baseprofiler::AutoProfilerLabel PROFILER_RAII( \
+ "", nullptr, \
+ ::mozilla::baseprofiler::ProfilingCategoryPair::categoryPair, \
+ uint32_t(::mozilla::baseprofiler::ProfilingStackFrame::Flags:: \
+ LABEL_DETERMINED_BY_CATEGORY_PAIR))
+
+// Similar to AUTO_BASE_PROFILER_LABEL, but with an additional string. The
+// inserted RAII object stores the cStr pointer in a field; it does not copy the
+// string.
+//
+// WARNING: This means that the string you pass to this macro needs to live at
+// least until the end of the current scope. Be careful using this macro with
+// ns[C]String; the other AUTO_BASE_PROFILER_LABEL_DYNAMIC_* macros below are
+// preferred because they avoid this problem.
+//
+// If the profiler samples the current thread and walks the label stack while
+// this RAII object is on the stack, it will copy the supplied string into the
+// profile buffer. So there's one string copy operation, and it happens at
+// sample time.
+//
+// Compare this to the plain AUTO_BASE_PROFILER_LABEL macro, which only accepts
+// literal strings: When the label stack frames generated by
+// AUTO_BASE_PROFILER_LABEL are sampled, no string copy needs to be made because
+// the profile buffer can just store the raw pointers to the literal strings.
+// Consequently, AUTO_BASE_PROFILER_LABEL frames take up considerably less space
+// in the profile buffer than AUTO_BASE_PROFILER_LABEL_DYNAMIC_* frames.
+# define AUTO_BASE_PROFILER_LABEL_DYNAMIC_CSTR(label, categoryPair, cStr) \
+ ::mozilla::baseprofiler::AutoProfilerLabel PROFILER_RAII( \
+ label, cStr, \
+ ::mozilla::baseprofiler::ProfilingCategoryPair::categoryPair)
+
+// Similar to AUTO_BASE_PROFILER_LABEL_DYNAMIC_CSTR, but takes an std::string.
+//
+// Note: The use of the Maybe<>s ensures the scopes for the dynamic string and
+// the AutoProfilerLabel are appropriate, while also not incurring the runtime
+// cost of the string assignment unless the profiler is active. Therefore,
+// unlike AUTO_BASE_PROFILER_LABEL and AUTO_BASE_PROFILER_LABEL_DYNAMIC_CSTR,
+// this macro doesn't push/pop a label when the profiler is inactive.
+# define AUTO_BASE_PROFILER_LABEL_DYNAMIC_STRING(label, categoryPair, str) \
+ Maybe<std::string> autoStr; \
+ Maybe<::mozilla::baseprofiler::AutoProfilerLabel> raiiObjectString; \
+ if (::mozilla::baseprofiler::profiler_is_active()) { \
+ autoStr.emplace(str); \
+ raiiObjectString.emplace( \
+ label, autoStr->c_str(), \
+ ::mozilla::baseprofiler::ProfilingCategoryPair::categoryPair); \
+ }
+
+// Similar to AUTO_BASE_PROFILER_LABEL, but accepting a JSContext* parameter,
+// and a no-op if the profiler is disabled. Used to annotate functions for which
+// overhead in the range of nanoseconds is noticeable. It avoids overhead from
+// the TLS lookup because it can get the ProfilingStack from the JS context, and
+// avoids almost all overhead in the case where the profiler is disabled.
+# define AUTO_BASE_PROFILER_LABEL_FAST(label, categoryPair, ctx) \
+ ::mozilla::baseprofiler::AutoProfilerLabel PROFILER_RAII( \
+ ctx, label, nullptr, \
+ ::mozilla::baseprofiler::ProfilingCategoryPair::categoryPair)
+
+// Similar to AUTO_BASE_PROFILER_LABEL_FAST, but also takes an extra string and
+// an additional set of flags. The flags parameter should carry values from the
+// ProfilingStackFrame::Flags enum.
+# define AUTO_BASE_PROFILER_LABEL_DYNAMIC_FAST(label, dynamicString, \
+ categoryPair, ctx, flags) \
+ ::mozilla::baseprofiler::AutoProfilerLabel PROFILER_RAII( \
+ ctx, label, dynamicString, \
+ ::mozilla::baseprofiler::ProfilingCategoryPair::categoryPair, flags)
+
+// This class creates a non-owning ProfilingStack reference. Objects of this
+// class are stack-allocated, and so exist within a thread, and are thus bounded
+// by the lifetime of the thread, which ensures that the references held can't
+// be used after the ProfilingStack is destroyed.
+class MOZ_RAII AutoProfilerLabel {
+ public:
+ // This is the AUTO_BASE_PROFILER_LABEL and AUTO_BASE_PROFILER_LABEL_DYNAMIC
+ // variant.
+ AutoProfilerLabel(const char* aLabel, const char* aDynamicString,
+ ProfilingCategoryPair aCategoryPair, uint32_t aFlags = 0) {
+ // Get the ProfilingStack from TLS.
+ Push(GetProfilingStack(), aLabel, aDynamicString, aCategoryPair, aFlags);
+ }
+
+ void Push(ProfilingStack* aProfilingStack, const char* aLabel,
+ const char* aDynamicString, ProfilingCategoryPair aCategoryPair,
+ uint32_t aFlags = 0) {
+ // This function runs both on and off the main thread.
+
+ mProfilingStack = aProfilingStack;
+ if (mProfilingStack) {
+ mProfilingStack->pushLabelFrame(aLabel, aDynamicString, this,
+ aCategoryPair, aFlags);
+ }
+ }
+
+ ~AutoProfilerLabel() {
+ // This function runs both on and off the main thread.
+
+ if (mProfilingStack) {
+ mProfilingStack->pop();
+ }
+ }
+
+ MFBT_API static ProfilingStack* GetProfilingStack();
+
+ private:
+ // We save a ProfilingStack pointer in the ctor so we don't have to redo the
+ // TLS lookup in the dtor.
+ ProfilingStack* mProfilingStack;
+
+ public:
+ // See the comment on the definition in platform.cpp for details about this.
+ static MOZ_THREAD_LOCAL(ProfilingStack*) sProfilingStack;
+};
+
+} // namespace mozilla::baseprofiler
+
+#endif // !MOZ_GECKO_PROFILER
+
+#endif // BaseProfilerLabels_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerMarkerTypes.h b/mozglue/baseprofiler/public/BaseProfilerMarkerTypes.h
new file mode 100644
index 0000000000..404e15c5f6
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerMarkerTypes.h
@@ -0,0 +1,125 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef BaseProfilerMarkerTypes_h
+#define BaseProfilerMarkerTypes_h
+
+// This header contains common marker type definitions.
+//
+// It #include's "mozilla/BaseProfilerMarkers.h", see that file for how to
+// define other marker types, and how to add markers to the profiler buffers.
+//
+// If you don't need to use these common types, #include
+// "mozilla/BaseProfilerMarkers.h" instead.
+//
+// Types in this files can be defined without relying on xpcom.
+// Others are defined in "ProfilerMarkerTypes.h".
+
+// !!! /!\ WORK IN PROGRESS /!\ !!!
+// This file contains draft marker definitions, but most are not used yet.
+// Further work is needed to complete these definitions, and use them to convert
+// existing PROFILER_ADD_MARKER calls. See meta bug 1661394.
+
+#include "mozilla/BaseProfilerMarkers.h"
+
+namespace mozilla::baseprofiler::markers {
+
+struct MediaSampleMarker {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("MediaSample");
+ }
+ static void StreamJSONMarkerData(SpliceableJSONWriter& aWriter,
+ int64_t aSampleStartTimeUs,
+ int64_t aSampleEndTimeUs,
+ int64_t aQueueLength) {
+ aWriter.IntProperty("sampleStartTimeUs", aSampleStartTimeUs);
+ aWriter.IntProperty("sampleEndTimeUs", aSampleEndTimeUs);
+ aWriter.IntProperty("queueLength", aQueueLength);
+ }
+ static MarkerSchema MarkerTypeDisplay() {
+ using MS = MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ schema.AddKeyLabelFormat("sampleStartTimeUs", "Sample start time",
+ MS::Format::Microseconds);
+ schema.AddKeyLabelFormat("sampleEndTimeUs", "Sample end time",
+ MS::Format::Microseconds);
+ schema.AddKeyLabelFormat("queueLength", "Queue length",
+ MS::Format::Integer);
+ return schema;
+ }
+};
+
+struct VideoFallingBehindMarker {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("VideoFallingBehind");
+ }
+ static void StreamJSONMarkerData(SpliceableJSONWriter& aWriter,
+ int64_t aVideoFrameStartTimeUs,
+ int64_t aMediaCurrentTimeUs) {
+ aWriter.IntProperty("videoFrameStartTimeUs", aVideoFrameStartTimeUs);
+ aWriter.IntProperty("mediaCurrentTimeUs", aMediaCurrentTimeUs);
+ }
+ static MarkerSchema MarkerTypeDisplay() {
+ using MS = MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ schema.AddKeyLabelFormat("videoFrameStartTimeUs", "Video frame start time",
+ MS::Format::Microseconds);
+ schema.AddKeyLabelFormat("mediaCurrentTimeUs", "Media current time",
+ MS::Format::Microseconds);
+ return schema;
+ }
+};
+
+struct ContentBuildMarker {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("CONTENT_FULL_PAINT_TIME");
+ }
+ static void StreamJSONMarkerData(SpliceableJSONWriter& aWriter) {}
+ static MarkerSchema MarkerTypeDisplay() {
+ using MS = MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ return schema;
+ }
+};
+
+struct MediaEngineMarker {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("MediaEngine");
+ }
+ static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+ uint64_t aMediaEngineId) {
+ aWriter.IntProperty("id", aMediaEngineId);
+ }
+ static MarkerSchema MarkerTypeDisplay() {
+ using MS = MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ schema.AddKeyLabelFormat("id", "Id", MS::Format::Integer);
+ return schema;
+ }
+};
+
+struct MediaEngineTextMarker {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("MediaEngineText");
+ }
+ static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+ uint64_t aMediaEngineId,
+ const ProfilerString8View& aText) {
+ aWriter.IntProperty("id", aMediaEngineId);
+ aWriter.StringProperty("text", aText);
+ }
+ static MarkerSchema MarkerTypeDisplay() {
+ using MS = MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ schema.AddKeyLabelFormat("id", "Id", MS::Format::Integer);
+ schema.AddKeyLabelFormat("text", "Details", MS::Format::String);
+ return schema;
+ }
+};
+
+} // namespace mozilla::baseprofiler::markers
+
+#endif // BaseProfilerMarkerTypes_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerMarkers.h b/mozglue/baseprofiler/public/BaseProfilerMarkers.h
new file mode 100644
index 0000000000..d706cefd4a
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerMarkers.h
@@ -0,0 +1,255 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+// Markers are useful to delimit something important happening such as the first
+// paint. Unlike labels, which are only recorded in the profile buffer if a
+// sample is collected while the label is on the label stack, markers will
+// always be recorded in the profile buffer.
+//
+// This header contains basic definitions necessary to create marker types, and
+// to add markers to the profiler buffers.
+//
+// If basic marker types are needed, #include
+// "mozilla/BaseProfilerMarkerTypes.h" instead.
+//
+// But if you want to create your own marker type locally, you can #include this
+// header only; look at mozilla/BaseProfilerMarkerTypes.h for examples of how to
+// define types, and mozilla/BaseProfilerMarkerPrerequisites.h for some
+// supporting types.
+//
+// To then record markers:
+// - Use `baseprofiler::AddMarker(...)` from mozglue or other libraries that
+// are outside of xul, especially if they may happen outside of xpcom's
+// lifetime (typically startup, shutdown, or tests).
+// - Otherwise #include "ProfilerMarkers.h" instead, and use
+// `profiler_add_marker(...)`.
+// See these functions for more details.
+
+#ifndef BaseProfilerMarkers_h
+#define BaseProfilerMarkers_h
+
+#include "mozilla/BaseProfilerMarkersDetail.h"
+#include "mozilla/BaseProfilerLabels.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Unused.h"
+
+#include <functional>
+#include <string>
+#include <utility>
+
+namespace mozilla::baseprofiler {
+
+#ifdef MOZ_GECKO_PROFILER
+// Forward-declaration. TODO: Move to more common header, see bug 1681416.
+MFBT_API bool profiler_capture_backtrace_into(
+ ProfileChunkedBuffer& aChunkedBuffer, StackCaptureOptions aCaptureOptions);
+
+// Add a marker to a given buffer. `AddMarker()` and related macros should be
+// used in most cases, see below for more information about them and the
+// parameters; This function may be useful when markers need to be recorded in a
+// local buffer outside of the main profiler buffer.
+template <typename MarkerType, typename... PayloadArguments>
+ProfileBufferBlockIndex AddMarkerToBuffer(
+ ProfileChunkedBuffer& aBuffer, const ProfilerString8View& aName,
+ const MarkerCategory& aCategory, MarkerOptions&& aOptions,
+ MarkerType aMarkerType, const PayloadArguments&... aPayloadArguments) {
+ Unused << aMarkerType; // Only the empty object type is useful.
+ AUTO_BASE_PROFILER_LABEL("baseprofiler::AddMarkerToBuffer", PROFILER);
+ return base_profiler_markers_detail::AddMarkerToBuffer<MarkerType>(
+ aBuffer, aName, aCategory, std::move(aOptions),
+ // Do not capture a stack if the NoMarkerStacks feature is set.
+ profiler_active_without_feature(ProfilerFeature::NoMarkerStacks)
+ ? ::mozilla::baseprofiler::profiler_capture_backtrace_into
+ : nullptr,
+ aPayloadArguments...);
+}
+
+// Add a marker (without payload) to a given buffer.
+inline ProfileBufferBlockIndex AddMarkerToBuffer(
+ ProfileChunkedBuffer& aBuffer, const ProfilerString8View& aName,
+ const MarkerCategory& aCategory, MarkerOptions&& aOptions = {}) {
+ return AddMarkerToBuffer(aBuffer, aName, aCategory, std::move(aOptions),
+ markers::NoPayload{});
+}
+#endif // MOZ_GECKO_PROFILER
+
+// Add a marker to the Base Profiler buffer.
+// - aName: Main name of this marker.
+// - aCategory: Category for this marker.
+// - aOptions: Optional settings (such as timing, inner window id,
+// backtrace...), see `MarkerOptions` for details.
+// - aMarkerType: Empty object that specifies the type of marker.
+// - aPayloadArguments: Arguments expected by this marker type's
+// ` StreamJSONMarkerData` function.
+template <typename MarkerType, typename... PayloadArguments>
+ProfileBufferBlockIndex AddMarker(
+ const ProfilerString8View& aName, const MarkerCategory& aCategory,
+ MarkerOptions&& aOptions, MarkerType aMarkerType,
+ const PayloadArguments&... aPayloadArguments) {
+#ifndef MOZ_GECKO_PROFILER
+ return {};
+#else
+ // Record base markers whenever the core buffer is in session.
+ // TODO: When profiler_thread_is_being_profiled becomes available from
+ // mozglue, use it instead.
+ ProfileChunkedBuffer& coreBuffer =
+ ::mozilla::baseprofiler::profiler_get_core_buffer();
+ if (!coreBuffer.IsInSession()) {
+ return {};
+ }
+ return ::mozilla::baseprofiler::AddMarkerToBuffer(
+ coreBuffer, aName, aCategory, std::move(aOptions), aMarkerType,
+ aPayloadArguments...);
+#endif
+}
+
+// Add a marker (without payload) to the Base Profiler buffer.
+inline ProfileBufferBlockIndex AddMarker(const ProfilerString8View& aName,
+ const MarkerCategory& aCategory,
+ MarkerOptions&& aOptions = {}) {
+ return AddMarker(aName, aCategory, std::move(aOptions), markers::NoPayload{});
+}
+
+} // namespace mozilla::baseprofiler
+
+// Same as `AddMarker()` (without payload). This macro is safe to use even if
+// MOZ_GECKO_PROFILER is not #defined.
+#define BASE_PROFILER_MARKER_UNTYPED(markerName, categoryName, ...) \
+ do { \
+ AUTO_PROFILER_STATS(BASE_PROFILER_MARKER_UNTYPED); \
+ ::mozilla::baseprofiler::AddMarker( \
+ markerName, ::mozilla::baseprofiler::category::categoryName, \
+ ##__VA_ARGS__); \
+ } while (false)
+
+// Same as `AddMarker()` (with payload). This macro is safe to use even if
+// MOZ_GECKO_PROFILER is not #defined.
+#define BASE_PROFILER_MARKER(markerName, categoryName, options, MarkerType, \
+ ...) \
+ do { \
+ AUTO_PROFILER_STATS(BASE_PROFILER_MARKER_with_##MarkerType); \
+ ::mozilla::baseprofiler::AddMarker( \
+ markerName, ::mozilla::baseprofiler::category::categoryName, options, \
+ ::mozilla::baseprofiler::markers::MarkerType{}, ##__VA_ARGS__); \
+ } while (false)
+
+namespace mozilla::baseprofiler::markers {
+// Most common marker type. Others are in BaseProfilerMarkerTypes.h.
+struct TextMarker {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("Text");
+ }
+ static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+ const ProfilerString8View& aText) {
+ aWriter.StringProperty("name", aText);
+ }
+ static MarkerSchema MarkerTypeDisplay() {
+ using MS = MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ schema.SetChartLabel("{marker.data.name}");
+ schema.SetTableLabel("{marker.name} - {marker.data.name}");
+ schema.AddKeyLabelFormatSearchable("name", "Details", MS::Format::String,
+ MS::Searchable::Searchable);
+ return schema;
+ }
+};
+
+// Keep this struct in sync with the `gecko_profiler::marker::Tracing` Rust
+// counterpart.
+struct Tracing {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("tracing");
+ }
+ static void StreamJSONMarkerData(SpliceableJSONWriter& aWriter,
+ const ProfilerString8View& aCategory) {
+ if (aCategory.Length() != 0) {
+ aWriter.StringProperty("category", aCategory);
+ }
+ }
+ static MarkerSchema MarkerTypeDisplay() {
+ using MS = MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable,
+ MS::Location::TimelineOverview};
+ schema.AddKeyLabelFormatSearchable("category", "Type", MS::Format::String,
+ MS::Searchable::Searchable);
+ return schema;
+ }
+};
+} // namespace mozilla::baseprofiler::markers
+
+// Add a text marker. This macro is safe to use even if MOZ_GECKO_PROFILER is
+// not #defined.
+#define BASE_PROFILER_MARKER_TEXT(markerName, categoryName, options, text) \
+ do { \
+ AUTO_PROFILER_STATS(BASE_PROFILER_MARKER_TEXT); \
+ ::mozilla::baseprofiler::AddMarker( \
+ markerName, ::mozilla::baseprofiler::category::categoryName, options, \
+ ::mozilla::baseprofiler::markers::TextMarker{}, text); \
+ } while (false)
+
+namespace mozilla::baseprofiler {
+
+// RAII object that adds a BASE_PROFILER_MARKER_TEXT when destroyed; the
+// marker's timing will be the interval from construction (unless an instant or
+// start time is already specified in the provided options) until destruction.
+class MOZ_RAII AutoProfilerTextMarker {
+ public:
+ AutoProfilerTextMarker(const char* aMarkerName,
+ const MarkerCategory& aCategory,
+ MarkerOptions&& aOptions, const std::string& aText)
+ : mMarkerName(aMarkerName),
+ mCategory(aCategory),
+ mOptions(std::move(aOptions)),
+ mText(aText) {
+ MOZ_ASSERT(mOptions.Timing().EndTime().IsNull(),
+ "AutoProfilerTextMarker options shouldn't have an end time");
+ if (profiler_is_active_and_unpaused() &&
+ mOptions.Timing().StartTime().IsNull()) {
+ mOptions.Set(MarkerTiming::InstantNow());
+ }
+ }
+
+ ~AutoProfilerTextMarker() {
+ if (profiler_is_active_and_unpaused()) {
+ mOptions.TimingRef().SetIntervalEnd();
+ AUTO_PROFILER_STATS(AUTO_BASE_PROFILER_MARKER_TEXT);
+ AddMarker(ProfilerString8View::WrapNullTerminatedString(mMarkerName),
+ mCategory, std::move(mOptions), markers::TextMarker{}, mText);
+ }
+ }
+
+ protected:
+ const char* mMarkerName;
+ MarkerCategory mCategory;
+ MarkerOptions mOptions;
+ std::string mText;
+};
+
+#ifdef MOZ_GECKO_PROFILER
+extern template MFBT_API ProfileBufferBlockIndex
+AddMarker(const ProfilerString8View&, const MarkerCategory&, MarkerOptions&&,
+ markers::TextMarker, const std::string&);
+
+extern template MFBT_API ProfileBufferBlockIndex
+AddMarkerToBuffer(ProfileChunkedBuffer&, const ProfilerString8View&,
+ const MarkerCategory&, MarkerOptions&&, markers::NoPayload);
+
+extern template MFBT_API ProfileBufferBlockIndex AddMarkerToBuffer(
+ ProfileChunkedBuffer&, const ProfilerString8View&, const MarkerCategory&,
+ MarkerOptions&&, markers::TextMarker, const std::string&);
+#endif // MOZ_GECKO_PROFILER
+
+} // namespace mozilla::baseprofiler
+
+// Creates an AutoProfilerTextMarker RAII object. This macro is safe to use
+// even if MOZ_GECKO_PROFILER is not #defined.
+#define AUTO_BASE_PROFILER_MARKER_TEXT(markerName, categoryName, options, \
+ text) \
+ ::mozilla::baseprofiler::AutoProfilerTextMarker PROFILER_RAII( \
+ markerName, ::mozilla::baseprofiler::category::categoryName, options, \
+ text)
+
+#endif // BaseProfilerMarkers_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerMarkersDetail.h b/mozglue/baseprofiler/public/BaseProfilerMarkersDetail.h
new file mode 100644
index 0000000000..1102499100
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerMarkersDetail.h
@@ -0,0 +1,741 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef BaseProfilerMarkersDetail_h
+#define BaseProfilerMarkersDetail_h
+
+#ifndef BaseProfilerMarkers_h
+# error "This header should only be #included by BaseProfilerMarkers.h"
+#endif
+
+#include "mozilla/BaseProfilerMarkersPrerequisites.h"
+
+// ~~ HERE BE DRAGONS ~~
+//
+// Everything below is internal implementation detail, you shouldn't need to
+// look at it unless working on the profiler code.
+
+#include "mozilla/BaseProfileJSONWriter.h"
+#include "mozilla/ProfileBufferEntryKinds.h"
+
+#include <limits>
+#include <tuple>
+#include <type_traits>
+
+namespace mozilla::baseprofiler {
+// Implemented in platform.cpp
+MFBT_API ProfileChunkedBuffer& profiler_get_core_buffer();
+} // namespace mozilla::baseprofiler
+
+namespace mozilla::base_profiler_markers_detail {
+
+struct Streaming {
+ // A `MarkerDataDeserializer` is a free function that can read a serialized
+ // payload from an `EntryReader` and streams it as JSON object properties.
+ using MarkerDataDeserializer = void (*)(ProfileBufferEntryReader&,
+ baseprofiler::SpliceableJSONWriter&);
+
+ // A `MarkerTypeNameFunction` is a free function that returns the name of the
+ // marker type.
+ using MarkerTypeNameFunction = Span<const char> (*)();
+
+ // A `MarkerSchemaFunction` is a free function that returns a
+ // `MarkerSchema`, which contains all the information needed to stream
+ // the display schema associated with a marker type.
+ using MarkerSchemaFunction = MarkerSchema (*)();
+
+ struct MarkerTypeFunctions {
+ MarkerDataDeserializer mMarkerDataDeserializer = nullptr;
+ MarkerTypeNameFunction mMarkerTypeNameFunction = nullptr;
+ MarkerSchemaFunction mMarkerSchemaFunction = nullptr;
+ };
+
+ // A `DeserializerTag` will be added before the payload, to help select the
+ // correct deserializer when reading back the payload.
+ using DeserializerTag = uint8_t;
+
+ // Store a deserializer (and other marker-type-specific functions) and get its
+ // `DeserializerTag`.
+ // This is intended to be only used once per deserializer when a new marker
+ // type is used for the first time, so it should be called to initialize a
+ // `static const` tag that will be re-used by all markers of the corresponding
+ // payload type -- see use below.
+ MFBT_API static DeserializerTag TagForMarkerTypeFunctions(
+ MarkerDataDeserializer aDeserializer,
+ MarkerTypeNameFunction aMarkerTypeNameFunction,
+ MarkerSchemaFunction aMarkerSchemaFunction);
+
+ // Get the `MarkerDataDeserializer` for a given `DeserializerTag`.
+ MFBT_API static MarkerDataDeserializer DeserializerForTag(
+ DeserializerTag aTag);
+
+ // Retrieve all MarkerTypeFunctions's.
+ // While this object lives, no other operations can happen on this list.
+ class LockedMarkerTypeFunctionsList {
+ public:
+ MFBT_API LockedMarkerTypeFunctionsList();
+ MFBT_API ~LockedMarkerTypeFunctionsList();
+
+ LockedMarkerTypeFunctionsList(const LockedMarkerTypeFunctionsList&) =
+ delete;
+ LockedMarkerTypeFunctionsList& operator=(
+ const LockedMarkerTypeFunctionsList&) = delete;
+
+ auto begin() const { return mMarkerTypeFunctionsSpan.begin(); }
+ auto end() const { return mMarkerTypeFunctionsSpan.end(); }
+
+ private:
+ Span<const MarkerTypeFunctions> mMarkerTypeFunctionsSpan;
+ };
+};
+
+// This helper will examine a marker type's `StreamJSONMarkerData` function, see
+// specialization below.
+template <typename T>
+struct StreamFunctionTypeHelper;
+
+// Helper specialization that takes the expected
+// `StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter&, ...)` function and
+// provide information about the `...` parameters.
+template <typename R, typename... As>
+struct StreamFunctionTypeHelper<R(baseprofiler::SpliceableJSONWriter&, As...)> {
+ constexpr static size_t scArity = sizeof...(As);
+ using TupleType =
+ std::tuple<std::remove_cv_t<std::remove_reference_t<As>>...>;
+
+ // Serialization function that takes the exact same parameter types
+ // (const-ref'd) as `StreamJSONMarkerData`. This has to be inside the helper
+ // because only here can we access the raw parameter pack `As...`.
+ // And because we're using the same argument types through
+ // references-to-const, permitted implicit conversions can happen.
+ static ProfileBufferBlockIndex Serialize(
+ ProfileChunkedBuffer& aBuffer, const ProfilerString8View& aName,
+ const MarkerCategory& aCategory, MarkerOptions&& aOptions,
+ Streaming::DeserializerTag aDeserializerTag, const As&... aAs) {
+ // Note that options are first after the entry kind, because they contain
+ // the thread id, which is handled first to filter markers by threads.
+ return aBuffer.PutObjects(ProfileBufferEntryKind::Marker, aOptions, aName,
+ aCategory, aDeserializerTag,
+ MarkerPayloadType::Cpp, aAs...);
+ }
+};
+
+// Helper for a marker type.
+// A marker type is defined in a `struct` with some expected static member
+// functions. See example in BaseProfilerMarkers.h.
+template <typename MarkerType>
+struct MarkerTypeSerialization {
+ // Definitions to access the expected
+ // `StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter&, ...)` function
+ // and its parameters.
+ using StreamFunctionType =
+ StreamFunctionTypeHelper<decltype(MarkerType::StreamJSONMarkerData)>;
+ constexpr static size_t scStreamFunctionParameterCount =
+ StreamFunctionType::scArity;
+ using StreamFunctionUserParametersTuple =
+ typename StreamFunctionType::TupleType;
+ template <size_t i>
+ using StreamFunctionParameter =
+ std::tuple_element_t<i, StreamFunctionUserParametersTuple>;
+
+ template <typename... Ts>
+ static ProfileBufferBlockIndex Serialize(ProfileChunkedBuffer& aBuffer,
+ const ProfilerString8View& aName,
+ const MarkerCategory& aCategory,
+ MarkerOptions&& aOptions,
+ const Ts&... aTs) {
+ static_assert(!std::is_same_v<MarkerType,
+ ::mozilla::baseprofiler::markers::NoPayload>,
+ "NoPayload should have been handled in the caller.");
+ // Register marker type functions, and get the tag for this deserializer.
+ // Note that the tag is stored in a function-static object, and this
+ // function is static in a templated struct, so there should only be one tag
+ // per MarkerType.
+ // Making the tag class-static may have been more efficient (to avoid a
+ // thread-safe init check at every call), but random global static
+ // initialization order would make it more complex to coordinate with
+ // `Streaming::TagForMarkerTypeFunctions()`, and also would add a (small)
+ // cost for everybody, even the majority of users not using the profiler.
+ static const Streaming::DeserializerTag tag =
+ Streaming::TagForMarkerTypeFunctions(Deserialize,
+ MarkerType::MarkerTypeName,
+ MarkerType::MarkerTypeDisplay);
+ return StreamFunctionType::Serialize(aBuffer, aName, aCategory,
+ std::move(aOptions), tag, aTs...);
+ }
+
+ private:
+ // This templated function will recursively deserialize each argument expected
+ // by `MarkerType::StreamJSONMarkerData()` on the stack, and call it at the
+ // end. E.g., for `StreamJSONMarkerData(int, char)`:
+ // - DeserializeArguments<0>(aER, aWriter) reads an int and calls:
+ // - DeserializeArguments<1>(aER, aWriter, const int&) reads a char and calls:
+ // - MarkerType::StreamJSONMarkerData(aWriter, const int&, const char&).
+ // Prototyping on godbolt showed that clang and gcc can flatten these
+ // recursive calls into one function with successive reads followed by the one
+ // stream call; tested up to 40 arguments: https://godbolt.org/z/5KeeM4
+ template <size_t i = 0, typename... Args>
+ static void DeserializeArguments(ProfileBufferEntryReader& aEntryReader,
+ baseprofiler::SpliceableJSONWriter& aWriter,
+ const Args&... aArgs) {
+ static_assert(sizeof...(Args) == i,
+ "We should have collected `i` arguments so far");
+ if constexpr (i < scStreamFunctionParameterCount) {
+ // Deserialize the i-th argument on this stack.
+ auto argument = aEntryReader.ReadObject<StreamFunctionParameter<i>>();
+ // Add our local argument to the next recursive call.
+ DeserializeArguments<i + 1>(aEntryReader, aWriter, aArgs..., argument);
+ } else {
+ // We've read all the arguments, finally call the `StreamJSONMarkerData`
+ // function, which should write the appropriate JSON elements for this
+ // marker type. Note that the MarkerType-specific "type" element is
+ // already written.
+ MarkerType::StreamJSONMarkerData(aWriter, aArgs...);
+ }
+ }
+
+ public:
+ static void Deserialize(ProfileBufferEntryReader& aEntryReader,
+ baseprofiler::SpliceableJSONWriter& aWriter) {
+ aWriter.StringProperty("type", MarkerType::MarkerTypeName());
+ DeserializeArguments(aEntryReader, aWriter);
+ }
+};
+
+template <>
+struct MarkerTypeSerialization<::mozilla::baseprofiler::markers::NoPayload> {
+ // Nothing! NoPayload has special handling avoiding payload work.
+};
+
+template <typename MarkerType, typename... Ts>
+static ProfileBufferBlockIndex AddMarkerWithOptionalStackToBuffer(
+ ProfileChunkedBuffer& aBuffer, const ProfilerString8View& aName,
+ const MarkerCategory& aCategory, MarkerOptions&& aOptions,
+ const Ts&... aTs) {
+ if constexpr (std::is_same_v<MarkerType,
+ ::mozilla::baseprofiler::markers::NoPayload>) {
+ static_assert(sizeof...(Ts) == 0,
+ "NoPayload does not accept any payload arguments.");
+ // Special case for NoPayload where there is a stack or inner window id:
+ // Because these options would be stored in the payload 'data' object, but
+ // there is no such object for NoPayload, we convert the marker to another
+ // type (without user fields in the 'data' object), so that the stack and/or
+ // inner window id are not lost.
+ // TODO: Remove this when bug 1646714 lands.
+ if (aOptions.Stack().GetChunkedBuffer() ||
+ !aOptions.InnerWindowId().IsUnspecified()) {
+ struct NoPayloadUserData {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("NoPayloadUserData");
+ }
+ static void StreamJSONMarkerData(
+ baseprofiler::SpliceableJSONWriter& aWriter) {
+ // No user payload.
+ }
+ static mozilla::MarkerSchema MarkerTypeDisplay() {
+ using MS = mozilla::MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ // No user data to display.
+ return schema;
+ }
+ };
+ return MarkerTypeSerialization<NoPayloadUserData>::Serialize(
+ aBuffer, aName, aCategory, std::move(aOptions));
+ }
+
+ // Note that options are first after the entry kind, because they contain
+ // the thread id, which is handled first to filter markers by threads.
+ return aBuffer.PutObjects(
+ ProfileBufferEntryKind::Marker, std::move(aOptions), aName, aCategory,
+ base_profiler_markers_detail::Streaming::DeserializerTag(0));
+ } else {
+ return MarkerTypeSerialization<MarkerType>::Serialize(
+ aBuffer, aName, aCategory, std::move(aOptions), aTs...);
+ }
+}
+
+// Pointer to a function that can capture a backtrace into the provided
+// `ProfileChunkedBuffer`, and returns true when successful.
+using OptionalBacktraceCaptureFunction = bool (*)(ProfileChunkedBuffer&,
+ StackCaptureOptions);
+
+// Use a pre-allocated and cleared chunked buffer in the main thread's
+// `AddMarkerToBuffer()`.
+// Null if not the main thread, or if profilers are not active.
+MFBT_API ProfileChunkedBuffer* GetClearedBufferForMainThreadAddMarker();
+// Called by the profiler(s) when starting/stopping. Safe to nest.
+MFBT_API void EnsureBufferForMainThreadAddMarker();
+MFBT_API void ReleaseBufferForMainThreadAddMarker();
+
+// Add a marker with the given name, options, and arguments to the given buffer.
+// Because this may be called from either Base or Gecko Profiler functions, the
+// appropriate backtrace-capturing function must also be provided.
+template <typename MarkerType, typename... Ts>
+ProfileBufferBlockIndex AddMarkerToBuffer(
+ ProfileChunkedBuffer& aBuffer, const ProfilerString8View& aName,
+ const MarkerCategory& aCategory, MarkerOptions&& aOptions,
+ OptionalBacktraceCaptureFunction aOptionalBacktraceCaptureFunction,
+ const Ts&... aTs) {
+ if (aOptions.ThreadId().IsUnspecified()) {
+ // If yet unspecified, set thread to this thread where the marker is added.
+ aOptions.Set(MarkerThreadId::CurrentThread());
+ }
+
+ if (aOptions.IsTimingUnspecified()) {
+ // If yet unspecified, set timing to this instant of adding the marker.
+ aOptions.Set(MarkerTiming::InstantNow());
+ }
+
+ StackCaptureOptions captureOptions = aOptions.Stack().CaptureOptions();
+ if (captureOptions != StackCaptureOptions::NoStack &&
+ // Backtrace capture function will be nullptr if the profiler
+ // NoMarkerStacks feature is set.
+ aOptionalBacktraceCaptureFunction != nullptr) {
+ // A capture was requested, let's attempt to do it here&now. This avoids a
+ // lot of allocations that would be necessary if capturing a backtrace
+ // separately.
+ // TODO reduce internal profiler stack levels, see bug 1659872.
+ auto CaptureStackAndAddMarker = [&](ProfileChunkedBuffer& aChunkedBuffer) {
+ aOptions.StackRef().UseRequestedBacktrace(
+ aOptionalBacktraceCaptureFunction(aChunkedBuffer, captureOptions)
+ ? &aChunkedBuffer
+ : nullptr);
+ // This call must be made from here, while chunkedBuffer is in scope.
+ return AddMarkerWithOptionalStackToBuffer<MarkerType>(
+ aBuffer, aName, aCategory, std::move(aOptions), aTs...);
+ };
+
+ if (ProfileChunkedBuffer* buffer = GetClearedBufferForMainThreadAddMarker();
+ buffer) {
+ // Use a pre-allocated buffer for the main thread (because it's the most
+ // used thread, and most sensitive to overhead), so it's only allocated
+ // once. It could be null if this is not the main thread, or no profilers
+ // are currently active.
+ return CaptureStackAndAddMarker(*buffer);
+ }
+ // TODO use a local on-stack byte buffer to remove last allocation.
+ ProfileBufferChunkManagerSingle chunkManager(
+ ProfileBufferChunkManager::scExpectedMaximumStackSize);
+ ProfileChunkedBuffer chunkedBuffer(
+ ProfileChunkedBuffer::ThreadSafety::WithoutMutex, chunkManager);
+ return CaptureStackAndAddMarker(chunkedBuffer);
+ }
+
+ return AddMarkerWithOptionalStackToBuffer<MarkerType>(
+ aBuffer, aName, aCategory, std::move(aOptions), aTs...);
+}
+
+// Assuming aEntryReader points right after the entry type (being Marker), this
+// reads the remainder of the marker and outputs it.
+// - GetWriterForThreadCallback, called first, after the thread id is read:
+// (ThreadId) -> SpliceableJSONWriter* or null
+// If null, nothing will be output, but aEntryReader will still be read fully.
+// - StackCallback, only called if GetWriterForThreadCallback didn't return
+// null, and if the marker contains a stack:
+// (ProfileChunkedBuffer&) -> void
+// - RustMarkerCallback, only called if GetWriterForThreadCallback didn't return
+// null, and if the marker contains a Rust payload:
+// (DeserializerTag) -> void
+template <typename GetWriterForThreadCallback, typename StackCallback,
+ typename RustMarkerCallback>
+void DeserializeAfterKindAndStream(
+ ProfileBufferEntryReader& aEntryReader,
+ GetWriterForThreadCallback&& aGetWriterForThreadCallback,
+ StackCallback&& aStackCallback, RustMarkerCallback&& aRustMarkerCallback) {
+ // Each entry is made up of the following:
+ // ProfileBufferEntry::Kind::Marker, <- already read by caller
+ // options, <- next location in entries
+ // name,
+ // payload
+ const MarkerOptions options = aEntryReader.ReadObject<MarkerOptions>();
+
+ baseprofiler::SpliceableJSONWriter* writer =
+ std::forward<GetWriterForThreadCallback>(aGetWriterForThreadCallback)(
+ options.ThreadId().ThreadId());
+ if (!writer) {
+ // No writer associated with this thread id, drop it.
+ aEntryReader.SetRemainingBytes(0);
+ return;
+ }
+
+ // Write the information to JSON with the following schema:
+ // [name, startTime, endTime, phase, category, data]
+ writer->StartArrayElement();
+ {
+ writer->UniqueStringElement(aEntryReader.ReadObject<ProfilerString8View>());
+
+ const double startTime = options.Timing().GetStartTime();
+ writer->TimeDoubleMsElement(startTime);
+
+ const double endTime = options.Timing().GetEndTime();
+ writer->TimeDoubleMsElement(endTime);
+
+ writer->IntElement(static_cast<int64_t>(options.Timing().MarkerPhase()));
+
+ MarkerCategory category = aEntryReader.ReadObject<MarkerCategory>();
+ writer->IntElement(static_cast<int64_t>(category.GetCategory()));
+
+ if (const auto tag =
+ aEntryReader.ReadObject<mozilla::base_profiler_markers_detail::
+ Streaming::DeserializerTag>();
+ tag != 0) {
+ writer->StartObjectElement();
+ {
+ // Stream "common props".
+
+ // TODO: Move this to top-level tuple, when frontend supports it.
+ if (!options.InnerWindowId().IsUnspecified()) {
+ // Here, we are converting uint64_t to double. Both Browsing Context
+ // and Inner Window IDs are created using
+ // `nsContentUtils::GenerateProcessSpecificId`, which is specifically
+ // designed to only use 53 of the 64 bits to be lossless when passed
+ // into and out of JS as a double.
+ writer->DoubleProperty(
+ "innerWindowID",
+ static_cast<double>(options.InnerWindowId().Id()));
+ }
+
+ // TODO: Move this to top-level tuple, when frontend supports it.
+ if (ProfileChunkedBuffer* chunkedBuffer =
+ options.Stack().GetChunkedBuffer();
+ chunkedBuffer) {
+ writer->StartObjectProperty("stack");
+ { std::forward<StackCallback>(aStackCallback)(*chunkedBuffer); }
+ writer->EndObject();
+ }
+
+ auto payloadType = static_cast<mozilla::MarkerPayloadType>(
+ aEntryReader.ReadObject<
+ std::underlying_type_t<mozilla::MarkerPayloadType>>());
+
+ // Stream the payload, including the type.
+ switch (payloadType) {
+ case mozilla::MarkerPayloadType::Cpp: {
+ mozilla::base_profiler_markers_detail::Streaming::
+ MarkerDataDeserializer deserializer =
+ mozilla::base_profiler_markers_detail::Streaming::
+ DeserializerForTag(tag);
+ MOZ_RELEASE_ASSERT(deserializer);
+ deserializer(aEntryReader, *writer);
+ MOZ_ASSERT(aEntryReader.RemainingBytes() == 0u);
+ break;
+ }
+ case mozilla::MarkerPayloadType::Rust:
+ std::forward<RustMarkerCallback>(aRustMarkerCallback)(tag);
+ MOZ_ASSERT(aEntryReader.RemainingBytes() == 0u);
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unknown payload type.");
+ break;
+ }
+ }
+ writer->EndObject();
+ }
+ }
+ writer->EndArray();
+ MOZ_ASSERT(aEntryReader.RemainingBytes() == 0u);
+}
+
+} // namespace mozilla::base_profiler_markers_detail
+
+namespace mozilla {
+
+// ----------------------------------------------------------------------------
+// Serializer, Deserializer: ProfilerStringView<CHAR>
+
+// The serialization starts with a ULEB128 number that encodes both whether the
+// ProfilerStringView is literal (Least Significant Bit = 0) or not (LSB = 1),
+// plus the string length (excluding null terminator) in bytes, shifted left by
+// 1 bit. Following that number:
+// - If literal, the string pointer value.
+// - If non-literal, the contents as bytes (excluding null terminator if any).
+template <typename CHAR>
+struct ProfileBufferEntryWriter::Serializer<ProfilerStringView<CHAR>> {
+ static Length Bytes(const ProfilerStringView<CHAR>& aString) {
+ MOZ_RELEASE_ASSERT(
+ aString.Length() < std::numeric_limits<Length>::max() / 2,
+ "Double the string length doesn't fit in Length type");
+ const Length stringLength = static_cast<Length>(aString.Length());
+ if (aString.IsLiteral()) {
+ // Literal -> Length shifted left and LSB=0, then pointer.
+ return ULEB128Size(stringLength << 1 | 0u) +
+ static_cast<ProfileChunkedBuffer::Length>(sizeof(const CHAR*));
+ }
+ // Non-literal -> Length shifted left and LSB=1, then string size in bytes.
+ return ULEB128Size((stringLength << 1) | 1u) + stringLength * sizeof(CHAR);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const ProfilerStringView<CHAR>& aString) {
+ MOZ_RELEASE_ASSERT(
+ aString.Length() < std::numeric_limits<Length>::max() / 2,
+ "Double the string length doesn't fit in Length type");
+ const Span<const CHAR> span = aString;
+ if (aString.IsLiteral()) {
+ // Literal -> Length shifted left and LSB=0, then pointer.
+ aEW.WriteULEB128(span.Length() << 1 | 0u);
+ aEW.WriteObject(WrapProfileBufferRawPointer(span.Elements()));
+ return;
+ }
+ // Non-literal -> Length shifted left and LSB=1, then string size in bytes.
+ aEW.WriteULEB128(span.Length() << 1 | 1u);
+ aEW.WriteBytes(span.Elements(), span.LengthBytes());
+ }
+};
+
+template <typename CHAR>
+struct ProfileBufferEntryReader::Deserializer<ProfilerStringView<CHAR>> {
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ ProfilerStringView<CHAR>& aString) {
+ aString = Read(aER);
+ }
+
+ static ProfilerStringView<CHAR> Read(ProfileBufferEntryReader& aER) {
+ const Length lengthAndIsLiteral = aER.ReadULEB128<Length>();
+ const Length stringLength = lengthAndIsLiteral >> 1;
+ if ((lengthAndIsLiteral & 1u) == 0u) {
+ // LSB==0 -> Literal string, read the string pointer.
+ return ProfilerStringView<CHAR>(
+ aER.ReadObject<const CHAR*>(), stringLength,
+ ProfilerStringView<CHAR>::Ownership::Literal);
+ }
+ // LSB==1 -> Not a literal string.
+ ProfileBufferEntryReader::DoubleSpanOfConstBytes spans =
+ aER.ReadSpans(stringLength * sizeof(CHAR));
+ if (MOZ_LIKELY(spans.IsSingleSpan()) &&
+ reinterpret_cast<uintptr_t>(spans.mFirstOrOnly.Elements()) %
+ alignof(CHAR) ==
+ 0u) {
+ // Only a single span, correctly aligned for the CHAR type, we can just
+ // refer to it directly, assuming that this ProfilerStringView will not
+ // outlive the chunk.
+ return ProfilerStringView<CHAR>(
+ reinterpret_cast<const CHAR*>(spans.mFirstOrOnly.Elements()),
+ stringLength, ProfilerStringView<CHAR>::Ownership::Reference);
+ } else {
+ // Two spans, we need to concatenate them; or one span, but misaligned.
+ // Allocate a buffer to store the string (plus terminal, for safety), and
+ // give it to the ProfilerStringView; Note that this is a secret use of
+ // ProfilerStringView, which is intended to only be used between
+ // deserialization and JSON streaming.
+ CHAR* buffer = new CHAR[stringLength + 1];
+ spans.CopyBytesTo(buffer);
+ buffer[stringLength] = CHAR(0);
+ return ProfilerStringView<CHAR>(
+ buffer, stringLength,
+ ProfilerStringView<CHAR>::Ownership::OwnedThroughStringView);
+ }
+ }
+};
+
+// Serializer, Deserializer: MarkerCategory
+
+// The serialization contains both category numbers encoded as ULEB128.
+template <>
+struct ProfileBufferEntryWriter::Serializer<MarkerCategory> {
+ static Length Bytes(const MarkerCategory& aCategory) {
+ return ULEB128Size(static_cast<uint32_t>(aCategory.CategoryPair()));
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const MarkerCategory& aCategory) {
+ aEW.WriteULEB128(static_cast<uint32_t>(aCategory.CategoryPair()));
+ }
+};
+
+template <>
+struct ProfileBufferEntryReader::Deserializer<MarkerCategory> {
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ MarkerCategory& aCategory) {
+ aCategory = Read(aER);
+ }
+
+ static MarkerCategory Read(ProfileBufferEntryReader& aER) {
+ return MarkerCategory(static_cast<baseprofiler::ProfilingCategoryPair>(
+ aER.ReadULEB128<uint32_t>()));
+ }
+};
+
+// ----------------------------------------------------------------------------
+// Serializer, Deserializer: MarkerTiming
+
+// The serialization starts with the marker phase, followed by one or two
+// timestamps as needed.
+template <>
+struct ProfileBufferEntryWriter::Serializer<MarkerTiming> {
+ static Length Bytes(const MarkerTiming& aTiming) {
+ MOZ_ASSERT(!aTiming.IsUnspecified());
+ const auto phase = aTiming.MarkerPhase();
+ switch (phase) {
+ case MarkerTiming::Phase::Instant:
+ return SumBytes(phase, aTiming.StartTime());
+ case MarkerTiming::Phase::Interval:
+ return SumBytes(phase, aTiming.StartTime(), aTiming.EndTime());
+ case MarkerTiming::Phase::IntervalStart:
+ return SumBytes(phase, aTiming.StartTime());
+ case MarkerTiming::Phase::IntervalEnd:
+ return SumBytes(phase, aTiming.EndTime());
+ default:
+ MOZ_RELEASE_ASSERT(phase == MarkerTiming::Phase::Instant ||
+ phase == MarkerTiming::Phase::Interval ||
+ phase == MarkerTiming::Phase::IntervalStart ||
+ phase == MarkerTiming::Phase::IntervalEnd);
+ return 0; // Only to avoid build errors.
+ }
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const MarkerTiming& aTiming) {
+ MOZ_ASSERT(!aTiming.IsUnspecified());
+ const auto phase = aTiming.MarkerPhase();
+ switch (phase) {
+ case MarkerTiming::Phase::Instant:
+ aEW.WriteObjects(phase, aTiming.StartTime());
+ return;
+ case MarkerTiming::Phase::Interval:
+ aEW.WriteObjects(phase, aTiming.StartTime(), aTiming.EndTime());
+ return;
+ case MarkerTiming::Phase::IntervalStart:
+ aEW.WriteObjects(phase, aTiming.StartTime());
+ return;
+ case MarkerTiming::Phase::IntervalEnd:
+ aEW.WriteObjects(phase, aTiming.EndTime());
+ return;
+ default:
+ MOZ_RELEASE_ASSERT(phase == MarkerTiming::Phase::Instant ||
+ phase == MarkerTiming::Phase::Interval ||
+ phase == MarkerTiming::Phase::IntervalStart ||
+ phase == MarkerTiming::Phase::IntervalEnd);
+ return;
+ }
+ }
+};
+
+template <>
+struct ProfileBufferEntryReader::Deserializer<MarkerTiming> {
+ static void ReadInto(ProfileBufferEntryReader& aER, MarkerTiming& aTiming) {
+ aTiming.mPhase = aER.ReadObject<MarkerTiming::Phase>();
+ switch (aTiming.mPhase) {
+ case MarkerTiming::Phase::Instant:
+ aTiming.mStartTime = aER.ReadObject<TimeStamp>();
+ aTiming.mEndTime = TimeStamp{};
+ break;
+ case MarkerTiming::Phase::Interval:
+ aTiming.mStartTime = aER.ReadObject<TimeStamp>();
+ aTiming.mEndTime = aER.ReadObject<TimeStamp>();
+ break;
+ case MarkerTiming::Phase::IntervalStart:
+ aTiming.mStartTime = aER.ReadObject<TimeStamp>();
+ aTiming.mEndTime = TimeStamp{};
+ break;
+ case MarkerTiming::Phase::IntervalEnd:
+ aTiming.mStartTime = TimeStamp{};
+ aTiming.mEndTime = aER.ReadObject<TimeStamp>();
+ break;
+ default:
+ MOZ_RELEASE_ASSERT(aTiming.mPhase == MarkerTiming::Phase::Instant ||
+ aTiming.mPhase == MarkerTiming::Phase::Interval ||
+ aTiming.mPhase ==
+ MarkerTiming::Phase::IntervalStart ||
+ aTiming.mPhase == MarkerTiming::Phase::IntervalEnd);
+ break;
+ }
+ }
+
+ static MarkerTiming Read(ProfileBufferEntryReader& aER) {
+ TimeStamp start;
+ TimeStamp end;
+ auto phase = aER.ReadObject<MarkerTiming::Phase>();
+ switch (phase) {
+ case MarkerTiming::Phase::Instant:
+ start = aER.ReadObject<TimeStamp>();
+ break;
+ case MarkerTiming::Phase::Interval:
+ start = aER.ReadObject<TimeStamp>();
+ end = aER.ReadObject<TimeStamp>();
+ break;
+ case MarkerTiming::Phase::IntervalStart:
+ start = aER.ReadObject<TimeStamp>();
+ break;
+ case MarkerTiming::Phase::IntervalEnd:
+ end = aER.ReadObject<TimeStamp>();
+ break;
+ default:
+ MOZ_RELEASE_ASSERT(phase == MarkerTiming::Phase::Instant ||
+ phase == MarkerTiming::Phase::Interval ||
+ phase == MarkerTiming::Phase::IntervalStart ||
+ phase == MarkerTiming::Phase::IntervalEnd);
+ break;
+ }
+ return MarkerTiming(start, end, phase);
+ }
+};
+
+// ----------------------------------------------------------------------------
+// Serializer, Deserializer: MarkerStack
+
+// The serialization only contains the `ProfileChunkedBuffer` from the
+// backtrace; if there is no backtrace or if it's empty, this will implicitly
+// store a nullptr (see
+// `ProfileBufferEntryWriter::Serializer<ProfilerChunkedBuffer*>`).
+template <>
+struct ProfileBufferEntryWriter::Serializer<MarkerStack> {
+ static Length Bytes(const MarkerStack& aStack) {
+ return SumBytes(aStack.GetChunkedBuffer());
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW, const MarkerStack& aStack) {
+ aEW.WriteObject(aStack.GetChunkedBuffer());
+ }
+};
+
+template <>
+struct ProfileBufferEntryReader::Deserializer<MarkerStack> {
+ static void ReadInto(ProfileBufferEntryReader& aER, MarkerStack& aStack) {
+ aStack = Read(aER);
+ }
+
+ static MarkerStack Read(ProfileBufferEntryReader& aER) {
+ return MarkerStack(aER.ReadObject<UniquePtr<ProfileChunkedBuffer>>());
+ }
+};
+
+// ----------------------------------------------------------------------------
+// Serializer, Deserializer: MarkerOptions
+
+// The serialization contains all members (either trivially-copyable, or they
+// provide their specialization above).
+template <>
+struct ProfileBufferEntryWriter::Serializer<MarkerOptions> {
+ static Length Bytes(const MarkerOptions& aOptions) {
+ return SumBytes(aOptions.ThreadId(), aOptions.Timing(), aOptions.Stack(),
+ aOptions.InnerWindowId());
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const MarkerOptions& aOptions) {
+ aEW.WriteObjects(aOptions.ThreadId(), aOptions.Timing(), aOptions.Stack(),
+ aOptions.InnerWindowId());
+ }
+};
+
+template <>
+struct ProfileBufferEntryReader::Deserializer<MarkerOptions> {
+ static void ReadInto(ProfileBufferEntryReader& aER, MarkerOptions& aOptions) {
+ aER.ReadIntoObjects(aOptions.mThreadId, aOptions.mTiming, aOptions.mStack,
+ aOptions.mInnerWindowId);
+ }
+
+ static MarkerOptions Read(ProfileBufferEntryReader& aER) {
+ MarkerOptions options;
+ ReadInto(aER, options);
+ return options;
+ }
+};
+
+} // namespace mozilla
+
+#endif // BaseProfilerMarkersDetail_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerMarkersPrerequisites.h b/mozglue/baseprofiler/public/BaseProfilerMarkersPrerequisites.h
new file mode 100644
index 0000000000..15fd729d0c
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerMarkersPrerequisites.h
@@ -0,0 +1,886 @@
+/* -*- Mode: C++; tab-width: 2; 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 header contains basic definitions required to create marker types, and
+// to add markers to the profiler buffers.
+//
+// In most cases, #include "mozilla/BaseProfilerMarkers.h" instead, or
+// #include "mozilla/BaseProfilerMarkerTypes.h" for common marker types.
+
+#ifndef BaseProfilerMarkersPrerequisites_h
+#define BaseProfilerMarkersPrerequisites_h
+
+namespace mozilla {
+
+enum class StackCaptureOptions {
+ NoStack, // No stack captured.
+ Full, // Capture a full stack, including label frames, JS frames and
+ // native frames.
+ NonNative, // Capture a stack without native frames for reduced overhead.
+};
+
+}
+
+#include "BaseProfilingCategory.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ProfileChunkedBuffer.h"
+#include "mozilla/BaseProfilerState.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Variant.h"
+
+#include <initializer_list>
+#include <string_view>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace mozilla {
+
+// Return a NotNull<const CHAR*> pointing at the literal empty string `""`.
+template <typename CHAR>
+constexpr const CHAR* LiteralEmptyStringPointer() {
+ static_assert(std::is_same_v<CHAR, char> || std::is_same_v<CHAR, char16_t>,
+ "Only char and char16_t are supported in Firefox");
+ if constexpr (std::is_same_v<CHAR, char>) {
+ return "";
+ }
+ if constexpr (std::is_same_v<CHAR, char16_t>) {
+ return u"";
+ }
+}
+
+// Return a string_view<CHAR> pointing at the literal empty string.
+template <typename CHAR>
+constexpr std::basic_string_view<CHAR> LiteralEmptyStringView() {
+ static_assert(std::is_same_v<CHAR, char> || std::is_same_v<CHAR, char16_t>,
+ "Only char and char16_t are supported in Firefox");
+ // Use `operator""sv()` from <string_view>.
+ using namespace std::literals::string_view_literals;
+ if constexpr (std::is_same_v<CHAR, char>) {
+ return ""sv;
+ }
+ if constexpr (std::is_same_v<CHAR, char16_t>) {
+ return u""sv;
+ }
+}
+
+// General string view, optimized for short on-stack life before serialization,
+// and between deserialization and JSON-streaming.
+template <typename CHAR>
+class MOZ_STACK_CLASS ProfilerStringView {
+ public:
+ // Default constructor points at "" (literal empty string).
+ constexpr ProfilerStringView() = default;
+
+ // Don't allow copy.
+ ProfilerStringView(const ProfilerStringView&) = delete;
+ ProfilerStringView& operator=(const ProfilerStringView&) = delete;
+
+ // Allow move. For consistency the moved-from string is always reset to "".
+ constexpr ProfilerStringView(ProfilerStringView&& aOther)
+ : mStringView(std::move(aOther.mStringView)),
+ mOwnership(aOther.mOwnership) {
+ if (mOwnership == Ownership::OwnedThroughStringView) {
+ // We now own the buffer, make the other point at the literal "".
+ aOther.mStringView = LiteralEmptyStringView<CHAR>();
+ aOther.mOwnership = Ownership::Literal;
+ }
+ }
+ constexpr ProfilerStringView& operator=(ProfilerStringView&& aOther) {
+ mStringView = std::move(aOther.mStringView);
+ mOwnership = aOther.mOwnership;
+ if (mOwnership == Ownership::OwnedThroughStringView) {
+ // We now own the buffer, make the other point at the literal "".
+ aOther.mStringView = LiteralEmptyStringView<CHAR>();
+ aOther.mOwnership = Ownership::Literal;
+ }
+ return *this;
+ }
+
+ ~ProfilerStringView() {
+ if (MOZ_UNLIKELY(mOwnership == Ownership::OwnedThroughStringView)) {
+ // We own the buffer pointed at by mStringView, destroy it.
+ // This is only used between deserialization and streaming.
+ delete mStringView.data();
+ }
+ }
+
+ // Implicit construction from nullptr, points at "" (literal empty string).
+ constexpr MOZ_IMPLICIT ProfilerStringView(decltype(nullptr)) {}
+
+ // Implicit constructor from a literal string.
+ template <size_t Np1>
+ constexpr MOZ_IMPLICIT ProfilerStringView(const CHAR (&aLiteralString)[Np1])
+ : ProfilerStringView(aLiteralString, Np1 - 1, Ownership::Literal) {}
+
+ // Constructor from a non-literal string.
+ constexpr ProfilerStringView(const CHAR* aString, size_t aLength)
+ : ProfilerStringView(aString, aLength, Ownership::Reference) {}
+
+ // Implicit constructor from a string_view.
+ constexpr MOZ_IMPLICIT ProfilerStringView(
+ const std::basic_string_view<CHAR>& aStringView)
+ : ProfilerStringView(aStringView.data(), aStringView.length(),
+ Ownership::Reference) {}
+
+ // Implicit constructor from an expiring string_view. We assume that the
+ // pointed-at string will outlive this ProfilerStringView.
+ constexpr MOZ_IMPLICIT ProfilerStringView(
+ std::basic_string_view<CHAR>&& aStringView)
+ : ProfilerStringView(aStringView.data(), aStringView.length(),
+ Ownership::Reference) {}
+
+ // Implicit constructor from std::string.
+ constexpr MOZ_IMPLICIT ProfilerStringView(
+ const std::basic_string<CHAR>& aString)
+ : ProfilerStringView(aString.data(), aString.length(),
+ Ownership::Reference) {}
+
+ // Construction from a raw pointer to a null-terminated string.
+ // This is a named class-static function to make it more obvious where work is
+ // being done (to determine the string length), and encourage users to instead
+ // provide a length, if already known.
+ // TODO: Find callers and convert them to constructor instead if possible.
+ static constexpr ProfilerStringView WrapNullTerminatedString(
+ const CHAR* aString) {
+ return ProfilerStringView(
+ aString, aString ? std::char_traits<CHAR>::length(aString) : 0,
+ Ownership::Reference);
+ }
+
+ // Implicit constructor for an object with member functions `Data()`
+ // `Length()`, and `IsLiteral()`, common in xpcom strings.
+ template <
+ typename String,
+ typename DataReturnType = decltype(std::declval<const String>().Data()),
+ typename LengthReturnType =
+ decltype(std::declval<const String>().Length()),
+ typename IsLiteralReturnType =
+ decltype(std::declval<const String>().IsLiteral()),
+ typename =
+ std::enable_if_t<std::is_convertible_v<DataReturnType, const CHAR*> &&
+ std::is_integral_v<LengthReturnType> &&
+ std::is_same_v<IsLiteralReturnType, bool>>>
+ constexpr MOZ_IMPLICIT ProfilerStringView(const String& aString)
+ : ProfilerStringView(
+ static_cast<const CHAR*>(aString.Data()), aString.Length(),
+ aString.IsLiteral() ? Ownership::Literal : Ownership::Reference) {}
+
+ [[nodiscard]] constexpr const std::basic_string_view<CHAR>& StringView()
+ const {
+ return mStringView;
+ }
+
+ [[nodiscard]] constexpr size_t Length() const { return mStringView.length(); }
+
+ [[nodiscard]] constexpr bool IsLiteral() const {
+ return mOwnership == Ownership::Literal;
+ }
+ [[nodiscard]] constexpr bool IsReference() const {
+ return mOwnership == Ownership::Reference;
+ }
+ // No `IsOwned...()` because it's a secret, only used internally!
+
+ [[nodiscard]] Span<const CHAR> AsSpan() const {
+ return Span<const CHAR>(mStringView.data(), mStringView.length());
+ }
+ [[nodiscard]] operator Span<const CHAR>() const { return AsSpan(); }
+
+ private:
+ enum class Ownership { Literal, Reference, OwnedThroughStringView };
+
+ // Allow deserializer to store anything here.
+ friend ProfileBufferEntryReader::Deserializer<ProfilerStringView>;
+
+ constexpr ProfilerStringView(const CHAR* aString, size_t aLength,
+ Ownership aOwnership)
+ : mStringView(aString ? std::basic_string_view<CHAR>(aString, aLength)
+ : LiteralEmptyStringView<CHAR>()),
+ mOwnership(aString ? aOwnership : Ownership::Literal) {}
+
+ // String view to an outside string (literal or reference).
+ // We may actually own the pointed-at buffer, but it is only used internally
+ // between deserialization and JSON streaming.
+ std::basic_string_view<CHAR> mStringView = LiteralEmptyStringView<CHAR>();
+
+ Ownership mOwnership = Ownership::Literal;
+};
+
+using ProfilerString8View = ProfilerStringView<char>;
+using ProfilerString16View = ProfilerStringView<char16_t>;
+
+// This compulsory marker parameter contains the required category information.
+class MarkerCategory {
+ public:
+ // Constructor from category pair (includes both super- and sub-categories).
+ constexpr explicit MarkerCategory(
+ baseprofiler::ProfilingCategoryPair aCategoryPair)
+ : mCategoryPair(aCategoryPair) {}
+
+ // Returns the stored category pair.
+ constexpr baseprofiler::ProfilingCategoryPair CategoryPair() const {
+ return mCategoryPair;
+ }
+
+ // Returns the super-category from the stored category pair.
+ baseprofiler::ProfilingCategory GetCategory() const {
+ return GetProfilingCategoryPairInfo(mCategoryPair).mCategory;
+ }
+
+ private:
+ baseprofiler::ProfilingCategoryPair mCategoryPair =
+ baseprofiler::ProfilingCategoryPair::OTHER;
+};
+
+namespace baseprofiler::category {
+
+// Each category pair name constructs a MarkerCategory.
+// E.g.: mozilla::baseprofiler::category::OTHER_Profiling
+// Profiler macros will take the category name alone without namespace.
+// E.g.: `PROFILER_MARKER_UNTYPED("name", OTHER_Profiling)`
+#define CATEGORY_ENUM_BEGIN_CATEGORY(name, labelAsString, color)
+#define CATEGORY_ENUM_SUBCATEGORY(supercategory, name, labelAsString) \
+ static constexpr MarkerCategory name{ProfilingCategoryPair::name};
+#define CATEGORY_ENUM_END_CATEGORY
+MOZ_PROFILING_CATEGORY_LIST(CATEGORY_ENUM_BEGIN_CATEGORY,
+ CATEGORY_ENUM_SUBCATEGORY,
+ CATEGORY_ENUM_END_CATEGORY)
+#undef CATEGORY_ENUM_BEGIN_CATEGORY
+#undef CATEGORY_ENUM_SUBCATEGORY
+#undef CATEGORY_ENUM_END_CATEGORY
+
+// Import `MarkerCategory` into this namespace. This will allow using this type
+// dynamically in macros that prepend `::mozilla::baseprofiler::category::` to
+// the given category, e.g.:
+// `PROFILER_MARKER_UNTYPED("name", MarkerCategory(...))`
+using MarkerCategory = ::mozilla::MarkerCategory;
+
+} // namespace baseprofiler::category
+
+// The classes below are all embedded in a `MarkerOptions` object.
+class MarkerOptions;
+
+// This marker option captures a given thread id.
+// If left unspecified (by default construction) during the add-marker call, the
+// current thread id will be used then.
+class MarkerThreadId {
+ public:
+ // Default constructor, keeps the thread id unspecified.
+ constexpr MarkerThreadId() = default;
+
+ // Constructor from a given thread id.
+ constexpr explicit MarkerThreadId(
+ baseprofiler::BaseProfilerThreadId aThreadId)
+ : mThreadId(aThreadId) {}
+
+ // Use the current thread's id.
+ static MarkerThreadId CurrentThread() {
+ return MarkerThreadId(baseprofiler::profiler_current_thread_id());
+ }
+
+ // Use the main thread's id. This can be useful to record a marker from a
+ // possibly-unregistered thread, and display it in the main thread track.
+ static MarkerThreadId MainThread() {
+ return MarkerThreadId(baseprofiler::profiler_main_thread_id());
+ }
+
+ [[nodiscard]] constexpr baseprofiler::BaseProfilerThreadId ThreadId() const {
+ return mThreadId;
+ }
+
+ [[nodiscard]] constexpr bool IsUnspecified() const {
+ return !mThreadId.IsSpecified();
+ }
+
+ private:
+ baseprofiler::BaseProfilerThreadId mThreadId;
+};
+
+// This marker option contains marker timing information.
+// This class encapsulates the logic for correctly storing a marker based on its
+// Use the static methods to create the MarkerTiming. This is a transient object
+// that is being used to enforce the constraints of the combinations of the
+// data.
+class MarkerTiming {
+ public:
+ // The following static methods are used to create the MarkerTiming based on
+ // the type that it is.
+
+ static MarkerTiming InstantAt(const TimeStamp& aTime) {
+ MOZ_ASSERT(!aTime.IsNull(), "Time is null for an instant marker.");
+ return MarkerTiming{aTime, TimeStamp{}, MarkerTiming::Phase::Instant};
+ }
+
+ static MarkerTiming InstantNow() { return InstantAt(TimeStamp::Now()); }
+
+ static MarkerTiming Interval(const TimeStamp& aStartTime,
+ const TimeStamp& aEndTime) {
+ MOZ_ASSERT(!aStartTime.IsNull(),
+ "Start time is null for an interval marker.");
+ MOZ_ASSERT(!aEndTime.IsNull(), "End time is null for an interval marker.");
+ return MarkerTiming{aStartTime, aEndTime, MarkerTiming::Phase::Interval};
+ }
+
+ static MarkerTiming IntervalUntilNowFrom(const TimeStamp& aStartTime) {
+ return Interval(aStartTime, TimeStamp::Now());
+ }
+
+ static MarkerTiming IntervalStart(const TimeStamp& aTime = TimeStamp::Now()) {
+ MOZ_ASSERT(!aTime.IsNull(), "Time is null for an interval start marker.");
+ return MarkerTiming{aTime, TimeStamp{}, MarkerTiming::Phase::IntervalStart};
+ }
+
+ static MarkerTiming IntervalEnd(const TimeStamp& aTime = TimeStamp::Now()) {
+ MOZ_ASSERT(!aTime.IsNull(), "Time is null for an interval end marker.");
+ return MarkerTiming{TimeStamp{}, aTime, MarkerTiming::Phase::IntervalEnd};
+ }
+
+ // Set the interval end in this timing.
+ // If there was already a start time, this makes it a full interval.
+ void SetIntervalEnd(const TimeStamp& aTime = TimeStamp::Now()) {
+ MOZ_ASSERT(!aTime.IsNull(), "Time is null for an interval end marker.");
+ mEndTime = aTime;
+ mPhase = mStartTime.IsNull() ? Phase::IntervalEnd : Phase::Interval;
+ }
+
+ [[nodiscard]] const TimeStamp& StartTime() const { return mStartTime; }
+ [[nodiscard]] const TimeStamp& EndTime() const { return mEndTime; }
+
+ enum class Phase : uint8_t {
+ Instant = 0,
+ Interval = 1,
+ IntervalStart = 2,
+ IntervalEnd = 3,
+ };
+
+ [[nodiscard]] Phase MarkerPhase() const {
+ MOZ_ASSERT(!IsUnspecified());
+ return mPhase;
+ }
+
+ // The following getter methods are used to put the value into the buffer for
+ // storage.
+ [[nodiscard]] double GetStartTime() const {
+ MOZ_ASSERT(!IsUnspecified());
+ // If mStartTime is null (e.g., for IntervalEnd), this will output 0.0 as
+ // expected.
+ return MarkerTiming::timeStampToDouble(mStartTime);
+ }
+
+ [[nodiscard]] double GetEndTime() const {
+ MOZ_ASSERT(!IsUnspecified());
+ // If mEndTime is null (e.g., for Instant or IntervalStart), this will
+ // output 0.0 as expected.
+ return MarkerTiming::timeStampToDouble(mEndTime);
+ }
+
+ [[nodiscard]] uint8_t GetPhase() const {
+ MOZ_ASSERT(!IsUnspecified());
+ return static_cast<uint8_t>(mPhase);
+ }
+
+ // This is a constructor for Rust FFI bindings. It must not be used outside of
+ // this! Please see the other static constructors above.
+ static void UnsafeConstruct(MarkerTiming* aMarkerTiming,
+ const TimeStamp& aStartTime,
+ const TimeStamp& aEndTime, Phase aPhase) {
+ new (aMarkerTiming) MarkerTiming{aStartTime, aEndTime, aPhase};
+ }
+
+ private:
+ friend ProfileBufferEntryWriter::Serializer<MarkerTiming>;
+ friend ProfileBufferEntryReader::Deserializer<MarkerTiming>;
+ friend MarkerOptions;
+
+ // Default timing leaves it internally "unspecified", serialization getters
+ // and add-marker functions will default to `InstantNow()`.
+ constexpr MarkerTiming() = default;
+
+ // This should only be used by internal profiler code.
+ [[nodiscard]] bool IsUnspecified() const {
+ return mStartTime.IsNull() && mEndTime.IsNull();
+ }
+
+ // Full constructor, used by static factory functions.
+ constexpr MarkerTiming(const TimeStamp& aStartTime, const TimeStamp& aEndTime,
+ Phase aPhase)
+ : mStartTime(aStartTime), mEndTime(aEndTime), mPhase(aPhase) {}
+
+ static double timeStampToDouble(const TimeStamp& time) {
+ if (time.IsNull()) {
+ // The Phase lets us know not to use this value.
+ return 0;
+ }
+ return (time - TimeStamp::ProcessCreation()).ToMilliseconds();
+ }
+
+ TimeStamp mStartTime;
+ TimeStamp mEndTime;
+ Phase mPhase = Phase::Instant;
+};
+
+// This marker option allows three cases:
+// - By default, no stacks are captured.
+// - The caller can request a stack capture, and the add-marker code will take
+// care of it in the most efficient way.
+// - The caller can still provide an existing backtrace, for cases where a
+// marker reports something that happened elsewhere.
+class MarkerStack {
+ public:
+ // Default constructor, no capture.
+ constexpr MarkerStack() = default;
+
+ // Disallow copy.
+ MarkerStack(const MarkerStack&) = delete;
+ MarkerStack& operator=(const MarkerStack&) = delete;
+
+ // Allow move.
+ MarkerStack(MarkerStack&& aOther)
+ : mCaptureOptions(aOther.mCaptureOptions),
+ mOptionalChunkedBufferStorage(
+ std::move(aOther.mOptionalChunkedBufferStorage)),
+ mChunkedBuffer(aOther.mChunkedBuffer) {
+ AssertInvariants();
+ aOther.Clear();
+ }
+ MarkerStack& operator=(MarkerStack&& aOther) {
+ mCaptureOptions = aOther.mCaptureOptions;
+ mOptionalChunkedBufferStorage =
+ std::move(aOther.mOptionalChunkedBufferStorage);
+ mChunkedBuffer = aOther.mChunkedBuffer;
+ AssertInvariants();
+ aOther.Clear();
+ return *this;
+ }
+
+ // Take ownership of a backtrace. If null or empty, equivalent to NoStack().
+ explicit MarkerStack(UniquePtr<ProfileChunkedBuffer>&& aExternalChunkedBuffer)
+ : mOptionalChunkedBufferStorage(
+ (!aExternalChunkedBuffer || aExternalChunkedBuffer->IsEmpty())
+ ? nullptr
+ : std::move(aExternalChunkedBuffer)),
+ mChunkedBuffer(mOptionalChunkedBufferStorage.get()) {
+ AssertInvariants();
+ }
+
+ // Use an existing backtrace stored elsewhere, which the user must guarantee
+ // is alive during the add-marker call. If empty, equivalent to NoStack().
+ explicit MarkerStack(ProfileChunkedBuffer& aExternalChunkedBuffer)
+ : mChunkedBuffer(aExternalChunkedBuffer.IsEmpty()
+ ? nullptr
+ : &aExternalChunkedBuffer) {
+ AssertInvariants();
+ }
+
+ // Don't capture a stack in this marker.
+ static MarkerStack NoStack() {
+ return MarkerStack(StackCaptureOptions::NoStack);
+ }
+
+ // Capture a stack when adding this marker.
+ static MarkerStack Capture(
+ StackCaptureOptions aCaptureOptions = StackCaptureOptions::Full) {
+ // Actual capture will be handled inside profiler_add_marker.
+ return MarkerStack(aCaptureOptions);
+ }
+
+ // Optionally capture a stack, useful for avoiding long-winded ternaries.
+ static MarkerStack MaybeCapture(bool aDoCapture) {
+ return aDoCapture ? Capture() : NoStack();
+ }
+
+ // Use an existing backtrace stored elsewhere, which the user must guarantee
+ // is alive during the add-marker call. If empty, equivalent to NoStack().
+ static MarkerStack UseBacktrace(
+ ProfileChunkedBuffer& aExternalChunkedBuffer) {
+ return MarkerStack(aExternalChunkedBuffer);
+ }
+
+ // Take ownership of a backtrace previously captured with
+ // `profiler_capture_backtrace()`. If null, equivalent to NoStack().
+ static MarkerStack TakeBacktrace(
+ UniquePtr<ProfileChunkedBuffer>&& aExternalChunkedBuffer) {
+ return MarkerStack(std::move(aExternalChunkedBuffer));
+ }
+
+ // Construct with the given capture options.
+ static MarkerStack WithCaptureOptions(StackCaptureOptions aCaptureOptions) {
+ return MarkerStack(aCaptureOptions);
+ }
+
+ [[nodiscard]] StackCaptureOptions CaptureOptions() const {
+ return mCaptureOptions;
+ }
+
+ ProfileChunkedBuffer* GetChunkedBuffer() const { return mChunkedBuffer; }
+
+ // Use backtrace after a request. If null, equivalent to NoStack().
+ void UseRequestedBacktrace(ProfileChunkedBuffer* aExternalChunkedBuffer) {
+ MOZ_RELEASE_ASSERT(mCaptureOptions != StackCaptureOptions::NoStack);
+ mCaptureOptions = StackCaptureOptions::NoStack;
+ if (aExternalChunkedBuffer && !aExternalChunkedBuffer->IsEmpty()) {
+ // We only need to use the provided buffer if it is not empty.
+ mChunkedBuffer = aExternalChunkedBuffer;
+ }
+ AssertInvariants();
+ }
+
+ void Clear() {
+ mCaptureOptions = StackCaptureOptions::NoStack;
+ mOptionalChunkedBufferStorage.reset();
+ mChunkedBuffer = nullptr;
+ AssertInvariants();
+ }
+
+ private:
+ explicit MarkerStack(StackCaptureOptions aCaptureOptions)
+ : mCaptureOptions(aCaptureOptions) {
+ AssertInvariants();
+ }
+
+ // This should be called after every constructor and non-const function.
+ void AssertInvariants() const {
+#ifdef DEBUG
+ if (mCaptureOptions != StackCaptureOptions::NoStack) {
+ MOZ_ASSERT(!mOptionalChunkedBufferStorage,
+ "We should not hold a buffer when capture is requested");
+ MOZ_ASSERT(!mChunkedBuffer,
+ "We should not point at a buffer when capture is requested");
+ } else {
+ if (mOptionalChunkedBufferStorage) {
+ MOZ_ASSERT(mChunkedBuffer == mOptionalChunkedBufferStorage.get(),
+ "Non-null mOptionalChunkedBufferStorage must be pointed-at "
+ "by mChunkedBuffer");
+ }
+ if (mChunkedBuffer) {
+ MOZ_ASSERT(!mChunkedBuffer->IsEmpty(),
+ "Non-null mChunkedBuffer must not be empty");
+ }
+ }
+#endif // DEBUG
+ }
+
+ StackCaptureOptions mCaptureOptions = StackCaptureOptions::NoStack;
+
+ // Optional storage for the backtrace, in case it was captured before the
+ // add-marker call.
+ UniquePtr<ProfileChunkedBuffer> mOptionalChunkedBufferStorage;
+
+ // If not null, this points to the backtrace. It may point to a backtrace
+ // temporarily stored on the stack, or to mOptionalChunkedBufferStorage.
+ ProfileChunkedBuffer* mChunkedBuffer = nullptr;
+};
+
+// This marker option captures a given inner window id.
+class MarkerInnerWindowId {
+ public:
+ // Default constructor, it leaves the id unspecified.
+ constexpr MarkerInnerWindowId() = default;
+
+ // Constructor with a specified inner window id.
+ constexpr explicit MarkerInnerWindowId(uint64_t i) : mInnerWindowId(i) {}
+
+ // Constructor with either specified inner window id or Nothing.
+ constexpr explicit MarkerInnerWindowId(const Maybe<uint64_t>& i)
+ : mInnerWindowId(i.valueOr(scNoId)) {}
+
+ // Explicit option with unspecified id.
+ constexpr static MarkerInnerWindowId NoId() { return MarkerInnerWindowId{}; }
+
+ [[nodiscard]] bool IsUnspecified() const { return mInnerWindowId == scNoId; }
+
+ [[nodiscard]] constexpr uint64_t Id() const { return mInnerWindowId; }
+
+ private:
+ static constexpr uint64_t scNoId = 0;
+ uint64_t mInnerWindowId = scNoId;
+};
+
+// This class combines each of the possible marker options above.
+class MarkerOptions {
+ public:
+ // Constructor from individual options (including none).
+ // Implicit to allow `{}` and one option type as-is.
+ // Options that are not provided here are defaulted. In particular, timing
+ // defaults to `MarkerTiming::InstantNow()` when the marker is recorded.
+ template <typename... Options>
+ MOZ_IMPLICIT MarkerOptions(Options&&... aOptions) {
+ (Set(std::forward<Options>(aOptions)), ...);
+ }
+
+ // Disallow copy.
+ MarkerOptions(const MarkerOptions&) = delete;
+ MarkerOptions& operator=(const MarkerOptions&) = delete;
+
+ // Allow move.
+ MarkerOptions(MarkerOptions&&) = default;
+ MarkerOptions& operator=(MarkerOptions&&) = default;
+
+ // The embedded `MarkerTiming` hasn't been specified yet.
+ [[nodiscard]] bool IsTimingUnspecified() const {
+ return mTiming.IsUnspecified();
+ }
+
+ // Each option may be added in a chain by e.g.:
+ // `options.Set(MarkerThreadId(123)).Set(MarkerTiming::IntervalEnd())`.
+ // When passed to an add-marker function, it must be an rvalue, either created
+ // on the spot, or `std::move`d from storage, e.g.:
+ // `PROFILER_MARKER_UNTYPED("...", std::move(options).Set(...))`;
+ //
+ // Options can be read by their name (without "Marker"), e.g.: `o.ThreadId()`.
+ // Add "Ref" for a non-const reference, e.g.: `o.ThreadIdRef() = ...;`
+#define FUNCTIONS_ON_MEMBER(NAME) \
+ MarkerOptions& Set(Marker##NAME&& a##NAME)& { \
+ m##NAME = std::move(a##NAME); \
+ return *this; \
+ } \
+ \
+ MarkerOptions&& Set(Marker##NAME&& a##NAME)&& { \
+ m##NAME = std::move(a##NAME); \
+ return std::move(*this); \
+ } \
+ \
+ const Marker##NAME& NAME() const { return m##NAME; } \
+ \
+ Marker##NAME& NAME##Ref() { return m##NAME; }
+
+ FUNCTIONS_ON_MEMBER(ThreadId);
+ FUNCTIONS_ON_MEMBER(Timing);
+ FUNCTIONS_ON_MEMBER(Stack);
+ FUNCTIONS_ON_MEMBER(InnerWindowId);
+#undef FUNCTIONS_ON_MEMBER
+
+ private:
+ friend ProfileBufferEntryReader::Deserializer<MarkerOptions>;
+
+ MarkerThreadId mThreadId;
+ MarkerTiming mTiming;
+ MarkerStack mStack;
+ MarkerInnerWindowId mInnerWindowId;
+};
+
+} // namespace mozilla
+
+namespace mozilla::baseprofiler::markers {
+
+// Default marker payload types, with no extra information, not even a marker
+// type and payload. This is intended for label-only markers.
+struct NoPayload final {};
+
+} // namespace mozilla::baseprofiler::markers
+
+namespace mozilla {
+
+class JSONWriter;
+
+// This class collects all the information necessary to stream the JSON schema
+// that informs the front-end how to display a type of markers.
+// It will be created and populated in `MarkerTypeDisplay()` functions in each
+// marker type definition, see Add/Set functions.
+class MarkerSchema {
+ public:
+ enum class Location : unsigned {
+ MarkerChart,
+ MarkerTable,
+ // This adds markers to the main marker timeline in the header.
+ TimelineOverview,
+ // In the timeline, this is a section that breaks out markers that are
+ // related to memory. When memory counters are enabled, this is its own
+ // track, otherwise it is displayed with the main thread.
+ TimelineMemory,
+ // This adds markers to the IPC timeline area in the header.
+ TimelineIPC,
+ // This adds markers to the FileIO timeline area in the header.
+ TimelineFileIO,
+ // TODO - This is not supported yet.
+ StackChart
+ };
+
+ // Used as constructor parameter, to explicitly specify that the location (and
+ // other display options) are handled as a special case in the front-end.
+ // In this case, *no* schema will be output for this type.
+ struct SpecialFrontendLocation {};
+
+ enum class Format {
+ // ----------------------------------------------------
+ // String types.
+
+ // Show the URL, and handle PII sanitization
+ Url,
+ // Show the file path, and handle PII sanitization.
+ FilePath,
+ // Important, do not put URL or file path information here, as it will not
+ // be sanitized. Please be careful with including other types of PII here as
+ // well.
+ // e.g. "Label: Some String"
+ String,
+
+ // ----------------------------------------------------
+ // Numeric types
+
+ // For time data that represents a duration of time.
+ // e.g. "Label: 5s, 5ms, 5μs"
+ Duration,
+ // Data that happened at a specific time, relative to the start of the
+ // profile. e.g. "Label: 15.5s, 20.5ms, 30.5μs"
+ Time,
+ // The following are alternatives to display a time only in a specific unit
+ // of time.
+ Seconds, // "Label: 5s"
+ Milliseconds, // "Label: 5ms"
+ Microseconds, // "Label: 5μs"
+ Nanoseconds, // "Label: 5ns"
+ // e.g. "Label: 5.55mb, 5 bytes, 312.5kb"
+ Bytes,
+ // This should be a value between 0 and 1.
+ // "Label: 50%"
+ Percentage,
+ // The integer should be used for generic representations of numbers.
+ // Do not use it for time information.
+ // "Label: 52, 5,323, 1,234,567"
+ Integer,
+ // The decimal should be used for generic representations of numbers.
+ // Do not use it for time information.
+ // "Label: 52.23, 0.0054, 123,456.78"
+ Decimal
+ };
+
+ enum class Searchable { NotSearchable, Searchable };
+
+ // Marker schema, with a non-empty list of locations where markers should be
+ // shown.
+ // Tech note: Even though `aLocations` are templated arguments, they are
+ // assigned to an `enum class` object, so they can only be of that enum type.
+ template <typename... Locations>
+ explicit MarkerSchema(Location aLocation, Locations... aLocations)
+ : mLocations{aLocation, aLocations...} {}
+
+ // Alternative constructor for MarkerSchema.
+ explicit MarkerSchema(const mozilla::MarkerSchema::Location* aLocations,
+ size_t aLength)
+ : mLocations(aLocations, aLocations + aLength) {}
+
+ // Marker schema for types that have special frontend handling.
+ // Nothing else should be set in this case.
+ // Implicit to allow quick return from MarkerTypeDisplay functions.
+ MOZ_IMPLICIT MarkerSchema(SpecialFrontendLocation) {}
+
+ // Caller must specify location(s) or SpecialFrontendLocation above.
+ MarkerSchema() = delete;
+
+ // Optional labels in the marker chart, the chart tooltip, and the marker
+ // table. If not provided, the marker "name" will be used. The given string
+ // can contain element keys in braces to include data elements streamed by
+ // `StreamJSONMarkerData()`. E.g.: "This is {text}"
+
+#define LABEL_SETTER(name) \
+ MarkerSchema& Set##name(std::string a##name) { \
+ m##name = std::move(a##name); \
+ return *this; \
+ }
+
+ LABEL_SETTER(ChartLabel)
+ LABEL_SETTER(TooltipLabel)
+ LABEL_SETTER(TableLabel)
+
+#undef LABEL_SETTER
+
+ MarkerSchema& SetAllLabels(std::string aText) {
+ // Here we set the same text in each label.
+ // TODO: Move to a single "label" field once the front-end allows it.
+ SetChartLabel(aText);
+ SetTooltipLabel(aText);
+ SetTableLabel(std::move(aText));
+ return *this;
+ }
+
+ // Each data element that is streamed by `StreamJSONMarkerData()` can be
+ // displayed as indicated by using one of the `Add...` function below.
+ // Each `Add...` will add a line in the full marker description. Parameters:
+ // - `aKey`: Element property name as streamed by `StreamJSONMarkerData()`.
+ // - `aLabel`: Optional prefix. Defaults to the key name.
+ // - `aFormat`: How to format the data element value, see `Format` above.
+ // - `aSearchable`: Optional, indicates if the value is used in searches,
+ // defaults to false.
+
+ MarkerSchema& AddKeyFormat(std::string aKey, Format aFormat) {
+ mData.emplace_back(mozilla::VariantType<DynamicData>{},
+ DynamicData{std::move(aKey), mozilla::Nothing{}, aFormat,
+ mozilla::Nothing{}});
+ return *this;
+ }
+
+ MarkerSchema& AddKeyLabelFormat(std::string aKey, std::string aLabel,
+ Format aFormat) {
+ mData.emplace_back(
+ mozilla::VariantType<DynamicData>{},
+ DynamicData{std::move(aKey), mozilla::Some(std::move(aLabel)), aFormat,
+ mozilla::Nothing{}});
+ return *this;
+ }
+
+ MarkerSchema& AddKeyFormatSearchable(std::string aKey, Format aFormat,
+ Searchable aSearchable) {
+ mData.emplace_back(mozilla::VariantType<DynamicData>{},
+ DynamicData{std::move(aKey), mozilla::Nothing{}, aFormat,
+ mozilla::Some(aSearchable)});
+ return *this;
+ }
+
+ MarkerSchema& AddKeyLabelFormatSearchable(std::string aKey,
+ std::string aLabel, Format aFormat,
+ Searchable aSearchable) {
+ mData.emplace_back(
+ mozilla::VariantType<DynamicData>{},
+ DynamicData{std::move(aKey), mozilla::Some(std::move(aLabel)), aFormat,
+ mozilla::Some(aSearchable)});
+ return *this;
+ }
+
+ // The display may also include static rows.
+
+ MarkerSchema& AddStaticLabelValue(std::string aLabel, std::string aValue) {
+ mData.emplace_back(mozilla::VariantType<StaticData>{},
+ StaticData{std::move(aLabel), std::move(aValue)});
+ return *this;
+ }
+
+ // Internal streaming function.
+ MFBT_API void Stream(JSONWriter& aWriter, const Span<const char>& aName) &&;
+
+ private:
+ MFBT_API static Span<const char> LocationToStringSpan(Location aLocation);
+ MFBT_API static Span<const char> FormatToStringSpan(Format aFormat);
+
+ // List of marker display locations. Empty for SpecialFrontendLocation.
+ std::vector<Location> mLocations;
+ // Labels for different places.
+ std::string mChartLabel;
+ std::string mTooltipLabel;
+ std::string mTableLabel;
+ // Main display, made of zero or more rows of key+label+format or label+value.
+ private:
+ struct DynamicData {
+ std::string mKey;
+ mozilla::Maybe<std::string> mLabel;
+ Format mFormat;
+ mozilla::Maybe<Searchable> mSearchable;
+ };
+ struct StaticData {
+ std::string mLabel;
+ std::string mValue;
+ };
+ using DataRow = mozilla::Variant<DynamicData, StaticData>;
+ using DataRowVector = std::vector<DataRow>;
+
+ DataRowVector mData;
+};
+
+} // namespace mozilla
+
+#endif // BaseProfilerMarkersPrerequisites_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerRAIIMacro.h b/mozglue/baseprofiler/public/BaseProfilerRAIIMacro.h
new file mode 100644
index 0000000000..b89f7e1f77
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerRAIIMacro.h
@@ -0,0 +1,15 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef BaseProfilerRAIIMacro_h
+#define BaseProfilerRAIIMacro_h
+
+// Macros used by the AUTO_PROFILER_* macros to generate unique variable names.
+#define PROFILER_RAII_PASTE(id, line) id##line
+#define PROFILER_RAII_EXPAND(id, line) PROFILER_RAII_PASTE(id, line)
+#define PROFILER_RAII PROFILER_RAII_EXPAND(raiiObject, __LINE__)
+
+#endif // BaseProfilerRAIIMacro_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerSharedLibraries.h b/mozglue/baseprofiler/public/BaseProfilerSharedLibraries.h
new file mode 100644
index 0000000000..705ca55f4b
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerSharedLibraries.h
@@ -0,0 +1,170 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 BASE_PROFILER_SHARED_LIBRARIES_H_
+#define BASE_PROFILER_SHARED_LIBRARIES_H_
+
+#include "BaseProfiler.h"
+
+#ifndef MOZ_GECKO_PROFILER
+# error Do not #include this header when MOZ_GECKO_PROFILER is not #defined.
+#endif
+
+#include <algorithm>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string>
+#include <vector>
+
+class SharedLibrary {
+ public:
+ SharedLibrary(uintptr_t aStart, uintptr_t aEnd, uintptr_t aOffset,
+ const std::string& aBreakpadId, const std::string& aCodeId,
+ const std::string& aModuleName, const std::string& aModulePath,
+ const std::string& aDebugName, const std::string& aDebugPath,
+ const std::string& aVersion, const char* aArch)
+ : mStart(aStart),
+ mEnd(aEnd),
+ mOffset(aOffset),
+ mBreakpadId(aBreakpadId),
+ mCodeId(aCodeId),
+ mModuleName(aModuleName),
+ mModulePath(aModulePath),
+ mDebugName(aDebugName),
+ mDebugPath(aDebugPath),
+ mVersion(aVersion),
+ mArch(aArch) {}
+
+ SharedLibrary(const SharedLibrary& aEntry)
+ : mStart(aEntry.mStart),
+ mEnd(aEntry.mEnd),
+ mOffset(aEntry.mOffset),
+ mBreakpadId(aEntry.mBreakpadId),
+ mCodeId(aEntry.mCodeId),
+ mModuleName(aEntry.mModuleName),
+ mModulePath(aEntry.mModulePath),
+ mDebugName(aEntry.mDebugName),
+ mDebugPath(aEntry.mDebugPath),
+ mVersion(aEntry.mVersion),
+ mArch(aEntry.mArch) {}
+
+ SharedLibrary& operator=(const SharedLibrary& aEntry) {
+ // Gracefully handle self assignment
+ if (this == &aEntry) return *this;
+
+ mStart = aEntry.mStart;
+ mEnd = aEntry.mEnd;
+ mOffset = aEntry.mOffset;
+ mBreakpadId = aEntry.mBreakpadId;
+ mCodeId = aEntry.mCodeId;
+ mModuleName = aEntry.mModuleName;
+ mModulePath = aEntry.mModulePath;
+ mDebugName = aEntry.mDebugName;
+ mDebugPath = aEntry.mDebugPath;
+ mVersion = aEntry.mVersion;
+ mArch = aEntry.mArch;
+ return *this;
+ }
+
+ bool operator==(const SharedLibrary& other) const {
+ return (mStart == other.mStart) && (mEnd == other.mEnd) &&
+ (mOffset == other.mOffset) && (mModuleName == other.mModuleName) &&
+ (mModulePath == other.mModulePath) &&
+ (mDebugName == other.mDebugName) &&
+ (mDebugPath == other.mDebugPath) &&
+ (mBreakpadId == other.mBreakpadId) && (mCodeId == other.mCodeId) &&
+ (mVersion == other.mVersion) && (mArch == other.mArch);
+ }
+
+ uintptr_t GetStart() const { return mStart; }
+ uintptr_t GetEnd() const { return mEnd; }
+ uintptr_t GetOffset() const { return mOffset; }
+ const std::string& GetBreakpadId() const { return mBreakpadId; }
+ const std::string& GetCodeId() const { return mCodeId; }
+ const std::string& GetModuleName() const { return mModuleName; }
+ const std::string& GetModulePath() const { return mModulePath; }
+ const std::string& GetDebugName() const { return mDebugName; }
+ const std::string& GetDebugPath() const { return mDebugPath; }
+ const std::string& GetVersion() const { return mVersion; }
+ const std::string& GetArch() const { return mArch; }
+
+ private:
+ SharedLibrary() : mStart{0}, mEnd{0}, mOffset{0} {}
+
+ uintptr_t mStart;
+ uintptr_t mEnd;
+ uintptr_t mOffset;
+ std::string mBreakpadId;
+ // A string carrying an identifier for a binary.
+ //
+ // All platforms have different formats:
+ // - Windows: The code ID for a Windows PE file.
+ // It's the PE timestamp and PE image size.
+ // - macOS: The code ID for a macOS / iOS binary (mach-O).
+ // It's the mach-O UUID without dashes and without the trailing 0 for the
+ // breakpad ID.
+ // - Linux/Android: The code ID for a Linux ELF file.
+ // It's the complete build ID, as hex string.
+ std::string mCodeId;
+ std::string mModuleName;
+ std::string mModulePath;
+ std::string mDebugName;
+ std::string mDebugPath;
+ std::string mVersion;
+ std::string mArch;
+};
+
+static bool CompareAddresses(const SharedLibrary& first,
+ const SharedLibrary& second) {
+ return first.GetStart() < second.GetStart();
+}
+
+class SharedLibraryInfo {
+ public:
+ static SharedLibraryInfo GetInfoForSelf();
+#ifdef XP_WIN
+ static SharedLibraryInfo GetInfoFromPath(const wchar_t* aPath);
+#endif
+
+ static void Initialize();
+
+ SharedLibraryInfo() {}
+
+ void AddSharedLibrary(SharedLibrary entry) { mEntries.push_back(entry); }
+
+ const SharedLibrary& GetEntry(size_t i) const { return mEntries[i]; }
+
+ SharedLibrary& GetMutableEntry(size_t i) { return mEntries[i]; }
+
+ // Removes items in the range [first, last)
+ // i.e. element at the "last" index is not removed
+ void RemoveEntries(size_t first, size_t last) {
+ mEntries.erase(mEntries.begin() + first, mEntries.begin() + last);
+ }
+
+ bool Contains(const SharedLibrary& searchItem) const {
+ return (mEntries.end() !=
+ std::find(mEntries.begin(), mEntries.end(), searchItem));
+ }
+
+ size_t GetSize() const { return mEntries.size(); }
+
+ void SortByAddress() {
+ std::sort(mEntries.begin(), mEntries.end(), CompareAddresses);
+ }
+
+ void Clear() { mEntries.clear(); }
+
+ private:
+#ifdef XP_WIN
+ void AddSharedLibraryFromModuleInfo(const wchar_t* aModulePath,
+ mozilla::Maybe<HMODULE> aModule);
+#endif
+
+ std::vector<SharedLibrary> mEntries;
+};
+
+#endif // BASE_PROFILER_SHARED_LIBRARIES_H_
diff --git a/mozglue/baseprofiler/public/BaseProfilerState.h b/mozglue/baseprofiler/public/BaseProfilerState.h
new file mode 100644
index 0000000000..15be2743a4
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerState.h
@@ -0,0 +1,405 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+// The Gecko Profiler is an always-on profiler that takes fast and low overhead
+// samples of the program execution using only userspace functionality for
+// portability. The goal of this module is to provide performance data in a
+// generic cross-platform way without requiring custom tools or kernel support.
+//
+// Samples are collected to form a timeline with optional timeline event
+// (markers) used for filtering. The samples include both native stacks and
+// platform-independent "label stack" frames.
+
+#ifndef BaseProfilerState_h
+#define BaseProfilerState_h
+
+// This header contains most functions that give information about the Base
+// Profiler: Whether it is active or not, paused, the selected features, and
+// some generic process and thread information.
+// It is safe to include unconditionally, but uses of structs and functions must
+// be guarded by `#ifdef MOZ_GECKO_PROFILER`.
+
+#include "mozilla/BaseProfilerUtils.h"
+
+#ifndef MOZ_GECKO_PROFILER
+
+# define AUTO_PROFILER_STATS(name)
+
+namespace mozilla::baseprofiler {
+
+[[nodiscard]] inline bool profiler_is_active() { return false; }
+[[nodiscard]] inline bool profiler_is_active_and_unpaused() { return false; }
+
+} // namespace mozilla::baseprofiler
+
+#else // !MOZ_GECKO_PROFILER
+
+# include "mozilla/Atomics.h"
+# include "mozilla/Maybe.h"
+
+# include <stdint.h>
+# include <string>
+
+// Uncomment the following line to display profiler runtime statistics at
+// shutdown.
+// # define PROFILER_RUNTIME_STATS
+
+# ifdef PROFILER_RUNTIME_STATS
+# include "mozilla/TimeStamp.h"
+# endif
+
+namespace mozilla::baseprofiler {
+
+# ifdef PROFILER_RUNTIME_STATS
+// This class gathers durations and displays some basic stats when destroyed.
+// It is intended to be used as a static variable (see `AUTO_PROFILER_STATS`
+// below), to display stats at the end of the program.
+class StaticBaseProfilerStats {
+ public:
+ explicit StaticBaseProfilerStats(const char* aName) : mName(aName) {}
+
+ ~StaticBaseProfilerStats() {
+ // Using unsigned long long for computations and printfs.
+ using ULL = unsigned long long;
+ ULL n = static_cast<ULL>(mNumberDurations);
+ if (n != 0) {
+ ULL sumNs = static_cast<ULL>(mSumDurationsNs);
+ printf(
+ "[%d] Profiler stats `%s`: %llu ns / %llu = %llu ns, max %llu ns\n",
+ int(profiler_current_process_id().ToNumber()), mName, sumNs, n,
+ sumNs / n, static_cast<ULL>(mLongestDurationNs));
+ } else {
+ printf("[%d] Profiler stats `%s`: (nothing)\n",
+ int(profiler_current_process_id().ToNumber()), mName);
+ }
+ }
+
+ void AddDurationFrom(TimeStamp aStart) {
+ DurationNs duration = static_cast<DurationNs>(
+ (TimeStamp::Now() - aStart).ToMicroseconds() * 1000 + 0.5);
+ mSumDurationsNs += duration;
+ ++mNumberDurations;
+ // Update mLongestDurationNs if this one is longer.
+ for (;;) {
+ DurationNs longest = mLongestDurationNs;
+ if (MOZ_LIKELY(longest >= duration)) {
+ // This duration is not the longest, nothing to do.
+ break;
+ }
+ if (MOZ_LIKELY(mLongestDurationNs.compareExchange(longest, duration))) {
+ // Successfully updated `mLongestDurationNs` with the new value.
+ break;
+ }
+ // Otherwise someone else just updated `mLongestDurationNs`, we need to
+ // try again by looping.
+ }
+ }
+
+ private:
+ using DurationNs = uint64_t;
+ using Count = uint32_t;
+
+ Atomic<DurationNs> mSumDurationsNs{0};
+ Atomic<DurationNs> mLongestDurationNs{0};
+ Atomic<Count> mNumberDurations{0};
+ const char* mName;
+};
+
+// RAII object that measure its scoped lifetime duration and reports it to a
+// `StaticBaseProfilerStats`.
+class MOZ_RAII AutoProfilerStats {
+ public:
+ explicit AutoProfilerStats(StaticBaseProfilerStats& aStats)
+ : mStats(aStats), mStart(TimeStamp::Now()) {}
+
+ ~AutoProfilerStats() { mStats.AddDurationFrom(mStart); }
+
+ private:
+ StaticBaseProfilerStats& mStats;
+ TimeStamp mStart;
+};
+
+// Macro that should be used to collect basic statistics from measurements of
+// block durations, from where this macro is, until the end of its enclosing
+// scope. The name is used in the static variable name and when displaying stats
+// at the end of the program; Another location could use the same name but their
+// stats will not be combined, so use different name if these locations should
+// be distinguished.
+# define AUTO_PROFILER_STATS(name) \
+ static ::mozilla::baseprofiler::StaticBaseProfilerStats sStat##name( \
+ #name); \
+ ::mozilla::baseprofiler::AutoProfilerStats autoStat##name(sStat##name);
+
+# else // PROFILER_RUNTIME_STATS
+
+# define AUTO_PROFILER_STATS(name)
+
+# endif // PROFILER_RUNTIME_STATS else
+
+//---------------------------------------------------------------------------
+// Profiler features
+//---------------------------------------------------------------------------
+
+# if defined(__APPLE__) && defined(__aarch64__)
+# define POWER_HELP "Sample per process power use"
+# elif defined(__APPLE__) && defined(__x86_64__)
+# define POWER_HELP \
+ "Record the power used by the entire system with each sample."
+# elif defined(__linux__) && defined(__x86_64__)
+# define POWER_HELP \
+ "Record the power used by the entire system with each sample. " \
+ "Only available with Intel CPUs and requires setting " \
+ "the sysctl kernel.perf_event_paranoid to 0."
+# elif defined(_MSC_VER)
+# define POWER_HELP \
+ "Record the value of every energy meter available on the system with " \
+ "each sample. Only available on Windows 11 with Intel CPUs."
+# else
+# define POWER_HELP "Not supported on this platform."
+# endif
+
+// Higher-order macro containing all the feature info in one place. Define
+// |MACRO| appropriately to extract the relevant parts. Note that the number
+// values are used internally only and so can be changed without consequence.
+// Any changes to this list should also be applied to the feature list in
+// toolkit/components/extensions/schemas/geckoProfiler.json.
+// *** Synchronize with lists in ProfilerState.h and geckoProfiler.json ***
+# define BASE_PROFILER_FOR_EACH_FEATURE(MACRO) \
+ MACRO(0, "java", Java, "Profile Java code, Android only") \
+ \
+ MACRO(1, "js", JS, \
+ "Get the JS engine to expose the JS stack to the profiler") \
+ \
+ MACRO(2, "mainthreadio", MainThreadIO, "Add main thread file I/O") \
+ \
+ MACRO(3, "fileio", FileIO, \
+ "Add file I/O from all profiled threads, implies mainthreadio") \
+ \
+ MACRO(4, "fileioall", FileIOAll, \
+ "Add file I/O from all threads, implies fileio") \
+ \
+ MACRO(5, "nomarkerstacks", NoMarkerStacks, \
+ "Markers do not capture stacks, to reduce overhead") \
+ \
+ MACRO(6, "screenshots", Screenshots, \
+ "Take a snapshot of the window on every composition") \
+ \
+ MACRO(7, "seqstyle", SequentialStyle, \
+ "Disable parallel traversal in styling") \
+ \
+ MACRO(8, "stackwalk", StackWalk, \
+ "Walk the C++ stack, not available on all platforms") \
+ \
+ MACRO(9, "jsallocations", JSAllocations, \
+ "Have the JavaScript engine track allocations") \
+ \
+ MACRO(10, "nostacksampling", NoStackSampling, \
+ "Disable all stack sampling: Cancels \"js\", \"stackwalk\" and " \
+ "labels") \
+ \
+ MACRO(11, "nativeallocations", NativeAllocations, \
+ "Collect the stacks from a smaller subset of all native " \
+ "allocations, biasing towards collecting larger allocations") \
+ \
+ MACRO(12, "ipcmessages", IPCMessages, \
+ "Have the IPC layer track cross-process messages") \
+ \
+ MACRO(13, "audiocallbacktracing", AudioCallbackTracing, \
+ "Audio callback tracing") \
+ \
+ MACRO(14, "cpu", CPUUtilization, "CPU utilization") \
+ \
+ MACRO(15, "notimerresolutionchange", NoTimerResolutionChange, \
+ "Do not adjust the timer resolution for fast sampling, so that " \
+ "other Firefox timers do not get affected") \
+ \
+ MACRO(16, "cpuallthreads", CPUAllThreads, \
+ "Sample the CPU utilization of all registered threads") \
+ \
+ MACRO(17, "samplingallthreads", SamplingAllThreads, \
+ "Sample the stacks of all registered threads") \
+ \
+ MACRO(18, "markersallthreads", MarkersAllThreads, \
+ "Record markers from all registered threads") \
+ \
+ MACRO(19, "unregisteredthreads", UnregisteredThreads, \
+ "Discover and profile unregistered threads -- beware: expensive!") \
+ \
+ MACRO(20, "processcpu", ProcessCPU, \
+ "Sample the CPU utilization of each process") \
+ \
+ MACRO(21, "power", Power, POWER_HELP)
+// *** Synchronize with lists in ProfilerState.h and geckoProfiler.json ***
+
+struct ProfilerFeature {
+# define DECLARE(n_, str_, Name_, desc_) \
+ static constexpr uint32_t Name_ = (1u << n_); \
+ [[nodiscard]] static constexpr bool Has##Name_(uint32_t aFeatures) { \
+ return aFeatures & Name_; \
+ } \
+ static constexpr void Set##Name_(uint32_t& aFeatures) { \
+ aFeatures |= Name_; \
+ } \
+ static constexpr void Clear##Name_(uint32_t& aFeatures) { \
+ aFeatures &= ~Name_; \
+ }
+
+ // Define a bitfield constant, a getter, and two setters for each feature.
+ BASE_PROFILER_FOR_EACH_FEATURE(DECLARE)
+
+# undef DECLARE
+};
+
+namespace detail {
+
+// RacyFeatures is only defined in this header file so that its methods can
+// be inlined into profiler_is_active(). Please do not use anything from the
+// detail namespace outside the profiler.
+
+// Within the profiler's code, the preferred way to check profiler activeness
+// and features is via ActivePS(). However, that requires locking gPSMutex.
+// There are some hot operations where absolute precision isn't required, so we
+// duplicate the activeness/feature state in a lock-free manner in this class.
+class RacyFeatures {
+ public:
+ MFBT_API static void SetActive(uint32_t aFeatures);
+
+ MFBT_API static void SetInactive();
+
+ MFBT_API static void SetPaused();
+
+ MFBT_API static void SetUnpaused();
+
+ MFBT_API static void SetSamplingPaused();
+
+ MFBT_API static void SetSamplingUnpaused();
+
+ [[nodiscard]] MFBT_API static mozilla::Maybe<uint32_t> FeaturesIfActive() {
+ if (uint32_t af = sActiveAndFeatures; af & Active) {
+ // Active, remove the Active&Paused bits to get all features.
+ return Some(af & ~(Active | Paused | SamplingPaused));
+ }
+ return Nothing();
+ }
+
+ [[nodiscard]] MFBT_API static bool IsActive();
+
+ [[nodiscard]] MFBT_API static bool IsActiveWithFeature(uint32_t aFeature);
+
+ [[nodiscard]] MFBT_API static bool IsActiveWithoutFeature(uint32_t aFeature);
+
+ // True if profiler is active, and not fully paused.
+ // Note that periodic sampling *could* be paused!
+ [[nodiscard]] MFBT_API static bool IsActiveAndUnpaused();
+
+ // True if profiler is active, and sampling is not paused (though generic
+ // `SetPaused()` or specific `SetSamplingPaused()`).
+ [[nodiscard]] MFBT_API static bool IsActiveAndSamplingUnpaused();
+
+ private:
+ static constexpr uint32_t Active = 1u << 31;
+ static constexpr uint32_t Paused = 1u << 30;
+ static constexpr uint32_t SamplingPaused = 1u << 29;
+
+// Ensure Active/Paused don't overlap with any of the feature bits.
+# define NO_OVERLAP(n_, str_, Name_, desc_) \
+ static_assert(ProfilerFeature::Name_ != SamplingPaused, \
+ "bad feature value");
+
+ BASE_PROFILER_FOR_EACH_FEATURE(NO_OVERLAP);
+
+# undef NO_OVERLAP
+
+ // We combine the active bit with the feature bits so they can be read or
+ // written in a single atomic operation.
+ // TODO: Could this be MFBT_DATA for better inlining optimization?
+ static Atomic<uint32_t, MemoryOrdering::Relaxed> sActiveAndFeatures;
+};
+
+MFBT_API bool IsThreadBeingProfiled();
+
+} // namespace detail
+
+//---------------------------------------------------------------------------
+// Get information from the profiler
+//---------------------------------------------------------------------------
+
+// Is the profiler active? Note: the return value of this function can become
+// immediately out-of-date. E.g. the profile might be active but then
+// profiler_stop() is called immediately afterward. One common and reasonable
+// pattern of usage is the following:
+//
+// if (profiler_is_active()) {
+// ExpensiveData expensiveData = CreateExpensiveData();
+// PROFILER_OPERATION(expensiveData);
+// }
+//
+// where PROFILER_OPERATION is a no-op if the profiler is inactive. In this
+// case the profiler_is_active() check is just an optimization -- it prevents
+// us calling CreateExpensiveData() unnecessarily in most cases, but the
+// expensive data will end up being created but not used if another thread
+// stops the profiler between the CreateExpensiveData() and PROFILER_OPERATION
+// calls.
+[[nodiscard]] inline bool profiler_is_active() {
+ return baseprofiler::detail::RacyFeatures::IsActive();
+}
+
+// Same as profiler_is_active(), but also checks if the profiler is not paused.
+[[nodiscard]] inline bool profiler_is_active_and_unpaused() {
+ return baseprofiler::detail::RacyFeatures::IsActiveAndUnpaused();
+}
+
+// Is the profiler active and unpaused, and is the current thread being
+// profiled? (Same caveats and recommented usage as profiler_is_active().)
+[[nodiscard]] inline bool profiler_thread_is_being_profiled() {
+ return baseprofiler::detail::RacyFeatures::IsActiveAndUnpaused() &&
+ baseprofiler::detail::IsThreadBeingProfiled();
+}
+
+// Is the profiler active and paused? Returns false if the profiler is inactive.
+[[nodiscard]] MFBT_API bool profiler_is_paused();
+
+// Is the profiler active and sampling is paused? Returns false if the profiler
+// is inactive.
+[[nodiscard]] MFBT_API bool profiler_is_sampling_paused();
+
+// Is the current thread sleeping?
+[[nodiscard]] MFBT_API bool profiler_thread_is_sleeping();
+
+// Get all the features supported by the profiler that are accepted by
+// profiler_start(). The result is the same whether the profiler is active or
+// not.
+[[nodiscard]] MFBT_API uint32_t profiler_get_available_features();
+
+// Returns the full feature set if the profiler is active.
+// Note: the return value can become immediately out-of-date, much like the
+// return value of profiler_is_active().
+[[nodiscard]] inline mozilla::Maybe<uint32_t> profiler_features_if_active() {
+ return baseprofiler::detail::RacyFeatures::FeaturesIfActive();
+}
+
+// Check if a profiler feature (specified via the ProfilerFeature type) is
+// active. Returns false if the profiler is inactive. Note: the return value
+// can become immediately out-of-date, much like the return value of
+// profiler_is_active().
+[[nodiscard]] MFBT_API bool profiler_feature_active(uint32_t aFeature);
+
+// Check if the profiler is active without a feature (specified via the
+// ProfilerFeature type). Note: the return value can become immediately
+// out-of-date, much like the return value of profiler_is_active().
+[[nodiscard]] MFBT_API bool profiler_active_without_feature(uint32_t aFeature);
+
+// Returns true if any of the profiler mutexes are currently locked *on the
+// current thread*. This may be used by re-entrant code that may call profiler
+// functions while the same of a different profiler mutex is locked, which could
+// deadlock.
+[[nodiscard]] bool profiler_is_locked_on_current_thread();
+
+} // namespace mozilla::baseprofiler
+
+#endif // !MOZ_GECKO_PROFILER
+
+#endif // BaseProfilerState_h
diff --git a/mozglue/baseprofiler/public/BaseProfilerUtils.h b/mozglue/baseprofiler/public/BaseProfilerUtils.h
new file mode 100644
index 0000000000..ab02e03b95
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilerUtils.h
@@ -0,0 +1,227 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef BaseProfilerUtils_h
+#define BaseProfilerUtils_h
+
+// This header contains most process- and thread-related functions.
+// It is safe to include unconditionally.
+
+// --------------------------------------------- WASI process & thread ids
+#if defined(__wasi__)
+
+namespace mozilla::baseprofiler::detail {
+using ProcessIdType = unsigned;
+using ThreadIdType = unsigned;
+} // namespace mozilla::baseprofiler::detail
+
+// --------------------------------------------- Windows process & thread ids
+#elif defined(XP_WIN)
+
+namespace mozilla::baseprofiler::detail {
+using ProcessIdType = int;
+using ThreadIdType = unsigned long;
+} // namespace mozilla::baseprofiler::detail
+
+// --------------------------------------------- Non-Windows process id
+#else
+// All non-Windows platforms are assumed to be POSIX, which has getpid().
+
+# include <unistd.h>
+namespace mozilla::baseprofiler::detail {
+using ProcessIdType = decltype(getpid());
+} // namespace mozilla::baseprofiler::detail
+
+// --------------------------------------------- Non-Windows thread id
+// ------------------------------------------------------- macOS
+# if defined(XP_MACOSX)
+
+namespace mozilla::baseprofiler::detail {
+using ThreadIdType = uint64_t;
+} // namespace mozilla::baseprofiler::detail
+
+// ------------------------------------------------------- Android
+// Test Android before Linux, because Linux includes Android.
+# elif defined(__ANDROID__) || defined(ANDROID)
+
+# include <sys/types.h>
+namespace mozilla::baseprofiler::detail {
+using ThreadIdType = decltype(gettid());
+} // namespace mozilla::baseprofiler::detail
+
+// ------------------------------------------------------- Linux
+# elif defined(XP_LINUX)
+
+namespace mozilla::baseprofiler::detail {
+using ThreadIdType = long;
+} // namespace mozilla::baseprofiler::detail
+
+// ------------------------------------------------------- FreeBSD
+# elif defined(XP_FREEBSD)
+
+namespace mozilla::baseprofiler::detail {
+using ThreadIdType = long;
+} // namespace mozilla::baseprofiler::detail
+
+// ------------------------------------------------------- Others
+# else
+
+# include <thread>
+
+namespace mozilla::baseprofiler::detail {
+using ThreadIdType = std::thread::id;
+} // namespace mozilla::baseprofiler::detail
+
+# endif
+#endif // End of non-XP_WIN.
+
+#include <stdint.h>
+#include <string.h>
+#include <type_traits>
+
+namespace mozilla::baseprofiler {
+
+// Trivially-copyable class containing a process id. It may be left unspecified.
+class BaseProfilerProcessId {
+ public:
+ using NativeType = detail::ProcessIdType;
+
+ using NumberType =
+ std::conditional_t<(sizeof(NativeType) <= 4), uint32_t, uint64_t>;
+ static_assert(sizeof(NativeType) <= sizeof(NumberType));
+
+ // Unspecified process id.
+ constexpr BaseProfilerProcessId() = default;
+
+ [[nodiscard]] constexpr bool IsSpecified() const {
+ return mProcessId != scUnspecified;
+ }
+
+ // Construct from a native type.
+ [[nodiscard]] static BaseProfilerProcessId FromNativeId(
+ const NativeType& aNativeProcessId) {
+ BaseProfilerProcessId id;
+ // Convert trivially-copyable native id by copying its bits.
+ static_assert(std::is_trivially_copyable_v<NativeType>);
+ memcpy(&id.mProcessId, &aNativeProcessId, sizeof(NativeType));
+ return id;
+ }
+
+ // Get the process id as a number, which may be unspecified.
+ // This should only be used for serialization or logging.
+ [[nodiscard]] constexpr NumberType ToNumber() const { return mProcessId; }
+
+ // BaseProfilerProcessId from given number (which may be unspecified).
+ constexpr static BaseProfilerProcessId FromNumber(
+ const NumberType& aProcessId) {
+ BaseProfilerProcessId id;
+ id.mProcessId = aProcessId;
+ return id;
+ }
+
+ [[nodiscard]] constexpr bool operator==(
+ const BaseProfilerProcessId& aOther) const {
+ return mProcessId == aOther.mProcessId;
+ }
+ [[nodiscard]] constexpr bool operator!=(
+ const BaseProfilerProcessId& aOther) const {
+ return mProcessId != aOther.mProcessId;
+ }
+
+ private:
+ static constexpr NumberType scUnspecified = 0;
+ NumberType mProcessId = scUnspecified;
+};
+
+// Check traits. These should satisfy usage in std::atomic.
+static_assert(std::is_trivially_copyable_v<BaseProfilerProcessId>);
+static_assert(std::is_copy_constructible_v<BaseProfilerProcessId>);
+static_assert(std::is_move_constructible_v<BaseProfilerProcessId>);
+static_assert(std::is_copy_assignable_v<BaseProfilerProcessId>);
+static_assert(std::is_move_assignable_v<BaseProfilerProcessId>);
+
+// Trivially-copyable class containing a thread id. It may be left unspecified.
+class BaseProfilerThreadId {
+ public:
+ using NativeType = detail::ThreadIdType;
+
+ using NumberType =
+ std::conditional_t<(sizeof(NativeType) <= 4), uint32_t, uint64_t>;
+ static_assert(sizeof(NativeType) <= sizeof(NumberType));
+
+ // Unspecified thread id.
+ constexpr BaseProfilerThreadId() = default;
+
+ [[nodiscard]] constexpr bool IsSpecified() const {
+ return mThreadId != scUnspecified;
+ }
+
+ // Construct from a native type.
+ [[nodiscard]] static BaseProfilerThreadId FromNativeId(
+ const NativeType& aNativeThreadId) {
+ BaseProfilerThreadId id;
+ // Convert trivially-copyable native id by copying its bits.
+ static_assert(std::is_trivially_copyable_v<NativeType>);
+ memcpy(&id.mThreadId, &aNativeThreadId, sizeof(NativeType));
+ return id;
+ }
+
+ // Get the thread id as a number, which may be unspecified.
+ // This should only be used for serialization or logging.
+ [[nodiscard]] constexpr NumberType ToNumber() const { return mThreadId; }
+
+ // BaseProfilerThreadId from given number (which may be unspecified).
+ constexpr static BaseProfilerThreadId FromNumber(
+ const NumberType& aThreadId) {
+ BaseProfilerThreadId id;
+ id.mThreadId = aThreadId;
+ return id;
+ }
+
+ [[nodiscard]] constexpr bool operator==(
+ const BaseProfilerThreadId& aOther) const {
+ return mThreadId == aOther.mThreadId;
+ }
+ [[nodiscard]] constexpr bool operator!=(
+ const BaseProfilerThreadId& aOther) const {
+ return mThreadId != aOther.mThreadId;
+ }
+
+ private:
+ static constexpr NumberType scUnspecified = 0;
+ NumberType mThreadId = scUnspecified;
+};
+
+// Check traits. These should satisfy usage in std::atomic.
+static_assert(std::is_trivially_copyable_v<BaseProfilerThreadId>);
+static_assert(std::is_copy_constructible_v<BaseProfilerThreadId>);
+static_assert(std::is_move_constructible_v<BaseProfilerThreadId>);
+static_assert(std::is_copy_assignable_v<BaseProfilerThreadId>);
+static_assert(std::is_move_assignable_v<BaseProfilerThreadId>);
+
+} // namespace mozilla::baseprofiler
+
+#include "mozilla/Types.h"
+
+namespace mozilla::baseprofiler {
+
+// Get the current process's ID.
+[[nodiscard]] MFBT_API BaseProfilerProcessId profiler_current_process_id();
+
+// Get the current thread's ID.
+[[nodiscard]] MFBT_API BaseProfilerThreadId profiler_current_thread_id();
+
+// Must be called at least once from the main thread, before any other main-
+// thread id function.
+MFBT_API void profiler_init_main_thread_id();
+
+[[nodiscard]] MFBT_API BaseProfilerThreadId profiler_main_thread_id();
+
+[[nodiscard]] MFBT_API bool profiler_is_main_thread();
+
+} // namespace mozilla::baseprofiler
+
+#endif // BaseProfilerUtils_h
diff --git a/mozglue/baseprofiler/public/BaseProfilingCategory.h b/mozglue/baseprofiler/public/BaseProfilingCategory.h
new file mode 100644
index 0000000000..2e80950966
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilingCategory.h
@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ * 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 BaseProfilingCategory_h
+#define BaseProfilingCategory_h
+
+#include "mozilla/Types.h"
+
+#include <cstdint>
+
+#include "ProfilingCategoryList.h"
+
+namespace mozilla {
+namespace baseprofiler {
+
+// clang-format off
+
+// An enum that lists all possible category pairs in one list.
+// This is the enum that is used in profiler stack labels. Having one list that
+// includes subcategories from all categories in one list allows assigning the
+// category pair to a stack label with just one number.
+#define CATEGORY_ENUM_BEGIN_CATEGORY(name, labelAsString, color)
+#define CATEGORY_ENUM_SUBCATEGORY(supercategory, name, labelAsString) name,
+#define CATEGORY_ENUM_END_CATEGORY
+enum class ProfilingCategoryPair : uint32_t {
+ MOZ_PROFILING_CATEGORY_LIST(CATEGORY_ENUM_BEGIN_CATEGORY,
+ CATEGORY_ENUM_SUBCATEGORY,
+ CATEGORY_ENUM_END_CATEGORY)
+ COUNT,
+ LAST = COUNT - 1,
+};
+#undef CATEGORY_ENUM_BEGIN_CATEGORY
+#undef CATEGORY_ENUM_SUBCATEGORY
+#undef CATEGORY_ENUM_END_CATEGORY
+
+// An enum that lists just the categories without their subcategories.
+#define SUPERCATEGORY_ENUM_BEGIN_CATEGORY(name, labelAsString, color) name,
+#define SUPERCATEGORY_ENUM_SUBCATEGORY(supercategory, name, labelAsString)
+#define SUPERCATEGORY_ENUM_END_CATEGORY
+enum class ProfilingCategory : uint32_t {
+ MOZ_PROFILING_CATEGORY_LIST(SUPERCATEGORY_ENUM_BEGIN_CATEGORY,
+ SUPERCATEGORY_ENUM_SUBCATEGORY,
+ SUPERCATEGORY_ENUM_END_CATEGORY)
+ COUNT,
+ LAST = COUNT - 1,
+};
+#undef SUPERCATEGORY_ENUM_BEGIN_CATEGORY
+#undef SUPERCATEGORY_ENUM_SUBCATEGORY
+#undef SUPERCATEGORY_ENUM_END_CATEGORY
+
+// clang-format on
+
+struct ProfilingCategoryPairInfo {
+ ProfilingCategory mCategory;
+ uint32_t mSubcategoryIndex;
+ const char* mLabel;
+};
+
+MFBT_API const ProfilingCategoryPairInfo& GetProfilingCategoryPairInfo(
+ ProfilingCategoryPair aCategoryPair);
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif /* BaseProfilingCategory_h */
diff --git a/mozglue/baseprofiler/public/BaseProfilingStack.h b/mozglue/baseprofiler/public/BaseProfilingStack.h
new file mode 100644
index 0000000000..2e3781cf17
--- /dev/null
+++ b/mozglue/baseprofiler/public/BaseProfilingStack.h
@@ -0,0 +1,517 @@
+/* -*- 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/. */
+
+#ifndef BaseProfilingStack_h
+#define BaseProfilingStack_h
+
+#ifndef MOZ_GECKO_PROFILER
+# error Do not #include this header when MOZ_GECKO_PROFILER is not #defined.
+#endif
+
+#include "BaseProfilingCategory.h"
+
+#include "mozilla/Atomics.h"
+
+#include <stdint.h>
+
+// This file defines the classes ProfilingStack and ProfilingStackFrame.
+// The ProfilingStack manages an array of ProfilingStackFrames.
+// It keeps track of the "label stack" and the JS interpreter stack.
+// The two stack types are interleaved.
+//
+// Usage:
+//
+// ProfilingStack* profilingStack = ...;
+//
+// // For label frames:
+// profilingStack->pushLabelFrame(...);
+// // Execute some code. When finished, pop the frame:
+// profilingStack->pop();
+//
+// // For JS stack frames:
+// profilingStack->pushJSFrame(...);
+// // Execute some code. When finished, pop the frame:
+// profilingStack->pop();
+//
+//
+// Concurrency considerations
+//
+// A thread's profiling stack (and the frames inside it) is only modified by
+// that thread. However, the profiling stack can be *read* by a different
+// thread, the sampler thread: Whenever the profiler wants to sample a given
+// thread A, the following happens:
+// (1) Thread A is suspended.
+// (2) The sampler thread (thread S) reads the ProfilingStack of thread A,
+// including all ProfilingStackFrames that are currently in that stack
+// (profilingStack->frames[0..profilingStack->stackSize()]).
+// (3) Thread A is resumed.
+//
+// Thread suspension is achieved using platform-specific APIs; refer to each
+// platform's Sampler::SuspendAndSampleAndResumeThread implementation in
+// platform-*.cpp for details.
+//
+// When the thread is suspended, the values in profilingStack->stackPointer and
+// in the stack frame range
+// profilingStack->frames[0..profilingStack->stackPointer] need to be in a
+// consistent state, so that thread S does not read partially- constructed stack
+// frames. More specifically, we have two requirements:
+// (1) When adding a new frame at the top of the stack, its ProfilingStackFrame
+// data needs to be put in place *before* the stackPointer is incremented,
+// and the compiler + CPU need to know that this order matters.
+// (2) When popping an frame from the stack and then preparing the
+// ProfilingStackFrame data for the next frame that is about to be pushed,
+// the decrement of the stackPointer in pop() needs to happen *before* the
+// ProfilingStackFrame for the new frame is being popuplated, and the
+// compiler + CPU need to know that this order matters.
+//
+// We can express the relevance of these orderings in multiple ways.
+// Option A is to make stackPointer an atomic with SequentiallyConsistent
+// memory ordering. This would ensure that no writes in thread A would be
+// reordered across any writes to stackPointer, which satisfies requirements
+// (1) and (2) at the same time. Option A is the simplest.
+// Option B is to use ReleaseAcquire memory ordering both for writes to
+// stackPointer *and* for writes to ProfilingStackFrame fields. Release-stores
+// ensure that all writes that happened *before this write in program order* are
+// not reordered to happen after this write. ReleaseAcquire ordering places no
+// requirements on the ordering of writes that happen *after* this write in
+// program order.
+// Using release-stores for writes to stackPointer expresses requirement (1),
+// and using release-stores for writes to the ProfilingStackFrame fields
+// expresses requirement (2).
+//
+// Option B is more complicated than option A, but has much better performance
+// on x86/64: In a microbenchmark run on a Macbook Pro from 2017, switching
+// from option A to option B reduced the overhead of pushing+popping a
+// ProfilingStackFrame by 10 nanoseconds.
+// On x86/64, release-stores require no explicit hardware barriers or lock
+// instructions.
+// On ARM/64, option B may be slower than option A, because the compiler will
+// generate hardware barriers for every single release-store instead of just
+// for the writes to stackPointer. However, the actual performance impact of
+// this has not yet been measured on ARM, so we're currently using option B
+// everywhere. This is something that we may want to change in the future once
+// we've done measurements.
+
+namespace mozilla {
+namespace baseprofiler {
+
+// A call stack can be specified to the JS engine such that all JS entry/exits
+// to functions push/pop a stack frame to/from the specified stack.
+//
+// For more detailed information, see vm/GeckoProfiler.h.
+//
+class ProfilingStackFrame {
+ // A ProfilingStackFrame represents either a label frame or a JS frame.
+
+ // WARNING WARNING WARNING
+ //
+ // All the fields below are Atomic<...,ReleaseAcquire>. This is needed so
+ // that writes to these fields are release-writes, which ensures that
+ // earlier writes in this thread don't get reordered after the writes to
+ // these fields. In particular, the decrement of the stack pointer in
+ // ProfilingStack::pop() is a write that *must* happen before the values in
+ // this ProfilingStackFrame are changed. Otherwise, the sampler thread might
+ // see an inconsistent state where the stack pointer still points to a
+ // ProfilingStackFrame which has already been popped off the stack and whose
+ // fields have now been partially repopulated with new values.
+ // See the "Concurrency considerations" paragraph at the top of this file
+ // for more details.
+
+ // Descriptive label for this stack frame. Must be a static string! Can be
+ // an empty string, but not a null pointer.
+ Atomic<const char*, ReleaseAcquire> label_;
+
+ // An additional descriptive string of this frame which is combined with
+ // |label_| in profiler output. Need not be (and usually isn't) static. Can
+ // be null.
+ Atomic<const char*, ReleaseAcquire> dynamicString_;
+
+ // Stack pointer for non-JS stack frames, the script pointer otherwise.
+ Atomic<void*, ReleaseAcquire> spOrScript;
+
+ // ID of the JS Realm for JS stack frames.
+ // Must not be used on non-JS frames; it'll contain either the default 0,
+ // or a leftover value from a previous JS stack frame that was using this
+ // ProfilingStackFrame object.
+ mozilla::Atomic<uint64_t, mozilla::ReleaseAcquire> realmID_;
+
+ // The bytecode offset for JS stack frames.
+ // Must not be used on non-JS frames; it'll contain either the default 0,
+ // or a leftover value from a previous JS stack frame that was using this
+ // ProfilingStackFrame object.
+ Atomic<int32_t, ReleaseAcquire> pcOffsetIfJS_;
+
+ // Bits 0...8 hold the Flags. Bits 9...31 hold the category pair.
+ Atomic<uint32_t, ReleaseAcquire> flagsAndCategoryPair_;
+
+ public:
+ ProfilingStackFrame() = default;
+ ProfilingStackFrame& operator=(const ProfilingStackFrame& other) {
+ label_ = other.label();
+ dynamicString_ = other.dynamicString();
+ void* spScript = other.spOrScript;
+ spOrScript = spScript;
+ int32_t offsetIfJS = other.pcOffsetIfJS_;
+ pcOffsetIfJS_ = offsetIfJS;
+ int64_t realmID = other.realmID_;
+ realmID_ = realmID;
+ uint32_t flagsAndCategory = other.flagsAndCategoryPair_;
+ flagsAndCategoryPair_ = flagsAndCategory;
+ return *this;
+ }
+
+ // Reserve up to 16 bits for flags, and 16 for category pair.
+ enum class Flags : uint32_t {
+ // The first three flags describe the kind of the frame and are
+ // mutually exclusive. (We still give them individual bits for
+ // simplicity.)
+
+ // A regular label frame. These usually come from AutoProfilerLabel.
+ IS_LABEL_FRAME = 1 << 0,
+
+ // A special frame indicating the start of a run of JS profiling stack
+ // frames. IS_SP_MARKER_FRAME frames are ignored, except for the sp
+ // field. These frames are needed to get correct ordering between JS
+ // and LABEL frames because JS frames don't carry sp information.
+ // SP is short for "stack pointer".
+ IS_SP_MARKER_FRAME = 1 << 1,
+
+ // A JS frame.
+ IS_JS_FRAME = 1 << 2,
+
+ // An interpreter JS frame that has OSR-ed into baseline. IS_JS_FRAME
+ // frames can have this flag set and unset during their lifetime.
+ // JS_OSR frames are ignored.
+ JS_OSR = 1 << 3,
+
+ // The next three are mutually exclusive.
+ // By default, for profiling stack frames that have both a label and a
+ // dynamic string, the two strings are combined into one string of the
+ // form "<label> <dynamicString>" during JSON serialization. The
+ // following flags can be used to change this preset.
+ STRING_TEMPLATE_METHOD = 1 << 4, // "<label>.<dynamicString>"
+ STRING_TEMPLATE_GETTER = 1 << 5, // "get <label>.<dynamicString>"
+ STRING_TEMPLATE_SETTER = 1 << 6, // "set <label>.<dynamicString>"
+
+ // If set, causes this stack frame to be marked as "relevantForJS" in
+ // the profile JSON, which will make it show up in the "JS only" call
+ // tree view.
+ RELEVANT_FOR_JS = 1 << 7,
+
+ // If set, causes the label on this ProfilingStackFrame to be ignored
+ // and to be replaced by the subcategory's label.
+ LABEL_DETERMINED_BY_CATEGORY_PAIR = 1 << 8,
+
+ // Frame dynamic string does not contain user data.
+ NONSENSITIVE = 1 << 9,
+
+ // A JS Baseline Interpreter frame.
+ IS_BLINTERP_FRAME = 1 << 10,
+
+ FLAGS_BITCOUNT = 16,
+ FLAGS_MASK = (1 << FLAGS_BITCOUNT) - 1
+ };
+
+ static_assert(
+ uint32_t(ProfilingCategoryPair::LAST) <=
+ (UINT32_MAX >> uint32_t(Flags::FLAGS_BITCOUNT)),
+ "Too many category pairs to fit into u32 with together with the "
+ "reserved bits for the flags");
+
+ bool isLabelFrame() const {
+ return uint32_t(flagsAndCategoryPair_) & uint32_t(Flags::IS_LABEL_FRAME);
+ }
+
+ bool isSpMarkerFrame() const {
+ return uint32_t(flagsAndCategoryPair_) &
+ uint32_t(Flags::IS_SP_MARKER_FRAME);
+ }
+
+ bool isJsFrame() const {
+ return uint32_t(flagsAndCategoryPair_) & uint32_t(Flags::IS_JS_FRAME);
+ }
+
+ bool isOSRFrame() const {
+ return uint32_t(flagsAndCategoryPair_) & uint32_t(Flags::JS_OSR);
+ }
+
+ void setIsOSRFrame(bool isOSR) {
+ if (isOSR) {
+ flagsAndCategoryPair_ =
+ uint32_t(flagsAndCategoryPair_) | uint32_t(Flags::JS_OSR);
+ } else {
+ flagsAndCategoryPair_ =
+ uint32_t(flagsAndCategoryPair_) & ~uint32_t(Flags::JS_OSR);
+ }
+ }
+
+ const char* label() const {
+ uint32_t flagsAndCategoryPair = flagsAndCategoryPair_;
+ if (flagsAndCategoryPair &
+ uint32_t(Flags::LABEL_DETERMINED_BY_CATEGORY_PAIR)) {
+ auto categoryPair = ProfilingCategoryPair(
+ flagsAndCategoryPair >> uint32_t(Flags::FLAGS_BITCOUNT));
+ return GetProfilingCategoryPairInfo(categoryPair).mLabel;
+ }
+ return label_;
+ }
+
+ const char* dynamicString() const { return dynamicString_; }
+
+ void initLabelFrame(const char* aLabel, const char* aDynamicString, void* sp,
+ ProfilingCategoryPair aCategoryPair, uint32_t aFlags) {
+ label_ = aLabel;
+ dynamicString_ = aDynamicString;
+ spOrScript = sp;
+ // pcOffsetIfJS_ is not set and must not be used on label frames.
+ flagsAndCategoryPair_ =
+ uint32_t(Flags::IS_LABEL_FRAME) |
+ (uint32_t(aCategoryPair) << uint32_t(Flags::FLAGS_BITCOUNT)) | aFlags;
+ MOZ_ASSERT(isLabelFrame());
+ }
+
+ void initSpMarkerFrame(void* sp) {
+ label_ = "";
+ dynamicString_ = nullptr;
+ spOrScript = sp;
+ // pcOffsetIfJS_ is not set and must not be used on sp marker frames.
+ flagsAndCategoryPair_ = uint32_t(Flags::IS_SP_MARKER_FRAME) |
+ (uint32_t(ProfilingCategoryPair::OTHER)
+ << uint32_t(Flags::FLAGS_BITCOUNT));
+ MOZ_ASSERT(isSpMarkerFrame());
+ }
+
+ void initJsFrame(const char* aLabel, const char* aDynamicString,
+ void* /* JSScript* */ aScript, int32_t aOffset,
+ uint64_t aRealmID) {
+ label_ = aLabel;
+ dynamicString_ = aDynamicString;
+ spOrScript = aScript;
+ pcOffsetIfJS_ = aOffset;
+ realmID_ = aRealmID;
+ flagsAndCategoryPair_ =
+ uint32_t(Flags::IS_JS_FRAME) | (uint32_t(ProfilingCategoryPair::JS)
+ << uint32_t(Flags::FLAGS_BITCOUNT));
+ MOZ_ASSERT(isJsFrame());
+ }
+
+ uint32_t flags() const {
+ return uint32_t(flagsAndCategoryPair_) & uint32_t(Flags::FLAGS_MASK);
+ }
+
+ ProfilingCategoryPair categoryPair() const {
+ return ProfilingCategoryPair(flagsAndCategoryPair_ >>
+ uint32_t(Flags::FLAGS_BITCOUNT));
+ }
+
+ uint64_t realmID() const { return realmID_; }
+
+ void* stackAddress() const {
+ MOZ_ASSERT(!isJsFrame());
+ return spOrScript;
+ }
+
+ // Note that the pointer returned might be invalid.
+ void* rawScript() const {
+ MOZ_ASSERT(isJsFrame());
+ return spOrScript;
+ }
+ void setRawScript(void* aScript) {
+ MOZ_ASSERT(isJsFrame());
+ spOrScript = aScript;
+ }
+
+ int32_t pcOffset() const {
+ MOZ_ASSERT(isJsFrame());
+ return pcOffsetIfJS_;
+ }
+
+ void setPCOffset(int32_t aOffset) {
+ MOZ_ASSERT(isJsFrame());
+ pcOffsetIfJS_ = aOffset;
+ }
+
+ // The offset of a pc into a script's code can actually be 0, so to
+ // signify a nullptr pc, use a -1 index. This is checked against in
+ // pc() and setPC() to set/get the right pc.
+ static const int32_t NullPCOffset = -1;
+};
+
+// Each thread has its own ProfilingStack. That thread modifies the
+// ProfilingStack, pushing and popping elements as necessary.
+//
+// The ProfilingStack is also read periodically by the profiler's sampler
+// thread. This happens only when the thread that owns the ProfilingStack is
+// suspended. So there are no genuine parallel accesses.
+//
+// However, it is possible for pushing/popping to be interrupted by a periodic
+// sample. Because of this, we need pushing/popping to be effectively atomic.
+//
+// - When pushing a new frame, we increment the stack pointer -- making the new
+// frame visible to the sampler thread -- only after the new frame has been
+// fully written. The stack pointer is Atomic<uint32_t,ReleaseAcquire>, so
+// the increment is a release-store, which ensures that this store is not
+// reordered before the writes of the frame.
+//
+// - When popping an old frame, the only operation is the decrementing of the
+// stack pointer, which is obviously atomic.
+//
+class ProfilingStack final {
+ public:
+ ProfilingStack() = default;
+
+ MFBT_API ~ProfilingStack();
+
+ void pushLabelFrame(const char* label, const char* dynamicString, void* sp,
+ ProfilingCategoryPair categoryPair, uint32_t flags = 0) {
+ // This thread is the only one that ever changes the value of
+ // stackPointer.
+ // Store the value of the atomic in a non-atomic local variable so that
+ // the compiler won't generate two separate loads from the atomic for
+ // the size check and the frames[] array indexing operation.
+ uint32_t stackPointerVal = stackPointer;
+
+ if (MOZ_UNLIKELY(stackPointerVal >= capacity)) {
+ ensureCapacitySlow();
+ }
+ frames[stackPointerVal].initLabelFrame(label, dynamicString, sp,
+ categoryPair, flags);
+
+ // This must happen at the end! The compiler will not reorder this
+ // update because stackPointer is Atomic<..., ReleaseAcquire>, so any
+ // the writes above will not be reordered below the stackPointer store.
+ // Do the read and the write as two separate statements, in order to
+ // make it clear that we don't need an atomic increment, which would be
+ // more expensive on x86 than the separate operations done here.
+ // However, don't use stackPointerVal here; instead, allow the compiler
+ // to turn this store into a non-atomic increment instruction which
+ // takes up less code size.
+ stackPointer = stackPointer + 1;
+ }
+
+ void pushSpMarkerFrame(void* sp) {
+ uint32_t oldStackPointer = stackPointer;
+
+ if (MOZ_UNLIKELY(oldStackPointer >= capacity)) {
+ ensureCapacitySlow();
+ }
+ frames[oldStackPointer].initSpMarkerFrame(sp);
+
+ // This must happen at the end, see the comment in pushLabelFrame.
+ stackPointer = oldStackPointer + 1;
+ }
+
+ void pushJsOffsetFrame(const char* label, const char* dynamicString,
+ void* script, int32_t offset, uint64_t aRealmID) {
+ // This thread is the only one that ever changes the value of
+ // stackPointer. Only load the atomic once.
+ uint32_t oldStackPointer = stackPointer;
+
+ if (MOZ_UNLIKELY(oldStackPointer >= capacity)) {
+ ensureCapacitySlow();
+ }
+ frames[oldStackPointer].initJsFrame(label, dynamicString, script, offset,
+ aRealmID);
+
+ // This must happen at the end, see the comment in pushLabelFrame.
+ stackPointer = stackPointer + 1;
+ }
+
+ void pop() {
+ MOZ_ASSERT(stackPointer > 0);
+ // Do the read and the write as two separate statements, in order to
+ // make it clear that we don't need an atomic decrement, which would be
+ // more expensive on x86 than the separate operations done here.
+ // This thread is the only one that ever changes the value of
+ // stackPointer.
+ uint32_t oldStackPointer = stackPointer;
+ stackPointer = oldStackPointer - 1;
+ }
+
+ uint32_t stackSize() const { return stackPointer; }
+ uint32_t stackCapacity() const { return capacity; }
+
+ private:
+ // Out of line path for expanding the buffer, since otherwise this would get
+ // inlined in every DOM WebIDL call.
+ MFBT_API MOZ_COLD void ensureCapacitySlow();
+
+ // No copying.
+ ProfilingStack(const ProfilingStack&) = delete;
+ void operator=(const ProfilingStack&) = delete;
+
+ // No moving either.
+ ProfilingStack(ProfilingStack&&) = delete;
+ void operator=(ProfilingStack&&) = delete;
+
+ uint32_t capacity = 0;
+
+ public:
+ // The pointer to the stack frames, this is read from the profiler thread and
+ // written from the current thread.
+ //
+ // This is effectively a unique pointer.
+ Atomic<ProfilingStackFrame*, SequentiallyConsistent> frames{nullptr};
+
+ // This may exceed the capacity, so instead use the stackSize() method to
+ // determine the number of valid frames in stackFrames. When this is less
+ // than stackCapacity(), it refers to the first free stackframe past the top
+ // of the in-use stack (i.e. frames[stackPointer - 1] is the top stack
+ // frame).
+ //
+ // WARNING WARNING WARNING
+ //
+ // This is an atomic variable that uses ReleaseAcquire memory ordering.
+ // See the "Concurrency considerations" paragraph at the top of this file
+ // for more details.
+ Atomic<uint32_t, ReleaseAcquire> stackPointer{0};
+};
+
+class AutoGeckoProfilerEntry;
+class GeckoProfilerEntryMarker;
+class GeckoProfilerBaselineOSRMarker;
+
+class GeckoProfilerThread {
+ friend class AutoGeckoProfilerEntry;
+ friend class GeckoProfilerEntryMarker;
+ friend class GeckoProfilerBaselineOSRMarker;
+
+ ProfilingStack* profilingStack_;
+
+ // Same as profilingStack_ if the profiler is currently active, otherwise
+ // null.
+ ProfilingStack* profilingStackIfEnabled_;
+
+ public:
+ MFBT_API GeckoProfilerThread();
+
+ uint32_t stackPointer() {
+ MOZ_ASSERT(infraInstalled());
+ return profilingStack_->stackPointer;
+ }
+ ProfilingStackFrame* stack() { return profilingStack_->frames; }
+ ProfilingStack* getProfilingStack() { return profilingStack_; }
+ ProfilingStack* getProfilingStackIfEnabled() {
+ return profilingStackIfEnabled_;
+ }
+
+ /*
+ * True if the profiler infrastructure is setup. Should be true in builds
+ * that include profiler support except during early startup or late
+ * shutdown. Unrelated to the presence of the Gecko Profiler addon.
+ */
+ bool infraInstalled() { return profilingStack_ != nullptr; }
+
+ MFBT_API void setProfilingStack(ProfilingStack* profilingStack, bool enabled);
+ void enable(bool enable) {
+ profilingStackIfEnabled_ = enable ? profilingStack_ : nullptr;
+ }
+};
+
+} // namespace baseprofiler
+} // namespace mozilla
+
+#endif /* BaseProfilingStack_h */
diff --git a/mozglue/baseprofiler/public/BlocksRingBuffer.h b/mozglue/baseprofiler/public/BlocksRingBuffer.h
new file mode 100644
index 0000000000..32cbe6b93c
--- /dev/null
+++ b/mozglue/baseprofiler/public/BlocksRingBuffer.h
@@ -0,0 +1,999 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef BlocksRingBuffer_h
+#define BlocksRingBuffer_h
+
+#include "mozilla/BaseProfilerDetail.h"
+#include "mozilla/ModuloBuffer.h"
+#include "mozilla/ProfileBufferIndex.h"
+#include "mozilla/ScopeExit.h"
+
+#include <functional>
+#include <string>
+#include <tuple>
+#include <utility>
+
+namespace mozilla {
+
+// Thread-safe Ring buffer that can store blocks of different sizes during
+// defined sessions.
+// Each *block* contains an *entry* and the entry size:
+// [ entry_size | entry ] [ entry_size | entry ] ...
+// *In-session* is a period of time during which `BlocksRingBuffer` allows
+// reading and writing. *Out-of-session*, the `BlocksRingBuffer` object is
+// still valid, but contains no data, and gracefully denies accesses.
+//
+// To write an entry, the buffer reserves a block of sufficient size (to contain
+// user data of predetermined size), writes the entry size, and lets the caller
+// fill the entry contents using ModuloBuffer::Iterator APIs and a few entry-
+// specific APIs. E.g.:
+// ```
+// BlockRingsBuffer brb(PowerOfTwo<BlockRingsBuffer::Length>(1024));
+// brb.ReserveAndPut([]() { return sizeof(123); },
+// [&](ProfileBufferEntryWriter& aEW) {
+// aEW.WriteObject(123);
+// });
+// ```
+// Other `Put...` functions may be used as shortcuts for simple entries.
+// The objects given to the caller's callbacks should only be used inside the
+// callbacks and not stored elsewhere, because they keep their own references to
+// the BlocksRingBuffer and therefore should not live longer.
+// Different type of objects may be serialized into an entry, see `Serializer`
+// for more information.
+//
+// When reading data, the buffer iterates over blocks (it knows how to read the
+// entry size, and therefore move to the next block), and lets the caller read
+// the entry inside of each block. E.g.:
+// ```
+// brb.Read([](BlocksRingBuffer::Reader aR) {}
+// for (ProfileBufferEntryReader aER : aR) {
+// /* Use ProfileBufferEntryReader functions to read serialized objects. */
+// int n = aER.ReadObject<int>();
+// }
+// });
+// ```
+// Different type of objects may be deserialized from an entry, see
+// `Deserializer` for more information.
+//
+// The caller may retrieve the `ProfileBufferBlockIndex` corresponding to an
+// entry (`ProfileBufferBlockIndex` is an opaque type preventing the user from
+// modifying it). That index may later be used to get back to that particular
+// entry if it still exists.
+class BlocksRingBuffer {
+ public:
+ // Using ModuloBuffer as underlying circular byte buffer.
+ using Buffer = ModuloBuffer<uint32_t, ProfileBufferIndex>;
+ using Byte = Buffer::Byte;
+
+ // Length type for total buffer (as PowerOfTwo<Length>) and each entry.
+ using Length = uint32_t;
+
+ enum class ThreadSafety { WithoutMutex, WithMutex };
+
+ // Default constructor starts out-of-session (nothing to read or write).
+ explicit BlocksRingBuffer(ThreadSafety aThreadSafety)
+ : mMutex(aThreadSafety != ThreadSafety::WithoutMutex) {}
+
+ // Create a buffer of the given length.
+ explicit BlocksRingBuffer(ThreadSafety aThreadSafety,
+ PowerOfTwo<Length> aLength)
+ : mMutex(aThreadSafety != ThreadSafety::WithoutMutex),
+ mMaybeUnderlyingBuffer(Some(UnderlyingBuffer(aLength))) {}
+
+ // Take ownership of an existing buffer.
+ BlocksRingBuffer(ThreadSafety aThreadSafety,
+ UniquePtr<Buffer::Byte[]> aExistingBuffer,
+ PowerOfTwo<Length> aLength)
+ : mMutex(aThreadSafety != ThreadSafety::WithoutMutex),
+ mMaybeUnderlyingBuffer(
+ Some(UnderlyingBuffer(std::move(aExistingBuffer), aLength))) {}
+
+ // Use an externally-owned buffer.
+ BlocksRingBuffer(ThreadSafety aThreadSafety, Buffer::Byte* aExternalBuffer,
+ PowerOfTwo<Length> aLength)
+ : mMutex(aThreadSafety != ThreadSafety::WithoutMutex),
+ mMaybeUnderlyingBuffer(
+ Some(UnderlyingBuffer(aExternalBuffer, aLength))) {}
+
+ // Destructor doesn't need to do anything special. (Clearing entries would
+ // only update indices and stats, which won't be accessible after the object
+ // is destroyed anyway.)
+ ~BlocksRingBuffer() = default;
+
+ // Remove underlying buffer, if any.
+ void Reset() {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ ResetUnderlyingBuffer();
+ }
+
+ // Create a buffer of the given length.
+ void Set(PowerOfTwo<Length> aLength) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ ResetUnderlyingBuffer();
+ mMaybeUnderlyingBuffer.emplace(aLength);
+ }
+
+ // Take ownership of an existing buffer.
+ void Set(UniquePtr<Buffer::Byte[]> aExistingBuffer,
+ PowerOfTwo<Length> aLength) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ ResetUnderlyingBuffer();
+ mMaybeUnderlyingBuffer.emplace(std::move(aExistingBuffer), aLength);
+ }
+
+ // Use an externally-owned buffer.
+ void Set(Buffer::Byte* aExternalBuffer, PowerOfTwo<Length> aLength) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ ResetUnderlyingBuffer();
+ mMaybeUnderlyingBuffer.emplace(aExternalBuffer, aLength);
+ }
+
+ // This cannot change during the lifetime of this buffer, so there's no need
+ // to lock.
+ bool IsThreadSafe() const { return mMutex.IsActivated(); }
+
+ [[nodiscard]] bool IsInSession() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return !!mMaybeUnderlyingBuffer;
+ }
+
+ // Lock the buffer mutex and run the provided callback.
+ // This can be useful when the caller needs to explicitly lock down this
+ // buffer, but not do anything else with it.
+ template <typename Callback>
+ auto LockAndRun(Callback&& aCallback) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return std::forward<Callback>(aCallback)();
+ }
+
+ // Buffer length in bytes.
+ Maybe<PowerOfTwo<Length>> BufferLength() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return mMaybeUnderlyingBuffer.map([](const UnderlyingBuffer& aBuffer) {
+ return aBuffer.mBuffer.BufferLength();
+ });
+ ;
+ }
+
+ // Size of external resources.
+ size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+ if (!mMaybeUnderlyingBuffer) {
+ return 0;
+ }
+ return mMaybeUnderlyingBuffer->mBuffer.SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ // Snapshot of the buffer state.
+ struct State {
+ // Index to the first block.
+ ProfileBufferBlockIndex mRangeStart;
+
+ // Index past the last block. Equals mRangeStart if empty.
+ ProfileBufferBlockIndex mRangeEnd;
+
+ // Number of blocks that have been pushed into this buffer.
+ uint64_t mPushedBlockCount = 0;
+
+ // Number of blocks that have been removed from this buffer.
+ // Note: Live entries = pushed - cleared.
+ uint64_t mClearedBlockCount = 0;
+ };
+
+ // Get a snapshot of the current state.
+ // When out-of-session, mFirstReadIndex==mNextWriteIndex, and
+ // mPushedBlockCount==mClearedBlockCount==0.
+ // Note that these may change right after this thread-safe call, so they
+ // should only be used for statistical purposes.
+ State GetState() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return {
+ mFirstReadIndex, mNextWriteIndex,
+ mMaybeUnderlyingBuffer ? mMaybeUnderlyingBuffer->mPushedBlockCount : 0,
+ mMaybeUnderlyingBuffer ? mMaybeUnderlyingBuffer->mClearedBlockCount
+ : 0};
+ }
+
+ class Reader;
+
+ // Class that can iterate through blocks and provide
+ // `ProfileBufferEntryReader`s.
+ // Created through `Reader`, lives within a lock guard lifetime.
+ class BlockIterator {
+ public:
+#ifdef DEBUG
+ ~BlockIterator() {
+ // No BlockIterator should live outside of a mutexed call.
+ mRing->mMutex.AssertCurrentThreadOwns();
+ }
+#endif // DEBUG
+
+ // Comparison with other iterator, mostly used in range-for loops.
+ bool operator==(const BlockIterator aRhs) const {
+ MOZ_ASSERT(mRing == aRhs.mRing);
+ return mBlockIndex == aRhs.mBlockIndex;
+ }
+ bool operator!=(const BlockIterator aRhs) const {
+ MOZ_ASSERT(mRing == aRhs.mRing);
+ return mBlockIndex != aRhs.mBlockIndex;
+ }
+
+ // Advance to next BlockIterator.
+ BlockIterator& operator++() {
+ mBlockIndex = NextBlockIndex();
+ return *this;
+ }
+
+ // Dereferencing creates a `ProfileBufferEntryReader` for the entry inside
+ // this block.
+ ProfileBufferEntryReader operator*() const {
+ return mRing->ReaderInBlockAt(mBlockIndex);
+ }
+
+ // True if this iterator is just past the last entry.
+ bool IsAtEnd() const {
+ MOZ_ASSERT(mBlockIndex <= BufferRangeEnd());
+ return mBlockIndex == BufferRangeEnd();
+ }
+
+ // Can be used as reference to come back to this entry with `ReadAt()`.
+ ProfileBufferBlockIndex CurrentBlockIndex() const { return mBlockIndex; }
+
+ // Index past the end of this block, which is the start of the next block.
+ ProfileBufferBlockIndex NextBlockIndex() const {
+ MOZ_ASSERT(!IsAtEnd());
+ const Length entrySize =
+ mRing->ReaderInBlockAt(mBlockIndex).RemainingBytes();
+ return ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mBlockIndex.ConvertToProfileBufferIndex() + ULEB128Size(entrySize) +
+ entrySize);
+ }
+
+ // Index of the first block in the whole buffer.
+ ProfileBufferBlockIndex BufferRangeStart() const {
+ return mRing->mFirstReadIndex;
+ }
+
+ // Index past the last block in the whole buffer.
+ ProfileBufferBlockIndex BufferRangeEnd() const {
+ return mRing->mNextWriteIndex;
+ }
+
+ private:
+ // Only a Reader can instantiate a BlockIterator.
+ friend class Reader;
+
+ BlockIterator(const BlocksRingBuffer& aRing,
+ ProfileBufferBlockIndex aBlockIndex)
+ : mRing(WrapNotNull(&aRing)), mBlockIndex(aBlockIndex) {
+ // No BlockIterator should live outside of a mutexed call.
+ mRing->mMutex.AssertCurrentThreadOwns();
+ }
+
+ // Using a non-null pointer instead of a reference, to allow copying.
+ // This BlockIterator should only live inside one of the thread-safe
+ // BlocksRingBuffer functions, for this reference to stay valid.
+ NotNull<const BlocksRingBuffer*> mRing;
+ ProfileBufferBlockIndex mBlockIndex;
+ };
+
+ // Class that can create `BlockIterator`s (e.g., for range-for), or just
+ // iterate through entries; lives within a lock guard lifetime.
+ class MOZ_RAII Reader {
+ public:
+ Reader(const Reader&) = delete;
+ Reader& operator=(const Reader&) = delete;
+ Reader(Reader&&) = delete;
+ Reader& operator=(Reader&&) = delete;
+
+#ifdef DEBUG
+ ~Reader() {
+ // No Reader should live outside of a mutexed call.
+ mRing.mMutex.AssertCurrentThreadOwns();
+ }
+#endif // DEBUG
+
+ // Index of the first block in the whole buffer.
+ ProfileBufferBlockIndex BufferRangeStart() const {
+ return mRing.mFirstReadIndex;
+ }
+
+ // Index past the last block in the whole buffer.
+ ProfileBufferBlockIndex BufferRangeEnd() const {
+ return mRing.mNextWriteIndex;
+ }
+
+ // Iterators to the first and past-the-last blocks.
+ // Compatible with range-for (see `ForEach` below as example).
+ BlockIterator begin() const {
+ return BlockIterator(mRing, BufferRangeStart());
+ }
+ // Note that a `BlockIterator` at the `end()` should not be dereferenced, as
+ // there is no actual block there!
+ BlockIterator end() const { return BlockIterator(mRing, BufferRangeEnd()); }
+
+ // Get a `BlockIterator` at the given `ProfileBufferBlockIndex`, clamped to
+ // the stored range. Note that a `BlockIterator` at the `end()` should not
+ // be dereferenced, as there is no actual block there!
+ BlockIterator At(ProfileBufferBlockIndex aBlockIndex) const {
+ if (aBlockIndex < BufferRangeStart()) {
+ // Anything before the range (including null ProfileBufferBlockIndex) is
+ // clamped at the beginning.
+ return begin();
+ }
+ // Otherwise we at least expect the index to be valid (pointing exactly at
+ // a live block, or just past the end.)
+ mRing.AssertBlockIndexIsValidOrEnd(aBlockIndex);
+ return BlockIterator(mRing, aBlockIndex);
+ }
+
+ // Run `aCallback(ProfileBufferEntryReader&)` on each entry from first to
+ // last. Callback should not store `ProfileBufferEntryReader`, as it may
+ // become invalid after this thread-safe call.
+ template <typename Callback>
+ void ForEach(Callback&& aCallback) const {
+ for (ProfileBufferEntryReader reader : *this) {
+ aCallback(reader);
+ }
+ }
+
+ private:
+ friend class BlocksRingBuffer;
+
+ explicit Reader(const BlocksRingBuffer& aRing) : mRing(aRing) {
+ // No Reader should live outside of a mutexed call.
+ mRing.mMutex.AssertCurrentThreadOwns();
+ }
+
+ // This Reader should only live inside one of the thread-safe
+ // BlocksRingBuffer functions, for this reference to stay valid.
+ const BlocksRingBuffer& mRing;
+ };
+
+ // Call `aCallback(BlocksRingBuffer::Reader*)` (nullptr when out-of-session),
+ // and return whatever `aCallback` returns. Callback should not store
+ // `Reader`, because it may become invalid after this call.
+ template <typename Callback>
+ auto Read(Callback&& aCallback) const {
+ {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (MOZ_LIKELY(mMaybeUnderlyingBuffer)) {
+ Reader reader(*this);
+ return std::forward<Callback>(aCallback)(&reader);
+ }
+ }
+ return std::forward<Callback>(aCallback)(nullptr);
+ }
+
+ // Call `aCallback(ProfileBufferEntryReader&)` on each item.
+ // Callback should not store `ProfileBufferEntryReader`, because it may become
+ // invalid after this call.
+ template <typename Callback>
+ void ReadEach(Callback&& aCallback) const {
+ Read([&](Reader* aReader) {
+ if (MOZ_LIKELY(aReader)) {
+ aReader->ForEach(aCallback);
+ }
+ });
+ }
+
+ // Call `aCallback(Maybe<ProfileBufferEntryReader>&&)` on the entry at
+ // the given ProfileBufferBlockIndex; The `Maybe` will be `Nothing` if
+ // out-of-session, or if that entry doesn't exist anymore, or if we've reached
+ // just past the last entry. Return whatever `aCallback` returns. Callback
+ // should not store `ProfileBufferEntryReader`, because it may become invalid
+ // after this call.
+ template <typename Callback>
+ auto ReadAt(ProfileBufferBlockIndex aBlockIndex, Callback&& aCallback) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ MOZ_ASSERT(aBlockIndex <= mNextWriteIndex);
+ Maybe<ProfileBufferEntryReader> maybeEntryReader;
+ if (MOZ_LIKELY(mMaybeUnderlyingBuffer) && aBlockIndex >= mFirstReadIndex &&
+ aBlockIndex < mNextWriteIndex) {
+ AssertBlockIndexIsValid(aBlockIndex);
+ maybeEntryReader.emplace(ReaderInBlockAt(aBlockIndex));
+ }
+ return std::forward<Callback>(aCallback)(std::move(maybeEntryReader));
+ }
+
+ // Main function to write entries.
+ // Reserve `aCallbackBytes()` bytes, call `aCallback()` with a pointer to an
+ // on-stack temporary ProfileBufferEntryWriter (nullptr when out-of-session),
+ // and return whatever `aCallback` returns. Callback should not store
+ // `ProfileBufferEntryWriter`, because it may become invalid after this
+ // thread-safe call. Note: `aCallbackBytes` is a callback instead of a simple
+ // value, to delay this potentially-expensive computation until after we're
+ // checked that we're in-session; use `Put(Length, Callback)` below if you
+ // know the size already.
+ template <typename CallbackBytes, typename Callback>
+ auto ReserveAndPut(CallbackBytes aCallbackBytes, Callback&& aCallback) {
+ Maybe<ProfileBufferEntryWriter> maybeEntryWriter;
+
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+
+ if (MOZ_LIKELY(mMaybeUnderlyingBuffer)) {
+ const Length entryBytes = std::forward<CallbackBytes>(aCallbackBytes)();
+ MOZ_RELEASE_ASSERT(entryBytes > 0);
+ const Length bufferBytes =
+ mMaybeUnderlyingBuffer->mBuffer.BufferLength().Value();
+ MOZ_RELEASE_ASSERT(entryBytes <= bufferBytes - ULEB128Size(entryBytes),
+ "Entry would wrap and overwrite itself");
+ // Compute block size from the requested entry size.
+ const Length blockBytes = ULEB128Size(entryBytes) + entryBytes;
+ // We will put this new block at the end of the current buffer.
+ const ProfileBufferIndex blockIndex =
+ mNextWriteIndex.ConvertToProfileBufferIndex();
+ // Compute the end of this new block.
+ const ProfileBufferIndex blockEnd = blockIndex + blockBytes;
+ while (blockEnd >
+ mFirstReadIndex.ConvertToProfileBufferIndex() + bufferBytes) {
+ // About to trample on an old block.
+ ProfileBufferEntryReader reader = ReaderInBlockAt(mFirstReadIndex);
+ mMaybeUnderlyingBuffer->mClearedBlockCount += 1;
+ // Move the buffer reading start past this cleared block.
+ mFirstReadIndex = ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mFirstReadIndex.ConvertToProfileBufferIndex() +
+ ULEB128Size(reader.RemainingBytes()) + reader.RemainingBytes());
+ }
+ // Store the new end of buffer.
+ mNextWriteIndex =
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(blockEnd);
+ mMaybeUnderlyingBuffer->mPushedBlockCount += 1;
+ // Finally, let aCallback write into the entry.
+ mMaybeUnderlyingBuffer->mBuffer.EntryWriterFromTo(maybeEntryWriter,
+ blockIndex, blockEnd);
+ MOZ_ASSERT(maybeEntryWriter.isSome(),
+ "Non-empty entry should always create an EntryWriter");
+ maybeEntryWriter->WriteULEB128(entryBytes);
+ MOZ_ASSERT(maybeEntryWriter->RemainingBytes() == entryBytes);
+ }
+
+#ifdef DEBUG
+ auto checkAllWritten = MakeScopeExit([&]() {
+ MOZ_ASSERT(!maybeEntryWriter || maybeEntryWriter->RemainingBytes() == 0);
+ });
+#endif // DEBUG
+ return std::forward<Callback>(aCallback)(maybeEntryWriter);
+ }
+
+ // Add a new entry of known size, call `aCallback` with a pointer to a
+ // temporary ProfileBufferEntryWriter (can be null when out-of-session), and
+ // return whatever `aCallback` returns. Callback should not store the
+ // `ProfileBufferEntryWriter`, as it may become invalid after this thread-safe
+ // call.
+ template <typename Callback>
+ auto Put(Length aBytes, Callback&& aCallback) {
+ return ReserveAndPut([aBytes]() { return aBytes; },
+ std::forward<Callback>(aCallback));
+ }
+
+ // Add a new entry copied from the given buffer, return block index.
+ ProfileBufferBlockIndex PutFrom(const void* aSrc, Length aBytes) {
+ return ReserveAndPut([aBytes]() { return aBytes; },
+ [&](Maybe<ProfileBufferEntryWriter>& aEntryWriter) {
+ if (MOZ_UNLIKELY(aEntryWriter.isNothing())) {
+ // Out-of-session, return "empty" index.
+ return ProfileBufferBlockIndex{};
+ }
+ aEntryWriter->WriteBytes(aSrc, aBytes);
+ return aEntryWriter->CurrentBlockIndex();
+ });
+ }
+
+ // Add a new single entry with *all* given object (using a Serializer for
+ // each), return block index.
+ template <typename... Ts>
+ ProfileBufferBlockIndex PutObjects(const Ts&... aTs) {
+ static_assert(sizeof...(Ts) > 0,
+ "PutObjects must be given at least one object.");
+ return ReserveAndPut(
+ [&]() { return ProfileBufferEntryWriter::SumBytes(aTs...); },
+ [&](Maybe<ProfileBufferEntryWriter>& aEntryWriter) {
+ if (MOZ_UNLIKELY(aEntryWriter.isNothing())) {
+ // Out-of-session, return "empty" index.
+ return ProfileBufferBlockIndex{};
+ }
+ aEntryWriter->WriteObjects(aTs...);
+ return aEntryWriter->CurrentBlockIndex();
+ });
+ }
+
+ // Add a new entry copied from the given object, return block index.
+ template <typename T>
+ ProfileBufferBlockIndex PutObject(const T& aOb) {
+ return PutObjects(aOb);
+ }
+
+ // Append the contents of another BlocksRingBuffer to this one.
+ ProfileBufferBlockIndex AppendContents(const BlocksRingBuffer& aSrc) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+
+ if (MOZ_UNLIKELY(!mMaybeUnderlyingBuffer)) {
+ // We are out-of-session, could not append contents.
+ return ProfileBufferBlockIndex{};
+ }
+
+ baseprofiler::detail::BaseProfilerMaybeAutoLock srcLock(aSrc.mMutex);
+
+ if (MOZ_UNLIKELY(!aSrc.mMaybeUnderlyingBuffer)) {
+ // The other BRB is out-of-session, nothing to copy, we're done.
+ return ProfileBufferBlockIndex{};
+ }
+
+ const ProfileBufferIndex srcStartIndex =
+ aSrc.mFirstReadIndex.ConvertToProfileBufferIndex();
+ const ProfileBufferIndex srcEndIndex =
+ aSrc.mNextWriteIndex.ConvertToProfileBufferIndex();
+ const Length bytesToCopy = static_cast<Length>(srcEndIndex - srcStartIndex);
+
+ if (MOZ_UNLIKELY(bytesToCopy == 0)) {
+ // The other BRB is empty, nothing to copy, we're done.
+ return ProfileBufferBlockIndex{};
+ }
+
+ const Length bufferBytes =
+ mMaybeUnderlyingBuffer->mBuffer.BufferLength().Value();
+
+ MOZ_RELEASE_ASSERT(bytesToCopy <= bufferBytes,
+ "Entry would wrap and overwrite itself");
+
+ // We will put all copied blocks at the end of the current buffer.
+ const ProfileBufferIndex dstStartIndex =
+ mNextWriteIndex.ConvertToProfileBufferIndex();
+ // Compute where the copy will end...
+ const ProfileBufferIndex dstEndIndex = dstStartIndex + bytesToCopy;
+
+ while (dstEndIndex >
+ mFirstReadIndex.ConvertToProfileBufferIndex() + bufferBytes) {
+ // About to trample on an old block.
+ ProfileBufferEntryReader reader = ReaderInBlockAt(mFirstReadIndex);
+ mMaybeUnderlyingBuffer->mClearedBlockCount += 1;
+ // Move the buffer reading start past this cleared block.
+ mFirstReadIndex = ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mFirstReadIndex.ConvertToProfileBufferIndex() +
+ ULEB128Size(reader.RemainingBytes()) + reader.RemainingBytes());
+ }
+
+ // Store the new end of buffer.
+ mNextWriteIndex =
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(dstEndIndex);
+ // Update our pushed count with the number of live blocks we are copying.
+ mMaybeUnderlyingBuffer->mPushedBlockCount +=
+ aSrc.mMaybeUnderlyingBuffer->mPushedBlockCount -
+ aSrc.mMaybeUnderlyingBuffer->mClearedBlockCount;
+
+ auto reader = aSrc.mMaybeUnderlyingBuffer->mBuffer.EntryReaderFromTo(
+ srcStartIndex, srcEndIndex, nullptr, nullptr);
+ auto writer = mMaybeUnderlyingBuffer->mBuffer.EntryWriterFromTo(
+ dstStartIndex, dstEndIndex);
+ writer.WriteFromReader(reader, bytesToCopy);
+
+ return ProfileBufferBlockIndex::CreateFromProfileBufferIndex(dstStartIndex);
+ }
+
+ // Clear all entries: Move read index to the end so that these entries cannot
+ // be read anymore.
+ void Clear() {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ ClearAllEntries();
+ }
+
+ // Clear all entries strictly before aBlockIndex, and move read index to the
+ // end so that these entries cannot be read anymore.
+ void ClearBefore(ProfileBufferBlockIndex aBlockIndex) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (!mMaybeUnderlyingBuffer) {
+ return;
+ }
+ // Don't accept a not-yet-written index. One-past-the-end is ok.
+ MOZ_ASSERT(aBlockIndex <= mNextWriteIndex);
+ if (aBlockIndex <= mFirstReadIndex) {
+ // Already cleared.
+ return;
+ }
+ if (aBlockIndex == mNextWriteIndex) {
+ // Right past the end, just clear everything.
+ ClearAllEntries();
+ return;
+ }
+ // Otherwise we need to clear a subset of entries.
+ AssertBlockIndexIsValid(aBlockIndex);
+ // Just count skipped entries.
+ Reader reader(*this);
+ BlockIterator it = reader.begin();
+ for (; it.CurrentBlockIndex() < aBlockIndex; ++it) {
+ MOZ_ASSERT(it.CurrentBlockIndex() < reader.end().CurrentBlockIndex());
+ mMaybeUnderlyingBuffer->mClearedBlockCount += 1;
+ }
+ MOZ_ASSERT(it.CurrentBlockIndex() == aBlockIndex);
+ // Move read index to given index, so there's effectively no more entries
+ // before.
+ mFirstReadIndex = aBlockIndex;
+ }
+
+#ifdef DEBUG
+ void Dump() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (!mMaybeUnderlyingBuffer) {
+ printf("empty BlocksRingBuffer\n");
+ return;
+ }
+ using ULL = unsigned long long;
+ printf("start=%llu (%llu) end=%llu (%llu) - ",
+ ULL(mFirstReadIndex.ConvertToProfileBufferIndex()),
+ ULL(mFirstReadIndex.ConvertToProfileBufferIndex() &
+ (mMaybeUnderlyingBuffer->mBuffer.BufferLength().Value() - 1)),
+ ULL(mNextWriteIndex.ConvertToProfileBufferIndex()),
+ ULL(mNextWriteIndex.ConvertToProfileBufferIndex() &
+ (mMaybeUnderlyingBuffer->mBuffer.BufferLength().Value() - 1)));
+ mMaybeUnderlyingBuffer->mBuffer.Dump();
+ }
+#endif // DEBUG
+
+ private:
+ // In DEBUG mode, assert that `aBlockIndex` is a valid index for a live block.
+ // (Not just in range, but points exactly at the start of a block.)
+ // Slow, so avoid it for internal checks; this is more to check what callers
+ // provide us.
+ void AssertBlockIndexIsValid(ProfileBufferBlockIndex aBlockIndex) const {
+#ifdef DEBUG
+ mMutex.AssertCurrentThreadOwns();
+ MOZ_ASSERT(aBlockIndex >= mFirstReadIndex);
+ MOZ_ASSERT(aBlockIndex < mNextWriteIndex);
+ // Quick check (default), or slow check (change '1' to '0') below:
+# if 1
+ // Quick check that this looks like a valid block start.
+ // Read the entry size at the start of the block.
+ const Length entryBytes = ReaderInBlockAt(aBlockIndex).RemainingBytes();
+ MOZ_ASSERT(entryBytes > 0, "Empty entries are not allowed");
+ MOZ_ASSERT(
+ entryBytes < mMaybeUnderlyingBuffer->mBuffer.BufferLength().Value() -
+ ULEB128Size(entryBytes),
+ "Entry would wrap and overwrite itself");
+ // The end of the block should be inside the live buffer range.
+ MOZ_ASSERT(aBlockIndex.ConvertToProfileBufferIndex() +
+ ULEB128Size(entryBytes) + entryBytes <=
+ mNextWriteIndex.ConvertToProfileBufferIndex());
+# else
+ // Slow check that the index is really the start of the block.
+ // This kills performances, as it reads from the first index until
+ // aBlockIndex. Only use to debug issues locally.
+ Reader reader(*this);
+ BlockIterator it = reader.begin();
+ for (; it.CurrentBlockIndex() < aBlockIndex; ++it) {
+ MOZ_ASSERT(it.CurrentBlockIndex() < reader.end().CurrentBlockIndex());
+ }
+ MOZ_ASSERT(it.CurrentBlockIndex() == aBlockIndex);
+# endif
+#endif // DEBUG
+ }
+
+ // In DEBUG mode, assert that `aBlockIndex` is a valid index for a live block,
+ // or is just past-the-end. (Not just in range, but points exactly at the
+ // start of a block.) Slow, so avoid it for internal checks; this is more to
+ // check what callers provide us.
+ void AssertBlockIndexIsValidOrEnd(ProfileBufferBlockIndex aBlockIndex) const {
+#ifdef DEBUG
+ mMutex.AssertCurrentThreadOwns();
+ if (aBlockIndex == mNextWriteIndex) {
+ return;
+ }
+ AssertBlockIndexIsValid(aBlockIndex);
+#endif // DEBUG
+ }
+
+ // Create a reader for the block starting at aBlockIndex.
+ ProfileBufferEntryReader ReaderInBlockAt(
+ ProfileBufferBlockIndex aBlockIndex) const {
+ mMutex.AssertCurrentThreadOwns();
+ MOZ_ASSERT(mMaybeUnderlyingBuffer.isSome());
+ MOZ_ASSERT(aBlockIndex >= mFirstReadIndex);
+ MOZ_ASSERT(aBlockIndex < mNextWriteIndex);
+ // Create a reader from the given index until the end of the buffer.
+ ProfileBufferEntryReader reader =
+ mMaybeUnderlyingBuffer->mBuffer.EntryReaderFromTo(
+ aBlockIndex.ConvertToProfileBufferIndex(),
+ mNextWriteIndex.ConvertToProfileBufferIndex(), nullptr, nullptr);
+ // Read the block size at the beginning.
+ const Length entryBytes = reader.ReadULEB128<Length>();
+ // Make sure we don't overshoot the buffer.
+ MOZ_RELEASE_ASSERT(entryBytes <= reader.RemainingBytes());
+ ProfileBufferIndex nextBlockIndex =
+ aBlockIndex.ConvertToProfileBufferIndex() + ULEB128Size(entryBytes) +
+ entryBytes;
+ // And reduce the reader to the entry area. Only provide a next-block-index
+ // if it's not at the end of the buffer (i.e., there's an actual block
+ // there).
+ reader = mMaybeUnderlyingBuffer->mBuffer.EntryReaderFromTo(
+ aBlockIndex.ConvertToProfileBufferIndex() + ULEB128Size(entryBytes),
+ nextBlockIndex, aBlockIndex,
+ (nextBlockIndex < mNextWriteIndex.ConvertToProfileBufferIndex())
+ ? ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ nextBlockIndex)
+ : ProfileBufferBlockIndex{});
+ return reader;
+ }
+
+ ProfileBufferEntryReader FullBufferReader() const {
+ mMutex.AssertCurrentThreadOwns();
+ if (!mMaybeUnderlyingBuffer) {
+ return {};
+ }
+ return mMaybeUnderlyingBuffer->mBuffer.EntryReaderFromTo(
+ mFirstReadIndex.ConvertToProfileBufferIndex(),
+ mNextWriteIndex.ConvertToProfileBufferIndex(), nullptr, nullptr);
+ }
+
+ // Clear all entries: Move read index to the end so that these entries cannot
+ // be read anymore.
+ void ClearAllEntries() {
+ mMutex.AssertCurrentThreadOwns();
+ if (!mMaybeUnderlyingBuffer) {
+ return;
+ }
+ // Mark all entries pushed so far as cleared.
+ mMaybeUnderlyingBuffer->mClearedBlockCount =
+ mMaybeUnderlyingBuffer->mPushedBlockCount;
+ // Move read index to write index, so there's effectively no more entries
+ // that can be read. (Not setting both to 0, in case user is keeping
+ // `ProfileBufferBlockIndex`'es to old entries.)
+ mFirstReadIndex = mNextWriteIndex;
+ }
+
+ // If there is an underlying buffer, clear all entries, and discard the
+ // buffer. This BlocksRingBuffer will now gracefully reject all API calls, and
+ // is in a state where a new underlying buffer may be set.
+ void ResetUnderlyingBuffer() {
+ mMutex.AssertCurrentThreadOwns();
+ if (!mMaybeUnderlyingBuffer) {
+ return;
+ }
+ ClearAllEntries();
+ mMaybeUnderlyingBuffer.reset();
+ }
+
+ // Used to de/serialize a BlocksRingBuffer (e.g., containing a backtrace).
+ friend ProfileBufferEntryWriter::Serializer<BlocksRingBuffer>;
+ friend ProfileBufferEntryReader::Deserializer<BlocksRingBuffer>;
+ friend ProfileBufferEntryWriter::Serializer<UniquePtr<BlocksRingBuffer>>;
+ friend ProfileBufferEntryReader::Deserializer<UniquePtr<BlocksRingBuffer>>;
+
+ // Mutex guarding the following members.
+ mutable baseprofiler::detail::BaseProfilerMaybeMutex mMutex;
+
+ struct UnderlyingBuffer {
+ // Create a buffer of the given length.
+ explicit UnderlyingBuffer(PowerOfTwo<Length> aLength) : mBuffer(aLength) {
+ MOZ_ASSERT(aLength.Value() > ULEB128MaxSize<Length>(),
+ "Buffer should be able to contain more than a block size");
+ }
+
+ // Take ownership of an existing buffer.
+ UnderlyingBuffer(UniquePtr<Buffer::Byte[]> aExistingBuffer,
+ PowerOfTwo<Length> aLength)
+ : mBuffer(std::move(aExistingBuffer), aLength) {
+ MOZ_ASSERT(aLength.Value() > ULEB128MaxSize<Length>(),
+ "Buffer should be able to contain more than a block size");
+ }
+
+ // Use an externally-owned buffer.
+ UnderlyingBuffer(Buffer::Byte* aExternalBuffer, PowerOfTwo<Length> aLength)
+ : mBuffer(aExternalBuffer, aLength) {
+ MOZ_ASSERT(aLength.Value() > ULEB128MaxSize<Length>(),
+ "Buffer should be able to contain more than a block size");
+ }
+
+ // Only allow move-construction.
+ UnderlyingBuffer(UnderlyingBuffer&&) = default;
+
+ // Copies and move-assignment are explictly disallowed.
+ UnderlyingBuffer(const UnderlyingBuffer&) = delete;
+ UnderlyingBuffer& operator=(const UnderlyingBuffer&) = delete;
+ UnderlyingBuffer& operator=(UnderlyingBuffer&&) = delete;
+
+ // Underlying circular byte buffer.
+ Buffer mBuffer;
+
+ // Statistics.
+ uint64_t mPushedBlockCount = 0;
+ uint64_t mClearedBlockCount = 0;
+ };
+
+ // Underlying buffer, with stats.
+ // Only valid during in-session period.
+ Maybe<UnderlyingBuffer> mMaybeUnderlyingBuffer;
+
+ // Index to the first block to be read (or cleared). Initialized to 1 because
+ // 0 is reserved for the "empty" ProfileBufferBlockIndex value. Kept between
+ // sessions, so that stored indices from one session will be gracefully denied
+ // in future sessions.
+ ProfileBufferBlockIndex mFirstReadIndex =
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ ProfileBufferIndex(1));
+ // Index where the next new block should be allocated. Initialized to 1
+ // because 0 is reserved for the "empty" ProfileBufferBlockIndex value. Kept
+ // between sessions, so that stored indices from one session will be
+ // gracefully denied in future sessions.
+ ProfileBufferBlockIndex mNextWriteIndex =
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ ProfileBufferIndex(1));
+};
+
+// ----------------------------------------------------------------------------
+// BlocksRingBuffer serialization
+
+// A BlocksRingBuffer can hide another one!
+// This will be used to store marker backtraces; They can be read back into a
+// UniquePtr<BlocksRingBuffer>.
+// Format: len (ULEB128) | start | end | buffer (len bytes) | pushed | cleared
+// len==0 marks an out-of-session buffer, or empty buffer.
+template <>
+struct ProfileBufferEntryWriter::Serializer<BlocksRingBuffer> {
+ static Length Bytes(const BlocksRingBuffer& aBuffer) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(aBuffer.mMutex);
+ if (aBuffer.mMaybeUnderlyingBuffer.isNothing()) {
+ // Out-of-session, we only need 1 byte to store a length of 0.
+ return ULEB128Size<Length>(0);
+ }
+ const auto start = aBuffer.mFirstReadIndex.ConvertToProfileBufferIndex();
+ const auto end = aBuffer.mNextWriteIndex.ConvertToProfileBufferIndex();
+ const auto len = end - start;
+ if (len == 0) {
+ // In-session but empty, also store a length of 0.
+ return ULEB128Size<Length>(0);
+ }
+ return ULEB128Size(len) + sizeof(start) + sizeof(end) + len +
+ sizeof(aBuffer.mMaybeUnderlyingBuffer->mPushedBlockCount) +
+ sizeof(aBuffer.mMaybeUnderlyingBuffer->mClearedBlockCount);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const BlocksRingBuffer& aBuffer) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(aBuffer.mMutex);
+ if (aBuffer.mMaybeUnderlyingBuffer.isNothing()) {
+ // Out-of-session, only store a length of 0.
+ aEW.WriteULEB128<Length>(0);
+ return;
+ }
+ const auto start = aBuffer.mFirstReadIndex.ConvertToProfileBufferIndex();
+ const auto end = aBuffer.mNextWriteIndex.ConvertToProfileBufferIndex();
+ MOZ_ASSERT(end - start <= std::numeric_limits<Length>::max());
+ const auto len = static_cast<Length>(end - start);
+ if (len == 0) {
+ // In-session but empty, only store a length of 0.
+ aEW.WriteULEB128<Length>(0);
+ return;
+ }
+ // In-session.
+ // Store buffer length, start and end indices.
+ aEW.WriteULEB128<Length>(len);
+ aEW.WriteObject(start);
+ aEW.WriteObject(end);
+ // Write all the bytes.
+ auto reader = aBuffer.FullBufferReader();
+ aEW.WriteFromReader(reader, reader.RemainingBytes());
+ // And write stats.
+ aEW.WriteObject(aBuffer.mMaybeUnderlyingBuffer->mPushedBlockCount);
+ aEW.WriteObject(aBuffer.mMaybeUnderlyingBuffer->mClearedBlockCount);
+ }
+};
+
+// A serialized BlocksRingBuffer can be read into an empty buffer (either
+// out-of-session, or in-session with enough room).
+template <>
+struct ProfileBufferEntryReader::Deserializer<BlocksRingBuffer> {
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ BlocksRingBuffer& aBuffer) {
+ // Expect an empty buffer, as we're going to overwrite it.
+ MOZ_ASSERT(aBuffer.GetState().mRangeStart == aBuffer.GetState().mRangeEnd);
+ // Read the stored buffer length.
+ const auto len = aER.ReadULEB128<Length>();
+ if (len == 0) {
+ // 0-length means an "uninteresting" buffer, just return now.
+ return;
+ }
+ // We have a non-empty buffer to read.
+ if (aBuffer.BufferLength().isSome()) {
+ // Output buffer is in-session (i.e., it already has a memory buffer
+ // attached). Make sure the caller allocated enough space.
+ MOZ_RELEASE_ASSERT(aBuffer.BufferLength()->Value() >= len);
+ } else {
+ // Output buffer is out-of-session, attach a new memory buffer.
+ aBuffer.Set(PowerOfTwo<Length>(len));
+ MOZ_ASSERT(aBuffer.BufferLength()->Value() >= len);
+ }
+ // Read start and end indices.
+ const auto start = aER.ReadObject<ProfileBufferIndex>();
+ aBuffer.mFirstReadIndex =
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(start);
+ const auto end = aER.ReadObject<ProfileBufferIndex>();
+ aBuffer.mNextWriteIndex =
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(end);
+ MOZ_ASSERT(end - start == len);
+ // Copy bytes into the buffer.
+ auto writer =
+ aBuffer.mMaybeUnderlyingBuffer->mBuffer.EntryWriterFromTo(start, end);
+ writer.WriteFromReader(aER, end - start);
+ MOZ_ASSERT(writer.RemainingBytes() == 0);
+ // Finally copy stats.
+ aBuffer.mMaybeUnderlyingBuffer->mPushedBlockCount = aER.ReadObject<
+ decltype(aBuffer.mMaybeUnderlyingBuffer->mPushedBlockCount)>();
+ aBuffer.mMaybeUnderlyingBuffer->mClearedBlockCount = aER.ReadObject<
+ decltype(aBuffer.mMaybeUnderlyingBuffer->mClearedBlockCount)>();
+ }
+
+ // We cannot output a BlocksRingBuffer object (not copyable), use `ReadInto()`
+ // or `aER.ReadObject<UniquePtr<BlocksRinbBuffer>>()` instead.
+ static BlocksRingBuffer Read(ProfileBufferEntryReader& aER) = delete;
+};
+
+// A BlocksRingBuffer is usually refererenced through a UniquePtr, for
+// convenience we support (de)serializing that UniquePtr directly.
+// This is compatible with the non-UniquePtr serialization above, with a null
+// pointer being treated like an out-of-session or empty buffer; and any of
+// these would be deserialized into a null pointer.
+template <>
+struct ProfileBufferEntryWriter::Serializer<UniquePtr<BlocksRingBuffer>> {
+ static Length Bytes(const UniquePtr<BlocksRingBuffer>& aBufferUPtr) {
+ if (!aBufferUPtr) {
+ // Null pointer, treat it like an empty buffer, i.e., write length of 0.
+ return ULEB128Size<Length>(0);
+ }
+ // Otherwise write the pointed-at BlocksRingBuffer (which could be
+ // out-of-session or empty.)
+ return SumBytes(*aBufferUPtr);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const UniquePtr<BlocksRingBuffer>& aBufferUPtr) {
+ if (!aBufferUPtr) {
+ // Null pointer, treat it like an empty buffer, i.e., write length of 0.
+ aEW.WriteULEB128<Length>(0);
+ return;
+ }
+ // Otherwise write the pointed-at BlocksRingBuffer (which could be
+ // out-of-session or empty.)
+ aEW.WriteObject(*aBufferUPtr);
+ }
+};
+
+template <>
+struct ProfileBufferEntryReader::Deserializer<UniquePtr<BlocksRingBuffer>> {
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ UniquePtr<BlocksRingBuffer>& aBuffer) {
+ aBuffer = Read(aER);
+ }
+
+ static UniquePtr<BlocksRingBuffer> Read(ProfileBufferEntryReader& aER) {
+ UniquePtr<BlocksRingBuffer> bufferUPtr;
+ // Keep a copy of the reader before reading the length, so we can restart
+ // from here below.
+ ProfileBufferEntryReader readerBeforeLen = aER;
+ // Read the stored buffer length.
+ const auto len = aER.ReadULEB128<Length>();
+ if (len == 0) {
+ // 0-length means an "uninteresting" buffer, just return nullptr.
+ return bufferUPtr;
+ }
+ // We have a non-empty buffer.
+ // allocate an empty BlocksRingBuffer without mutex.
+ bufferUPtr = MakeUnique<BlocksRingBuffer>(
+ BlocksRingBuffer::ThreadSafety::WithoutMutex);
+ // Rewind the reader before the length and deserialize the contents, using
+ // the non-UniquePtr Deserializer.
+ aER = readerBeforeLen;
+ aER.ReadIntoObject(*bufferUPtr);
+ return bufferUPtr;
+ }
+};
+
+} // namespace mozilla
+
+#endif // BlocksRingBuffer_h
diff --git a/mozglue/baseprofiler/public/FailureLatch.h b/mozglue/baseprofiler/public/FailureLatch.h
new file mode 100644
index 0000000000..10205e009b
--- /dev/null
+++ b/mozglue/baseprofiler/public/FailureLatch.h
@@ -0,0 +1,217 @@
+/* -*- 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 header contains an interface `FailureLatch`, and some implementation
+// helpers that may be used across a range of classes and functions to handle
+// failures at any point during a process, and share that failure state so that
+// the process may gracefully stop quickly and report the first error.
+//
+// It could be thought as a replacement for C++ exceptions, but it's less strong
+// (cancellations may be delayed).
+// Now, if possible, mozilla::Result may be a better option as C++ exceptions
+// replacement, as it is more visible in all affected functions.
+// Consider FailureLatch if failures may happen in different places, but where
+// `return`ing this potential failure from all functions would be too arduous.
+
+#ifndef mozilla_FailureLatch_h
+#define mozilla_FailureLatch_h
+
+#include <mozilla/Assertions.h>
+
+#include <string>
+
+namespace mozilla {
+
+// ----------------------------------------------------------------------------
+// Main interface
+// ----------------------------------------------------------------------------
+
+// Interface handling a failure latch (starting in a successful state, the first
+// failure gets recorded, subsequent failures are ignored.)
+class FailureLatch {
+ public:
+ virtual ~FailureLatch() = default;
+
+ // Can this ever fail? (This may influence how some code deals with
+ // failures, e.g., if infallible, OOMs should assert&crash.)
+ [[nodiscard]] virtual bool Fallible() const = 0;
+
+ // Set latch in its failed state because of an external cause.
+ // The first call sets the reason, subsequent calls are ignored.
+ virtual void SetFailure(std::string aReason) = 0;
+
+ // Has there been any failure so far?
+ [[nodiscard]] virtual bool Failed() const = 0;
+
+ // Return first failure string, may be null if not failed yet.
+ [[nodiscard]] virtual const char* GetFailure() const = 0;
+
+ // Retrieve the one source FailureLatch. It could reference `*this`!
+ // This may be used by dependent proxy FailureLatch'es to find where to
+ // redirect calls.
+ [[nodiscard]] virtual const FailureLatch& SourceFailureLatch() const = 0;
+ [[nodiscard]] virtual FailureLatch& SourceFailureLatch() = 0;
+
+ // Non-virtual helpers.
+
+ // Transfer any failure from another FailureLatch.
+ void SetFailureFrom(const FailureLatch& aOther) {
+ if (Failed()) {
+ return;
+ }
+ if (const char* otherFailure = aOther.GetFailure(); otherFailure) {
+ SetFailure(otherFailure);
+ }
+ }
+};
+
+// ----------------------------------------------------------------------------
+// Concrete implementations
+// ----------------------------------------------------------------------------
+
+// Concrete infallible FailureLatch class.
+// Any `SetFailure` leads to an assert-crash, so the final runtime result can
+// always be assumed to be succesful.
+class FailureLatchInfallibleSource final : public FailureLatch {
+ public:
+ [[nodiscard]] bool Fallible() const final { return false; }
+
+ void SetFailure(std::string aReason) final {
+ MOZ_RELEASE_ASSERT(false,
+ "SetFailure in infallible FailureLatchInfallibleSource");
+ }
+
+ [[nodiscard]] bool Failed() const final { return false; }
+
+ [[nodiscard]] const char* GetFailure() const final { return nullptr; }
+
+ [[nodiscard]] const ::mozilla::FailureLatch& SourceFailureLatch()
+ const final {
+ return *this;
+ }
+
+ [[nodiscard]] ::mozilla::FailureLatch& SourceFailureLatch() final {
+ return *this;
+ }
+
+ // Singleton FailureLatchInfallibleSource that may be used as default
+ // FailureLatch proxy.
+ static FailureLatchInfallibleSource& Singleton() {
+ static FailureLatchInfallibleSource singleton;
+ return singleton;
+ }
+};
+
+// Concrete FailureLatch class, intended to be intantiated as an object shared
+// between classes and functions that are part of a long operation, so that
+// failures can happen anywhere and be visible everywhere.
+// Not thread-safe.
+class FailureLatchSource final : public FailureLatch {
+ public:
+ [[nodiscard]] bool Fallible() const final { return true; }
+
+ void SetFailure(std::string aReason) final {
+ if (!mFailed) {
+ mFailed = true;
+ mReason = std::move(aReason);
+ }
+ }
+
+ [[nodiscard]] bool Failed() const final { return mFailed; }
+
+ [[nodiscard]] const char* GetFailure() const final {
+ return mFailed ? mReason.c_str() : nullptr;
+ }
+
+ [[nodiscard]] const FailureLatch& SourceFailureLatch() const final {
+ return *this;
+ }
+
+ [[nodiscard]] FailureLatch& SourceFailureLatch() final { return *this; }
+
+ private:
+ bool mFailed = false;
+ std::string mReason;
+};
+
+// ----------------------------------------------------------------------------
+// Helper macros, to be used in FailureLatch-derived classes
+// ----------------------------------------------------------------------------
+
+// Classes deriving from FailureLatch can use this to forward virtual calls to
+// another FailureLatch.
+#define FAILURELATCH_IMPL_PROXY(FAILURELATCH_REF) \
+ [[nodiscard]] bool Fallible() const final { \
+ return static_cast<const ::mozilla::FailureLatch&>(FAILURELATCH_REF) \
+ .Fallible(); \
+ } \
+ void SetFailure(std::string aReason) final { \
+ static_cast<::mozilla::FailureLatch&>(FAILURELATCH_REF) \
+ .SetFailure(std::move(aReason)); \
+ } \
+ [[nodiscard]] bool Failed() const final { \
+ return static_cast<const ::mozilla::FailureLatch&>(FAILURELATCH_REF) \
+ .Failed(); \
+ } \
+ [[nodiscard]] const char* GetFailure() const final { \
+ return static_cast<const ::mozilla::FailureLatch&>(FAILURELATCH_REF) \
+ .GetFailure(); \
+ } \
+ [[nodiscard]] const FailureLatch& SourceFailureLatch() const final { \
+ return static_cast<const ::mozilla::FailureLatch&>(FAILURELATCH_REF) \
+ .SourceFailureLatch(); \
+ } \
+ [[nodiscard]] FailureLatch& SourceFailureLatch() final { \
+ return static_cast<::mozilla::FailureLatch&>(FAILURELATCH_REF) \
+ .SourceFailureLatch(); \
+ }
+
+// Classes deriving from FailureLatch can use this to forward virtual calls to
+// another FailureLatch through a pointer, unless it's null in which case act
+// like an infallible FailureLatch.
+#define FAILURELATCH_IMPL_PROXY_OR_INFALLIBLE(FAILURELATCH_PTR, CLASS_NAME) \
+ [[nodiscard]] bool Fallible() const final { \
+ return FAILURELATCH_PTR \
+ ? static_cast<const ::mozilla::FailureLatch*>(FAILURELATCH_PTR) \
+ ->Fallible() \
+ : false; \
+ } \
+ void SetFailure(std::string aReason) final { \
+ if (FAILURELATCH_PTR) { \
+ static_cast<::mozilla::FailureLatch*>(FAILURELATCH_PTR) \
+ ->SetFailure(std::move(aReason)); \
+ } else { \
+ MOZ_RELEASE_ASSERT(false, "SetFailure in infallible " #CLASS_NAME); \
+ } \
+ } \
+ [[nodiscard]] bool Failed() const final { \
+ return FAILURELATCH_PTR \
+ ? static_cast<const ::mozilla::FailureLatch*>(FAILURELATCH_PTR) \
+ ->Failed() \
+ : false; \
+ } \
+ [[nodiscard]] const char* GetFailure() const final { \
+ return FAILURELATCH_PTR \
+ ? static_cast<const ::mozilla::FailureLatch*>(FAILURELATCH_PTR) \
+ ->GetFailure() \
+ : nullptr; \
+ } \
+ [[nodiscard]] const FailureLatch& SourceFailureLatch() const final { \
+ return FAILURELATCH_PTR \
+ ? static_cast<const ::mozilla::FailureLatch*>(FAILURELATCH_PTR) \
+ ->SourceFailureLatch() \
+ : ::mozilla::FailureLatchInfallibleSource::Singleton(); \
+ } \
+ [[nodiscard]] FailureLatch& SourceFailureLatch() final { \
+ return FAILURELATCH_PTR \
+ ? static_cast<::mozilla::FailureLatch*>(FAILURELATCH_PTR) \
+ ->SourceFailureLatch() \
+ : ::mozilla::FailureLatchInfallibleSource::Singleton(); \
+ }
+
+} // namespace mozilla
+
+#endif /* mozilla_FailureLatch_h */
diff --git a/mozglue/baseprofiler/public/ModuloBuffer.h b/mozglue/baseprofiler/public/ModuloBuffer.h
new file mode 100644
index 0000000000..80e765279e
--- /dev/null
+++ b/mozglue/baseprofiler/public/ModuloBuffer.h
@@ -0,0 +1,618 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ModuloBuffer_h
+#define ModuloBuffer_h
+
+#include "mozilla/leb128iterator.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/PowerOfTwo.h"
+#include "mozilla/ProfileBufferEntrySerialization.h"
+#include "mozilla/UniquePtr.h"
+
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <type_traits>
+
+namespace mozilla {
+
+// The ModuloBuffer class is a circular buffer that holds raw byte values, with
+// data-read/write helpers.
+//
+// OffsetT: Type of the internal offset into the buffer of bytes, it should be
+// large enough to access all bytes of the buffer. It will also be used as
+// Length (in bytes) of the buffer and of any subset. Default uint32_t
+// IndexT: Type of the external index, it should be large enough that overflows
+// should not happen during the lifetime of the ModuloBuffer.
+//
+// The basic usage is to create an iterator-like object with `ReaderAt(Index)`
+// or `WriterAt(Index)`, and use it to read/write data blobs. Iterators
+// automatically manage the wrap-around (through "Modulo", which is effectively
+// an AND-masking with the PowerOfTwo buffer size.)
+//
+// There is zero safety: No thread safety, no checks that iterators may be
+// overwriting data that's still to be read, etc. It's up to the caller to add
+// adequate checks.
+// The intended use is as an underlying buffer for a safer container.
+template <typename OffsetT = uint32_t, typename IndexT = uint64_t>
+class ModuloBuffer {
+ public:
+ using Byte = uint8_t;
+ static_assert(sizeof(Byte) == 1, "ModuloBuffer::Byte must be 1 byte");
+ using Offset = OffsetT;
+ static_assert(!std::numeric_limits<Offset>::is_signed,
+ "ModuloBuffer::Offset must be an unsigned integral type");
+ using Length = Offset;
+ using Index = IndexT;
+ static_assert(!std::numeric_limits<Index>::is_signed,
+ "ModuloBuffer::Index must be an unsigned integral type");
+ static_assert(sizeof(Index) >= sizeof(Offset),
+ "ModuloBuffer::Index size must >= Offset");
+
+ // Create a buffer of the given length.
+ explicit ModuloBuffer(PowerOfTwo<Length> aLength)
+ : mMask(aLength.Mask()),
+ mBuffer(WrapNotNull(new Byte[aLength.Value()])),
+ mBufferDeleter([](Byte* aBuffer) { delete[] aBuffer; }) {}
+
+ // Take ownership of an existing buffer. Existing contents is ignored.
+ // Done by extracting the raw pointer from UniquePtr<Byte[]>, and adding
+ // an equivalent `delete[]` in `mBufferDeleter`.
+ ModuloBuffer(UniquePtr<Byte[]> aExistingBuffer, PowerOfTwo<Length> aLength)
+ : mMask(aLength.Mask()),
+ mBuffer(WrapNotNull(aExistingBuffer.release())),
+ mBufferDeleter([](Byte* aBuffer) { delete[] aBuffer; }) {}
+
+ // Use an externally-owned buffer. Existing contents is ignored.
+ ModuloBuffer(Byte* aExternalBuffer, PowerOfTwo<Length> aLength)
+ : mMask(aLength.Mask()), mBuffer(WrapNotNull(aExternalBuffer)) {}
+
+ // Disallow copying, as we may uniquely own the resource.
+ ModuloBuffer(const ModuloBuffer& aOther) = delete;
+ ModuloBuffer& operator=(const ModuloBuffer& aOther) = delete;
+
+ // Allow move-construction. Stealing ownership if the original had it.
+ // This effectively prevents copy construction, and all assignments; needed so
+ // that a ModuloBuffer may be initialized from a separate construction.
+ // The moved-from ModuloBuffer still points at the resource but doesn't own
+ // it, so it won't try to free it; but accesses are not guaranteed, so it
+ // should not be used anymore.
+ ModuloBuffer(ModuloBuffer&& aOther)
+ : mMask(std::move(aOther.mMask)),
+ mBuffer(std::move(aOther.mBuffer)),
+ mBufferDeleter(std::move(aOther.mBufferDeleter)) {
+ // The above move leaves `aOther.mBufferDeleter` in a valid state but with
+ // an unspecified value, so it could theoretically still contain the
+ // original function, which would be bad because we don't want aOther to
+ // delete the resource that `this` now owns.
+ if (aOther.mBufferDeleter) {
+ // `aOther` still had a non-empty deleter, reset it.
+ aOther.mBufferDeleter = nullptr;
+ }
+ }
+
+ // Disallow assignment, as we have some `const` members.
+ ModuloBuffer& operator=(ModuloBuffer&& aOther) = delete;
+
+ // Destructor, deletes the resource if we uniquely own it.
+ ~ModuloBuffer() {
+ if (mBufferDeleter) {
+ mBufferDeleter(mBuffer);
+ }
+ }
+
+ PowerOfTwo<Length> BufferLength() const {
+ return PowerOfTwo<Length>(mMask.MaskValue() + 1);
+ }
+
+ // Size of external resources.
+ // Note: `mBufferDeleter`'s potential external data (for its captures) is not
+ // included, as it's hidden in the `std::function` implementation.
+ size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+ if (!mBufferDeleter) {
+ // If we don't have a buffer deleter, assume we don't own the data, so
+ // it's probably on the stack, or should be reported by its owner.
+ return 0;
+ }
+ return aMallocSizeOf(mBuffer);
+ }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ ProfileBufferEntryReader EntryReaderFromTo(
+ Index aStart, Index aEnd, ProfileBufferBlockIndex aBlockIndex,
+ ProfileBufferBlockIndex aNextBlockIndex) const {
+ using EntrySpan = Span<const ProfileBufferEntryReader::Byte>;
+ if (aStart == aEnd) {
+ return ProfileBufferEntryReader{};
+ }
+ // Don't allow over-wrapping.
+ MOZ_ASSERT(aEnd - aStart <= mMask.MaskValue() + 1);
+ // Start offset in 0 .. (buffer size - 1)
+ Offset start = static_cast<Offset>(aStart) & mMask;
+ // End offset in 1 .. (buffer size)
+ Offset end = (static_cast<Offset>(aEnd - 1) & mMask) + 1;
+ if (start < end) {
+ // Segment doesn't cross buffer threshold, one span is enough.
+ return ProfileBufferEntryReader{EntrySpan(&mBuffer[start], end - start),
+ aBlockIndex, aNextBlockIndex};
+ }
+ // Segment crosses buffer threshold, we need one span until the end and one
+ // span restarting at the beginning of the buffer.
+ return ProfileBufferEntryReader{
+ EntrySpan(&mBuffer[start], mMask.MaskValue() + 1 - start),
+ EntrySpan(&mBuffer[0], end), aBlockIndex, aNextBlockIndex};
+ }
+
+ // Return an entry writer for the given range.
+ ProfileBufferEntryWriter EntryWriterFromTo(Index aStart, Index aEnd) const {
+ using EntrySpan = Span<ProfileBufferEntryReader::Byte>;
+ if (aStart == aEnd) {
+ return ProfileBufferEntryWriter{};
+ }
+ MOZ_ASSERT(aEnd - aStart <= mMask.MaskValue() + 1);
+ // Start offset in 0 .. (buffer size - 1)
+ Offset start = static_cast<Offset>(aStart) & mMask;
+ // End offset in 1 .. (buffer size)
+ Offset end = (static_cast<Offset>(aEnd - 1) & mMask) + 1;
+ if (start < end) {
+ // Segment doesn't cross buffer threshold, one span is enough.
+ return ProfileBufferEntryWriter{
+ EntrySpan(&mBuffer[start], end - start),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(aStart),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(aEnd)};
+ }
+ // Segment crosses buffer threshold, we need one span until the end and one
+ // span restarting at the beginning of the buffer.
+ return ProfileBufferEntryWriter{
+ EntrySpan(&mBuffer[start], mMask.MaskValue() + 1 - start),
+ EntrySpan(&mBuffer[0], end),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(aStart),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(aEnd)};
+ }
+
+ // Emplace an entry writer into `aMaybeEntryWriter` for the given range.
+ void EntryWriterFromTo(Maybe<ProfileBufferEntryWriter>& aMaybeEntryWriter,
+ Index aStart, Index aEnd) const {
+ MOZ_ASSERT(aMaybeEntryWriter.isNothing(),
+ "Reference entry writer should be Nothing.");
+ using EntrySpan = Span<ProfileBufferEntryReader::Byte>;
+ if (aStart == aEnd) {
+ return;
+ }
+ MOZ_ASSERT(aEnd - aStart <= mMask.MaskValue() + 1);
+ // Start offset in 0 .. (buffer size - 1)
+ Offset start = static_cast<Offset>(aStart) & mMask;
+ // End offset in 1 .. (buffer size)
+ Offset end = (static_cast<Offset>(aEnd - 1) & mMask) + 1;
+ if (start < end) {
+ // Segment doesn't cross buffer threshold, one span is enough.
+ aMaybeEntryWriter.emplace(
+ EntrySpan(&mBuffer[start], end - start),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(aStart),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(aEnd));
+ } else {
+ // Segment crosses buffer threshold, we need one span until the end and
+ // one span restarting at the beginning of the buffer.
+ aMaybeEntryWriter.emplace(
+ EntrySpan(&mBuffer[start], mMask.MaskValue() + 1 - start),
+ EntrySpan(&mBuffer[0], end),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(aStart),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(aEnd));
+ }
+ }
+
+ // All ModuloBuffer operations should be done through this iterator, which has
+ // an effectively infinite range. The underlying wrapping-around is hidden.
+ // Use `ReaderAt(Index)` or `WriterAt(Index)` to create it.
+ //
+ // `const Iterator<...>` means the iterator itself cannot change, i.e., it
+ // cannot move, and only its const methods are available. Note that these
+ // const methods may still be used to modify the buffer contents (e.g.:
+ // `operator*()`, `Poke()`).
+ //
+ // `Iterator</*IsBufferConst=*/true>` means the buffer contents cannot be
+ // modified, i.e., write operations are forbidden, but the iterator may still
+ // move if non-const itself.
+ template <bool IsBufferConst>
+ class Iterator {
+ // Alias to const- or mutable-`ModuloBuffer` depending on `IsBufferConst`.
+ using ConstOrMutableBuffer =
+ std::conditional_t<IsBufferConst, const ModuloBuffer, ModuloBuffer>;
+
+ // Implementation note about the strange enable-if's below:
+ // `template <bool NotIBC = !IsBufferConst> enable_if_t<NotIBC>`
+ // which intuitively could be simplified to:
+ // `enable_if_t<!IsBufferConst>`
+ // The former extra-templated syntax is in fact necessary to delay
+ // instantiation of these functions until they are actually needed.
+ //
+ // If we were just doing `enable_if_t<!IsBufferConst>`, this would only
+ // depend on the *class* (`ModuloBuffer<...>::Iterator`), which gets
+ // instantiated when a `ModuloBuffer` is created with some template
+ // arguments; at that point, all non-templated methods get instantiated, so
+ // there's no "SFINAE" happening, and `enable_if_t<...>` is actually doing
+ // `typename enable_if<...>::type` on the spot, but there is no `type` if
+ // `IsBufferConst` is true, so it just fails right away. E.g.:
+ // error: no type named 'type' in 'std::enable_if<false, void>';
+ // 'enable_if' cannot be used to disable this declaration
+ // note: in instantiation of template type alias 'enable_if_t'
+ // > std::enable_if_t<!IsBufferConst> WriteObject(const T& aObject) {
+ // in instantiation of template class
+ // 'mozilla::ModuloBuffer<...>::Iterator<true>'
+ // > auto it = mb.ReaderAt(1);
+ //
+ // By adding another template level `template <bool NotIsBufferConst =
+ // !IsBufferConst>`, the instantiation is delayed until the function is
+ // actually invoked somewhere, e.g. `it.Poke(...);`.
+ // So at that invocation point, the compiler looks for a "Poke" name in it,
+ // and considers potential template instantiations that could work. The
+ // `enable_if_t` is *now* attempted, with `NotIsBufferConst` taking its
+ // value from `!IsBufferConst`:
+ // - If `IsBufferConst` is false, `NotIsBufferConst` is true,
+ // `enable_if<NotIsBufferConst>` does define a `type` (`void` by default),
+ // so `enable_if_t` happily becomes `void`, the function exists and may be
+ // called.
+ // - Otherwise if `IsBufferConst` is true, `NotIsBufferConst` is false,
+ // `enable_if<NotIsBufferConst>` does *not* define a `type`, therefore
+ // `enable_if_t` produces an error because there is no `type`. Now "SFINAE"
+ // happens: This "Substitution Failure Is Not An Error" (by itself)... But
+ // then, there are no other functions named "Poke" as requested in the
+ // `it.Poke(...);` call, so we are now getting an error (can't find
+ // function), as expected because `it` had `IsBufferConst`==true. (But at
+ // least the compiler waited until this invocation attempt before outputting
+ // an error.)
+ //
+ // C++ is fun!
+
+ public:
+ // These definitions are expected by std functions, to recognize this as an
+ // iterator. See https://en.cppreference.com/w/cpp/iterator/iterator_traits
+ using difference_type = Index;
+ using value_type = Byte;
+ using pointer = std::conditional_t<IsBufferConst, const Byte*, Byte*>;
+ using reference = std::conditional_t<IsBufferConst, const Byte&, Byte&>;
+ using iterator_category = std::random_access_iterator_tag;
+
+ // Can always copy/assign from the same kind of iterator.
+ Iterator(const Iterator& aRhs) = default;
+ Iterator& operator=(const Iterator& aRhs) = default;
+
+ // Can implicitly copy an Iterator-to-mutable (reader+writer) to
+ // Iterator-to-const (reader-only), but not the reverse.
+ template <bool IsRhsBufferConst,
+ typename = std::enable_if_t<(!IsRhsBufferConst) && IsBufferConst>>
+ MOZ_IMPLICIT Iterator(const Iterator<IsRhsBufferConst>& aRhs)
+ : mModuloBuffer(aRhs.mModuloBuffer), mIndex(aRhs.mIndex) {}
+
+ // Can implicitly assign from an Iterator-to-mutable (reader+writer) to
+ // Iterator-to-const (reader-only), but not the reverse.
+ template <bool IsRhsBufferConst,
+ typename = std::enable_if_t<(!IsRhsBufferConst) && IsBufferConst>>
+ Iterator& operator=(const Iterator<IsRhsBufferConst>& aRhs) {
+ mModuloBuffer = aRhs.mModuloBuffer;
+ mIndex = aRhs.mIndex;
+ return *this;
+ }
+
+ // Current location of the iterator in the `Index` range.
+ // Note that due to wrapping, multiple indices may effectively point at the
+ // same byte in the buffer.
+ Index CurrentIndex() const { return mIndex; }
+
+ // Location comparison in the `Index` range. I.e., two `Iterator`s may look
+ // unequal, but refer to the same buffer location.
+ // Must be on the same buffer.
+ bool operator==(const Iterator& aRhs) const {
+ MOZ_ASSERT(mModuloBuffer == aRhs.mModuloBuffer);
+ return mIndex == aRhs.mIndex;
+ }
+ bool operator!=(const Iterator& aRhs) const {
+ MOZ_ASSERT(mModuloBuffer == aRhs.mModuloBuffer);
+ return mIndex != aRhs.mIndex;
+ }
+ bool operator<(const Iterator& aRhs) const {
+ MOZ_ASSERT(mModuloBuffer == aRhs.mModuloBuffer);
+ return mIndex < aRhs.mIndex;
+ }
+ bool operator<=(const Iterator& aRhs) const {
+ MOZ_ASSERT(mModuloBuffer == aRhs.mModuloBuffer);
+ return mIndex <= aRhs.mIndex;
+ }
+ bool operator>(const Iterator& aRhs) const {
+ MOZ_ASSERT(mModuloBuffer == aRhs.mModuloBuffer);
+ return mIndex > aRhs.mIndex;
+ }
+ bool operator>=(const Iterator& aRhs) const {
+ MOZ_ASSERT(mModuloBuffer == aRhs.mModuloBuffer);
+ return mIndex >= aRhs.mIndex;
+ }
+
+ // Movement in the `Index` range.
+ Iterator& operator++() {
+ ++mIndex;
+ return *this;
+ }
+ Iterator operator++(int) {
+ Iterator here(*mModuloBuffer, mIndex);
+ ++mIndex;
+ return here;
+ }
+ Iterator& operator--() {
+ --mIndex;
+ return *this;
+ }
+ Iterator operator--(int) {
+ Iterator here(*mModuloBuffer, mIndex);
+ --mIndex;
+ return here;
+ }
+ Iterator& operator+=(Length aLength) {
+ mIndex += aLength;
+ return *this;
+ }
+ Iterator operator+(Length aLength) const {
+ return Iterator(*mModuloBuffer, mIndex + aLength);
+ }
+ friend Iterator operator+(Length aLength, const Iterator& aIt) {
+ return aIt + aLength;
+ }
+ Iterator& operator-=(Length aLength) {
+ mIndex -= aLength;
+ return *this;
+ }
+ Iterator operator-(Length aLength) const {
+ return Iterator(*mModuloBuffer, mIndex - aLength);
+ }
+
+ // Distance from `aRef` to here in the `Index` range.
+ // May be negative (as 2's complement) if `aRef > *this`.
+ Index operator-(const Iterator& aRef) const {
+ MOZ_ASSERT(mModuloBuffer == aRef.mModuloBuffer);
+ return mIndex - aRef.mIndex;
+ }
+
+ // Dereference a single byte (read-only if `IsBufferConst` is true).
+ reference operator*() const {
+ return mModuloBuffer->mBuffer[OffsetInBuffer()];
+ }
+
+ // Random-access dereference.
+ reference operator[](Length aLength) const { return *(*this + aLength); }
+
+ // Write data (if `IsBufferConst` is false) but don't move iterator.
+ template <bool NotIsBufferConst = !IsBufferConst>
+ std::enable_if_t<NotIsBufferConst> Poke(const void* aSrc,
+ Length aLength) const {
+ // Don't allow data larger than the buffer.
+ MOZ_ASSERT(aLength <= mModuloBuffer->BufferLength().Value());
+ // Offset inside the buffer (corresponding to our Index).
+ Offset offset = OffsetInBuffer();
+ // Compute remaining bytes between this offset and the end of the buffer.
+ Length remaining = mModuloBuffer->BufferLength().Value() - offset;
+ if (MOZ_LIKELY(remaining >= aLength)) {
+ // Enough space to write everything before the end.
+ memcpy(&mModuloBuffer->mBuffer[offset], aSrc, aLength);
+ } else {
+ // Not enough space. Write as much as possible before the end.
+ memcpy(&mModuloBuffer->mBuffer[offset], aSrc, remaining);
+ // And then continue from the beginning of the buffer.
+ memcpy(&mModuloBuffer->mBuffer[0],
+ static_cast<const Byte*>(aSrc) + remaining,
+ (aLength - remaining));
+ }
+ }
+
+ // Write object data (if `IsBufferConst` is false) but don't move iterator.
+ // Note that this copies bytes from the object, with the intent to read them
+ // back later. Restricted to trivially-copyable types, which support this
+ // without Undefined Behavior!
+ template <typename T, bool NotIsBufferConst = !IsBufferConst>
+ std::enable_if_t<NotIsBufferConst> PokeObject(const T& aObject) const {
+ static_assert(std::is_trivially_copyable<T>::value,
+ "PokeObject<T> - T must be trivially copyable");
+ return Poke(&aObject, sizeof(T));
+ }
+
+ // Write data (if `IsBufferConst` is false) and move iterator ahead.
+ template <bool NotIsBufferConst = !IsBufferConst>
+ std::enable_if_t<NotIsBufferConst> Write(const void* aSrc, Length aLength) {
+ Poke(aSrc, aLength);
+ mIndex += aLength;
+ }
+
+ // Write object data (if `IsBufferConst` is false) and move iterator ahead.
+ // Note that this copies bytes from the object, with the intent to read them
+ // back later. Restricted to trivially-copyable types, which support this
+ // without Undefined Behavior!
+ template <typename T, bool NotIsBufferConst = !IsBufferConst>
+ std::enable_if_t<NotIsBufferConst> WriteObject(const T& aObject) {
+ static_assert(std::is_trivially_copyable<T>::value,
+ "WriteObject<T> - T must be trivially copyable");
+ return Write(&aObject, sizeof(T));
+ }
+
+ // Number of bytes needed to represent `aValue` in unsigned LEB128.
+ template <typename T>
+ static unsigned ULEB128Size(T aValue) {
+ return ::mozilla::ULEB128Size(aValue);
+ }
+
+ // Write number as unsigned LEB128 (if `IsBufferConst` is false) and move
+ // iterator ahead.
+ template <typename T, bool NotIsBufferConst = !IsBufferConst>
+ std::enable_if_t<NotIsBufferConst> WriteULEB128(T aValue) {
+ ::mozilla::WriteULEB128(aValue, *this);
+ }
+
+ // Read data but don't move iterator.
+ void Peek(void* aDst, Length aLength) const {
+ // Don't allow data larger than the buffer.
+ MOZ_ASSERT(aLength <= mModuloBuffer->BufferLength().Value());
+ // Offset inside the buffer (corresponding to our Index).
+ Offset offset = OffsetInBuffer();
+ // Compute remaining bytes between this offset and the end of the buffer.
+ Length remaining = mModuloBuffer->BufferLength().Value() - offset;
+ if (MOZ_LIKELY(remaining >= aLength)) {
+ // Can read everything we need before the end of the buffer.
+ memcpy(aDst, &mModuloBuffer->mBuffer[offset], aLength);
+ } else {
+ // Read as much as possible before the end of the buffer.
+ memcpy(aDst, &mModuloBuffer->mBuffer[offset], remaining);
+ // And then continue from the beginning of the buffer.
+ memcpy(static_cast<Byte*>(aDst) + remaining, &mModuloBuffer->mBuffer[0],
+ (aLength - remaining));
+ }
+ }
+
+ // Read data into an object but don't move iterator.
+ // Note that this overwrites `aObject` with bytes from the buffer.
+ // Restricted to trivially-copyable types, which support this without
+ // Undefined Behavior!
+ template <typename T>
+ void PeekIntoObject(T& aObject) const {
+ static_assert(std::is_trivially_copyable<T>::value,
+ "PeekIntoObject<T> - T must be trivially copyable");
+ Peek(&aObject, sizeof(T));
+ }
+
+ // Read data as an object but don't move iterator.
+ // Note that this creates an default `T` first, and then overwrites it with
+ // bytes from the buffer. Restricted to trivially-copyable types, which
+ // support this without Undefined Behavior!
+ template <typename T>
+ T PeekObject() const {
+ static_assert(std::is_trivially_copyable<T>::value,
+ "PeekObject<T> - T must be trivially copyable");
+ T object;
+ PeekIntoObject(object);
+ return object;
+ }
+
+ // Read data and move iterator ahead.
+ void Read(void* aDst, Length aLength) {
+ Peek(aDst, aLength);
+ mIndex += aLength;
+ }
+
+ // Read data into a mutable iterator and move both iterators ahead.
+ void ReadInto(Iterator</* IsBufferConst */ false>& aDst, Length aLength) {
+ // Don't allow data larger than the buffer.
+ MOZ_ASSERT(aLength <= mModuloBuffer->BufferLength().Value());
+ MOZ_ASSERT(aLength <= aDst.mModuloBuffer->BufferLength().Value());
+ // Offset inside the buffer (corresponding to our Index).
+ Offset offset = OffsetInBuffer();
+ // Compute remaining bytes between this offset and the end of the buffer.
+ Length remaining = mModuloBuffer->BufferLength().Value() - offset;
+ if (MOZ_LIKELY(remaining >= aLength)) {
+ // Can read everything we need before the end of the buffer.
+ aDst.Write(&mModuloBuffer->mBuffer[offset], aLength);
+ } else {
+ // Read as much as possible before the end of the buffer.
+ aDst.Write(&mModuloBuffer->mBuffer[offset], remaining);
+ // And then continue from the beginning of the buffer.
+ aDst.Write(&mModuloBuffer->mBuffer[0], (aLength - remaining));
+ }
+ mIndex += aLength;
+ }
+
+ // Read data into an object and move iterator ahead.
+ // Note that this overwrites `aObject` with bytes from the buffer.
+ // Restricted to trivially-copyable types, which support this without
+ // Undefined Behavior!
+ template <typename T>
+ void ReadIntoObject(T& aObject) {
+ static_assert(std::is_trivially_copyable<T>::value,
+ "ReadIntoObject<T> - T must be trivially copyable");
+ Read(&aObject, sizeof(T));
+ }
+
+ // Read data as an object and move iterator ahead.
+ // Note that this creates an default `T` first, and then overwrites it with
+ // bytes from the buffer. Restricted to trivially-copyable types, which
+ // support this without Undefined Behavior!
+ template <typename T>
+ T ReadObject() {
+ static_assert(std::is_trivially_copyable<T>::value,
+ "ReadObject<T> - T must be trivially copyable");
+ T object;
+ ReadIntoObject(object);
+ return object;
+ }
+
+ // Read an unsigned LEB128 number and move iterator ahead.
+ template <typename T>
+ T ReadULEB128() {
+ return ::mozilla::ReadULEB128<T>(*this);
+ }
+
+ private:
+ // Only a ModuloBuffer can instantiate its iterator.
+ friend class ModuloBuffer;
+
+ Iterator(ConstOrMutableBuffer& aBuffer, Index aIndex)
+ : mModuloBuffer(WrapNotNull(&aBuffer)), mIndex(aIndex) {}
+
+ // Convert the Iterator's mIndex into an offset inside the byte buffer.
+ Offset OffsetInBuffer() const {
+ return static_cast<Offset>(mIndex) & mModuloBuffer->mMask;
+ }
+
+ // ModuloBuffer that this Iterator operates on.
+ // Using a non-null pointer instead of a reference, to allow re-assignment
+ // of an Iterator variable.
+ NotNull<ConstOrMutableBuffer*> mModuloBuffer;
+
+ // Position of this iterator in the wider `Index` range. (Will be wrapped
+ // around as needed when actually accessing bytes from the buffer.)
+ Index mIndex;
+ };
+
+ // Shortcut to iterator to const (read-only) data.
+ using Reader = Iterator<true>;
+ // Shortcut to iterator to non-const (read/write) data.
+ using Writer = Iterator<false>;
+
+ // Create an iterator to const data at the given index.
+ Reader ReaderAt(Index aIndex) const { return Reader(*this, aIndex); }
+
+ // Create an iterator to non-const data at the given index.
+ Writer WriterAt(Index aIndex) { return Writer(*this, aIndex); }
+
+#ifdef DEBUG
+ void Dump() const {
+ Length len = BufferLength().Value();
+ if (len > 128) {
+ len = 128;
+ }
+ for (Length i = 0; i < len; ++i) {
+ printf("%02x ", mBuffer[i]);
+ }
+ printf("\n");
+ }
+#endif // DEBUG
+
+ private:
+ // Mask used to convert an index to an offset in `mBuffer`
+ const PowerOfTwoMask<Offset> mMask;
+
+ // Buffer data. `const NotNull<...>` shows that `mBuffer is `const`, and
+ // `Byte* const` shows that the pointer cannot be changed to point at
+ // something else, but the pointed-at `Byte`s are writable.
+ const NotNull<Byte* const> mBuffer;
+
+ // Function used to release the buffer resource (if needed).
+ std::function<void(Byte*)> mBufferDeleter;
+};
+
+} // namespace mozilla
+
+#endif // ModuloBuffer_h
diff --git a/mozglue/baseprofiler/public/PowerOfTwo.h b/mozglue/baseprofiler/public/PowerOfTwo.h
new file mode 100644
index 0000000000..7d396c15e6
--- /dev/null
+++ b/mozglue/baseprofiler/public/PowerOfTwo.h
@@ -0,0 +1,322 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+// PowerOfTwo is a value type that always hold a power of 2.
+// It has the same size as their underlying unsigned type, but offer the
+// guarantee of being a power of 2, which permits some optimizations when
+// involved in modulo operations (using masking instead of actual modulo).
+//
+// PowerOfTwoMask contains a mask corresponding to a power of 2.
+// E.g., 2^8 is 256 or 0x100, the corresponding mask is 2^8-1 or 255 or 0xFF.
+// It should be used instead of PowerOfTwo in situations where most operations
+// would be modulo, this saves having to recompute the mask from the stored
+// power of 2.
+//
+// One common use would be for ring-buffer containers with a power-of-2 size,
+// where an index is usually converted to an in-buffer offset by `i % size`.
+// Instead, the container could store a PowerOfTwo or PowerOfTwoMask, and do
+// `i % p2` or `i & p2m`, which is more efficient than for arbitrary sizes.
+//
+// Shortcuts for common 32- and 64-bit values: PowerOfTwo32, etc.
+//
+// To create constexpr constants, use MakePowerOfTwo<Type, Value>(), etc.
+
+#ifndef PowerOfTwo_h
+#define PowerOfTwo_h
+
+#include "mozilla/MathAlgorithms.h"
+
+#include <limits>
+
+namespace mozilla {
+
+// Compute the smallest power of 2 greater than or equal to aInput, except if
+// that would overflow in which case the highest possible power of 2 if chosen.
+// 0->1, 1->1, 2->2, 3->4, ... 2^31->2^31, 2^31+1->2^31 (for uint32_t), etc.
+template <typename T>
+T FriendlyRoundUpPow2(T aInput) {
+ // This is the same code as `RoundUpPow2()`, except we handle any type (that
+ // CeilingLog2 supports) and allow the greater-than-max-power case.
+ constexpr T max = T(1) << (sizeof(T) * CHAR_BIT - 1);
+ if (aInput >= max) {
+ return max;
+ }
+ return T(1) << CeilingLog2(aInput);
+}
+
+namespace detail {
+// Same function name `CountLeadingZeroes` with uint32_t and uint64_t overloads.
+inline uint_fast8_t CountLeadingZeroes(uint32_t aValue) {
+ MOZ_ASSERT(aValue != 0);
+ return detail::CountLeadingZeroes32(aValue);
+}
+inline uint_fast8_t CountLeadingZeroes(uint64_t aValue) {
+ MOZ_ASSERT(aValue != 0);
+ return detail::CountLeadingZeroes64(aValue);
+}
+// Refuse anything else.
+template <typename T>
+inline uint_fast8_t CountLeadingZeroes(T aValue) = delete;
+} // namespace detail
+
+// Compute the smallest 2^N-1 mask where aInput can fit.
+// I.e., `x & mask == x`, but `x & (mask >> 1) != x`.
+// Or looking at binary, we want a mask with as many leading zeroes as the
+// input, by right-shifting a full mask: (8-bit examples)
+// input: 00000000 00000001 00000010 00010110 01111111 10000000
+// N leading 0s: ^^^^^^^^ 8 ^^^^^^^ 7 ^^^^^^ 6 ^^^ 3 ^ 1 0
+// full mask: 11111111 11111111 11111111 11111111 11111111 11111111
+// full mask >> N: 00000000 00000001 00000011 00011111 01111111 11111111
+template <typename T>
+T RoundUpPow2Mask(T aInput) {
+ // Special case, as CountLeadingZeroes(0) is undefined. (And even if that was
+ // defined, shifting by the full type size is also undefined!)
+ if (aInput == 0) {
+ return 0;
+ }
+ return T(-1) >> detail::CountLeadingZeroes(aInput);
+}
+
+template <typename T>
+class PowerOfTwoMask;
+
+template <typename T, T Mask>
+constexpr PowerOfTwoMask<T> MakePowerOfTwoMask();
+
+template <typename T>
+class PowerOfTwo;
+
+template <typename T, T Value>
+constexpr PowerOfTwo<T> MakePowerOfTwo();
+
+// PowerOfTwoMask will always contain a mask for a power of 2, which is useful
+// for power-of-2 modulo operations (e.g., to keep an index inside a power-of-2
+// container).
+// Use this instead of PowerOfTwo if masking is the primary use of the value.
+//
+// Note that this class can store a "full" mask where all bits are set, so it
+// works for mask corresponding to the power of 2 that would overflow `T`
+// (e.g., 2^32 for uint32_t gives a mask of 2^32-1, which fits in a uint32_t).
+// For this reason there is no API that computes the power of 2 corresponding to
+// the mask; But this can be done explicitly with `MaskValue() + 1`, which may
+// be useful for computing things like distance-to-the-end by doing
+// `MaskValue() + 1 - offset`, which works fine with unsigned number types.
+template <typename T>
+class PowerOfTwoMask {
+ static_assert(!std::numeric_limits<T>::is_signed,
+ "PowerOfTwoMask must use an unsigned type");
+
+ public:
+ // Construct a power of 2 mask where the given value can fit.
+ // Cannot be constexpr because of `RoundUpPow2Mask()`.
+ explicit PowerOfTwoMask(T aInput) : mMask(RoundUpPow2Mask(aInput)) {}
+
+ // Compute the mask corresponding to a PowerOfTwo.
+ // This saves having to compute the nearest 2^N-1.
+ // Not a conversion constructor, as that could be ambiguous whether we'd want
+ // the mask corresponding to the power of 2 (2^N -> 2^N-1), or the mask that
+ // can *contain* the PowerOfTwo value (2^N -> 2^(N+1)-1).
+ // Note: Not offering reverse PowerOfTwoMark-to-PowerOfTwo conversion, because
+ // that could result in an unexpected 0 result for the largest possible mask.
+ template <typename U>
+ static constexpr PowerOfTwoMask<U> MaskForPowerOfTwo(
+ const PowerOfTwo<U>& aP2) {
+ return PowerOfTwoMask(aP2);
+ }
+
+ // Allow smaller unsigned types as input.
+ // Bigger or signed types must be explicitly converted by the caller.
+ template <typename U>
+ explicit constexpr PowerOfTwoMask(U aInput)
+ : mMask(RoundUpPow2Mask(static_cast<T>(aInput))) {
+ static_assert(!std::numeric_limits<T>::is_signed,
+ "PowerOfTwoMask does not accept signed types");
+ static_assert(sizeof(U) <= sizeof(T),
+ "PowerOfTwoMask does not accept bigger types");
+ }
+
+ constexpr T MaskValue() const { return mMask; }
+
+ // `x & aPowerOfTwoMask` just works.
+ template <typename U>
+ friend U operator&(U aNumber, PowerOfTwoMask aP2M) {
+ return static_cast<U>(aNumber & aP2M.MaskValue());
+ }
+
+ // `aPowerOfTwoMask & x` just works.
+ template <typename U>
+ friend constexpr U operator&(PowerOfTwoMask aP2M, U aNumber) {
+ return static_cast<U>(aP2M.MaskValue() & aNumber);
+ }
+
+ // `x % aPowerOfTwoMask(2^N-1)` is equivalent to `x % 2^N` but is more
+ // optimal by doing `x & (2^N-1)`.
+ // Useful for templated code doing modulo with a template argument type.
+ template <typename U>
+ friend constexpr U operator%(U aNumerator, PowerOfTwoMask aDenominator) {
+ return aNumerator & aDenominator.MaskValue();
+ }
+
+ constexpr bool operator==(const PowerOfTwoMask& aRhs) const {
+ return mMask == aRhs.mMask;
+ }
+ constexpr bool operator!=(const PowerOfTwoMask& aRhs) const {
+ return mMask != aRhs.mMask;
+ }
+
+ private:
+ // Trust `PowerOfTwo` to call the private Trusted constructor below.
+ friend class PowerOfTwo<T>;
+
+ // Trust `MakePowerOfTwoMask()` to call the private Trusted constructor below.
+ template <typename U, U Mask>
+ friend constexpr PowerOfTwoMask<U> MakePowerOfTwoMask();
+
+ struct Trusted {
+ T mMask;
+ };
+ // Construct the mask corresponding to a PowerOfTwo.
+ // This saves having to compute the nearest 2^N-1.
+ // Note: Not a public PowerOfTwo->PowerOfTwoMask conversion constructor, as
+ // that could be ambiguous whether we'd want the mask corresponding to the
+ // power of 2 (2^N -> 2^N-1), or the mask that can *contain* the PowerOfTwo
+ // value (2^N -> 2^(N+1)-1).
+ explicit constexpr PowerOfTwoMask(const Trusted& aP2) : mMask(aP2.mMask) {}
+
+ T mMask = 0;
+};
+
+// Make a PowerOfTwoMask constant, statically-checked.
+template <typename T, T Mask>
+constexpr PowerOfTwoMask<T> MakePowerOfTwoMask() {
+ static_assert(Mask == T(-1) || IsPowerOfTwo(Mask + 1),
+ "MakePowerOfTwoMask<T, Mask>: Mask must be 2^N-1");
+ using Trusted = typename PowerOfTwoMask<T>::Trusted;
+ return PowerOfTwoMask<T>(Trusted{Mask});
+}
+
+// PowerOfTwo will always contain a power of 2.
+template <typename T>
+class PowerOfTwo {
+ static_assert(!std::numeric_limits<T>::is_signed,
+ "PowerOfTwo must use an unsigned type");
+
+ public:
+ // Construct a power of 2 that can fit the given value, or the highest power
+ // of 2 possible.
+ // Caller should explicitly check/assert `Value() <= aInput` if they want to.
+ // Cannot be constexpr because of `FriendlyRoundUpPow2()`.
+ explicit PowerOfTwo(T aInput) : mValue(FriendlyRoundUpPow2(aInput)) {}
+
+ // Allow smaller unsigned types as input.
+ // Bigger or signed types must be explicitly converted by the caller.
+ template <typename U>
+ explicit PowerOfTwo(U aInput)
+ : mValue(FriendlyRoundUpPow2(static_cast<T>(aInput))) {
+ static_assert(!std::numeric_limits<T>::is_signed,
+ "PowerOfTwo does not accept signed types");
+ static_assert(sizeof(U) <= sizeof(T),
+ "PowerOfTwo does not accept bigger types");
+ }
+
+ constexpr T Value() const { return mValue; }
+
+ // Binary mask corresponding to the power of 2, useful for modulo.
+ // E.g., `x & powerOfTwo(y).Mask()` == `x % powerOfTwo(y)`.
+ // Consider PowerOfTwoMask class instead of PowerOfTwo if masking is the
+ // primary use case.
+ constexpr T MaskValue() const { return mValue - 1; }
+
+ // PowerOfTwoMask corresponding to this power of 2, useful for modulo.
+ constexpr PowerOfTwoMask<T> Mask() const {
+ using Trusted = typename PowerOfTwoMask<T>::Trusted;
+ return PowerOfTwoMask<T>(Trusted{MaskValue()});
+ }
+
+ // `x % aPowerOfTwo` works optimally.
+ // Useful for templated code doing modulo with a template argument type.
+ // Use PowerOfTwoMask class instead if masking is the primary use case.
+ template <typename U>
+ friend constexpr U operator%(U aNumerator, PowerOfTwo aDenominator) {
+ return aNumerator & aDenominator.MaskValue();
+ }
+
+ constexpr bool operator==(const PowerOfTwo& aRhs) const {
+ return mValue == aRhs.mValue;
+ }
+ constexpr bool operator!=(const PowerOfTwo& aRhs) const {
+ return mValue != aRhs.mValue;
+ }
+ constexpr bool operator<(const PowerOfTwo& aRhs) const {
+ return mValue < aRhs.mValue;
+ }
+ constexpr bool operator<=(const PowerOfTwo& aRhs) const {
+ return mValue <= aRhs.mValue;
+ }
+ constexpr bool operator>(const PowerOfTwo& aRhs) const {
+ return mValue > aRhs.mValue;
+ }
+ constexpr bool operator>=(const PowerOfTwo& aRhs) const {
+ return mValue >= aRhs.mValue;
+ }
+
+ private:
+ // Trust `MakePowerOfTwo()` to call the private Trusted constructor below.
+ template <typename U, U Value>
+ friend constexpr PowerOfTwo<U> MakePowerOfTwo();
+
+ struct Trusted {
+ T mValue;
+ };
+ // Construct a PowerOfTwo with the given trusted value.
+ // This saves having to compute the nearest 2^N.
+ // Note: Not offering PowerOfTwoMark-to-PowerOfTwo conversion, because that
+ // could result in an unexpected 0 result for the largest possible mask.
+ explicit constexpr PowerOfTwo(const Trusted& aP2) : mValue(aP2.mValue) {}
+
+ // The smallest power of 2 is 2^0 == 1.
+ T mValue = 1;
+};
+
+// Make a PowerOfTwo constant, statically-checked.
+template <typename T, T Value>
+constexpr PowerOfTwo<T> MakePowerOfTwo() {
+ static_assert(IsPowerOfTwo(Value),
+ "MakePowerOfTwo<T, Value>: Value must be 2^N");
+ using Trusted = typename PowerOfTwo<T>::Trusted;
+ return PowerOfTwo<T>(Trusted{Value});
+}
+
+// Shortcuts for the most common types and functions.
+
+using PowerOfTwoMask32 = PowerOfTwoMask<uint32_t>;
+using PowerOfTwo32 = PowerOfTwo<uint32_t>;
+using PowerOfTwoMask64 = PowerOfTwoMask<uint64_t>;
+using PowerOfTwo64 = PowerOfTwo<uint64_t>;
+
+template <uint32_t Mask>
+constexpr PowerOfTwoMask32 MakePowerOfTwoMask32() {
+ return MakePowerOfTwoMask<uint32_t, Mask>();
+}
+
+template <uint32_t Value>
+constexpr PowerOfTwo32 MakePowerOfTwo32() {
+ return MakePowerOfTwo<uint32_t, Value>();
+}
+
+template <uint64_t Mask>
+constexpr PowerOfTwoMask64 MakePowerOfTwoMask64() {
+ return MakePowerOfTwoMask<uint64_t, Mask>();
+}
+
+template <uint64_t Value>
+constexpr PowerOfTwo64 MakePowerOfTwo64() {
+ return MakePowerOfTwo<uint64_t, Value>();
+}
+
+} // namespace mozilla
+
+#endif // PowerOfTwo_h
diff --git a/mozglue/baseprofiler/public/ProfileBufferChunk.h b/mozglue/baseprofiler/public/ProfileBufferChunk.h
new file mode 100644
index 0000000000..9ba2483372
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileBufferChunk.h
@@ -0,0 +1,547 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferChunk_h
+#define ProfileBufferChunk_h
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/ProfileBufferIndex.h"
+#include "mozilla/Span.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+
+#if defined(MOZ_MEMORY)
+# include "mozmemory.h"
+#endif
+
+#include <algorithm>
+#include <limits>
+#include <type_traits>
+
+#ifdef DEBUG
+# include <cstdio>
+#endif
+
+namespace mozilla {
+
+// Represents a single chunk of memory, with a link to the next chunk (or null).
+//
+// A chunk is made of an internal header (which contains a public part) followed
+// by user-accessible bytes.
+//
+// +---------------+---------+----------------------------------------------+
+// | public Header | private | memory containing user blocks |
+// +---------------+---------+----------------------------------------------+
+// <---------------BufferBytes()------------------>
+// <------------------------------ChunkBytes()------------------------------>
+//
+// The chunk can reserve "blocks", but doesn't know the internal contents of
+// each block, it only knows where the first one starts, and where the last one
+// ends (which is where the next one will begin, if not already out of range).
+// It is up to the user to add structure to each block so that they can be
+// distinguished when later read.
+//
+// +---------------+---------+----------------------------------------------+
+// | public Header | private | [1st block]...[last full block] |
+// +---------------+---------+----------------------------------------------+
+// ChunkHeader().mOffsetFirstBlock ^ ^
+// ChunkHeader().mOffsetPastLastBlock --'
+//
+// It is possible to attempt to reserve more than the remaining space, in which
+// case only what is available is returned. The caller is responsible for using
+// another chunk, reserving a block "tail" in it, and using both parts to
+// constitute a full block. (This initial tail may be empty in some chunks.)
+//
+// +---------------+---------+----------------------------------------------+
+// | public Header | private | tail][1st block]...[last full block][head... |
+// +---------------+---------+----------------------------------------------+
+// ChunkHeader().mOffsetFirstBlock ^ ^
+// ChunkHeader().mOffsetPastLastBlock --'
+//
+// Each Chunk has an internal state (checked in DEBUG builds) that directs how
+// to use it during creation, initialization, use, end of life, recycling, and
+// destruction. See `State` below for details.
+// In particular:
+// - `ReserveInitialBlockAsTail()` must be called before the first `Reserve()`
+// after construction or recycling, even with a size of 0 (no actual tail),
+// - `MarkDone()` and `MarkRecycled()` must be called as appropriate.
+class ProfileBufferChunk {
+ public:
+ using Byte = uint8_t;
+ using Length = uint32_t;
+
+ using SpanOfBytes = Span<Byte>;
+
+ // Hint about the size of the metadata (public and private headers).
+ // `Create()` below takes the minimum *buffer* size, so the minimum total
+ // Chunk size is at least `SizeofChunkMetadata() + aMinBufferBytes`.
+ [[nodiscard]] static constexpr Length SizeofChunkMetadata() {
+ return static_cast<Length>(sizeof(InternalHeader));
+ }
+
+ // Allocate space for a chunk with a given minimum size, and construct it.
+ // The actual size may be higher, to match the actual space taken in the
+ // memory pool.
+ [[nodiscard]] static UniquePtr<ProfileBufferChunk> Create(
+ Length aMinBufferBytes) {
+ // We need at least one byte, to cover the always-present `mBuffer` byte.
+ aMinBufferBytes = std::max(aMinBufferBytes, Length(1));
+ // Trivial struct with the same alignment as `ProfileBufferChunk`, and size
+ // equal to that alignment, because typically the sizeof of an object is
+ // a multiple of its alignment.
+ struct alignas(alignof(InternalHeader)) ChunkStruct {
+ Byte c[alignof(InternalHeader)];
+ };
+ static_assert(std::is_trivial_v<ChunkStruct>,
+ "ChunkStruct must be trivial to avoid any construction");
+ // Allocate an array of that struct, enough to contain the expected
+ // `ProfileBufferChunk` (with its header+buffer).
+ size_t count = (sizeof(InternalHeader) + aMinBufferBytes +
+ (alignof(InternalHeader) - 1)) /
+ alignof(InternalHeader);
+#if defined(MOZ_MEMORY)
+ // Potentially expand the array to use more of the effective allocation.
+ count = (malloc_good_size(count * sizeof(ChunkStruct)) +
+ (sizeof(ChunkStruct) - 1)) /
+ sizeof(ChunkStruct);
+#endif
+ auto chunkStorage = MakeUnique<ChunkStruct[]>(count);
+ MOZ_ASSERT(reinterpret_cast<uintptr_t>(chunkStorage.get()) %
+ alignof(InternalHeader) ==
+ 0);
+ // After the allocation, compute the actual chunk size (including header).
+ const size_t chunkBytes = count * sizeof(ChunkStruct);
+ MOZ_ASSERT(chunkBytes >= sizeof(ProfileBufferChunk),
+ "Not enough space to construct a ProfileBufferChunk");
+ MOZ_ASSERT(chunkBytes <=
+ static_cast<size_t>(std::numeric_limits<Length>::max()));
+ // Compute the size of the user-accessible buffer inside the chunk.
+ const Length bufferBytes =
+ static_cast<Length>(chunkBytes - sizeof(InternalHeader));
+ MOZ_ASSERT(bufferBytes >= aMinBufferBytes,
+ "Not enough space for minimum buffer size");
+ // Construct the header at the beginning of the allocated array, with the
+ // known buffer size.
+ new (chunkStorage.get()) ProfileBufferChunk(bufferBytes);
+ // We now have a proper `ProfileBufferChunk` object, create the appropriate
+ // UniquePtr for it.
+ UniquePtr<ProfileBufferChunk> chunk{
+ reinterpret_cast<ProfileBufferChunk*>(chunkStorage.release())};
+ MOZ_ASSERT(
+ size_t(reinterpret_cast<const char*>(
+ &chunk.get()->BufferSpan()[bufferBytes - 1]) -
+ reinterpret_cast<const char*>(chunk.get())) == chunkBytes - 1,
+ "Buffer span spills out of chunk allocation");
+ return chunk;
+ }
+
+#ifdef DEBUG
+ ~ProfileBufferChunk() {
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::InUse);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Full);
+ MOZ_ASSERT(mInternalHeader.mState == InternalHeader::State::Created ||
+ mInternalHeader.mState == InternalHeader::State::Done ||
+ mInternalHeader.mState == InternalHeader::State::Recycled);
+ }
+#endif
+
+ // Must be called with the first block tail (may be empty), which will be
+ // skipped if the reader starts with this ProfileBufferChunk.
+ [[nodiscard]] SpanOfBytes ReserveInitialBlockAsTail(Length aTailSize) {
+#ifdef DEBUG
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::InUse);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Full);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Done);
+ MOZ_ASSERT(mInternalHeader.mState == InternalHeader::State::Created ||
+ mInternalHeader.mState == InternalHeader::State::Recycled);
+ mInternalHeader.mState = InternalHeader::State::InUse;
+#endif
+ mInternalHeader.mHeader.mOffsetFirstBlock = aTailSize;
+ mInternalHeader.mHeader.mOffsetPastLastBlock = aTailSize;
+ mInternalHeader.mHeader.mStartTimeStamp = TimeStamp::Now();
+ return SpanOfBytes(&mBuffer, aTailSize);
+ }
+
+ struct ReserveReturn {
+ SpanOfBytes mSpan;
+ ProfileBufferBlockIndex mBlockRangeIndex;
+ };
+
+ // Reserve a block of up to `aBlockSize` bytes, and return a Span to it, and
+ // its starting index. The actual size may be smaller, if the block cannot fit
+ // in the remaining space.
+ [[nodiscard]] ReserveReturn ReserveBlock(Length aBlockSize) {
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Created);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Full);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Done);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Recycled);
+ MOZ_ASSERT(mInternalHeader.mState == InternalHeader::State::InUse);
+ MOZ_ASSERT(RangeStart() != 0,
+ "Expected valid range start before first Reserve()");
+ const Length blockOffset = mInternalHeader.mHeader.mOffsetPastLastBlock;
+ Length reservedSize = aBlockSize;
+ if (MOZ_UNLIKELY(aBlockSize >= RemainingBytes())) {
+ reservedSize = RemainingBytes();
+#ifdef DEBUG
+ mInternalHeader.mState = InternalHeader::State::Full;
+#endif
+ }
+ mInternalHeader.mHeader.mOffsetPastLastBlock += reservedSize;
+ mInternalHeader.mHeader.mBlockCount += 1;
+ return {SpanOfBytes(&mBuffer + blockOffset, reservedSize),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mInternalHeader.mHeader.mRangeStart + blockOffset)};
+ }
+
+ // When a chunk will not be used to store more blocks (because it is full, or
+ // because the profiler will not add more data), it should be marked "done".
+ // Access to its content is still allowed.
+ void MarkDone() {
+#ifdef DEBUG
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Created);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Done);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Recycled);
+ MOZ_ASSERT(mInternalHeader.mState == InternalHeader::State::InUse ||
+ mInternalHeader.mState == InternalHeader::State::Full);
+ mInternalHeader.mState = InternalHeader::State::Done;
+#endif
+ mInternalHeader.mHeader.mDoneTimeStamp = TimeStamp::Now();
+ }
+
+ // A "Done" chunk may be recycled, to avoid allocating a new one.
+ void MarkRecycled() {
+#ifdef DEBUG
+ // We also allow Created and already-Recycled chunks to be recycled, this
+ // way it's easier to recycle chunks when their state is not easily
+ // trackable.
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::InUse);
+ MOZ_ASSERT(mInternalHeader.mState != InternalHeader::State::Full);
+ MOZ_ASSERT(mInternalHeader.mState == InternalHeader::State::Created ||
+ mInternalHeader.mState == InternalHeader::State::Done ||
+ mInternalHeader.mState == InternalHeader::State::Recycled);
+ mInternalHeader.mState = InternalHeader::State::Recycled;
+#endif
+ // Reset all header fields, in case this recycled chunk gets read.
+ mInternalHeader.mHeader.Reset();
+ }
+
+ // Public header, meant to uniquely identify a chunk, it may be shared with
+ // other processes to coordinate global memory handling.
+ struct Header {
+ explicit Header(Length aBufferBytes) : mBufferBytes(aBufferBytes) {}
+
+ // Reset all members to their as-new values (apart from the buffer size,
+ // which cannot change), ready for re-use.
+ void Reset() {
+ mOffsetFirstBlock = 0;
+ mOffsetPastLastBlock = 0;
+ mStartTimeStamp = TimeStamp{};
+ mDoneTimeStamp = TimeStamp{};
+ mBlockCount = 0;
+ mRangeStart = 0;
+ mProcessId = 0;
+ }
+
+ // Note: Part of the ordering of members below is to avoid unnecessary
+ // padding.
+
+ // Members managed by the ProfileBufferChunk.
+
+ // Offset of the first block (past the initial tail block, which may be 0).
+ Length mOffsetFirstBlock = 0;
+ // Offset past the last byte of the last reserved block
+ // It may be past mBufferBytes when last block continues in the next
+ // ProfileBufferChunk. It may be before mBufferBytes if ProfileBufferChunk
+ // is marked "Done" before the end is reached.
+ Length mOffsetPastLastBlock = 0;
+ // Timestamp when the buffer becomes in-use, ready to record data.
+ TimeStamp mStartTimeStamp;
+ // Timestamp when the buffer is "Done" (which happens when the last block is
+ // written). This will be used to find and discard the oldest
+ // ProfileBufferChunk.
+ TimeStamp mDoneTimeStamp;
+ // Number of bytes in the buffer, set once at construction time.
+ const Length mBufferBytes;
+ // Number of reserved blocks (including final one even if partial, but
+ // excluding initial tail).
+ Length mBlockCount = 0;
+
+ // Meta-data set by the user.
+
+ // Index of the first byte of this ProfileBufferChunk, relative to all
+ // Chunks for this process. Index 0 is reserved as nullptr-like index,
+ // mRangeStart should be set to a non-0 value before the first `Reserve()`.
+ ProfileBufferIndex mRangeStart = 0;
+ // Process writing to this ProfileBufferChunk.
+ int mProcessId = 0;
+
+ // A bit of spare space (necessary here because of the alignment due to
+ // other members), may be later repurposed for extra data.
+ const int mPADDING = 0;
+ };
+
+ [[nodiscard]] const Header& ChunkHeader() const {
+ return mInternalHeader.mHeader;
+ }
+
+ [[nodiscard]] Length BufferBytes() const {
+ return ChunkHeader().mBufferBytes;
+ }
+
+ // Total size of the chunk (buffer + header).
+ [[nodiscard]] Length ChunkBytes() const {
+ return static_cast<Length>(sizeof(InternalHeader)) + BufferBytes();
+ }
+
+ // Size of external resources, in this case all the following chunks.
+ [[nodiscard]] size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+ const ProfileBufferChunk* const next = GetNext();
+ return next ? next->SizeOfIncludingThis(aMallocSizeOf) : 0;
+ }
+
+ // Size of this chunk and all following ones.
+ [[nodiscard]] size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ // Just in case `aMallocSizeOf` falls back on just `sizeof`, make sure we
+ // account for at least the actual Chunk requested allocation size.
+ return std::max<size_t>(aMallocSizeOf(this), ChunkBytes()) +
+ SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ [[nodiscard]] Length RemainingBytes() const {
+ return BufferBytes() - OffsetPastLastBlock();
+ }
+
+ [[nodiscard]] Length OffsetFirstBlock() const {
+ return ChunkHeader().mOffsetFirstBlock;
+ }
+
+ [[nodiscard]] Length OffsetPastLastBlock() const {
+ return ChunkHeader().mOffsetPastLastBlock;
+ }
+
+ [[nodiscard]] Length BlockCount() const { return ChunkHeader().mBlockCount; }
+
+ [[nodiscard]] int ProcessId() const { return ChunkHeader().mProcessId; }
+
+ void SetProcessId(int aProcessId) {
+ mInternalHeader.mHeader.mProcessId = aProcessId;
+ }
+
+ // Global range index at the start of this Chunk.
+ [[nodiscard]] ProfileBufferIndex RangeStart() const {
+ return ChunkHeader().mRangeStart;
+ }
+
+ void SetRangeStart(ProfileBufferIndex aRangeStart) {
+ mInternalHeader.mHeader.mRangeStart = aRangeStart;
+ }
+
+ // Get a read-only Span to the buffer. It is up to the caller to decypher the
+ // contents, based on known offsets and the internal block structure.
+ [[nodiscard]] Span<const Byte> BufferSpan() const {
+ return Span<const Byte>(&mBuffer, BufferBytes());
+ }
+
+ [[nodiscard]] Byte ByteAt(Length aOffset) const {
+ MOZ_ASSERT(aOffset < OffsetPastLastBlock());
+ return *(&mBuffer + aOffset);
+ }
+
+ [[nodiscard]] ProfileBufferChunk* GetNext() {
+ return mInternalHeader.mNext.get();
+ }
+ [[nodiscard]] const ProfileBufferChunk* GetNext() const {
+ return mInternalHeader.mNext.get();
+ }
+
+ [[nodiscard]] UniquePtr<ProfileBufferChunk> ReleaseNext() {
+ return std::move(mInternalHeader.mNext);
+ }
+
+ void InsertNext(UniquePtr<ProfileBufferChunk>&& aChunk) {
+ if (!aChunk) {
+ return;
+ }
+ aChunk->SetLast(ReleaseNext());
+ mInternalHeader.mNext = std::move(aChunk);
+ }
+
+ // Find the last chunk in this chain (it may be `this`).
+ [[nodiscard]] ProfileBufferChunk* Last() {
+ ProfileBufferChunk* chunk = this;
+ for (;;) {
+ ProfileBufferChunk* next = chunk->GetNext();
+ if (!next) {
+ return chunk;
+ }
+ chunk = next;
+ }
+ }
+ [[nodiscard]] const ProfileBufferChunk* Last() const {
+ const ProfileBufferChunk* chunk = this;
+ for (;;) {
+ const ProfileBufferChunk* next = chunk->GetNext();
+ if (!next) {
+ return chunk;
+ }
+ chunk = next;
+ }
+ }
+
+ void SetLast(UniquePtr<ProfileBufferChunk>&& aChunk) {
+ if (!aChunk) {
+ return;
+ }
+ Last()->mInternalHeader.mNext = std::move(aChunk);
+ }
+
+ // Join two possibly-null chunk lists.
+ [[nodiscard]] static UniquePtr<ProfileBufferChunk> Join(
+ UniquePtr<ProfileBufferChunk>&& aFirst,
+ UniquePtr<ProfileBufferChunk>&& aLast) {
+ if (aFirst) {
+ aFirst->SetLast(std::move(aLast));
+ return std::move(aFirst);
+ }
+ return std::move(aLast);
+ }
+
+#ifdef DEBUG
+ void Dump(std::FILE* aFile = stdout) const {
+ fprintf(aFile,
+ "Chunk[%p] chunkSize=%u bufferSize=%u state=%s rangeStart=%u "
+ "firstBlockOffset=%u offsetPastLastBlock=%u blockCount=%u",
+ this, unsigned(ChunkBytes()), unsigned(BufferBytes()),
+ mInternalHeader.StateString(), unsigned(RangeStart()),
+ unsigned(OffsetFirstBlock()), unsigned(OffsetPastLastBlock()),
+ unsigned(BlockCount()));
+ const auto len = OffsetPastLastBlock();
+ constexpr unsigned columns = 16;
+ unsigned char ascii[columns + 1];
+ ascii[columns] = '\0';
+ for (Length i = 0; i < len; ++i) {
+ if (i % columns == 0) {
+ fprintf(aFile, "\n %4u=0x%03x:", unsigned(i), unsigned(i));
+ for (unsigned a = 0; a < columns; ++a) {
+ ascii[a] = ' ';
+ }
+ }
+ unsigned char sep = ' ';
+ if (i == OffsetFirstBlock()) {
+ if (i == OffsetPastLastBlock()) {
+ sep = '#';
+ } else {
+ sep = '[';
+ }
+ } else if (i == OffsetPastLastBlock()) {
+ sep = ']';
+ }
+ unsigned char c = *(&mBuffer + i);
+ fprintf(aFile, "%c%02x", sep, c);
+
+ if (i == len - 1) {
+ if (i + 1 == OffsetPastLastBlock()) {
+ // Special case when last block ends right at the end.
+ fprintf(aFile, "]");
+ } else {
+ fprintf(aFile, " ");
+ }
+ } else if (i % columns == columns - 1) {
+ fprintf(aFile, " ");
+ }
+
+ ascii[i % columns] = (c >= ' ' && c <= '~') ? c : '.';
+
+ if (i % columns == columns - 1) {
+ fprintf(aFile, " %s", ascii);
+ }
+ }
+
+ if (len % columns < columns - 1) {
+ for (Length i = len % columns; i < columns; ++i) {
+ fprintf(aFile, " ");
+ }
+ fprintf(aFile, " %s", ascii);
+ }
+
+ fprintf(aFile, "\n");
+ }
+#endif // DEBUG
+
+ private:
+ // ProfileBufferChunk constructor. Use static `Create()` to allocate and
+ // construct a ProfileBufferChunk.
+ explicit ProfileBufferChunk(Length aBufferBytes)
+ : mInternalHeader(aBufferBytes) {}
+
+ // This internal header starts with the public `Header`, and adds some data
+ // only necessary for local handling.
+ // This encapsulation is also necessary to perform placement-new in
+ // `Create()`.
+ struct InternalHeader {
+ explicit InternalHeader(Length aBufferBytes) : mHeader(aBufferBytes) {}
+
+ Header mHeader;
+ UniquePtr<ProfileBufferChunk> mNext;
+
+#ifdef DEBUG
+ enum class State {
+ Created, // Self-set. Just constructed, waiting for initial block tail.
+ InUse, // Ready to accept blocks.
+ Full, // Self-set. Blocks reach the end (or further).
+ Done, // Blocks won't be added anymore.
+ Recycled // Still full of data, but expecting an initial block tail.
+ };
+
+ State mState = State::Created;
+ // Transition table: (X=unexpected)
+ // Method \ State Created InUse Full Done Recycled
+ // ReserveInitialBlockAsTail InUse X X X InUse
+ // Reserve X InUse/Full X X X
+ // MarkDone X Done Done X X
+ // MarkRecycled X X X Recycled X
+ // destructor ok X X ok ok
+
+ const char* StateString() const {
+ switch (mState) {
+ case State::Created:
+ return "Created";
+ case State::InUse:
+ return "InUse";
+ case State::Full:
+ return "Full";
+ case State::Done:
+ return "Done";
+ case State::Recycled:
+ return "Recycled";
+ default:
+ return "?";
+ }
+ }
+#else // DEBUG
+ const char* StateString() const { return "(non-DEBUG)"; }
+#endif
+ };
+
+ InternalHeader mInternalHeader;
+
+ // KEEP THIS LAST!
+ // First byte of the buffer. Note that ProfileBufferChunk::Create allocates a
+ // bigger block, such that `mBuffer` is the first of `mBufferBytes` available
+ // bytes.
+ // The initialization is not strictly needed, because bytes should only be
+ // read after they have been written and `mOffsetPastLastBlock` has been
+ // updated. However:
+ // - Reviewbot complains that it's not initialized.
+ // - It's cheap to initialize one byte.
+ // - In the worst case (reading does happen), zero is not a valid entry size
+ // and should get caught in entry readers.
+ Byte mBuffer = '\0';
+};
+
+} // namespace mozilla
+
+#endif // ProfileBufferChunk_h
diff --git a/mozglue/baseprofiler/public/ProfileBufferChunkManager.h b/mozglue/baseprofiler/public/ProfileBufferChunkManager.h
new file mode 100644
index 0000000000..e7f12bf21f
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileBufferChunkManager.h
@@ -0,0 +1,134 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferChunkManager_h
+#define ProfileBufferChunkManager_h
+
+#include "mozilla/ProfileBufferChunk.h"
+#include "mozilla/ScopeExit.h"
+
+#include <functional>
+
+namespace mozilla {
+
+// Manages the ProfileBufferChunks for this process.
+// The main user of this class is the buffer that needs chunks to store its
+// data.
+// The main ProfileBufferChunks responsibilities are:
+// - It can create new chunks, they are called "unreleased".
+// - Later these chunks are returned here, and become "released".
+// - The manager is free to destroy or recycle the oldest released chunks
+// (usually to reclaim memory), and will inform the user through a provided
+// callback.
+// - The user may access still-alive released chunks.
+class ProfileBufferChunkManager {
+ public:
+ virtual ~ProfileBufferChunkManager()
+#ifdef DEBUG
+ {
+ MOZ_ASSERT(!mUser, "Still registered when being destroyed");
+ }
+#else
+ = default;
+#endif
+
+ // Expected maximum size needed to store one stack sample.
+ // Most ChunkManager sub-classes will require chunk sizes, this can serve as
+ // a minimum recommendation to hold most backtraces.
+ constexpr static ProfileBufferChunk::Length scExpectedMaximumStackSize =
+ 128 * 1024;
+
+ // Estimated maximum buffer size.
+ [[nodiscard]] virtual size_t MaxTotalSize() const = 0;
+
+ // Create or recycle a chunk right now. May return null in case of allocation
+ // failure.
+ // Note that the chunk-destroyed callback may be invoked during this call;
+ // user should be careful with reentrancy issues.
+ [[nodiscard]] virtual UniquePtr<ProfileBufferChunk> GetChunk() = 0;
+
+ // `aChunkReceiver` may be called with a new or recycled chunk, or nullptr.
+ // (See `FulfillChunkRequests()` regarding when the callback may happen.)
+ virtual void RequestChunk(
+ std::function<void(UniquePtr<ProfileBufferChunk>)>&& aChunkReceiver) = 0;
+
+ // This method may be invoked at any time on any thread (and not necessarily
+ // by the main user of this class), to do the work necessary to respond to a
+ // previous `RequestChunk()`.
+ // It is optional: If it is never called, or called too late, the user is
+ // responsible for directly calling `GetChunk()` when a chunk is really
+ // needed (or it should at least fail gracefully).
+ // The idea is to fulfill chunk request on a separate thread, and most
+ // importantly outside of profiler calls, to avoid doing expensive memory
+ // allocations during these calls.
+ virtual void FulfillChunkRequests() = 0;
+
+ // One chunk is released by the user, the ProfileBufferChunkManager should
+ // keep it as long as possible (depending on local or global memory/time
+ // limits). Note that the chunk-destroyed callback may be invoked during this
+ // call; user should be careful with reentrancy issues.
+ virtual void ReleaseChunk(UniquePtr<ProfileBufferChunk> aChunk) = 0;
+
+ // `aChunkDestroyedCallback` will be called whenever the contents of a
+ // previously-released chunk is about to be destroyed or recycled.
+ // Note that it may be called during other functions above, or at other times
+ // from the same or other threads; user should be careful with reentrancy
+ // issues.
+ virtual void SetChunkDestroyedCallback(
+ std::function<void(const ProfileBufferChunk&)>&&
+ aChunkDestroyedCallback) = 0;
+
+ // Give away all released chunks that have not yet been destroyed.
+ [[nodiscard]] virtual UniquePtr<ProfileBufferChunk>
+ GetExtantReleasedChunks() = 0;
+
+ // Let a callback see all released chunks that have not yet been destroyed, if
+ // any. Return whatever the callback returns.
+ template <typename Callback>
+ [[nodiscard]] auto PeekExtantReleasedChunks(Callback&& aCallback) {
+ const ProfileBufferChunk* chunks = PeekExtantReleasedChunksAndLock();
+ auto unlock =
+ MakeScopeExit([&]() { UnlockAfterPeekExtantReleasedChunks(); });
+ return std::forward<Callback>(aCallback)(chunks);
+ }
+
+ // Chunks that were still unreleased will never be released.
+ virtual void ForgetUnreleasedChunks() = 0;
+
+ [[nodiscard]] virtual size_t SizeOfExcludingThis(
+ MallocSizeOf aMallocSizeOf) const = 0;
+ [[nodiscard]] virtual size_t SizeOfIncludingThis(
+ MallocSizeOf aMallocSizeOf) const = 0;
+
+ protected:
+ // Derived classes to implement `PeekExtantReleasedChunks` through these:
+ virtual const ProfileBufferChunk* PeekExtantReleasedChunksAndLock() = 0;
+ virtual void UnlockAfterPeekExtantReleasedChunks() = 0;
+
+#ifdef DEBUG
+ public:
+ // DEBUG checks ensuring that this manager and its users avoid UAFs.
+ // Derived classes should assert that mUser is not null in their functions.
+
+ void RegisteredWith(const void* aUser) {
+ MOZ_ASSERT(!mUser);
+ MOZ_ASSERT(aUser);
+ mUser = aUser;
+ }
+
+ void DeregisteredFrom(const void* aUser) {
+ MOZ_ASSERT(mUser == aUser);
+ mUser = nullptr;
+ }
+
+ protected:
+ const void* mUser = nullptr;
+#endif // DEBUG
+};
+
+} // namespace mozilla
+
+#endif // ProfileBufferChunkManager_h
diff --git a/mozglue/baseprofiler/public/ProfileBufferChunkManagerSingle.h b/mozglue/baseprofiler/public/ProfileBufferChunkManagerSingle.h
new file mode 100644
index 0000000000..c91b38cbdb
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileBufferChunkManagerSingle.h
@@ -0,0 +1,172 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferChunkManagerSingle_h
+#define ProfileBufferChunkManagerSingle_h
+
+#include "mozilla/ProfileBufferChunkManager.h"
+
+#ifdef DEBUG
+# include "mozilla/Atomics.h"
+#endif // DEBUG
+
+namespace mozilla {
+
+// Manages only one Chunk.
+// The first call to `Get`/`RequestChunk()` will retrieve the one chunk, and all
+// subsequent calls will return nullptr. That chunk may still be released, but
+// it will never be destroyed or recycled.
+// Unlike others, this manager may be `Reset()`, to allow another round of
+// small-data gathering.
+// The main use is with short-lived ProfileChunkedBuffers that collect little
+// data that can fit in one chunk, e.g., capturing one stack.
+// It is not thread-safe.
+class ProfileBufferChunkManagerSingle final : public ProfileBufferChunkManager {
+ public:
+ using Length = ProfileBufferChunk::Length;
+
+ // Use a preallocated chunk. (Accepting null to gracefully handle OOM.)
+ explicit ProfileBufferChunkManagerSingle(UniquePtr<ProfileBufferChunk> aChunk)
+ : mInitialChunk(std::move(aChunk)),
+ mBufferBytes(mInitialChunk ? mInitialChunk->BufferBytes() : 0) {
+ MOZ_ASSERT(!mInitialChunk || !mInitialChunk->GetNext(),
+ "Expected at most one chunk");
+ }
+
+ // ChunkMinBufferBytes: Minimum number of user-available bytes in the Chunk.
+ // Note that Chunks use a bit more memory for their header.
+ explicit ProfileBufferChunkManagerSingle(Length aChunkMinBufferBytes)
+ : mInitialChunk(ProfileBufferChunk::Create(aChunkMinBufferBytes)),
+ mBufferBytes(mInitialChunk ? mInitialChunk->BufferBytes() : 0) {}
+
+#ifdef DEBUG
+ ~ProfileBufferChunkManagerSingle() { MOZ_ASSERT(mVirtuallyLocked == false); }
+#endif // DEBUG
+
+ // Reset this manager, using the provided chunk (probably coming from the
+ // ProfileChunkedBuffer that just used it); if null, fallback on current or
+ // released chunk.
+ void Reset(UniquePtr<ProfileBufferChunk> aPossibleChunk) {
+ if (aPossibleChunk) {
+ mInitialChunk = std::move(aPossibleChunk);
+ mReleasedChunk = nullptr;
+ } else if (!mInitialChunk) {
+ MOZ_ASSERT(!!mReleasedChunk, "Can't reset properly!");
+ mInitialChunk = std::move(mReleasedChunk);
+ }
+
+ if (mInitialChunk) {
+ mInitialChunk->MarkRecycled();
+ mBufferBytes = mInitialChunk->BufferBytes();
+ } else {
+ mBufferBytes = 0;
+ }
+ }
+
+ [[nodiscard]] size_t MaxTotalSize() const final { return mBufferBytes; }
+
+ // One of `GetChunk` and `RequestChunk` will only work the very first time (if
+ // there's even a chunk).
+ [[nodiscard]] UniquePtr<ProfileBufferChunk> GetChunk() final {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ return std::move(mInitialChunk);
+ }
+
+ void RequestChunk(std::function<void(UniquePtr<ProfileBufferChunk>)>&&
+ aChunkReceiver) final {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ // Simple retrieval.
+ std::move(aChunkReceiver)(GetChunk());
+ }
+
+ void FulfillChunkRequests() final {
+ // Nothing to do here.
+ }
+
+ void ReleaseChunk(UniquePtr<ProfileBufferChunk> aChunk) final {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ if (!aChunk) {
+ return;
+ }
+ MOZ_ASSERT(!mReleasedChunk, "Unexpected 2nd released chunk");
+ MOZ_ASSERT(!aChunk->GetNext(), "Only expected one released chunk");
+ mReleasedChunk = std::move(aChunk);
+ }
+
+ void SetChunkDestroyedCallback(
+ std::function<void(const ProfileBufferChunk&)>&& aChunkDestroyedCallback)
+ final {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ // The chunk-destroyed callback will never actually be called, but we keep
+ // the callback here in case the caller expects it to live as long as this
+ // manager.
+ mChunkDestroyedCallback = std::move(aChunkDestroyedCallback);
+ }
+
+ [[nodiscard]] UniquePtr<ProfileBufferChunk> GetExtantReleasedChunks() final {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ return std::move(mReleasedChunk);
+ }
+
+ void ForgetUnreleasedChunks() final {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ }
+
+ [[nodiscard]] size_t SizeOfExcludingThis(
+ MallocSizeOf aMallocSizeOf) const final {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ size_t size = 0;
+ if (mInitialChunk) {
+ size += mInitialChunk->SizeOfIncludingThis(aMallocSizeOf);
+ }
+ if (mReleasedChunk) {
+ size += mReleasedChunk->SizeOfIncludingThis(aMallocSizeOf);
+ }
+ // Note: Missing size of std::function external resources (if any).
+ return size;
+ }
+
+ [[nodiscard]] size_t SizeOfIncludingThis(
+ MallocSizeOf aMallocSizeOf) const final {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ protected:
+ // This manager is not thread-safe, so there's not actual locking needed.
+ const ProfileBufferChunk* PeekExtantReleasedChunksAndLock() final {
+ MOZ_ASSERT(mVirtuallyLocked.compareExchange(false, true));
+ MOZ_ASSERT(mUser, "Not registered yet");
+ return mReleasedChunk.get();
+ }
+ void UnlockAfterPeekExtantReleasedChunks() final {
+ MOZ_ASSERT(mVirtuallyLocked.compareExchange(true, false));
+ }
+
+ private:
+ // Initial chunk created with this manager, given away at first Get/Request.
+ UniquePtr<ProfileBufferChunk> mInitialChunk;
+
+ // Storage for the released chunk (which should probably not happen, as it
+ // means the chunk is full).
+ UniquePtr<ProfileBufferChunk> mReleasedChunk;
+
+ // Size of the one chunk we're managing. Stored here, because the chunk may
+ // be moved out and inaccessible from here.
+ Length mBufferBytes;
+
+ // The chunk-destroyed callback will never actually be called, but we keep it
+ // here in case the caller expects it to live as long as this manager.
+ std::function<void(const ProfileBufferChunk&)> mChunkDestroyedCallback;
+
+#ifdef DEBUG
+ mutable Atomic<bool> mVirtuallyLocked{false};
+#endif // DEBUG
+};
+
+} // namespace mozilla
+
+#endif // ProfileBufferChunkManagerSingle_h
diff --git a/mozglue/baseprofiler/public/ProfileBufferChunkManagerWithLocalLimit.h b/mozglue/baseprofiler/public/ProfileBufferChunkManagerWithLocalLimit.h
new file mode 100644
index 0000000000..034279809d
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileBufferChunkManagerWithLocalLimit.h
@@ -0,0 +1,444 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferChunkManagerWithLocalLimit_h
+#define ProfileBufferChunkManagerWithLocalLimit_h
+
+#include "BaseProfiler.h"
+#include "mozilla/BaseProfilerDetail.h"
+#include "mozilla/ProfileBufferChunkManager.h"
+#include "mozilla/ProfileBufferControlledChunkManager.h"
+#include "mozilla/mozalloc.h"
+
+#include <utility>
+
+namespace mozilla {
+
+// Manages the Chunks for this process in a thread-safe manner, with a maximum
+// size per process.
+//
+// "Unreleased" chunks are not owned here, only "released" chunks can be
+// destroyed or recycled when reaching the memory limit, so it is theoretically
+// possible to break that limit, if:
+// - The user of this class doesn't release their chunks, AND/OR
+// - The limit is too small (e.g., smaller than 2 or 3 chunks, which should be
+// the usual number of unreleased chunks in flight).
+// In this case, it just means that we will use more memory than allowed,
+// potentially risking OOMs. Hopefully this shouldn't happen in real code,
+// assuming that the user is doing the right thing and releasing chunks ASAP,
+// and that the memory limit is reasonably large.
+class ProfileBufferChunkManagerWithLocalLimit final
+ : public ProfileBufferChunkManager,
+ public ProfileBufferControlledChunkManager {
+ public:
+ using Length = ProfileBufferChunk::Length;
+
+ // MaxTotalBytes: Maximum number of bytes allocated in all local Chunks.
+ // ChunkMinBufferBytes: Minimum number of user-available bytes in each Chunk.
+ // Note that Chunks use a bit more memory for their header.
+ explicit ProfileBufferChunkManagerWithLocalLimit(size_t aMaxTotalBytes,
+ Length aChunkMinBufferBytes)
+ : mMaxTotalBytes(aMaxTotalBytes),
+ mChunkMinBufferBytes(aChunkMinBufferBytes) {}
+
+ ~ProfileBufferChunkManagerWithLocalLimit() {
+ if (mUpdateCallback) {
+ // Signal the end of this callback.
+ std::move(mUpdateCallback)(Update(nullptr));
+ }
+ }
+
+ [[nodiscard]] size_t MaxTotalSize() const final {
+ // `mMaxTotalBytes` is `const` so there is no need to lock the mutex.
+ return mMaxTotalBytes;
+ }
+
+ [[nodiscard]] size_t TotalSize() const { return mTotalBytes; }
+
+ [[nodiscard]] UniquePtr<ProfileBufferChunk> GetChunk() final {
+ AUTO_PROFILER_STATS(Local_GetChunk);
+
+ ChunkAndUpdate chunkAndUpdate = [&]() {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ return GetChunk(lock);
+ }();
+
+ baseprofiler::detail::BaseProfilerAutoLock lock(mUpdateCallbackMutex);
+ if (mUpdateCallback && !chunkAndUpdate.second.IsNotUpdate()) {
+ mUpdateCallback(std::move(chunkAndUpdate.second));
+ }
+
+ return std::move(chunkAndUpdate.first);
+ }
+
+ void RequestChunk(std::function<void(UniquePtr<ProfileBufferChunk>)>&&
+ aChunkReceiver) final {
+ AUTO_PROFILER_STATS(Local_RequestChunk);
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ if (mChunkReceiver) {
+ // We already have a chunk receiver, meaning a request is pending.
+ return;
+ }
+ // Store the chunk receiver. This indicates that a request is pending, and
+ // it will be handled in the next `FulfillChunkRequests()` call.
+ mChunkReceiver = std::move(aChunkReceiver);
+ }
+
+ void FulfillChunkRequests() final {
+ AUTO_PROFILER_STATS(Local_FulfillChunkRequests);
+ std::function<void(UniquePtr<ProfileBufferChunk>)> chunkReceiver;
+ ChunkAndUpdate chunkAndUpdate = [&]() -> ChunkAndUpdate {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ if (!mChunkReceiver) {
+ // No receiver means no pending request, we're done.
+ return {};
+ }
+ // Otherwise there is a request, extract the receiver to call below.
+ std::swap(chunkReceiver, mChunkReceiver);
+ MOZ_ASSERT(!mChunkReceiver, "mChunkReceiver should have been emptied");
+ // And allocate the requested chunk. This may fail, it's fine, we're
+ // letting the receiver know about it.
+ AUTO_PROFILER_STATS(Local_FulfillChunkRequests_GetChunk);
+ return GetChunk(lock);
+ }();
+
+ if (chunkReceiver) {
+ {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mUpdateCallbackMutex);
+ if (mUpdateCallback && !chunkAndUpdate.second.IsNotUpdate()) {
+ mUpdateCallback(std::move(chunkAndUpdate.second));
+ }
+ }
+
+ // Invoke callback outside of lock, so that it can use other chunk manager
+ // functions if needed.
+ // Note that this means there could be a race, where another request
+ // happens now and even gets fulfilled before this one is! It should be
+ // rare, and shouldn't be a problem anyway, the user will still get their
+ // requested chunks, new/recycled chunks look the same so their order
+ // doesn't matter.
+ std::move(chunkReceiver)(std::move(chunkAndUpdate.first));
+ }
+ }
+
+ void ReleaseChunk(UniquePtr<ProfileBufferChunk> aChunk) final {
+ if (!aChunk) {
+ return;
+ }
+
+ MOZ_RELEASE_ASSERT(!aChunk->GetNext(), "ReleaseChunk only accepts 1 chunk");
+ MOZ_RELEASE_ASSERT(!aChunk->ChunkHeader().mDoneTimeStamp.IsNull(),
+ "Released chunk should have a 'Done' timestamp");
+
+ Update update = [&]() {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ MOZ_ASSERT(mUser, "Not registered yet");
+ // Keep a pointer to the first newly-released chunk, so we can use it to
+ // prepare an update (after `aChunk` is moved-from).
+ const ProfileBufferChunk* const newlyReleasedChunk = aChunk.get();
+ // Transfer the chunk size from the unreleased bucket to the released one.
+ mUnreleasedBufferBytes -= aChunk->BufferBytes();
+ mReleasedBufferBytes += aChunk->BufferBytes();
+ if (!mReleasedChunks) {
+ // No other released chunks at the moment, we're starting the list.
+ MOZ_ASSERT(mReleasedBufferBytes == aChunk->BufferBytes());
+ mReleasedChunks = std::move(aChunk);
+ } else {
+ // Insert aChunk in mReleasedChunks to keep done-timestamp order.
+ const TimeStamp& releasedChunkDoneTimeStamp =
+ aChunk->ChunkHeader().mDoneTimeStamp;
+ if (releasedChunkDoneTimeStamp <
+ mReleasedChunks->ChunkHeader().mDoneTimeStamp) {
+ // aChunk is the oldest -> Insert at the beginning.
+ aChunk->SetLast(std::move(mReleasedChunks));
+ mReleasedChunks = std::move(aChunk);
+ } else {
+ // Go through the already-released chunk list, and insert aChunk
+ // before the first younger released chunk, or at the end.
+ ProfileBufferChunk* chunk = mReleasedChunks.get();
+ for (;;) {
+ ProfileBufferChunk* const nextChunk = chunk->GetNext();
+ if (!nextChunk || releasedChunkDoneTimeStamp <
+ nextChunk->ChunkHeader().mDoneTimeStamp) {
+ // Either we're at the last released chunk, or the next released
+ // chunk is younger -> Insert right after this released chunk.
+ chunk->InsertNext(std::move(aChunk));
+ break;
+ }
+ chunk = nextChunk;
+ }
+ }
+ }
+
+ return Update(mUnreleasedBufferBytes, mReleasedBufferBytes,
+ mReleasedChunks.get(), newlyReleasedChunk);
+ }();
+
+ baseprofiler::detail::BaseProfilerAutoLock lock(mUpdateCallbackMutex);
+ if (mUpdateCallback && !update.IsNotUpdate()) {
+ mUpdateCallback(std::move(update));
+ }
+ }
+
+ void SetChunkDestroyedCallback(
+ std::function<void(const ProfileBufferChunk&)>&& aChunkDestroyedCallback)
+ final {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ MOZ_ASSERT(mUser, "Not registered yet");
+ mChunkDestroyedCallback = std::move(aChunkDestroyedCallback);
+ }
+
+ [[nodiscard]] UniquePtr<ProfileBufferChunk> GetExtantReleasedChunks() final {
+ UniquePtr<ProfileBufferChunk> chunks;
+ size_t unreleasedBufferBytes = [&]() {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ MOZ_ASSERT(mUser, "Not registered yet");
+ mReleasedBufferBytes = 0;
+ chunks = std::move(mReleasedChunks);
+ return mUnreleasedBufferBytes;
+ }();
+
+ baseprofiler::detail::BaseProfilerAutoLock lock(mUpdateCallbackMutex);
+ if (mUpdateCallback) {
+ mUpdateCallback(Update(unreleasedBufferBytes, 0, nullptr, nullptr));
+ }
+
+ return chunks;
+ }
+
+ void ForgetUnreleasedChunks() final {
+ Update update = [&]() {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ MOZ_ASSERT(mUser, "Not registered yet");
+ mUnreleasedBufferBytes = 0;
+ return Update(0, mReleasedBufferBytes, mReleasedChunks.get(), nullptr);
+ }();
+ baseprofiler::detail::BaseProfilerAutoLock lock(mUpdateCallbackMutex);
+ if (mUpdateCallback) {
+ mUpdateCallback(std::move(update));
+ }
+ }
+
+ [[nodiscard]] size_t SizeOfExcludingThis(
+ MallocSizeOf aMallocSizeOf) const final {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ return SizeOfExcludingThis(aMallocSizeOf, lock);
+ }
+
+ [[nodiscard]] size_t SizeOfIncludingThis(
+ MallocSizeOf aMallocSizeOf) const final {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ MOZ_ASSERT(mUser, "Not registered yet");
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf, lock);
+ }
+
+ void SetUpdateCallback(UpdateCallback&& aUpdateCallback) final {
+ {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mUpdateCallbackMutex);
+ if (mUpdateCallback) {
+ // Signal the end of the previous callback.
+ std::move(mUpdateCallback)(Update(nullptr));
+ mUpdateCallback = nullptr;
+ }
+ }
+
+ if (aUpdateCallback) {
+ Update initialUpdate = [&]() {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ return Update(mUnreleasedBufferBytes, mReleasedBufferBytes,
+ mReleasedChunks.get(), nullptr);
+ }();
+
+ baseprofiler::detail::BaseProfilerAutoLock lock(mUpdateCallbackMutex);
+ MOZ_ASSERT(!mUpdateCallback, "Only one update callback allowed");
+ mUpdateCallback = std::move(aUpdateCallback);
+ mUpdateCallback(std::move(initialUpdate));
+ }
+ }
+
+ void DestroyChunksAtOrBefore(TimeStamp aDoneTimeStamp) final {
+ MOZ_ASSERT(!aDoneTimeStamp.IsNull());
+ baseprofiler::detail::BaseProfilerAutoLock lock(mMutex);
+ for (;;) {
+ if (!mReleasedChunks) {
+ // We don't own any released chunks (anymore), we're done.
+ break;
+ }
+ if (mReleasedChunks->ChunkHeader().mDoneTimeStamp > aDoneTimeStamp) {
+ // The current chunk is strictly after the given timestamp, we're done.
+ break;
+ }
+ // We've found a chunk at or before the timestamp, discard it.
+ DiscardOldestReleasedChunk(lock);
+ }
+ }
+
+ protected:
+ const ProfileBufferChunk* PeekExtantReleasedChunksAndLock() final
+ MOZ_CAPABILITY_ACQUIRE(mMutex) {
+ mMutex.Lock();
+ MOZ_ASSERT(mUser, "Not registered yet");
+ return mReleasedChunks.get();
+ }
+ void UnlockAfterPeekExtantReleasedChunks() final
+ MOZ_CAPABILITY_RELEASE(mMutex) {
+ mMutex.Unlock();
+ }
+
+ private:
+ size_t MaybeRecycleChunkAndGetDeallocatedSize(
+ UniquePtr<ProfileBufferChunk>&& chunk,
+ const baseprofiler::detail::BaseProfilerAutoLock& aLock) {
+ // Try to recycle big-enough chunks. (All chunks should have the same size,
+ // but it's a cheap test and may allow future adjustments based on actual
+ // data rate.)
+ if (chunk->BufferBytes() >= mChunkMinBufferBytes) {
+ // We keep up to two recycled chunks at any time.
+ if (!mRecycledChunks) {
+ mRecycledChunks = std::move(chunk);
+ return 0;
+ } else if (!mRecycledChunks->GetNext()) {
+ mRecycledChunks->InsertNext(std::move(chunk));
+ return 0;
+ }
+ }
+ return moz_malloc_usable_size(chunk.get());
+ }
+
+ UniquePtr<ProfileBufferChunk> TakeRecycledChunk(
+ const baseprofiler::detail::BaseProfilerAutoLock& aLock) {
+ UniquePtr<ProfileBufferChunk> recycled;
+ if (mRecycledChunks) {
+ recycled = std::exchange(mRecycledChunks, mRecycledChunks->ReleaseNext());
+ recycled->MarkRecycled();
+ }
+ return recycled;
+ }
+
+ void DiscardOldestReleasedChunk(
+ const baseprofiler::detail::BaseProfilerAutoLock& aLock) {
+ MOZ_ASSERT(!!mReleasedChunks);
+ UniquePtr<ProfileBufferChunk> oldest =
+ std::exchange(mReleasedChunks, mReleasedChunks->ReleaseNext());
+ mReleasedBufferBytes -= oldest->BufferBytes();
+ if (mChunkDestroyedCallback) {
+ // Inform the user that we're going to destroy this chunk.
+ mChunkDestroyedCallback(*oldest);
+ }
+
+ mTotalBytes -=
+ MaybeRecycleChunkAndGetDeallocatedSize(std::move(oldest), aLock);
+ }
+
+ using ChunkAndUpdate = std::pair<UniquePtr<ProfileBufferChunk>, Update>;
+ [[nodiscard]] ChunkAndUpdate GetChunk(
+ const baseprofiler::detail::BaseProfilerAutoLock& aLock) {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ // After this function, the total memory consumption will be the sum of:
+ // - Bytes from released (i.e., full) chunks,
+ // - Bytes from unreleased (still in use) chunks,
+ // - Bytes from the chunk we want to create/recycle. (Note that we don't
+ // count the extra bytes of chunk header, and of extra allocation ability,
+ // for the new chunk, as it's assumed to be negligible compared to the
+ // total memory limit.)
+ // If this total is higher than the local limit, we'll want to destroy
+ // the oldest released chunks until we're under the limit; if any, we may
+ // recycle one of them to avoid a deallocation followed by an allocation.
+ while (mReleasedBufferBytes + mUnreleasedBufferBytes +
+ mChunkMinBufferBytes >=
+ mMaxTotalBytes &&
+ !!mReleasedChunks) {
+ // We have reached the local limit, discard the oldest released chunk.
+ DiscardOldestReleasedChunk(aLock);
+ }
+
+ // Extract the recycled chunk, if any.
+ ChunkAndUpdate chunkAndUpdate{TakeRecycledChunk(aLock), Update()};
+ UniquePtr<ProfileBufferChunk>& chunk = chunkAndUpdate.first;
+
+ if (!chunk) {
+ // No recycled chunk -> Create a chunk now. (This could still fail.)
+ chunk = ProfileBufferChunk::Create(mChunkMinBufferBytes);
+ mTotalBytes += moz_malloc_usable_size(chunk.get());
+ }
+
+ if (chunk) {
+ // We do have a chunk (recycled or new), record its size as "unreleased".
+ mUnreleasedBufferBytes += chunk->BufferBytes();
+
+ chunkAndUpdate.second =
+ Update(mUnreleasedBufferBytes, mReleasedBufferBytes,
+ mReleasedChunks.get(), nullptr);
+ }
+
+ return chunkAndUpdate;
+ }
+
+ [[nodiscard]] size_t SizeOfExcludingThis(
+ MallocSizeOf aMallocSizeOf,
+ const baseprofiler::detail::BaseProfilerAutoLock&) const {
+ MOZ_ASSERT(mUser, "Not registered yet");
+ size_t size = 0;
+ if (mReleasedChunks) {
+ size += mReleasedChunks->SizeOfIncludingThis(aMallocSizeOf);
+ }
+ if (mRecycledChunks) {
+ size += mRecycledChunks->SizeOfIncludingThis(aMallocSizeOf);
+ }
+ // Note: Missing size of std::function external resources (if any).
+ return size;
+ }
+
+ // Maxumum number of bytes that should be used by all unreleased and released
+ // chunks. Note that only released chunks can be destroyed here, so it is the
+ // responsibility of the user to properly release their chunks when possible.
+ const size_t mMaxTotalBytes;
+
+ // Minimum number of bytes that new chunks should be able to store.
+ // Used when calling `ProfileBufferChunk::Create()`.
+ const Length mChunkMinBufferBytes;
+
+ // Mutex guarding the following members.
+ mutable baseprofiler::detail::BaseProfilerMutex mMutex;
+
+ // Number of bytes currently held in chunks that have been given away (through
+ // `GetChunk` or `RequestChunk`) and not released yet.
+ size_t mUnreleasedBufferBytes = 0;
+
+ // Number of bytes currently held in chunks that have been released and stored
+ // in `mReleasedChunks` below.
+ size_t mReleasedBufferBytes = 0;
+
+ // Total allocated size (used to substract it from memory counters).
+ size_t mTotalBytes = 0;
+
+ // List of all released chunks. The oldest one should be at the start of the
+ // list, and may be destroyed or recycled when the memory limit is reached.
+ UniquePtr<ProfileBufferChunk> mReleasedChunks;
+
+ // This may hold chunks that were released then slated for destruction, they
+ // will be reused next time an allocation would have been needed.
+ UniquePtr<ProfileBufferChunk> mRecycledChunks;
+
+ // Optional callback used to notify the user when a chunk is about to be
+ // destroyed or recycled. (The data content is always destroyed, but the chunk
+ // container may be reused.)
+ std::function<void(const ProfileBufferChunk&)> mChunkDestroyedCallback;
+
+ // Callback set from `RequestChunk()`, until it is serviced in
+ // `FulfillChunkRequests()`. There can only be one request in flight.
+ std::function<void(UniquePtr<ProfileBufferChunk>)> mChunkReceiver;
+
+ // Separate mutex guarding mUpdateCallback, so that it may be invoked outside
+ // of the main buffer `mMutex`.
+ mutable baseprofiler::detail::BaseProfilerMutex mUpdateCallbackMutex;
+
+ UpdateCallback mUpdateCallback;
+};
+
+} // namespace mozilla
+
+#endif // ProfileBufferChunkManagerWithLocalLimit_h
diff --git a/mozglue/baseprofiler/public/ProfileBufferControlledChunkManager.h b/mozglue/baseprofiler/public/ProfileBufferControlledChunkManager.h
new file mode 100644
index 0000000000..45b39b163c
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileBufferControlledChunkManager.h
@@ -0,0 +1,203 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferControlledChunkManager_h
+#define ProfileBufferControlledChunkManager_h
+
+#include "mozilla/ProfileBufferChunk.h"
+
+#include <functional>
+#include <vector>
+
+namespace mozilla {
+
+// A "Controlled" chunk manager will provide updates about chunks that it
+// creates, releases, and destroys; and it can destroy released chunks as
+// requested.
+class ProfileBufferControlledChunkManager {
+ public:
+ using Length = ProfileBufferChunk::Length;
+
+ virtual ~ProfileBufferControlledChunkManager() = default;
+
+ // Minimum amount of chunk metadata to be transferred between processes.
+ struct ChunkMetadata {
+ // Timestamp when chunk was marked "done", which is used to:
+ // - determine its age, so the oldest one will be destroyed first,
+ // - uniquely identify this chunk in this process. (The parent process is
+ // responsible for associating this timestamp to its process id.)
+ TimeStamp mDoneTimeStamp;
+ // Size of this chunk's buffer.
+ Length mBufferBytes;
+
+ ChunkMetadata(TimeStamp aDoneTimeStamp, Length aBufferBytes)
+ : mDoneTimeStamp(aDoneTimeStamp), mBufferBytes(aBufferBytes) {}
+ };
+
+ // Class collecting all information necessary to describe updates that
+ // happened in a chunk manager.
+ // An update can be folded into a previous update.
+ class Update {
+ public:
+ // Construct a "not-an-Update" object, which should only be used after a
+ // real update is folded into it.
+ Update() = default;
+
+ // Construct a "final" Update, which marks the end of all updates from a
+ // chunk manager.
+ explicit Update(decltype(nullptr)) : mUnreleasedBytes(FINAL) {}
+
+ // Construct an Update from the given data and released chunks.
+ // The chunk pointers may be null, and it doesn't matter if
+ // `aNewlyReleasedChunks` is already linked to `aExistingReleasedChunks` or
+ // not.
+ Update(size_t aUnreleasedBytes, size_t aReleasedBytes,
+ const ProfileBufferChunk* aExistingReleasedChunks,
+ const ProfileBufferChunk* aNewlyReleasedChunks)
+ : mUnreleasedBytes(aUnreleasedBytes),
+ mReleasedBytes(aReleasedBytes),
+ mOldestDoneTimeStamp(
+ aExistingReleasedChunks
+ ? aExistingReleasedChunks->ChunkHeader().mDoneTimeStamp
+ : TimeStamp{}) {
+ MOZ_RELEASE_ASSERT(
+ !IsNotUpdate(),
+ "Empty update should only be constructed with default constructor");
+ MOZ_RELEASE_ASSERT(
+ !IsFinal(),
+ "Final update should only be constructed with nullptr constructor");
+ for (const ProfileBufferChunk* chunk = aNewlyReleasedChunks; chunk;
+ chunk = chunk->GetNext()) {
+ mNewlyReleasedChunks.emplace_back(ChunkMetadata{
+ chunk->ChunkHeader().mDoneTimeStamp, chunk->BufferBytes()});
+ }
+ }
+
+ // Construct an Update from raw data.
+ // This may be used to re-construct an Update that was previously
+ // serialized.
+ Update(size_t aUnreleasedBytes, size_t aReleasedBytes,
+ TimeStamp aOldestDoneTimeStamp,
+ std::vector<ChunkMetadata>&& aNewlyReleasedChunks)
+ : mUnreleasedBytes(aUnreleasedBytes),
+ mReleasedBytes(aReleasedBytes),
+ mOldestDoneTimeStamp(aOldestDoneTimeStamp),
+ mNewlyReleasedChunks(std::move(aNewlyReleasedChunks)) {}
+
+ // Clear the Update completely and return it to a "not-an-Update" state.
+ void Clear() {
+ mUnreleasedBytes = NO_UPDATE;
+ mReleasedBytes = 0;
+ mOldestDoneTimeStamp = TimeStamp{};
+ mNewlyReleasedChunks.clear();
+ }
+
+ bool IsNotUpdate() const { return mUnreleasedBytes == NO_UPDATE; }
+
+ bool IsFinal() const { return mUnreleasedBytes == FINAL; }
+
+ size_t UnreleasedBytes() const {
+ MOZ_RELEASE_ASSERT(!IsNotUpdate(),
+ "Cannot access UnreleasedBytes from empty update");
+ MOZ_RELEASE_ASSERT(!IsFinal(),
+ "Cannot access UnreleasedBytes from final update");
+ return mUnreleasedBytes;
+ }
+
+ size_t ReleasedBytes() const {
+ MOZ_RELEASE_ASSERT(!IsNotUpdate(),
+ "Cannot access ReleasedBytes from empty update");
+ MOZ_RELEASE_ASSERT(!IsFinal(),
+ "Cannot access ReleasedBytes from final update");
+ return mReleasedBytes;
+ }
+
+ TimeStamp OldestDoneTimeStamp() const {
+ MOZ_RELEASE_ASSERT(!IsNotUpdate(),
+ "Cannot access OldestDoneTimeStamp from empty update");
+ MOZ_RELEASE_ASSERT(!IsFinal(),
+ "Cannot access OldestDoneTimeStamp from final update");
+ return mOldestDoneTimeStamp;
+ }
+
+ const std::vector<ChunkMetadata>& NewlyReleasedChunksRef() const {
+ MOZ_RELEASE_ASSERT(
+ !IsNotUpdate(),
+ "Cannot access NewlyReleasedChunksRef from empty update");
+ MOZ_RELEASE_ASSERT(
+ !IsFinal(), "Cannot access NewlyReleasedChunksRef from final update");
+ return mNewlyReleasedChunks;
+ }
+
+ // Fold a later update into this one.
+ void Fold(Update&& aNewUpdate) {
+ MOZ_ASSERT(
+ !IsFinal() || aNewUpdate.IsFinal(),
+ "There shouldn't be another non-final update after the final update");
+
+ if (IsNotUpdate() || aNewUpdate.IsFinal()) {
+ // We were empty, or the new update is the final update, we just switch
+ // to that new update.
+ *this = std::move(aNewUpdate);
+ return;
+ }
+
+ mUnreleasedBytes = aNewUpdate.mUnreleasedBytes;
+ mReleasedBytes = aNewUpdate.mReleasedBytes;
+ if (!aNewUpdate.mOldestDoneTimeStamp.IsNull()) {
+ MOZ_ASSERT(mOldestDoneTimeStamp.IsNull() ||
+ mOldestDoneTimeStamp <= aNewUpdate.mOldestDoneTimeStamp);
+ mOldestDoneTimeStamp = aNewUpdate.mOldestDoneTimeStamp;
+ auto it = mNewlyReleasedChunks.begin();
+ while (it != mNewlyReleasedChunks.end() &&
+ it->mDoneTimeStamp < mOldestDoneTimeStamp) {
+ it = mNewlyReleasedChunks.erase(it);
+ }
+ }
+ if (!aNewUpdate.mNewlyReleasedChunks.empty()) {
+ mNewlyReleasedChunks.reserve(mNewlyReleasedChunks.size() +
+ aNewUpdate.mNewlyReleasedChunks.size());
+ mNewlyReleasedChunks.insert(mNewlyReleasedChunks.end(),
+ aNewUpdate.mNewlyReleasedChunks.begin(),
+ aNewUpdate.mNewlyReleasedChunks.end());
+ }
+ }
+
+ private:
+ static const size_t NO_UPDATE = size_t(-1);
+ static const size_t FINAL = size_t(-2);
+
+ size_t mUnreleasedBytes = NO_UPDATE;
+ size_t mReleasedBytes = 0;
+ TimeStamp mOldestDoneTimeStamp;
+ std::vector<ChunkMetadata> mNewlyReleasedChunks;
+ };
+
+ using UpdateCallback = std::function<void(Update&&)>;
+
+ // This *may* be set (or reset) by an object that needs to know about all
+ // chunk updates that happen in this manager. The main use will be to
+ // coordinate the global memory usage of Firefox.
+ // If a non-empty callback is given, it will be immediately invoked with the
+ // current state.
+ // When the callback is about to be destroyed (by overwriting it here, or in
+ // the class destructor), it will be invoked one last time with an empty
+ // update.
+ // Note that the callback (even the first current-state callback) will be
+ // invoked from inside a locked scope, so it should *not* call other functions
+ // of the chunk manager. A side benefit of this locking is that it guarantees
+ // that no two invocations can overlap.
+ virtual void SetUpdateCallback(UpdateCallback&& aUpdateCallback) = 0;
+
+ // This is a request to destroy all chunks before the given timestamp.
+ // This timestamp should be one that was given in a previous UpdateCallback
+ // call. Obviously, only released chunks can be destroyed.
+ virtual void DestroyChunksAtOrBefore(TimeStamp aDoneTimeStamp) = 0;
+};
+
+} // namespace mozilla
+
+#endif // ProfileBufferControlledChunkManager_h
diff --git a/mozglue/baseprofiler/public/ProfileBufferEntryKinds.h b/mozglue/baseprofiler/public/ProfileBufferEntryKinds.h
new file mode 100644
index 0000000000..cd5912c49b
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileBufferEntryKinds.h
@@ -0,0 +1,105 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferEntryKinds_h
+#define ProfileBufferEntryKinds_h
+
+#include "mozilla/BaseProfilerUtils.h"
+
+#include <cstdint>
+
+namespace mozilla {
+
+// This is equal to sizeof(double), which is the largest non-char variant in
+// |u|.
+static constexpr size_t ProfileBufferEntryNumChars = 8;
+
+// NOTE! If you add entries, you need to verify if they need to be added to the
+// switch statement in DuplicateLastSample!
+// This will evaluate the MACRO with (KIND, TYPE, SIZE)
+#define FOR_EACH_PROFILE_BUFFER_ENTRY_KIND(MACRO) \
+ MACRO(CategoryPair, int, sizeof(int)) \
+ MACRO(CollectionStart, double, sizeof(double)) \
+ MACRO(CollectionEnd, double, sizeof(double)) \
+ MACRO(Label, const char*, sizeof(const char*)) \
+ MACRO(FrameFlags, uint64_t, sizeof(uint64_t)) \
+ MACRO(DynamicStringFragment, char*, ProfileBufferEntryNumChars) \
+ MACRO(JitReturnAddr, void*, sizeof(void*)) \
+ MACRO(InnerWindowID, uint64_t, sizeof(uint64_t)) \
+ MACRO(LineNumber, int, sizeof(int)) \
+ MACRO(ColumnNumber, int, sizeof(int)) \
+ MACRO(NativeLeafAddr, void*, sizeof(void*)) \
+ MACRO(Pause, double, sizeof(double)) \
+ MACRO(Resume, double, sizeof(double)) \
+ MACRO(PauseSampling, double, sizeof(double)) \
+ MACRO(ResumeSampling, double, sizeof(double)) \
+ MACRO(Responsiveness, double, sizeof(double)) \
+ MACRO(ThreadId, ::mozilla::baseprofiler::BaseProfilerThreadId, \
+ sizeof(::mozilla::baseprofiler::BaseProfilerThreadId)) \
+ MACRO(Time, double, sizeof(double)) \
+ MACRO(TimeBeforeCompactStack, double, sizeof(double)) \
+ MACRO(TimeBeforeSameSample, double, sizeof(double)) \
+ MACRO(CounterId, void*, sizeof(void*)) \
+ MACRO(CounterKey, uint64_t, sizeof(uint64_t)) \
+ MACRO(Number, uint64_t, sizeof(uint64_t)) \
+ MACRO(Count, int64_t, sizeof(int64_t)) \
+ MACRO(ProfilerOverheadTime, double, sizeof(double)) \
+ MACRO(ProfilerOverheadDuration, double, sizeof(double))
+
+// The `Kind` is a single byte identifying the type of data that is actually
+// stored in a `ProfileBufferEntry`, as per the list in
+// `FOR_EACH_PROFILE_BUFFER_ENTRY_KIND`.
+//
+// This byte is also used to identify entries in ProfileChunkedBuffer blocks,
+// for both "legacy" entries that do contain a `ProfileBufferEntry`, and for
+// new types of entries that may carry more data of different types.
+// TODO: Eventually each type of "legacy" entry should be replaced with newer,
+// more efficient kinds of entries (e.g., stack frames could be stored in one
+// bigger entry, instead of multiple `ProfileBufferEntry`s); then we could
+// discard `ProfileBufferEntry` and move this enum to a more appropriate spot.
+enum class ProfileBufferEntryKind : uint8_t {
+ INVALID = 0,
+#define KIND(KIND, TYPE, SIZE) KIND,
+ FOR_EACH_PROFILE_BUFFER_ENTRY_KIND(KIND)
+#undef KIND
+
+ // Any value under `LEGACY_LIMIT` represents a `ProfileBufferEntry`.
+ LEGACY_LIMIT,
+
+ // Any value starting here does *not* represent a `ProfileBufferEntry` and
+ // requires separate decoding and handling.
+
+ // Markers and their data.
+ Marker = LEGACY_LIMIT,
+
+ // Entry with "running times", such as CPU usage measurements.
+ // Optional between TimeBeforeX and X.
+ RunningTimes,
+
+ // Optional between TimeBeforeX and X.
+ UnresponsiveDurationMs,
+
+ // Collection of legacy stack entries, must follow a ThreadId and
+ // TimeBeforeCompactStack (which are not included in the CompactStack;
+ // TimeBeforeCompactStack is equivalent to Time, but indicates that a
+ // CompactStack follows shortly afterwards).
+ CompactStack,
+
+ // Indicates that this sample is identical to the previous one, must follow a
+ // ThreadId and TimeBeforeSameSample.
+ SameSample,
+
+ MODERN_LIMIT
+};
+
+enum class MarkerPayloadType : uint8_t {
+ Cpp,
+ Rust,
+};
+
+} // namespace mozilla
+
+#endif // ProfileBufferEntryKinds_h
diff --git a/mozglue/baseprofiler/public/ProfileBufferEntrySerialization.h b/mozglue/baseprofiler/public/ProfileBufferEntrySerialization.h
new file mode 100644
index 0000000000..bdb3b54d41
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileBufferEntrySerialization.h
@@ -0,0 +1,1184 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferEntrySerialization_h
+#define ProfileBufferEntrySerialization_h
+
+#include "mozilla/Assertions.h"
+#include "mozilla/leb128iterator.h"
+#include "mozilla/Likely.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ProfileBufferIndex.h"
+#include "mozilla/Span.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/Unused.h"
+#include "mozilla/Variant.h"
+
+#include <string>
+#include <tuple>
+
+namespace mozilla {
+
+class ProfileBufferEntryWriter;
+
+// Iterator-like class used to read from an entry.
+// An entry may be split in two memory segments (e.g., the ends of a ring
+// buffer, or two chunks of a chunked buffer); it doesn't deal with this
+// underlying buffer, but only with one or two spans pointing at the space
+// where the entry lives.
+class ProfileBufferEntryReader {
+ public:
+ using Byte = uint8_t;
+ using Length = uint32_t;
+
+ using SpanOfConstBytes = Span<const Byte>;
+
+ // Class to be specialized for types to be read from a profile buffer entry.
+ // See common specializations at the bottom of this header.
+ // The following static functions must be provided:
+ // static void ReadInto(EntryReader aER&, T& aT)
+ // {
+ // /* Call `aER.ReadX(...)` function to deserialize into aT, be sure to
+ // read exactly `Bytes(aT)`! */
+ // }
+ // static T Read(EntryReader& aER) {
+ // /* Call `aER.ReadX(...)` function to deserialize and return a `T`, be
+ // sure to read exactly `Bytes(returned value)`! */
+ // }
+ template <typename T>
+ struct Deserializer;
+
+ ProfileBufferEntryReader() = default;
+
+ // Reader over one Span.
+ ProfileBufferEntryReader(SpanOfConstBytes aSpan,
+ ProfileBufferBlockIndex aCurrentBlockIndex,
+ ProfileBufferBlockIndex aNextBlockIndex)
+ : mCurrentSpan(aSpan),
+ mNextSpanOrEmpty(aSpan.Last(0)),
+ mCurrentBlockIndex(aCurrentBlockIndex),
+ mNextBlockIndex(aNextBlockIndex) {
+ // 2nd internal Span points at the end of the 1st internal Span, to enforce
+ // invariants.
+ CheckInvariants();
+ }
+
+ // Reader over two Spans, the second one must not be empty.
+ ProfileBufferEntryReader(SpanOfConstBytes aSpanHead,
+ SpanOfConstBytes aSpanTail,
+ ProfileBufferBlockIndex aCurrentBlockIndex,
+ ProfileBufferBlockIndex aNextBlockIndex)
+ : mCurrentSpan(aSpanHead),
+ mNextSpanOrEmpty(aSpanTail),
+ mCurrentBlockIndex(aCurrentBlockIndex),
+ mNextBlockIndex(aNextBlockIndex) {
+ MOZ_RELEASE_ASSERT(!mNextSpanOrEmpty.IsEmpty());
+ if (MOZ_UNLIKELY(mCurrentSpan.IsEmpty())) {
+ // First span is already empty, skip it.
+ mCurrentSpan = mNextSpanOrEmpty;
+ mNextSpanOrEmpty = mNextSpanOrEmpty.Last(0);
+ }
+ CheckInvariants();
+ }
+
+ // Allow copying, which is needed when used as an iterator in some std
+ // functions (e.g., string assignment), and to occasionally backtrack.
+ // Be aware that the main profile buffer APIs give a reference to an entry
+ // reader, and expect that reader to advance to the end of the entry, so don't
+ // just advance copies!
+ ProfileBufferEntryReader(const ProfileBufferEntryReader&) = default;
+ ProfileBufferEntryReader& operator=(const ProfileBufferEntryReader&) =
+ default;
+
+ // Don't =default moving, as it doesn't bring any benefit in this class.
+
+ [[nodiscard]] Length RemainingBytes() const {
+ return mCurrentSpan.LengthBytes() + mNextSpanOrEmpty.LengthBytes();
+ }
+
+ void SetRemainingBytes(Length aBytes) {
+ MOZ_RELEASE_ASSERT(aBytes <= RemainingBytes());
+ if (aBytes <= mCurrentSpan.LengthBytes()) {
+ mCurrentSpan = mCurrentSpan.First(aBytes);
+ mNextSpanOrEmpty = mCurrentSpan.Last(0);
+ } else {
+ mNextSpanOrEmpty =
+ mNextSpanOrEmpty.First(aBytes - mCurrentSpan.LengthBytes());
+ }
+ }
+
+ [[nodiscard]] ProfileBufferBlockIndex CurrentBlockIndex() const {
+ return mCurrentBlockIndex;
+ }
+
+ [[nodiscard]] ProfileBufferBlockIndex NextBlockIndex() const {
+ return mNextBlockIndex;
+ }
+
+ // Create a reader of size zero, pointing at aOffset past the current position
+ // of this Reader, so it can be used as end iterator.
+ [[nodiscard]] ProfileBufferEntryReader EmptyIteratorAtOffset(
+ Length aOffset) const {
+ MOZ_RELEASE_ASSERT(aOffset <= RemainingBytes());
+ if (MOZ_LIKELY(aOffset < mCurrentSpan.LengthBytes())) {
+ // aOffset is before the end of mCurrentSpan.
+ return ProfileBufferEntryReader(mCurrentSpan.Subspan(aOffset, 0),
+ mCurrentBlockIndex, mNextBlockIndex);
+ }
+ // aOffset is right at the end of mCurrentSpan, or inside mNextSpanOrEmpty.
+ return ProfileBufferEntryReader(
+ mNextSpanOrEmpty.Subspan(aOffset - mCurrentSpan.LengthBytes(), 0),
+ mCurrentBlockIndex, mNextBlockIndex);
+ }
+
+ // Be like a limited input iterator, with only `*`, prefix-`++`, `==`, `!=`.
+ // These definitions are expected by std functions, to recognize this as an
+ // iterator. See https://en.cppreference.com/w/cpp/iterator/iterator_traits
+ using difference_type = std::make_signed_t<Length>;
+ using value_type = Byte;
+ using pointer = const Byte*;
+ using reference = const Byte&;
+ using iterator_category = std::input_iterator_tag;
+
+ [[nodiscard]] const Byte& operator*() {
+ // Assume the caller will read from the returned reference (and not just
+ // take the address).
+ MOZ_RELEASE_ASSERT(mCurrentSpan.LengthBytes() >= 1);
+ return *(mCurrentSpan.Elements());
+ }
+
+ ProfileBufferEntryReader& operator++() {
+ MOZ_RELEASE_ASSERT(mCurrentSpan.LengthBytes() >= 1);
+ if (MOZ_LIKELY(mCurrentSpan.LengthBytes() > 1)) {
+ // More than 1 byte left in mCurrentSpan, just eat it.
+ mCurrentSpan = mCurrentSpan.From(1);
+ } else {
+ // mCurrentSpan will be empty, move mNextSpanOrEmpty to mCurrentSpan.
+ mCurrentSpan = mNextSpanOrEmpty;
+ mNextSpanOrEmpty = mNextSpanOrEmpty.Last(0);
+ }
+ CheckInvariants();
+ return *this;
+ }
+
+ ProfileBufferEntryReader& operator+=(Length aBytes) {
+ MOZ_RELEASE_ASSERT(aBytes <= RemainingBytes());
+ if (MOZ_LIKELY(aBytes <= mCurrentSpan.LengthBytes())) {
+ // All bytes are in mCurrentSpan.
+ // Update mCurrentSpan past the read bytes.
+ mCurrentSpan = mCurrentSpan.From(aBytes);
+ if (mCurrentSpan.IsEmpty() && !mNextSpanOrEmpty.IsEmpty()) {
+ // Don't leave mCurrentSpan empty, move non-empty mNextSpanOrEmpty into
+ // mCurrentSpan.
+ mCurrentSpan = mNextSpanOrEmpty;
+ mNextSpanOrEmpty = mNextSpanOrEmpty.Last(0);
+ }
+ } else {
+ // mCurrentSpan does not hold enough bytes.
+ // This should only happen at most once: Only for double spans, and when
+ // data crosses the gap.
+ const Length tail =
+ aBytes - static_cast<Length>(mCurrentSpan.LengthBytes());
+ // Move mNextSpanOrEmpty to mCurrentSpan, past the data. So the next call
+ // will go back to the true case above.
+ mCurrentSpan = mNextSpanOrEmpty.From(tail);
+ mNextSpanOrEmpty = mNextSpanOrEmpty.Last(0);
+ }
+ CheckInvariants();
+ return *this;
+ }
+
+ [[nodiscard]] bool operator==(const ProfileBufferEntryReader& aOther) const {
+ return mCurrentSpan.Elements() == aOther.mCurrentSpan.Elements();
+ }
+ [[nodiscard]] bool operator!=(const ProfileBufferEntryReader& aOther) const {
+ return mCurrentSpan.Elements() != aOther.mCurrentSpan.Elements();
+ }
+
+ // Read an unsigned LEB128 number and move iterator ahead.
+ template <typename T>
+ [[nodiscard]] T ReadULEB128() {
+ return ::mozilla::ReadULEB128<T>(*this);
+ }
+
+ // This struct points at a number of bytes through either one span, or two
+ // separate spans (in the rare cases when it is split between two chunks).
+ // So the possibilities are:
+ // - Totally empty: { [] [] }
+ // - First span is not empty: { [content] [] } (Most common case.)
+ // - Both spans are not empty: { [cont] [ent] }
+ // But something like { [] [content] } is not possible.
+ //
+ // Recommended usage patterns:
+ // - Call a utility function like `CopyBytesTo` if you always need to copy the
+ // data to an outside buffer, e.g., to deserialize an aligned object.
+ // - Access both spans one after the other; Note that the second one may be
+ // empty; and the fist could be empty as well if there is no data at all.
+ // - Check is the second span is empty, in which case you only need to read
+ // the first one; and since its part of a chunk, it may be directly passed
+ // as an unaligned pointer or reference, thereby saving one copy. But
+ // remember to always handle the double-span case as well.
+ //
+ // Reminder: An empty span still has a non-null pointer, so it's safe to use
+ // with functions like memcpy.
+ struct DoubleSpanOfConstBytes {
+ SpanOfConstBytes mFirstOrOnly;
+ SpanOfConstBytes mSecondOrEmpty;
+
+ void CheckInvariants() const {
+ MOZ_ASSERT(mFirstOrOnly.IsEmpty() ? mSecondOrEmpty.IsEmpty() : true,
+ "mSecondOrEmpty should not be the only span to contain data");
+ }
+
+ DoubleSpanOfConstBytes() : mFirstOrOnly(), mSecondOrEmpty() {
+ CheckInvariants();
+ }
+
+ DoubleSpanOfConstBytes(const Byte* aOnlyPointer, size_t aOnlyLength)
+ : mFirstOrOnly(aOnlyPointer, aOnlyLength), mSecondOrEmpty() {
+ CheckInvariants();
+ }
+
+ DoubleSpanOfConstBytes(const Byte* aFirstPointer, size_t aFirstLength,
+ const Byte* aSecondPointer, size_t aSecondLength)
+ : mFirstOrOnly(aFirstPointer, aFirstLength),
+ mSecondOrEmpty(aSecondPointer, aSecondLength) {
+ CheckInvariants();
+ }
+
+ // Is there no data at all?
+ [[nodiscard]] bool IsEmpty() const {
+ // We only need to check the first span, because if it's empty, the second
+ // one must be empty as well.
+ return mFirstOrOnly.IsEmpty();
+ }
+
+ // Total length (in bytes) pointed at by both spans.
+ [[nodiscard]] size_t LengthBytes() const {
+ return mFirstOrOnly.LengthBytes() + mSecondOrEmpty.LengthBytes();
+ }
+
+ // Utility functions to copy all `LengthBytes()` to a given buffer.
+ void CopyBytesTo(void* aDest) const {
+ memcpy(aDest, mFirstOrOnly.Elements(), mFirstOrOnly.LengthBytes());
+ if (MOZ_UNLIKELY(!mSecondOrEmpty.IsEmpty())) {
+ memcpy(static_cast<Byte*>(aDest) + mFirstOrOnly.LengthBytes(),
+ mSecondOrEmpty.Elements(), mSecondOrEmpty.LengthBytes());
+ }
+ }
+
+ // If the second span is empty, only the first span may point at data.
+ [[nodiscard]] bool IsSingleSpan() const { return mSecondOrEmpty.IsEmpty(); }
+ };
+
+ // Get Span(s) to a sequence of bytes, see `DoubleSpanOfConstBytes` for usage.
+ // Note that the reader location is *not* updated, do `+=` on it afterwards.
+ [[nodiscard]] DoubleSpanOfConstBytes PeekSpans(Length aBytes) const {
+ MOZ_RELEASE_ASSERT(aBytes <= RemainingBytes());
+ if (MOZ_LIKELY(aBytes <= mCurrentSpan.LengthBytes())) {
+ // All `aBytes` are in the current chunk, only one span is needed.
+ return DoubleSpanOfConstBytes{mCurrentSpan.Elements(), aBytes};
+ }
+ // Otherwise the first span covers then end of the current chunk, and the
+ // second span starts in the next chunk.
+ return DoubleSpanOfConstBytes{
+ mCurrentSpan.Elements(), mCurrentSpan.LengthBytes(),
+ mNextSpanOrEmpty.Elements(), aBytes - mCurrentSpan.LengthBytes()};
+ }
+
+ // Get Span(s) to a sequence of bytes, see `DoubleSpanOfConstBytes` for usage,
+ // and move the reader forward.
+ [[nodiscard]] DoubleSpanOfConstBytes ReadSpans(Length aBytes) {
+ DoubleSpanOfConstBytes spans = PeekSpans(aBytes);
+ (*this) += aBytes;
+ return spans;
+ }
+
+ // Read a sequence of bytes, like memcpy.
+ void ReadBytes(void* aDest, Length aBytes) {
+ DoubleSpanOfConstBytes spans = ReadSpans(aBytes);
+ MOZ_ASSERT(spans.LengthBytes() == aBytes);
+ spans.CopyBytesTo(aDest);
+ }
+
+ template <typename T>
+ void ReadIntoObject(T& aObject) {
+ Deserializer<T>::ReadInto(*this, aObject);
+ }
+
+ // Read into one or more objects, sequentially.
+ // `EntryReader::ReadIntoObjects()` with nothing is implicitly allowed, this
+ // could be useful for generic programming.
+ template <typename... Ts>
+ void ReadIntoObjects(Ts&... aTs) {
+ (ReadIntoObject(aTs), ...);
+ }
+
+ // Read data as an object and move iterator ahead.
+ template <typename T>
+ [[nodiscard]] T ReadObject() {
+ T ob = Deserializer<T>::Read(*this);
+ return ob;
+ }
+
+ private:
+ friend class ProfileBufferEntryWriter;
+
+ // Invariants:
+ // - mCurrentSpan cannot be empty unless mNextSpanOrEmpty is also empty. So
+ // mCurrentSpan always points at the next byte to read or the end.
+ // - If mNextSpanOrEmpty is empty, it points at the end of mCurrentSpan. So
+ // when reaching the end of mCurrentSpan, we can blindly move
+ // mNextSpanOrEmpty to mCurrentSpan and keep the invariants.
+ SpanOfConstBytes mCurrentSpan;
+ SpanOfConstBytes mNextSpanOrEmpty;
+ ProfileBufferBlockIndex mCurrentBlockIndex;
+ ProfileBufferBlockIndex mNextBlockIndex;
+
+ void CheckInvariants() const {
+ MOZ_ASSERT(!mCurrentSpan.IsEmpty() || mNextSpanOrEmpty.IsEmpty());
+ MOZ_ASSERT(!mNextSpanOrEmpty.IsEmpty() ||
+ (mNextSpanOrEmpty == mCurrentSpan.Last(0)));
+ }
+};
+
+// Iterator-like class used to write into an entry.
+// An entry may be split in two memory segments (e.g., the ends of a ring
+// buffer, or two chunks of a chunked buffer); it doesn't deal with this
+// underlying buffer, but only with one or two spans pointing at the space
+// reserved for the entry.
+class ProfileBufferEntryWriter {
+ public:
+ using Byte = uint8_t;
+ using Length = uint32_t;
+
+ using SpanOfBytes = Span<Byte>;
+
+ // Class to be specialized for types to be written in an entry.
+ // See common specializations at the bottom of this header.
+ // The following static functions must be provided:
+ // static Length Bytes(const T& aT) {
+ // /* Return number of bytes that will be written. */
+ // }
+ // static void Write(ProfileBufferEntryWriter& aEW,
+ // const T& aT) {
+ // /* Call `aEW.WriteX(...)` functions to serialize aT, be sure to write
+ // exactly `Bytes(aT)` bytes! */
+ // }
+ template <typename T>
+ struct Serializer;
+
+ ProfileBufferEntryWriter() = default;
+
+ ProfileBufferEntryWriter(SpanOfBytes aSpan,
+ ProfileBufferBlockIndex aCurrentBlockIndex,
+ ProfileBufferBlockIndex aNextBlockIndex)
+ : mCurrentSpan(aSpan),
+ mCurrentBlockIndex(aCurrentBlockIndex),
+ mNextBlockIndex(aNextBlockIndex) {}
+
+ ProfileBufferEntryWriter(SpanOfBytes aSpanHead, SpanOfBytes aSpanTail,
+ ProfileBufferBlockIndex aCurrentBlockIndex,
+ ProfileBufferBlockIndex aNextBlockIndex)
+ : mCurrentSpan(aSpanHead),
+ mNextSpanOrEmpty(aSpanTail),
+ mCurrentBlockIndex(aCurrentBlockIndex),
+ mNextBlockIndex(aNextBlockIndex) {
+ // Either:
+ // - mCurrentSpan is not empty, OR
+ // - mNextSpanOrEmpty is empty if mNextSpanOrEmpty is empty as well.
+ MOZ_RELEASE_ASSERT(!mCurrentSpan.IsEmpty() || mNextSpanOrEmpty.IsEmpty());
+ }
+
+ // Disable copying and moving, so we can't have multiple writing heads.
+ ProfileBufferEntryWriter(const ProfileBufferEntryWriter&) = delete;
+ ProfileBufferEntryWriter& operator=(const ProfileBufferEntryWriter&) = delete;
+ ProfileBufferEntryWriter(ProfileBufferEntryWriter&&) = delete;
+ ProfileBufferEntryWriter& operator=(ProfileBufferEntryWriter&&) = delete;
+
+ void Set() {
+ mCurrentSpan = SpanOfBytes{};
+ mNextSpanOrEmpty = SpanOfBytes{};
+ mCurrentBlockIndex = nullptr;
+ mNextBlockIndex = nullptr;
+ }
+
+ void Set(SpanOfBytes aSpan, ProfileBufferBlockIndex aCurrentBlockIndex,
+ ProfileBufferBlockIndex aNextBlockIndex) {
+ mCurrentSpan = aSpan;
+ mNextSpanOrEmpty = SpanOfBytes{};
+ mCurrentBlockIndex = aCurrentBlockIndex;
+ mNextBlockIndex = aNextBlockIndex;
+ }
+
+ void Set(SpanOfBytes aSpan0, SpanOfBytes aSpan1,
+ ProfileBufferBlockIndex aCurrentBlockIndex,
+ ProfileBufferBlockIndex aNextBlockIndex) {
+ mCurrentSpan = aSpan0;
+ mNextSpanOrEmpty = aSpan1;
+ mCurrentBlockIndex = aCurrentBlockIndex;
+ mNextBlockIndex = aNextBlockIndex;
+ // Either:
+ // - mCurrentSpan is not empty, OR
+ // - mNextSpanOrEmpty is empty if mNextSpanOrEmpty is empty as well.
+ MOZ_RELEASE_ASSERT(!mCurrentSpan.IsEmpty() || mNextSpanOrEmpty.IsEmpty());
+ }
+
+ [[nodiscard]] Length RemainingBytes() const {
+ return mCurrentSpan.LengthBytes() + mNextSpanOrEmpty.LengthBytes();
+ }
+
+ [[nodiscard]] ProfileBufferBlockIndex CurrentBlockIndex() const {
+ return mCurrentBlockIndex;
+ }
+
+ [[nodiscard]] ProfileBufferBlockIndex NextBlockIndex() const {
+ return mNextBlockIndex;
+ }
+
+ // Be like a limited output iterator, with only `*` and prefix-`++`.
+ // These definitions are expected by std functions, to recognize this as an
+ // iterator. See https://en.cppreference.com/w/cpp/iterator/iterator_traits
+ using value_type = Byte;
+ using pointer = Byte*;
+ using reference = Byte&;
+ using iterator_category = std::output_iterator_tag;
+
+ [[nodiscard]] Byte& operator*() {
+ MOZ_RELEASE_ASSERT(RemainingBytes() >= 1);
+ return *(
+ (MOZ_LIKELY(!mCurrentSpan.IsEmpty()) ? mCurrentSpan : mNextSpanOrEmpty)
+ .Elements());
+ }
+
+ ProfileBufferEntryWriter& operator++() {
+ if (MOZ_LIKELY(mCurrentSpan.LengthBytes() >= 1)) {
+ // There is at least 1 byte in mCurrentSpan, eat it.
+ mCurrentSpan = mCurrentSpan.From(1);
+ } else {
+ // mCurrentSpan is empty, move mNextSpanOrEmpty (past the first byte) to
+ // mCurrentSpan.
+ MOZ_RELEASE_ASSERT(mNextSpanOrEmpty.LengthBytes() >= 1);
+ mCurrentSpan = mNextSpanOrEmpty.From(1);
+ mNextSpanOrEmpty = mNextSpanOrEmpty.First(0);
+ }
+ return *this;
+ }
+
+ ProfileBufferEntryWriter& operator+=(Length aBytes) {
+ // Note: This is a rare operation. The code below is a copy of `WriteBytes`
+ // but without the `memcpy`s.
+ MOZ_RELEASE_ASSERT(aBytes <= RemainingBytes());
+ if (MOZ_LIKELY(aBytes <= mCurrentSpan.LengthBytes())) {
+ // Data fits in mCurrentSpan.
+ // Update mCurrentSpan. It may become empty, so in case of a double span,
+ // the next call will go to the false case below.
+ mCurrentSpan = mCurrentSpan.From(aBytes);
+ } else {
+ // Data does not fully fit in mCurrentSpan.
+ // This should only happen at most once: Only for double spans, and when
+ // data crosses the gap or starts there.
+ const Length tail =
+ aBytes - static_cast<Length>(mCurrentSpan.LengthBytes());
+ // Move mNextSpanOrEmpty to mCurrentSpan, past the data. So the next call
+ // will go back to the true case above.
+ mCurrentSpan = mNextSpanOrEmpty.From(tail);
+ mNextSpanOrEmpty = mNextSpanOrEmpty.First(0);
+ }
+ return *this;
+ }
+
+ // Number of bytes needed to represent `aValue` in unsigned LEB128.
+ template <typename T>
+ [[nodiscard]] static unsigned ULEB128Size(T aValue) {
+ return ::mozilla::ULEB128Size(aValue);
+ }
+
+ // Write number as unsigned LEB128 and move iterator ahead.
+ template <typename T>
+ void WriteULEB128(T aValue) {
+ ::mozilla::WriteULEB128(aValue, *this);
+ }
+
+ // Number of bytes needed to serialize objects.
+ template <typename... Ts>
+ [[nodiscard]] static Length SumBytes(const Ts&... aTs) {
+ return (0 + ... + Serializer<Ts>::Bytes(aTs));
+ }
+
+ // Write a sequence of bytes, like memcpy.
+ void WriteBytes(const void* aSrc, Length aBytes) {
+ MOZ_RELEASE_ASSERT(aBytes <= RemainingBytes());
+ if (MOZ_LIKELY(aBytes <= mCurrentSpan.LengthBytes())) {
+ // Data fits in mCurrentSpan.
+ memcpy(mCurrentSpan.Elements(), aSrc, aBytes);
+ // Update mCurrentSpan. It may become empty, so in case of a double span,
+ // the next call will go to the false case below.
+ mCurrentSpan = mCurrentSpan.From(aBytes);
+ } else {
+ // Data does not fully fit in mCurrentSpan.
+ // This should only happen at most once: Only for double spans, and when
+ // data crosses the gap or starts there.
+ // Split data between the end of mCurrentSpan and the beginning of
+ // mNextSpanOrEmpty. (mCurrentSpan could be empty, it's ok to do a memcpy
+ // because Span::Elements() is never null.)
+ memcpy(mCurrentSpan.Elements(), aSrc, mCurrentSpan.LengthBytes());
+ const Length tail =
+ aBytes - static_cast<Length>(mCurrentSpan.LengthBytes());
+ memcpy(mNextSpanOrEmpty.Elements(),
+ reinterpret_cast<const Byte*>(aSrc) + mCurrentSpan.LengthBytes(),
+ tail);
+ // Move mNextSpanOrEmpty to mCurrentSpan, past the data. So the next call
+ // will go back to the true case above.
+ mCurrentSpan = mNextSpanOrEmpty.From(tail);
+ mNextSpanOrEmpty = mNextSpanOrEmpty.First(0);
+ }
+ }
+
+ void WriteFromReader(ProfileBufferEntryReader& aReader, Length aBytes) {
+ MOZ_RELEASE_ASSERT(aBytes <= RemainingBytes());
+ MOZ_RELEASE_ASSERT(aBytes <= aReader.RemainingBytes());
+ Length read0 = std::min(
+ aBytes, static_cast<Length>(aReader.mCurrentSpan.LengthBytes()));
+ if (read0 != 0) {
+ WriteBytes(aReader.mCurrentSpan.Elements(), read0);
+ }
+ Length read1 = aBytes - read0;
+ if (read1 != 0) {
+ WriteBytes(aReader.mNextSpanOrEmpty.Elements(), read1);
+ }
+ aReader += aBytes;
+ }
+
+ // Write a single object by using the appropriate Serializer.
+ template <typename T>
+ void WriteObject(const T& aObject) {
+ Serializer<T>::Write(*this, aObject);
+ }
+
+ // Write one or more objects, sequentially.
+ // Allow `EntryWrite::WriteObjects()` with nothing, this could be useful
+ // for generic programming.
+ template <typename... Ts>
+ void WriteObjects(const Ts&... aTs) {
+ (WriteObject(aTs), ...);
+ }
+
+ private:
+ // The two spans covering the memory still to be written.
+ SpanOfBytes mCurrentSpan;
+ SpanOfBytes mNextSpanOrEmpty;
+ ProfileBufferBlockIndex mCurrentBlockIndex;
+ ProfileBufferBlockIndex mNextBlockIndex;
+};
+
+// ============================================================================
+// Serializer and Deserializer ready-to-use specializations.
+
+// ----------------------------------------------------------------------------
+// Trivially-copyable types (default)
+
+// The default implementation works for all trivially-copyable types (e.g.,
+// PODs).
+//
+// Usage: `aEW.WriteObject(123);`.
+//
+// Raw pointers, though trivially-copyable, are explictly forbidden when writing
+// (to avoid unexpected leaks/UAFs), instead use one of
+// `WrapProfileBufferLiteralCStringPointer`, `WrapProfileBufferUnownedCString`,
+// or `WrapProfileBufferRawPointer` as needed.
+template <typename T>
+struct ProfileBufferEntryWriter::Serializer {
+ static_assert(std::is_trivially_copyable<T>::value,
+ "Serializer only works with trivially-copyable types by "
+ "default, use/add specialization for other types.");
+
+ static constexpr Length Bytes(const T&) { return sizeof(T); }
+
+ static void Write(ProfileBufferEntryWriter& aEW, const T& aT) {
+ static_assert(!std::is_pointer<T>::value,
+ "Serializer won't write raw pointers by default, use "
+ "WrapProfileBufferRawPointer or other.");
+ aEW.WriteBytes(&aT, sizeof(T));
+ }
+};
+
+// Usage: `aER.ReadObject<int>();` or `int x; aER.ReadIntoObject(x);`.
+template <typename T>
+struct ProfileBufferEntryReader::Deserializer {
+ static_assert(std::is_trivially_copyable<T>::value,
+ "Deserializer only works with trivially-copyable types by "
+ "default, use/add specialization for other types.");
+
+ static void ReadInto(ProfileBufferEntryReader& aER, T& aT) {
+ aER.ReadBytes(&aT, sizeof(T));
+ }
+
+ static T Read(ProfileBufferEntryReader& aER) {
+ // Note that this creates a default `T` first, and then overwrites it with
+ // bytes from the buffer. Trivially-copyable types support this without UB.
+ T ob;
+ ReadInto(aER, ob);
+ return ob;
+ }
+};
+
+// ----------------------------------------------------------------------------
+// Strip const/volatile/reference from types.
+
+// Automatically strip `const`.
+template <typename T>
+struct ProfileBufferEntryWriter::Serializer<const T>
+ : public ProfileBufferEntryWriter::Serializer<T> {};
+
+template <typename T>
+struct ProfileBufferEntryReader::Deserializer<const T>
+ : public ProfileBufferEntryReader::Deserializer<T> {};
+
+// Automatically strip `volatile`.
+template <typename T>
+struct ProfileBufferEntryWriter::Serializer<volatile T>
+ : public ProfileBufferEntryWriter::Serializer<T> {};
+
+template <typename T>
+struct ProfileBufferEntryReader::Deserializer<volatile T>
+ : public ProfileBufferEntryReader::Deserializer<T> {};
+
+// Automatically strip `lvalue-reference`.
+template <typename T>
+struct ProfileBufferEntryWriter::Serializer<T&>
+ : public ProfileBufferEntryWriter::Serializer<T> {};
+
+template <typename T>
+struct ProfileBufferEntryReader::Deserializer<T&>
+ : public ProfileBufferEntryReader::Deserializer<T> {};
+
+// Automatically strip `rvalue-reference`.
+template <typename T>
+struct ProfileBufferEntryWriter::Serializer<T&&>
+ : public ProfileBufferEntryWriter::Serializer<T> {};
+
+template <typename T>
+struct ProfileBufferEntryReader::Deserializer<T&&>
+ : public ProfileBufferEntryReader::Deserializer<T> {};
+
+// ----------------------------------------------------------------------------
+// ProfileBufferBlockIndex
+
+// ProfileBufferBlockIndex, serialized as the underlying value.
+template <>
+struct ProfileBufferEntryWriter::Serializer<ProfileBufferBlockIndex> {
+ static constexpr Length Bytes(const ProfileBufferBlockIndex& aBlockIndex) {
+ return sizeof(ProfileBufferBlockIndex);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const ProfileBufferBlockIndex& aBlockIndex) {
+ aEW.WriteBytes(&aBlockIndex, sizeof(aBlockIndex));
+ }
+};
+
+template <>
+struct ProfileBufferEntryReader::Deserializer<ProfileBufferBlockIndex> {
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ ProfileBufferBlockIndex& aBlockIndex) {
+ aER.ReadBytes(&aBlockIndex, sizeof(aBlockIndex));
+ }
+
+ static ProfileBufferBlockIndex Read(ProfileBufferEntryReader& aER) {
+ ProfileBufferBlockIndex blockIndex;
+ ReadInto(aER, blockIndex);
+ return blockIndex;
+ }
+};
+
+// ----------------------------------------------------------------------------
+// Literal C string pointer
+
+// Wrapper around a pointer to a literal C string.
+template <size_t NonTerminalCharacters>
+struct ProfileBufferLiteralCStringPointer {
+ const char* mCString;
+};
+
+// Wrap a pointer to a literal C string.
+template <size_t CharactersIncludingTerminal>
+ProfileBufferLiteralCStringPointer<CharactersIncludingTerminal - 1>
+WrapProfileBufferLiteralCStringPointer(
+ const char (&aCString)[CharactersIncludingTerminal]) {
+ return {aCString};
+}
+
+// Literal C strings, serialized as the raw pointer because it is unique and
+// valid for the whole program lifetime.
+//
+// Usage: `aEW.WriteObject(WrapProfileBufferLiteralCStringPointer("hi"));`.
+//
+// No deserializer is provided for this type, instead it must be deserialized as
+// a raw pointer: `aER.ReadObject<const char*>();`
+template <size_t CharactersIncludingTerminal>
+struct ProfileBufferEntryReader::Deserializer<
+ ProfileBufferLiteralCStringPointer<CharactersIncludingTerminal>> {
+ static constexpr Length Bytes(
+ const ProfileBufferLiteralCStringPointer<CharactersIncludingTerminal>&) {
+ // We're only storing a pointer, its size is independent from the pointer
+ // value.
+ return sizeof(const char*);
+ }
+
+ static void Write(
+ ProfileBufferEntryWriter& aEW,
+ const ProfileBufferLiteralCStringPointer<CharactersIncludingTerminal>&
+ aWrapper) {
+ // Write the pointer *value*, not the string contents.
+ aEW.WriteBytes(aWrapper.mCString, sizeof(aWrapper.mCString));
+ }
+};
+
+// ----------------------------------------------------------------------------
+// C string contents
+
+// Wrapper around a pointer to a C string whose contents will be serialized.
+struct ProfileBufferUnownedCString {
+ const char* mCString;
+};
+
+// Wrap a pointer to a C string whose contents will be serialized.
+inline ProfileBufferUnownedCString WrapProfileBufferUnownedCString(
+ const char* aCString) {
+ return {aCString};
+}
+
+// The contents of a (probably) unowned C string are serialized as the number of
+// characters (encoded as ULEB128) and all the characters in the string. The
+// terminal '\0' is omitted.
+//
+// Usage: `aEW.WriteObject(WrapProfileBufferUnownedCString(str.c_str()))`.
+//
+// No deserializer is provided for this pointer type, instead it must be
+// deserialized as one of the other string types that manages its contents,
+// e.g.: `aER.ReadObject<std::string>();`
+template <>
+struct ProfileBufferEntryWriter::Serializer<ProfileBufferUnownedCString> {
+ static Length Bytes(const ProfileBufferUnownedCString& aS) {
+ const auto len = strlen(aS.mCString);
+ return ULEB128Size(len) + len;
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const ProfileBufferUnownedCString& aS) {
+ const auto len = strlen(aS.mCString);
+ aEW.WriteULEB128(len);
+ aEW.WriteBytes(aS.mCString, len);
+ }
+};
+
+// ----------------------------------------------------------------------------
+// Raw pointers
+
+// Wrapper around a pointer to be serialized as the raw pointer value.
+template <typename T>
+struct ProfileBufferRawPointer {
+ T* mRawPointer;
+};
+
+// Wrap a pointer to be serialized as the raw pointer value.
+template <typename T>
+ProfileBufferRawPointer<T> WrapProfileBufferRawPointer(T* aRawPointer) {
+ return {aRawPointer};
+}
+
+// Raw pointers are serialized as the raw pointer value.
+//
+// Usage: `aEW.WriteObject(WrapProfileBufferRawPointer(ptr));`
+//
+// The wrapper is compulsory when writing pointers (to avoid unexpected
+// leaks/UAFs), but reading can be done straight into a raw pointer object,
+// e.g.: `aER.ReadObject<Foo*>;`.
+template <typename T>
+struct ProfileBufferEntryWriter::Serializer<ProfileBufferRawPointer<T>> {
+ template <typename U>
+ static constexpr Length Bytes(const U&) {
+ return sizeof(T*);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const ProfileBufferRawPointer<T>& aWrapper) {
+ aEW.WriteBytes(&aWrapper.mRawPointer, sizeof(aWrapper.mRawPointer));
+ }
+};
+
+// Usage: `aER.ReadObject<Foo*>;` or `Foo* p; aER.ReadIntoObject(p);`, no
+// wrapper necessary.
+template <typename T>
+struct ProfileBufferEntryReader::Deserializer<ProfileBufferRawPointer<T>> {
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ ProfileBufferRawPointer<T>& aPtr) {
+ aER.ReadBytes(&aPtr.mRawPointer, sizeof(aPtr));
+ }
+
+ static ProfileBufferRawPointer<T> Read(ProfileBufferEntryReader& aER) {
+ ProfileBufferRawPointer<T> rawPointer;
+ ReadInto(aER, rawPointer);
+ return rawPointer;
+ }
+};
+
+// ----------------------------------------------------------------------------
+// std::string contents
+
+// std::string contents are serialized as the number of characters (encoded as
+// ULEB128) and all the characters in the string. The terminal '\0' is omitted.
+//
+// Usage: `std::string s = ...; aEW.WriteObject(s);`
+template <typename CHAR>
+struct ProfileBufferEntryWriter::Serializer<std::basic_string<CHAR>> {
+ static Length Bytes(const std::basic_string<CHAR>& aS) {
+ const Length len = static_cast<Length>(aS.length());
+ return ULEB128Size(len) + len;
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const std::basic_string<CHAR>& aS) {
+ const Length len = static_cast<Length>(aS.length());
+ aEW.WriteULEB128(len);
+ aEW.WriteBytes(aS.c_str(), len * sizeof(CHAR));
+ }
+};
+
+// Usage: `std::string s = aEW.ReadObject<std::string>(s);` or
+// `std::string s; aER.ReadIntoObject(s);`
+template <typename CHAR>
+struct ProfileBufferEntryReader::Deserializer<std::basic_string<CHAR>> {
+ static void ReadCharsInto(ProfileBufferEntryReader& aER,
+ std::basic_string<CHAR>& aS, size_t aLength) {
+ // Assign to `aS` by using iterators.
+ // (`aER+0` so we get the same iterator type as `aER+len`.)
+ aS.assign(aER, aER.EmptyIteratorAtOffset(aLength));
+ aER += aLength;
+ }
+
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ std::basic_string<CHAR>& aS) {
+ ReadCharsInto(
+ aER, aS,
+ aER.ReadULEB128<typename std::basic_string<CHAR>::size_type>());
+ }
+
+ static std::basic_string<CHAR> ReadChars(ProfileBufferEntryReader& aER,
+ size_t aLength) {
+ // Construct a string by using iterators.
+ // (`aER+0` so we get the same iterator type as `aER+len`.)
+ std::basic_string<CHAR> s(aER, aER.EmptyIteratorAtOffset(aLength));
+ aER += aLength;
+ return s;
+ }
+
+ static std::basic_string<CHAR> Read(ProfileBufferEntryReader& aER) {
+ return ReadChars(
+ aER, aER.ReadULEB128<typename std::basic_string<CHAR>::size_type>());
+ }
+};
+
+// ----------------------------------------------------------------------------
+// mozilla::UniqueFreePtr<CHAR>
+
+// UniqueFreePtr<CHAR>, which points at a string allocated with `malloc`
+// (typically generated by `strdup()`), is serialized as the number of
+// *bytes* (encoded as ULEB128) and all the characters in the string. The
+// null terminator is omitted.
+// `CHAR` can be any type that has a specialization for
+// `std::char_traits<CHAR>::length(const CHAR*)`.
+//
+// Note: A nullptr pointer will be serialized like an empty string, so when
+// deserializing it will result in an allocated buffer only containing a
+// single null terminator.
+template <typename CHAR>
+struct ProfileBufferEntryWriter::Serializer<UniqueFreePtr<CHAR>> {
+ static Length Bytes(const UniqueFreePtr<CHAR>& aS) {
+ if (!aS) {
+ // Null pointer, store it as if it was an empty string (so: 0 bytes).
+ return ULEB128Size(0u);
+ }
+ // Note that we store the size in *bytes*, not in number of characters.
+ const auto bytes = std::char_traits<CHAR>::length(aS.get()) * sizeof(CHAR);
+ return ULEB128Size(bytes) + bytes;
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const UniqueFreePtr<CHAR>& aS) {
+ if (!aS) {
+ // Null pointer, store it as if it was an empty string (so we write a
+ // length of 0 bytes).
+ aEW.WriteULEB128(0u);
+ return;
+ }
+ // Note that we store the size in *bytes*, not in number of characters.
+ const auto bytes = std::char_traits<CHAR>::length(aS.get()) * sizeof(CHAR);
+ aEW.WriteULEB128(bytes);
+ aEW.WriteBytes(aS.get(), bytes);
+ }
+};
+
+template <typename CHAR>
+struct ProfileBufferEntryReader::Deserializer<UniqueFreePtr<CHAR>> {
+ static void ReadInto(ProfileBufferEntryReader& aER, UniqueFreePtr<CHAR>& aS) {
+ aS = Read(aER);
+ }
+
+ static UniqueFreePtr<CHAR> Read(ProfileBufferEntryReader& aER) {
+ // Read the number of *bytes* that follow.
+ const auto bytes = aER.ReadULEB128<size_t>();
+ // We need a buffer of the non-const character type.
+ using NC_CHAR = std::remove_const_t<CHAR>;
+ // We allocate the required number of bytes, plus one extra character for
+ // the null terminator.
+ NC_CHAR* buffer = static_cast<NC_CHAR*>(malloc(bytes + sizeof(NC_CHAR)));
+ // Copy the characters into the buffer.
+ aER.ReadBytes(buffer, bytes);
+ // And append a null terminator.
+ buffer[bytes / sizeof(NC_CHAR)] = NC_CHAR(0);
+ return UniqueFreePtr<CHAR>(buffer);
+ }
+};
+
+// ----------------------------------------------------------------------------
+// std::tuple
+
+// std::tuple is serialized as a sequence of each recursively-serialized item.
+//
+// This is equivalent to manually serializing each item, so reading/writing
+// tuples is equivalent to reading/writing their elements in order, e.g.:
+// ```
+// std::tuple<int, std::string> is = ...;
+// aEW.WriteObject(is); // Write the tuple, equivalent to:
+// aEW.WriteObject(/* int */ std::get<0>(is), /* string */ std::get<1>(is));
+// ...
+// // Reading back can be done directly into a tuple:
+// auto is = aER.ReadObject<std::tuple<int, std::string>>();
+// // Or each item could be read separately:
+// auto i = aER.ReadObject<int>(); auto s = aER.ReadObject<std::string>();
+// ```
+template <typename... Ts>
+struct ProfileBufferEntryWriter::Serializer<std::tuple<Ts...>> {
+ private:
+ template <size_t... Is>
+ static Length TupleBytes(const std::tuple<Ts...>& aTuple,
+ std::index_sequence<Is...>) {
+ return (0 + ... + SumBytes(std::get<Is>(aTuple)));
+ }
+
+ template <size_t... Is>
+ static void TupleWrite(ProfileBufferEntryWriter& aEW,
+ const std::tuple<Ts...>& aTuple,
+ std::index_sequence<Is...>) {
+ (aEW.WriteObject(std::get<Is>(aTuple)), ...);
+ }
+
+ public:
+ static Length Bytes(const std::tuple<Ts...>& aTuple) {
+ // Generate a 0..N-1 index pack, we'll add the sizes of each item.
+ return TupleBytes(aTuple, std::index_sequence_for<Ts...>());
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const std::tuple<Ts...>& aTuple) {
+ // Generate a 0..N-1 index pack, we'll write each item.
+ TupleWrite(aEW, aTuple, std::index_sequence_for<Ts...>());
+ }
+};
+
+template <typename... Ts>
+struct ProfileBufferEntryReader::Deserializer<std::tuple<Ts...>> {
+ template <size_t I>
+ static void TupleIReadInto(ProfileBufferEntryReader& aER,
+ std::tuple<Ts...>& aTuple) {
+ aER.ReadIntoObject(std::get<I>(aTuple));
+ }
+
+ template <size_t... Is>
+ static void TupleReadInto(ProfileBufferEntryReader& aER,
+ std::tuple<Ts...>& aTuple,
+ std::index_sequence<Is...>) {
+ (TupleIReadInto<Is>(aER, aTuple), ...);
+ }
+
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ std::tuple<Ts...>& aTuple) {
+ TupleReadInto(aER, aTuple, std::index_sequence_for<Ts...>());
+ }
+
+ static std::tuple<Ts...> Read(ProfileBufferEntryReader& aER) {
+ // Note that this creates default `Ts` first, and then overwrites them.
+ std::tuple<Ts...> ob;
+ ReadInto(aER, ob);
+ return ob;
+ }
+};
+// ----------------------------------------------------------------------------
+// mozilla::Span
+
+// Span. All elements are serialized in sequence.
+// The caller is assumed to know the number of elements (they may manually
+// write&read it before the span if needed).
+// Similar to tuples, reading/writing spans is equivalent to reading/writing
+// their elements in order.
+template <class T, size_t N>
+struct ProfileBufferEntryWriter::Serializer<Span<T, N>> {
+ static Length Bytes(const Span<T, N>& aSpan) {
+ Length bytes = 0;
+ for (const T& element : aSpan) {
+ bytes += SumBytes(element);
+ }
+ return bytes;
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW, const Span<T, N>& aSpan) {
+ for (const T& element : aSpan) {
+ aEW.WriteObject(element);
+ }
+ }
+};
+
+template <class T, size_t N>
+struct ProfileBufferEntryReader::Deserializer<Span<T, N>> {
+ // Read elements back into span pointing at a pre-allocated buffer.
+ static void ReadInto(ProfileBufferEntryReader& aER, Span<T, N>& aSpan) {
+ for (T& element : aSpan) {
+ aER.ReadIntoObject(element);
+ }
+ }
+
+ // A Span does not own its data, this would probably leak so we forbid this.
+ static Span<T, N> Read(ProfileBufferEntryReader& aER) = delete;
+};
+
+// ----------------------------------------------------------------------------
+// mozilla::Maybe
+
+// Maybe<T> is serialized as one byte containing either 'm' (Nothing),
+// or 'M' followed by the recursively-serialized `T` object.
+template <typename T>
+struct ProfileBufferEntryWriter::Serializer<Maybe<T>> {
+ static Length Bytes(const Maybe<T>& aMaybe) {
+ // 1 byte to store nothing/something flag, then object size if present.
+ return aMaybe.isNothing() ? 1 : (1 + SumBytes(aMaybe.ref()));
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW, const Maybe<T>& aMaybe) {
+ // 'm'/'M' is just an arbitrary 1-byte value to distinguish states.
+ if (aMaybe.isNothing()) {
+ aEW.WriteObject<char>('m');
+ } else {
+ aEW.WriteObject<char>('M');
+ // Use the Serializer for the contained type.
+ aEW.WriteObject(aMaybe.ref());
+ }
+ }
+};
+
+template <typename T>
+struct ProfileBufferEntryReader::Deserializer<Maybe<T>> {
+ static void ReadInto(ProfileBufferEntryReader& aER, Maybe<T>& aMaybe) {
+ char c = aER.ReadObject<char>();
+ if (c == 'm') {
+ aMaybe.reset();
+ } else {
+ MOZ_ASSERT(c == 'M');
+ // If aMaybe is empty, create a default `T` first, to be overwritten.
+ // Otherwise we'll just overwrite whatever was already there.
+ if (aMaybe.isNothing()) {
+ aMaybe.emplace();
+ }
+ // Use the Deserializer for the contained type.
+ aER.ReadIntoObject(aMaybe.ref());
+ }
+ }
+
+ static Maybe<T> Read(ProfileBufferEntryReader& aER) {
+ Maybe<T> maybe;
+ char c = aER.ReadObject<char>();
+ MOZ_ASSERT(c == 'M' || c == 'm');
+ if (c == 'M') {
+ // Note that this creates a default `T` inside the Maybe first, and then
+ // overwrites it.
+ maybe = Some(T{});
+ // Use the Deserializer for the contained type.
+ aER.ReadIntoObject(maybe.ref());
+ }
+ return maybe;
+ }
+};
+
+// ----------------------------------------------------------------------------
+// mozilla::Variant
+
+// Variant is serialized as the tag (0-based index of the stored type, encoded
+// as ULEB128), and the recursively-serialized object.
+template <typename... Ts>
+struct ProfileBufferEntryWriter::Serializer<Variant<Ts...>> {
+ public:
+ static Length Bytes(const Variant<Ts...>& aVariantTs) {
+ return aVariantTs.match([](auto aIndex, const auto& aAlternative) {
+ return ULEB128Size(aIndex) + SumBytes(aAlternative);
+ });
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const Variant<Ts...>& aVariantTs) {
+ aVariantTs.match([&aEW](auto aIndex, const auto& aAlternative) {
+ aEW.WriteULEB128(aIndex);
+ aEW.WriteObject(aAlternative);
+ });
+ }
+};
+
+template <typename... Ts>
+struct ProfileBufferEntryReader::Deserializer<Variant<Ts...>> {
+ private:
+ // Called from the fold expression in `VariantReadInto()`, only the selected
+ // variant will deserialize the object.
+ template <size_t I>
+ static void VariantIReadInto(ProfileBufferEntryReader& aER,
+ Variant<Ts...>& aVariantTs, unsigned aTag) {
+ if (I == aTag) {
+ // Ensure the variant contains the target type. Note that this may create
+ // a default object.
+ if (!aVariantTs.template is<I>()) {
+ aVariantTs = Variant<Ts...>(VariantIndex<I>{});
+ }
+ aER.ReadIntoObject(aVariantTs.template as<I>());
+ }
+ }
+
+ template <size_t... Is>
+ static void VariantReadInto(ProfileBufferEntryReader& aER,
+ Variant<Ts...>& aVariantTs,
+ std::index_sequence<Is...>) {
+ unsigned tag = aER.ReadULEB128<unsigned>();
+ (VariantIReadInto<Is>(aER, aVariantTs, tag), ...);
+ }
+
+ public:
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ Variant<Ts...>& aVariantTs) {
+ // Generate a 0..N-1 index pack, the selected variant will deserialize
+ // itself.
+ VariantReadInto(aER, aVariantTs, std::index_sequence_for<Ts...>());
+ }
+
+ static Variant<Ts...> Read(ProfileBufferEntryReader& aER) {
+ // Note that this creates a default `Variant` of the first type, and then
+ // overwrites it. Consider using `ReadInto` for more control if needed.
+ Variant<Ts...> variant(VariantIndex<0>{});
+ ReadInto(aER, variant);
+ return variant;
+ }
+};
+
+} // namespace mozilla
+
+#endif // ProfileBufferEntrySerialization_h
diff --git a/mozglue/baseprofiler/public/ProfileBufferIndex.h b/mozglue/baseprofiler/public/ProfileBufferIndex.h
new file mode 100644
index 0000000000..5cda6bd89e
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileBufferIndex.h
@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileBufferIndex_h
+#define ProfileBufferIndex_h
+
+#include "mozilla/Attributes.h"
+
+#include <cstddef>
+#include <cstdint>
+
+namespace mozilla {
+
+// Generic index into a Profiler buffer, mostly for internal usage.
+// Intended to appear infinite (it should effectively never wrap).
+// 0 (zero) is reserved as nullptr-like value; it may indicate failure result,
+// or it may point at the earliest available block.
+using ProfileBufferIndex = uint64_t;
+
+// Externally-opaque class encapsulating a block index, i.e. a
+// ProfileBufferIndex that is guaranteed to point at the start of a Profile
+// buffer block (until it is destroyed, but then that index cannot be reused and
+// functions should gracefully handle expired blocks).
+// Users may get these from Profile buffer functions, to later access previous
+// blocks; they should avoid converting and operating on their value.
+class ProfileBufferBlockIndex {
+ public:
+ // Default constructor with internal 0 value, for which Profile buffers must
+ // guarantee that it is before any valid entries; All public APIs should
+ // fail gracefully, doing and/or returning Nothing.
+ ProfileBufferBlockIndex() : mBlockIndex(0) {}
+
+ // Implicit conversion from literal `nullptr` to internal 0 value, to allow
+ // convenient init/reset/comparison with 0 index.
+ MOZ_IMPLICIT ProfileBufferBlockIndex(std::nullptr_t) : mBlockIndex(0) {}
+
+ // Explicit conversion to bool, works in `if` and other tests.
+ // Only returns false for default `ProfileBufferBlockIndex{}` value.
+ explicit operator bool() const { return mBlockIndex != 0; }
+
+ // Comparison operators. Default `ProfileBufferBlockIndex{}` value is always
+ // the lowest.
+ [[nodiscard]] bool operator==(const ProfileBufferBlockIndex& aRhs) const {
+ return mBlockIndex == aRhs.mBlockIndex;
+ }
+ [[nodiscard]] bool operator!=(const ProfileBufferBlockIndex& aRhs) const {
+ return mBlockIndex != aRhs.mBlockIndex;
+ }
+ [[nodiscard]] bool operator<(const ProfileBufferBlockIndex& aRhs) const {
+ return mBlockIndex < aRhs.mBlockIndex;
+ }
+ [[nodiscard]] bool operator<=(const ProfileBufferBlockIndex& aRhs) const {
+ return mBlockIndex <= aRhs.mBlockIndex;
+ }
+ [[nodiscard]] bool operator>(const ProfileBufferBlockIndex& aRhs) const {
+ return mBlockIndex > aRhs.mBlockIndex;
+ }
+ [[nodiscard]] bool operator>=(const ProfileBufferBlockIndex& aRhs) const {
+ return mBlockIndex >= aRhs.mBlockIndex;
+ }
+
+ // Explicit conversion to ProfileBufferIndex, mostly used by internal Profile
+ // buffer code.
+ [[nodiscard]] ProfileBufferIndex ConvertToProfileBufferIndex() const {
+ return mBlockIndex;
+ }
+
+ // Explicit creation from ProfileBufferIndex, mostly used by internal
+ // Profile buffer code.
+ [[nodiscard]] static ProfileBufferBlockIndex CreateFromProfileBufferIndex(
+ ProfileBufferIndex aIndex) {
+ return ProfileBufferBlockIndex(aIndex);
+ }
+
+ private:
+ // Private to prevent easy construction from any value. Use
+ // `CreateFromProfileBufferIndex()` instead.
+ // The main reason for this indirection is to make it harder to create these
+ // objects, because only the profiler code should need to do it. Ideally, this
+ // class should be used wherever a block index should be stored, but there is
+ // so much code that uses `uint64_t` that it would be a big task to change
+ // them all. So for now we allow conversions to/from numbers, but it's as ugly
+ // as possible to make sure it doesn't get too common; and if one day we want
+ // to tackle a global change, it should be easy to find all these locations
+ // thanks to the explicit conversion functions.
+ explicit ProfileBufferBlockIndex(ProfileBufferIndex aBlockIndex)
+ : mBlockIndex(aBlockIndex) {}
+
+ ProfileBufferIndex mBlockIndex;
+};
+
+} // namespace mozilla
+
+#endif // ProfileBufferIndex_h
diff --git a/mozglue/baseprofiler/public/ProfileChunkedBuffer.h b/mozglue/baseprofiler/public/ProfileChunkedBuffer.h
new file mode 100644
index 0000000000..ded7fbd08b
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileChunkedBuffer.h
@@ -0,0 +1,1560 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileChunkedBuffer_h
+#define ProfileChunkedBuffer_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/BaseProfilerDetail.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/ProfileBufferChunkManager.h"
+#include "mozilla/ProfileBufferChunkManagerSingle.h"
+#include "mozilla/ProfileBufferEntrySerialization.h"
+#include "mozilla/ProfileChunkedBufferDetail.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Unused.h"
+
+#include <utility>
+
+#ifdef DEBUG
+# include <cstdio>
+#endif
+
+namespace mozilla {
+
+// Thread-safe buffer that can store blocks of different sizes during defined
+// sessions, using Chunks (from a ChunkManager) as storage.
+//
+// Each *block* contains an *entry* and the entry size:
+// [ entry_size | entry ] [ entry_size | entry ] ...
+//
+// *In-session* is a period of time during which `ProfileChunkedBuffer` allows
+// reading and writing.
+// *Out-of-session*, the `ProfileChunkedBuffer` object is still valid, but
+// contains no data, and gracefully denies accesses.
+//
+// To write an entry, the buffer reserves a block of sufficient size (to contain
+// user data of predetermined size), writes the entry size, and lets the caller
+// fill the entry contents using a ProfileBufferEntryWriter. E.g.:
+// ```
+// ProfileChunkedBuffer cb(...);
+// cb.ReserveAndPut([]() { return sizeof(123); },
+// [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+// if (aEW) { aEW->WriteObject(123); }
+// });
+// ```
+// Other `Put...` functions may be used as shortcuts for simple entries.
+// The objects given to the caller's callbacks should only be used inside the
+// callbacks and not stored elsewhere, because they keep their own references to
+// chunk memory and therefore should not live longer.
+// Different type of objects may be serialized into an entry, see
+// `ProfileBufferEntryWriter::Serializer` for more information.
+//
+// When reading data, the buffer iterates over blocks (it knows how to read the
+// entry size, and therefore move to the next block), and lets the caller read
+// the entry inside of each block. E.g.:
+// ```
+// cb.ReadEach([](ProfileBufferEntryReader& aER) {
+// /* Use ProfileBufferEntryReader functions to read serialized objects. */
+// int n = aER.ReadObject<int>();
+// });
+// ```
+// Different type of objects may be deserialized from an entry, see
+// `ProfileBufferEntryReader::Deserializer` for more information.
+//
+// Writers may retrieve the block index corresponding to an entry
+// (`ProfileBufferBlockIndex` is an opaque type preventing the user from easily
+// modifying it). That index may later be used with `ReadAt` to get back to the
+// entry in that particular block -- if it still exists.
+class ProfileChunkedBuffer {
+ public:
+ using Byte = ProfileBufferChunk::Byte;
+ using Length = ProfileBufferChunk::Length;
+
+ enum class ThreadSafety { WithoutMutex, WithMutex };
+
+ // Default constructor starts out-of-session (nothing to read or write).
+ explicit ProfileChunkedBuffer(ThreadSafety aThreadSafety)
+ : mMutex(aThreadSafety != ThreadSafety::WithoutMutex) {}
+
+ // Start in-session with external chunk manager.
+ ProfileChunkedBuffer(ThreadSafety aThreadSafety,
+ ProfileBufferChunkManager& aChunkManager)
+ : mMutex(aThreadSafety != ThreadSafety::WithoutMutex) {
+ SetChunkManager(aChunkManager);
+ }
+
+ // Start in-session with owned chunk manager.
+ ProfileChunkedBuffer(ThreadSafety aThreadSafety,
+ UniquePtr<ProfileBufferChunkManager>&& aChunkManager)
+ : mMutex(aThreadSafety != ThreadSafety::WithoutMutex) {
+ SetChunkManager(std::move(aChunkManager));
+ }
+
+ ~ProfileChunkedBuffer() {
+ // Do proper clean-up by resetting the chunk manager.
+ ResetChunkManager();
+ }
+
+ // This cannot change during the lifetime of this buffer, so there's no need
+ // to lock.
+ [[nodiscard]] bool IsThreadSafe() const { return mMutex.IsActivated(); }
+
+ [[nodiscard]] bool IsInSession() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return !!mChunkManager;
+ }
+
+ // Stop using the current chunk manager.
+ // If we own the current chunk manager, it will be destroyed.
+ // This will always clear currently-held chunks, if any.
+ void ResetChunkManager() {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ Unused << ResetChunkManager(lock);
+ }
+
+ // Set the current chunk manager.
+ // The caller is responsible for keeping the chunk manager alive as along as
+ // it's used here (until the next (Re)SetChunkManager, or
+ // ~ProfileChunkedBuffer).
+ void SetChunkManager(ProfileBufferChunkManager& aChunkManager) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ Unused << ResetChunkManager(lock);
+ SetChunkManager(aChunkManager, lock);
+ }
+
+ // Set the current chunk manager, and keep ownership of it.
+ void SetChunkManager(UniquePtr<ProfileBufferChunkManager>&& aChunkManager) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ Unused << ResetChunkManager(lock);
+ mOwnedChunkManager = std::move(aChunkManager);
+ if (mOwnedChunkManager) {
+ SetChunkManager(*mOwnedChunkManager, lock);
+ }
+ }
+
+ // Set the current chunk manager, except if it's already the one provided.
+ // The caller is responsible for keeping the chunk manager alive as along as
+ // it's used here (until the next (Re)SetChunkManager, or
+ // ~ProfileChunkedBuffer).
+ void SetChunkManagerIfDifferent(ProfileBufferChunkManager& aChunkManager) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (!mChunkManager || mChunkManager != &aChunkManager) {
+ Unused << ResetChunkManager(lock);
+ SetChunkManager(aChunkManager, lock);
+ }
+ }
+
+ // Clear the contents of this buffer, ready to receive new chunks.
+ // Note that memory is not freed: No chunks are destroyed, they are all
+ // receycled.
+ // Also the range doesn't reset, instead it continues at some point after the
+ // previous range. This may be useful if the caller may be keeping indexes
+ // into old chunks that have now been cleared, using these indexes will fail
+ // gracefully (instead of potentially pointing into new data).
+ void Clear() {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (MOZ_UNLIKELY(!mChunkManager)) {
+ // Out-of-session.
+ return;
+ }
+
+ mRangeStart = mRangeEnd = mNextChunkRangeStart;
+ mPushedBlockCount = 0;
+ mClearedBlockCount = 0;
+ mFailedPutBytes = 0;
+
+ // Recycle all released chunks as "next" chunks. This will reduce the number
+ // of future allocations. Also, when using ProfileBufferChunkManagerSingle,
+ // this retrieves the one chunk if it was released.
+ UniquePtr<ProfileBufferChunk> releasedChunks =
+ mChunkManager->GetExtantReleasedChunks();
+ if (releasedChunks) {
+ // Released chunks should be in the "Done" state, they need to be marked
+ // "recycled" before they can be reused.
+ for (ProfileBufferChunk* chunk = releasedChunks.get(); chunk;
+ chunk = chunk->GetNext()) {
+ chunk->MarkRecycled();
+ }
+ mNextChunks = ProfileBufferChunk::Join(std::move(mNextChunks),
+ std::move(releasedChunks));
+ }
+
+ if (mCurrentChunk) {
+ // We already have a current chunk (empty or in-use), mark it "done" and
+ // then "recycled", ready to be reused.
+ mCurrentChunk->MarkDone();
+ mCurrentChunk->MarkRecycled();
+ } else {
+ if (!mNextChunks) {
+ // No current chunk, and no next chunks to recycle, nothing more to do.
+ // The next "Put" operation will try to allocate a chunk as needed.
+ return;
+ }
+
+ // No current chunk, take a next chunk.
+ mCurrentChunk = std::exchange(mNextChunks, mNextChunks->ReleaseNext());
+ }
+
+ // Here, there was already a current chunk, or one has just been taken.
+ // Make sure it's ready to receive new entries.
+ InitializeCurrentChunk(lock);
+ }
+
+ // Buffer maximum length in bytes.
+ Maybe<size_t> BufferLength() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (!mChunkManager) {
+ return Nothing{};
+ }
+ return Some(mChunkManager->MaxTotalSize());
+ }
+
+ [[nodiscard]] size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return SizeOfExcludingThis(aMallocSizeOf, lock);
+ }
+
+ [[nodiscard]] size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf, lock);
+ }
+
+ // Snapshot of the buffer state.
+ struct State {
+ // Index to/before the first block.
+ ProfileBufferIndex mRangeStart = 1;
+
+ // Index past the last block. Equals mRangeStart if empty.
+ ProfileBufferIndex mRangeEnd = 1;
+
+ // Number of blocks that have been pushed into this buffer.
+ uint64_t mPushedBlockCount = 0;
+
+ // Number of blocks that have been removed from this buffer.
+ // Note: Live entries = pushed - cleared.
+ uint64_t mClearedBlockCount = 0;
+
+ // Number of bytes that could not be put into this buffer.
+ uint64_t mFailedPutBytes = 0;
+ };
+
+ // Get a snapshot of the current state.
+ // When out-of-session, mFirstReadIndex==mNextWriteIndex, and
+ // mPushedBlockCount==mClearedBlockCount==0.
+ // Note that these may change right after this thread-safe call, so they
+ // should only be used for statistical purposes.
+ [[nodiscard]] State GetState() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return {mRangeStart, mRangeEnd, mPushedBlockCount, mClearedBlockCount,
+ mFailedPutBytes};
+ }
+
+ // In in-session, return the start TimeStamp of the earliest chunk.
+ // If out-of-session, return a null TimeStamp.
+ [[nodiscard]] TimeStamp GetEarliestChunkStartTimeStamp() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (MOZ_UNLIKELY(!mChunkManager)) {
+ // Out-of-session.
+ return {};
+ }
+ return mChunkManager->PeekExtantReleasedChunks(
+ [&](const ProfileBufferChunk* aOldestChunk) -> TimeStamp {
+ if (aOldestChunk) {
+ return aOldestChunk->ChunkHeader().mStartTimeStamp;
+ }
+ if (mCurrentChunk) {
+ return mCurrentChunk->ChunkHeader().mStartTimeStamp;
+ }
+ return {};
+ });
+ }
+
+ [[nodiscard]] bool IsEmpty() const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return mRangeStart == mRangeEnd;
+ }
+
+ // True if this buffer is already locked on this thread.
+ // This should be used if some functions may call an already-locked buffer,
+ // e.g.: Put -> memory hook -> profiler_add_native_allocation_marker -> Put.
+ [[nodiscard]] bool IsThreadSafeAndLockedOnCurrentThread() const {
+ return mMutex.IsActivatedAndLockedOnCurrentThread();
+ }
+
+ // Lock the buffer mutex and run the provided callback.
+ // This can be useful when the caller needs to explicitly lock down this
+ // buffer, but not do anything else with it.
+ template <typename Callback>
+ auto LockAndRun(Callback&& aCallback) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return std::forward<Callback>(aCallback)();
+ }
+
+ // Reserve a block that can hold an entry of the given `aCallbackEntryBytes()`
+ // size, write the entry size (ULEB128-encoded), and invoke and return
+ // `aCallback(Maybe<ProfileBufferEntryWriter>&)`.
+ // Note: `aCallbackEntryBytes` is a callback instead of a simple value, to
+ // delay this potentially-expensive computation until after we're checked that
+ // we're in-session; use `Put(Length, Callback)` below if you know the size
+ // already.
+ template <typename CallbackEntryBytes, typename Callback>
+ auto ReserveAndPut(CallbackEntryBytes&& aCallbackEntryBytes,
+ Callback&& aCallback)
+ -> decltype(std::forward<Callback>(aCallback)(
+ std::declval<Maybe<ProfileBufferEntryWriter>&>())) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+
+ // This can only be read in the 2nd lambda below after it has been written
+ // by the first lambda.
+ Length entryBytes;
+
+ return ReserveAndPutRaw(
+ [&]() {
+ entryBytes = std::forward<CallbackEntryBytes>(aCallbackEntryBytes)();
+ MOZ_ASSERT(entryBytes != 0, "Empty entries are not allowed");
+ return ULEB128Size(entryBytes) + entryBytes;
+ },
+ [&](Maybe<ProfileBufferEntryWriter>& aMaybeEntryWriter) {
+ if (aMaybeEntryWriter.isSome()) {
+ aMaybeEntryWriter->WriteULEB128(entryBytes);
+ MOZ_ASSERT(aMaybeEntryWriter->RemainingBytes() == entryBytes);
+ }
+ return std::forward<Callback>(aCallback)(aMaybeEntryWriter);
+ },
+ lock);
+ }
+
+ template <typename Callback>
+ auto Put(Length aEntryBytes, Callback&& aCallback) {
+ return ReserveAndPut([aEntryBytes]() { return aEntryBytes; },
+ std::forward<Callback>(aCallback));
+ }
+
+ // Add a new entry copied from the given buffer, return block index.
+ ProfileBufferBlockIndex PutFrom(const void* aSrc, Length aBytes) {
+ return ReserveAndPut(
+ [aBytes]() { return aBytes; },
+ [aSrc, aBytes](Maybe<ProfileBufferEntryWriter>& aMaybeEntryWriter) {
+ if (aMaybeEntryWriter.isNothing()) {
+ return ProfileBufferBlockIndex{};
+ }
+ aMaybeEntryWriter->WriteBytes(aSrc, aBytes);
+ return aMaybeEntryWriter->CurrentBlockIndex();
+ });
+ }
+
+ // Add a new single entry with *all* given object (using a Serializer for
+ // each), return block index.
+ template <typename... Ts>
+ ProfileBufferBlockIndex PutObjects(const Ts&... aTs) {
+ static_assert(sizeof...(Ts) > 0,
+ "PutObjects must be given at least one object.");
+ return ReserveAndPut(
+ [&]() { return ProfileBufferEntryWriter::SumBytes(aTs...); },
+ [&](Maybe<ProfileBufferEntryWriter>& aMaybeEntryWriter) {
+ if (aMaybeEntryWriter.isNothing()) {
+ return ProfileBufferBlockIndex{};
+ }
+ aMaybeEntryWriter->WriteObjects(aTs...);
+ return aMaybeEntryWriter->CurrentBlockIndex();
+ });
+ }
+
+ // Add a new entry copied from the given object, return block index.
+ template <typename T>
+ ProfileBufferBlockIndex PutObject(const T& aOb) {
+ return PutObjects(aOb);
+ }
+
+ // Get *all* chunks related to this buffer, including extant chunks in its
+ // ChunkManager, and yet-unused new/recycled chunks.
+ // We don't expect this buffer to be used again, though it's still possible
+ // and will allocate the first buffer when needed.
+ [[nodiscard]] UniquePtr<ProfileBufferChunk> GetAllChunks() {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (MOZ_UNLIKELY(!mChunkManager)) {
+ // Out-of-session.
+ return nullptr;
+ }
+ UniquePtr<ProfileBufferChunk> chunks =
+ mChunkManager->GetExtantReleasedChunks();
+ Unused << HandleRequestedChunk_IsPending(lock);
+ if (MOZ_LIKELY(!!mCurrentChunk)) {
+ mCurrentChunk->MarkDone();
+ chunks =
+ ProfileBufferChunk::Join(std::move(chunks), std::move(mCurrentChunk));
+ }
+ chunks =
+ ProfileBufferChunk::Join(std::move(chunks), std::move(mNextChunks));
+ mChunkManager->ForgetUnreleasedChunks();
+ mRangeStart = mRangeEnd = mNextChunkRangeStart;
+ return chunks;
+ }
+
+ // True if the given index points inside the current chunk (up to the last
+ // written byte).
+ // This could be used to check if an index written now would have a good
+ // chance of referring to a previous block that has not been destroyed yet.
+ // But use with extreme care: This information may become incorrect right
+ // after this function returns, because new writes could start a new chunk.
+ [[nodiscard]] bool IsIndexInCurrentChunk(ProfileBufferIndex aIndex) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (MOZ_UNLIKELY(!mChunkManager || !mCurrentChunk)) {
+ // Out-of-session, or no current chunk.
+ return false;
+ }
+ return (mCurrentChunk->RangeStart() <= aIndex) &&
+ (aIndex < (mCurrentChunk->RangeStart() +
+ mCurrentChunk->OffsetPastLastBlock()));
+ }
+
+ class Reader;
+
+ // Class that can iterate through blocks and provide
+ // `ProfileBufferEntryReader`s.
+ // Created through `Reader`, lives within a lock guard lifetime.
+ class BlockIterator {
+ public:
+#ifdef DEBUG
+ ~BlockIterator() {
+ // No BlockIterator should live outside of a mutexed call.
+ mBuffer->mMutex.AssertCurrentThreadOwns();
+ }
+#endif // DEBUG
+
+ // Comparison with other iterator, mostly used in range-for loops.
+ [[nodiscard]] bool operator==(const BlockIterator& aRhs) const {
+ MOZ_ASSERT(mBuffer == aRhs.mBuffer);
+ return mCurrentBlockIndex == aRhs.mCurrentBlockIndex;
+ }
+ [[nodiscard]] bool operator!=(const BlockIterator& aRhs) const {
+ MOZ_ASSERT(mBuffer == aRhs.mBuffer);
+ return mCurrentBlockIndex != aRhs.mCurrentBlockIndex;
+ }
+
+ // Advance to next BlockIterator.
+ BlockIterator& operator++() {
+ mBuffer->mMutex.AssertCurrentThreadOwns();
+ mCurrentBlockIndex =
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mNextBlockPointer.GlobalRangePosition());
+ mCurrentEntry =
+ mNextBlockPointer.EntryReader(mNextBlockPointer.ReadEntrySize());
+ return *this;
+ }
+
+ // Dereferencing creates a `ProfileBufferEntryReader` object for the entry
+ // inside this block.
+ // (Note: It would be possible to return a `const
+ // ProfileBufferEntryReader&`, but not useful in practice, because in most
+ // case the user will want to read, which is non-const.)
+ [[nodiscard]] ProfileBufferEntryReader operator*() const {
+ return mCurrentEntry;
+ }
+
+ // True if this iterator is just past the last entry.
+ [[nodiscard]] bool IsAtEnd() const {
+ return mCurrentEntry.RemainingBytes() == 0;
+ }
+
+ // Can be used as reference to come back to this entry with `GetEntryAt()`.
+ [[nodiscard]] ProfileBufferBlockIndex CurrentBlockIndex() const {
+ return mCurrentBlockIndex;
+ }
+
+ // Index past the end of this block, which is the start of the next block.
+ [[nodiscard]] ProfileBufferBlockIndex NextBlockIndex() const {
+ MOZ_ASSERT(!IsAtEnd());
+ return ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mNextBlockPointer.GlobalRangePosition());
+ }
+
+ // Index of the first block in the whole buffer.
+ [[nodiscard]] ProfileBufferBlockIndex BufferRangeStart() const {
+ mBuffer->mMutex.AssertCurrentThreadOwns();
+ return ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mBuffer->mRangeStart);
+ }
+
+ // Index past the last block in the whole buffer.
+ [[nodiscard]] ProfileBufferBlockIndex BufferRangeEnd() const {
+ mBuffer->mMutex.AssertCurrentThreadOwns();
+ return ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mBuffer->mRangeEnd);
+ }
+
+ private:
+ // Only a Reader can instantiate a BlockIterator.
+ friend class Reader;
+
+ BlockIterator(const ProfileChunkedBuffer& aBuffer,
+ const ProfileBufferChunk* aChunks0,
+ const ProfileBufferChunk* aChunks1,
+ ProfileBufferBlockIndex aBlockIndex)
+ : mNextBlockPointer(aChunks0, aChunks1, aBlockIndex),
+ mCurrentBlockIndex(
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mNextBlockPointer.GlobalRangePosition())),
+ mCurrentEntry(
+ mNextBlockPointer.EntryReader(mNextBlockPointer.ReadEntrySize())),
+ mBuffer(WrapNotNull(&aBuffer)) {
+ // No BlockIterator should live outside of a mutexed call.
+ mBuffer->mMutex.AssertCurrentThreadOwns();
+ }
+
+ profiler::detail::InChunkPointer mNextBlockPointer;
+
+ ProfileBufferBlockIndex mCurrentBlockIndex;
+
+ ProfileBufferEntryReader mCurrentEntry;
+
+ // Using a non-null pointer instead of a reference, to allow copying.
+ // This BlockIterator should only live inside one of the thread-safe
+ // ProfileChunkedBuffer functions, for this reference to stay valid.
+ NotNull<const ProfileChunkedBuffer*> mBuffer;
+ };
+
+ // Class that can create `BlockIterator`s (e.g., for range-for), or just
+ // iterate through entries; lives within a lock guard lifetime.
+ class MOZ_RAII Reader {
+ public:
+ Reader(const Reader&) = delete;
+ Reader& operator=(const Reader&) = delete;
+ Reader(Reader&&) = delete;
+ Reader& operator=(Reader&&) = delete;
+
+#ifdef DEBUG
+ ~Reader() {
+ // No Reader should live outside of a mutexed call.
+ mBuffer.mMutex.AssertCurrentThreadOwns();
+ }
+#endif // DEBUG
+
+ // Index of the first block in the whole buffer.
+ [[nodiscard]] ProfileBufferBlockIndex BufferRangeStart() const {
+ mBuffer.mMutex.AssertCurrentThreadOwns();
+ return ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mBuffer.mRangeStart);
+ }
+
+ // Index past the last block in the whole buffer.
+ [[nodiscard]] ProfileBufferBlockIndex BufferRangeEnd() const {
+ mBuffer.mMutex.AssertCurrentThreadOwns();
+ return ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ mBuffer.mRangeEnd);
+ }
+
+ // Iterators to the first and past-the-last blocks.
+ // Compatible with range-for (see `ForEach` below as example).
+ [[nodiscard]] BlockIterator begin() const {
+ return BlockIterator(mBuffer, mChunks0, mChunks1, nullptr);
+ }
+ // Note that a `BlockIterator` at the `end()` should not be dereferenced, as
+ // there is no actual block there!
+ [[nodiscard]] BlockIterator end() const {
+ return BlockIterator(mBuffer, nullptr, nullptr, nullptr);
+ }
+
+ // Get a `BlockIterator` at the given `ProfileBufferBlockIndex`, clamped to
+ // the stored range. Note that a `BlockIterator` at the `end()` should not
+ // be dereferenced, as there is no actual block there!
+ [[nodiscard]] BlockIterator At(ProfileBufferBlockIndex aBlockIndex) const {
+ if (aBlockIndex < BufferRangeStart()) {
+ // Anything before the range (including null ProfileBufferBlockIndex) is
+ // clamped at the beginning.
+ return begin();
+ }
+ // Otherwise we at least expect the index to be valid (pointing exactly at
+ // a live block, or just past the end.)
+ return BlockIterator(mBuffer, mChunks0, mChunks1, aBlockIndex);
+ }
+
+ // Run `aCallback(ProfileBufferEntryReader&)` on each entry from first to
+ // last. Callback should not store `ProfileBufferEntryReader`, as it may
+ // become invalid after this thread-safe call.
+ template <typename Callback>
+ void ForEach(Callback&& aCallback) const {
+ for (ProfileBufferEntryReader reader : *this) {
+ aCallback(reader);
+ }
+ }
+
+ // If this reader only points at one chunk with some data, this data will be
+ // exposed as a single entry.
+ [[nodiscard]] ProfileBufferEntryReader SingleChunkDataAsEntry() {
+ const ProfileBufferChunk* onlyNonEmptyChunk = nullptr;
+ for (const ProfileBufferChunk* chunkList : {mChunks0, mChunks1}) {
+ for (const ProfileBufferChunk* chunk = chunkList; chunk;
+ chunk = chunk->GetNext()) {
+ if (chunk->OffsetFirstBlock() != chunk->OffsetPastLastBlock()) {
+ if (onlyNonEmptyChunk) {
+ // More than one non-empty chunk.
+ return ProfileBufferEntryReader();
+ }
+ onlyNonEmptyChunk = chunk;
+ }
+ }
+ }
+ if (!onlyNonEmptyChunk) {
+ // No non-empty chunks.
+ return ProfileBufferEntryReader();
+ }
+ // Here, we have found one chunk that had some data.
+ return ProfileBufferEntryReader(
+ onlyNonEmptyChunk->BufferSpan().FromTo(
+ onlyNonEmptyChunk->OffsetFirstBlock(),
+ onlyNonEmptyChunk->OffsetPastLastBlock()),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ onlyNonEmptyChunk->RangeStart()),
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ onlyNonEmptyChunk->RangeStart() +
+ (onlyNonEmptyChunk->OffsetPastLastBlock() -
+ onlyNonEmptyChunk->OffsetFirstBlock())));
+ }
+
+ private:
+ friend class ProfileChunkedBuffer;
+
+ explicit Reader(const ProfileChunkedBuffer& aBuffer,
+ const ProfileBufferChunk* aChunks0,
+ const ProfileBufferChunk* aChunks1)
+ : mBuffer(aBuffer), mChunks0(aChunks0), mChunks1(aChunks1) {
+ // No Reader should live outside of a mutexed call.
+ mBuffer.mMutex.AssertCurrentThreadOwns();
+ }
+
+ // This Reader should only live inside one of the thread-safe
+ // ProfileChunkedBuffer functions, for this reference to stay valid.
+ const ProfileChunkedBuffer& mBuffer;
+ const ProfileBufferChunk* mChunks0;
+ const ProfileBufferChunk* mChunks1;
+ };
+
+ // In in-session, call `aCallback(ProfileChunkedBuffer::Reader&)` and return
+ // true. Callback should not store `Reader`, because it may become invalid
+ // after this call.
+ // If out-of-session, return false (callback is not invoked).
+ template <typename Callback>
+ [[nodiscard]] auto Read(Callback&& aCallback) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (MOZ_UNLIKELY(!mChunkManager)) {
+ // Out-of-session.
+ return std::forward<Callback>(aCallback)(static_cast<Reader*>(nullptr));
+ }
+ return mChunkManager->PeekExtantReleasedChunks(
+ [&](const ProfileBufferChunk* aOldestChunk) {
+ Reader reader(*this, aOldestChunk, mCurrentChunk.get());
+ return std::forward<Callback>(aCallback)(&reader);
+ });
+ }
+
+ // Invoke `aCallback(ProfileBufferEntryReader& [, ProfileBufferBlockIndex])`
+ // on each entry, it must read or at least skip everything. Either/both chunk
+ // pointers may be null.
+ template <typename Callback>
+ static void ReadEach(const ProfileBufferChunk* aChunks0,
+ const ProfileBufferChunk* aChunks1,
+ Callback&& aCallback) {
+ static_assert(std::is_invocable_v<Callback, ProfileBufferEntryReader&> ||
+ std::is_invocable_v<Callback, ProfileBufferEntryReader&,
+ ProfileBufferBlockIndex>,
+ "ReadEach callback must take ProfileBufferEntryReader& and "
+ "optionally a ProfileBufferBlockIndex");
+ profiler::detail::InChunkPointer p{aChunks0, aChunks1};
+ while (!p.IsNull()) {
+ // The position right before an entry size *is* a block index.
+ const ProfileBufferBlockIndex blockIndex =
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ p.GlobalRangePosition());
+ Length entrySize = p.ReadEntrySize();
+ if (entrySize == 0) {
+ return;
+ }
+ ProfileBufferEntryReader entryReader = p.EntryReader(entrySize);
+ if (entryReader.RemainingBytes() == 0) {
+ return;
+ }
+ MOZ_ASSERT(entryReader.RemainingBytes() == entrySize);
+ if constexpr (std::is_invocable_v<Callback, ProfileBufferEntryReader&,
+ ProfileBufferBlockIndex>) {
+ aCallback(entryReader, blockIndex);
+ } else {
+ Unused << blockIndex;
+ aCallback(entryReader);
+ }
+ MOZ_ASSERT(entryReader.RemainingBytes() == 0);
+ }
+ }
+
+ // Invoke `aCallback(ProfileBufferEntryReader& [, ProfileBufferBlockIndex])`
+ // on each entry, it must read or at least skip everything.
+ template <typename Callback>
+ void ReadEach(Callback&& aCallback) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (MOZ_UNLIKELY(!mChunkManager)) {
+ // Out-of-session.
+ return;
+ }
+ mChunkManager->PeekExtantReleasedChunks(
+ [&](const ProfileBufferChunk* aOldestChunk) {
+ ReadEach(aOldestChunk, mCurrentChunk.get(),
+ std::forward<Callback>(aCallback));
+ });
+ }
+
+ // Call `aCallback(Maybe<ProfileBufferEntryReader>&&)` on the entry at
+ // the given ProfileBufferBlockIndex; The `Maybe` will be `Nothing` if
+ // out-of-session, or if that entry doesn't exist anymore, or if we've reached
+ // just past the last entry. Return whatever `aCallback` returns. Callback
+ // should not store `ProfileBufferEntryReader`, because it may become invalid
+ // after this call.
+ // Either/both chunk pointers may be null.
+ template <typename Callback>
+ [[nodiscard]] static auto ReadAt(ProfileBufferBlockIndex aMinimumBlockIndex,
+ const ProfileBufferChunk* aChunks0,
+ const ProfileBufferChunk* aChunks1,
+ Callback&& aCallback) {
+ static_assert(
+ std::is_invocable_v<Callback, Maybe<ProfileBufferEntryReader>&&>,
+ "ReadAt callback must take a Maybe<ProfileBufferEntryReader>&&");
+ Maybe<ProfileBufferEntryReader> maybeEntryReader;
+ if (profiler::detail::InChunkPointer p{aChunks0, aChunks1}; !p.IsNull()) {
+ // If the pointer position is before the given position, try to advance.
+ if (p.GlobalRangePosition() >=
+ aMinimumBlockIndex.ConvertToProfileBufferIndex() ||
+ p.AdvanceToGlobalRangePosition(
+ aMinimumBlockIndex.ConvertToProfileBufferIndex())) {
+ MOZ_ASSERT(p.GlobalRangePosition() >=
+ aMinimumBlockIndex.ConvertToProfileBufferIndex());
+ // Here we're pointing at the start of a block, try to read the entry
+ // size. (Entries cannot be empty, so 0 means failure.)
+ if (Length entrySize = p.ReadEntrySize(); entrySize != 0) {
+ maybeEntryReader.emplace(p.EntryReader(entrySize));
+ if (maybeEntryReader->RemainingBytes() == 0) {
+ // An empty entry reader means there was no complete block at the
+ // given index.
+ maybeEntryReader.reset();
+ } else {
+ MOZ_ASSERT(maybeEntryReader->RemainingBytes() == entrySize);
+ }
+ }
+ }
+ }
+#ifdef DEBUG
+ auto assertAllRead = MakeScopeExit([&]() {
+ MOZ_ASSERT(!maybeEntryReader || maybeEntryReader->RemainingBytes() == 0);
+ });
+#endif // DEBUG
+ return std::forward<Callback>(aCallback)(std::move(maybeEntryReader));
+ }
+
+ // Call `aCallback(Maybe<ProfileBufferEntryReader>&&)` on the entry at
+ // the given ProfileBufferBlockIndex; The `Maybe` will be `Nothing` if
+ // out-of-session, or if that entry doesn't exist anymore, or if we've reached
+ // just past the last entry. Return whatever `aCallback` returns. Callback
+ // should not store `ProfileBufferEntryReader`, because it may become invalid
+ // after this call.
+ template <typename Callback>
+ [[nodiscard]] auto ReadAt(ProfileBufferBlockIndex aBlockIndex,
+ Callback&& aCallback) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ if (MOZ_UNLIKELY(!mChunkManager)) {
+ // Out-of-session.
+ return std::forward<Callback>(aCallback)(Nothing{});
+ }
+ return mChunkManager->PeekExtantReleasedChunks(
+ [&](const ProfileBufferChunk* aOldestChunk) {
+ return ReadAt(aBlockIndex, aOldestChunk, mCurrentChunk.get(),
+ std::forward<Callback>(aCallback));
+ });
+ }
+
+ // Append the contents of another ProfileChunkedBuffer to this one.
+ ProfileBufferBlockIndex AppendContents(const ProfileChunkedBuffer& aSrc) {
+ ProfileBufferBlockIndex firstBlockIndex;
+ // If we start failing, we'll stop writing.
+ bool failed = false;
+ aSrc.ReadEach([&](ProfileBufferEntryReader& aER) {
+ if (failed) {
+ return;
+ }
+ failed =
+ !Put(aER.RemainingBytes(), [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ if (aEW.isNothing()) {
+ return false;
+ }
+ if (!firstBlockIndex) {
+ firstBlockIndex = aEW->CurrentBlockIndex();
+ }
+ aEW->WriteFromReader(aER, aER.RemainingBytes());
+ return true;
+ });
+ });
+ return failed ? nullptr : firstBlockIndex;
+ }
+
+#ifdef DEBUG
+ void Dump(std::FILE* aFile = stdout) const {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ fprintf(aFile,
+ "ProfileChunkedBuffer[%p] State: range %u-%u pushed=%u cleared=%u "
+ "(live=%u) failed-puts=%u bytes",
+ this, unsigned(mRangeStart), unsigned(mRangeEnd),
+ unsigned(mPushedBlockCount), unsigned(mClearedBlockCount),
+ unsigned(mPushedBlockCount) - unsigned(mClearedBlockCount),
+ unsigned(mFailedPutBytes));
+ if (MOZ_UNLIKELY(!mChunkManager)) {
+ fprintf(aFile, " - Out-of-session\n");
+ return;
+ }
+ fprintf(aFile, " - chunks:\n");
+ bool hasChunks = false;
+ mChunkManager->PeekExtantReleasedChunks(
+ [&](const ProfileBufferChunk* aOldestChunk) {
+ for (const ProfileBufferChunk* chunk = aOldestChunk; chunk;
+ chunk = chunk->GetNext()) {
+ fprintf(aFile, "R ");
+ chunk->Dump(aFile);
+ hasChunks = true;
+ }
+ });
+ if (mCurrentChunk) {
+ fprintf(aFile, "C ");
+ mCurrentChunk->Dump(aFile);
+ hasChunks = true;
+ }
+ for (const ProfileBufferChunk* chunk = mNextChunks.get(); chunk;
+ chunk = chunk->GetNext()) {
+ fprintf(aFile, "N ");
+ chunk->Dump(aFile);
+ hasChunks = true;
+ }
+ switch (mRequestedChunkHolder->GetState()) {
+ case RequestedChunkRefCountedHolder::State::Unused:
+ fprintf(aFile, " - No request pending.\n");
+ break;
+ case RequestedChunkRefCountedHolder::State::Requested:
+ fprintf(aFile, " - Request pending.\n");
+ break;
+ case RequestedChunkRefCountedHolder::State::Fulfilled:
+ fprintf(aFile, " - Request fulfilled.\n");
+ break;
+ }
+ if (!hasChunks) {
+ fprintf(aFile, " No chunks.\n");
+ }
+ }
+#endif // DEBUG
+
+ private:
+ // Used to de/serialize a ProfileChunkedBuffer (e.g., containing a backtrace).
+ friend ProfileBufferEntryWriter::Serializer<ProfileChunkedBuffer>;
+ friend ProfileBufferEntryReader::Deserializer<ProfileChunkedBuffer>;
+ friend ProfileBufferEntryWriter::Serializer<UniquePtr<ProfileChunkedBuffer>>;
+ friend ProfileBufferEntryReader::Deserializer<
+ UniquePtr<ProfileChunkedBuffer>>;
+
+ [[nodiscard]] UniquePtr<ProfileBufferChunkManager> ResetChunkManager(
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock&) {
+ UniquePtr<ProfileBufferChunkManager> chunkManager;
+ if (mChunkManager) {
+ mRequestedChunkHolder = nullptr;
+ mChunkManager->ForgetUnreleasedChunks();
+#ifdef DEBUG
+ mChunkManager->DeregisteredFrom(this);
+#endif
+ mChunkManager = nullptr;
+ chunkManager = std::move(mOwnedChunkManager);
+ if (mCurrentChunk) {
+ mCurrentChunk->MarkDone();
+ mCurrentChunk = nullptr;
+ }
+ mNextChunks = nullptr;
+ mNextChunkRangeStart = mRangeEnd;
+ mRangeStart = mRangeEnd;
+ mPushedBlockCount = 0;
+ mClearedBlockCount = 0;
+ mFailedPutBytes = 0;
+ }
+ return chunkManager;
+ }
+
+ void SetChunkManager(
+ ProfileBufferChunkManager& aChunkManager,
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock& aLock) {
+ MOZ_ASSERT(!mChunkManager);
+ mChunkManager = &aChunkManager;
+#ifdef DEBUG
+ mChunkManager->RegisteredWith(this);
+#endif
+
+ mChunkManager->SetChunkDestroyedCallback(
+ [this](const ProfileBufferChunk& aChunk) {
+ for (;;) {
+ ProfileBufferIndex rangeStart = mRangeStart;
+ if (MOZ_LIKELY(rangeStart <= aChunk.RangeStart())) {
+ if (MOZ_LIKELY(mRangeStart.compareExchange(
+ rangeStart,
+ aChunk.RangeStart() + aChunk.BufferBytes()))) {
+ break;
+ }
+ }
+ }
+ mClearedBlockCount += aChunk.BlockCount();
+ });
+
+ // We start with one chunk right away, and request a following one now
+ // so it should be available before the current chunk is full.
+ SetAndInitializeCurrentChunk(mChunkManager->GetChunk(), aLock);
+ mRequestedChunkHolder = MakeRefPtr<RequestedChunkRefCountedHolder>();
+ RequestChunk(aLock);
+ }
+
+ [[nodiscard]] size_t SizeOfExcludingThis(
+ MallocSizeOf aMallocSizeOf,
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock&) const {
+ if (MOZ_UNLIKELY(!mChunkManager)) {
+ // Out-of-session.
+ return 0;
+ }
+ size_t size = mChunkManager->SizeOfIncludingThis(aMallocSizeOf);
+ if (mCurrentChunk) {
+ size += mCurrentChunk->SizeOfIncludingThis(aMallocSizeOf);
+ }
+ if (mNextChunks) {
+ size += mNextChunks->SizeOfIncludingThis(aMallocSizeOf);
+ }
+ return size;
+ }
+
+ void InitializeCurrentChunk(
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock&) {
+ MOZ_ASSERT(!!mCurrentChunk);
+ mCurrentChunk->SetRangeStart(mNextChunkRangeStart);
+ mNextChunkRangeStart += mCurrentChunk->BufferBytes();
+ Unused << mCurrentChunk->ReserveInitialBlockAsTail(0);
+ }
+
+ void SetAndInitializeCurrentChunk(
+ UniquePtr<ProfileBufferChunk>&& aChunk,
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock& aLock) {
+ mCurrentChunk = std::move(aChunk);
+ if (mCurrentChunk) {
+ InitializeCurrentChunk(aLock);
+ }
+ }
+
+ void RequestChunk(
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock& aLock) {
+ if (HandleRequestedChunk_IsPending(aLock)) {
+ // There is already a pending request, don't start a new one.
+ return;
+ }
+
+ // Ensure the `RequestedChunkHolder` knows we're starting a request.
+ mRequestedChunkHolder->StartRequest();
+
+ // Request a chunk, the callback carries a `RefPtr` of the
+ // `RequestedChunkHolder`, so it's guaranteed to live until it's invoked,
+ // even if this `ProfileChunkedBuffer` changes its `ChunkManager` or is
+ // destroyed.
+ mChunkManager->RequestChunk(
+ [requestedChunkHolder = RefPtr<RequestedChunkRefCountedHolder>(
+ mRequestedChunkHolder)](UniquePtr<ProfileBufferChunk> aChunk) {
+ requestedChunkHolder->AddRequestedChunk(std::move(aChunk));
+ });
+ }
+
+ [[nodiscard]] bool HandleRequestedChunk_IsPending(
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock& aLock) {
+ MOZ_ASSERT(!!mChunkManager);
+ MOZ_ASSERT(!!mRequestedChunkHolder);
+
+ if (mRequestedChunkHolder->GetState() ==
+ RequestedChunkRefCountedHolder::State::Unused) {
+ return false;
+ }
+
+ // A request is either in-flight or fulfilled.
+ Maybe<UniquePtr<ProfileBufferChunk>> maybeChunk =
+ mRequestedChunkHolder->GetChunkIfFulfilled();
+ if (maybeChunk.isNothing()) {
+ // Request is still pending.
+ return true;
+ }
+
+ // Since we extracted the provided chunk, the holder should now be unused.
+ MOZ_ASSERT(mRequestedChunkHolder->GetState() ==
+ RequestedChunkRefCountedHolder::State::Unused);
+
+ // Request has been fulfilled.
+ UniquePtr<ProfileBufferChunk>& chunk = *maybeChunk;
+ if (chunk) {
+ // Try to use as current chunk if needed.
+ if (!mCurrentChunk) {
+ SetAndInitializeCurrentChunk(std::move(chunk), aLock);
+ // We've just received a chunk and made it current, request a next chunk
+ // for later.
+ MOZ_ASSERT(!mNextChunks);
+ RequestChunk(aLock);
+ return true;
+ }
+
+ if (!mNextChunks) {
+ mNextChunks = std::move(chunk);
+ } else {
+ mNextChunks->InsertNext(std::move(chunk));
+ }
+ }
+
+ return false;
+ }
+
+ // Get a pointer to the next chunk available
+ [[nodiscard]] ProfileBufferChunk* GetOrCreateCurrentChunk(
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock& aLock) {
+ ProfileBufferChunk* current = mCurrentChunk.get();
+ if (MOZ_UNLIKELY(!current)) {
+ // No current chunk ready.
+ MOZ_ASSERT(!mNextChunks,
+ "There shouldn't be next chunks when there is no current one");
+ // See if a request has recently been fulfilled, ignore pending status.
+ Unused << HandleRequestedChunk_IsPending(aLock);
+ current = mCurrentChunk.get();
+ if (MOZ_UNLIKELY(!current)) {
+ // There was no pending chunk, try to get one right now.
+ // This may still fail, but we can't do anything else about it, the
+ // caller must handle the nullptr case.
+ // Attempt a request for later.
+ SetAndInitializeCurrentChunk(mChunkManager->GetChunk(), aLock);
+ current = mCurrentChunk.get();
+ }
+ }
+ return current;
+ }
+
+ // Get a pointer to the next chunk available
+ [[nodiscard]] ProfileBufferChunk* GetOrCreateNextChunk(
+ const baseprofiler::detail::BaseProfilerMaybeAutoLock& aLock) {
+ MOZ_ASSERT(!!mCurrentChunk,
+ "Why ask for a next chunk when there isn't even a current one?");
+ ProfileBufferChunk* next = mNextChunks.get();
+ if (MOZ_UNLIKELY(!next)) {
+ // No next chunk ready, see if a request has recently been fulfilled,
+ // ignore pending status.
+ Unused << HandleRequestedChunk_IsPending(aLock);
+ next = mNextChunks.get();
+ if (MOZ_UNLIKELY(!next)) {
+ // There was no pending chunk, try to get one right now.
+ mNextChunks = mChunkManager->GetChunk();
+ next = mNextChunks.get();
+ // This may still fail, but we can't do anything else about it, the
+ // caller must handle the nullptr case.
+ if (MOZ_UNLIKELY(!next)) {
+ // Attempt a request for later.
+ RequestChunk(aLock);
+ }
+ }
+ }
+ return next;
+ }
+
+ // Reserve a block of `aCallbackBlockBytes()` size, and invoke and return
+ // `aCallback(Maybe<ProfileBufferEntryWriter>&)`. Note that this is the "raw"
+ // version that doesn't write the entry size at the beginning of the block.
+ // Note: `aCallbackBlockBytes` is a callback instead of a simple value, to
+ // delay this potentially-expensive computation until after we're checked that
+ // we're in-session; use `Put(Length, Callback)` below if you know the size
+ // already.
+ template <typename CallbackBlockBytes, typename Callback>
+ auto ReserveAndPutRaw(CallbackBlockBytes&& aCallbackBlockBytes,
+ Callback&& aCallback,
+ baseprofiler::detail::BaseProfilerMaybeAutoLock& aLock,
+ uint64_t aBlockCount = 1) {
+ // The entry writer that will point into one or two chunks to write
+ // into, empty by default (failure).
+ Maybe<ProfileBufferEntryWriter> maybeEntryWriter;
+
+ // The current chunk will be filled if we need to write more than its
+ // remaining space.
+ bool currentChunkFilled = false;
+
+ // If the current chunk gets filled, we may or may not initialize the next
+ // chunk!
+ bool nextChunkInitialized = false;
+
+ if (MOZ_LIKELY(mChunkManager)) {
+ // In-session.
+
+ const Length blockBytes =
+ std::forward<CallbackBlockBytes>(aCallbackBlockBytes)();
+
+ if (ProfileBufferChunk* current = GetOrCreateCurrentChunk(aLock);
+ MOZ_LIKELY(current)) {
+ if (blockBytes <= current->RemainingBytes()) {
+ // Block fits in current chunk with only one span.
+ currentChunkFilled = blockBytes == current->RemainingBytes();
+ const auto [mem0, blockIndex] = current->ReserveBlock(blockBytes);
+ MOZ_ASSERT(mem0.LengthBytes() == blockBytes);
+ maybeEntryWriter.emplace(
+ mem0, blockIndex,
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ blockIndex.ConvertToProfileBufferIndex() + blockBytes));
+ MOZ_ASSERT(maybeEntryWriter->RemainingBytes() == blockBytes);
+ mRangeEnd += blockBytes;
+ mPushedBlockCount += aBlockCount;
+ } else if (blockBytes >= current->BufferBytes()) {
+ // Currently only two buffer chunks are held at a time and it is not
+ // possible to write an object that takes up more space than this. In
+ // this scenario, silently discard this block of data if it is unable
+ // to fit into the two reserved profiler chunks.
+ mFailedPutBytes += blockBytes;
+ } else {
+ // Block doesn't fit fully in current chunk, it needs to overflow into
+ // the next one.
+ // Whether or not we can write this entry, the current chunk is now
+ // considered full, so it will be released. (Otherwise we could refuse
+ // this entry, but later accept a smaller entry into this chunk, which
+ // would be somewhat inconsistent.)
+ currentChunkFilled = true;
+ // Make sure the next chunk is available (from a previous request),
+ // otherwise create one on the spot.
+ if (ProfileBufferChunk* next = GetOrCreateNextChunk(aLock);
+ MOZ_LIKELY(next)) {
+ // Here, we know we have a current and a next chunk.
+ // Reserve head of block at the end of the current chunk.
+ const auto [mem0, blockIndex] =
+ current->ReserveBlock(current->RemainingBytes());
+ MOZ_ASSERT(mem0.LengthBytes() < blockBytes);
+ MOZ_ASSERT(current->RemainingBytes() == 0);
+ // Set the next chunk range, and reserve the needed space for the
+ // tail of the block.
+ next->SetRangeStart(mNextChunkRangeStart);
+ mNextChunkRangeStart += next->BufferBytes();
+ const auto mem1 = next->ReserveInitialBlockAsTail(
+ blockBytes - mem0.LengthBytes());
+ MOZ_ASSERT(next->RemainingBytes() != 0);
+ nextChunkInitialized = true;
+ // Block is split in two spans.
+ maybeEntryWriter.emplace(
+ mem0, mem1, blockIndex,
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ blockIndex.ConvertToProfileBufferIndex() + blockBytes));
+ MOZ_ASSERT(maybeEntryWriter->RemainingBytes() == blockBytes);
+ mRangeEnd += blockBytes;
+ mPushedBlockCount += aBlockCount;
+ } else {
+ // Cannot get a new chunk. Record put failure.
+ mFailedPutBytes += blockBytes;
+ }
+ }
+ } else {
+ // Cannot get a current chunk. Record put failure.
+ mFailedPutBytes += blockBytes;
+ }
+ } // end of `if (MOZ_LIKELY(mChunkManager))`
+
+ // Here, we either have a `Nothing` (failure), or a non-empty entry writer
+ // pointing at the start of the block.
+
+ // After we invoke the callback and return, we may need to handle the
+ // current chunk being filled.
+ auto handleFilledChunk = MakeScopeExit([&]() {
+ // If the entry writer was not already empty, the callback *must* have
+ // filled the full entry.
+ MOZ_ASSERT(!maybeEntryWriter || maybeEntryWriter->RemainingBytes() == 0);
+
+ if (currentChunkFilled) {
+ // Extract current (now filled) chunk.
+ UniquePtr<ProfileBufferChunk> filled = std::move(mCurrentChunk);
+
+ if (mNextChunks) {
+ // Cycle to the next chunk.
+ mCurrentChunk =
+ std::exchange(mNextChunks, mNextChunks->ReleaseNext());
+
+ // Make sure it is initialized (it is now the current chunk).
+ if (!nextChunkInitialized) {
+ InitializeCurrentChunk(aLock);
+ }
+ }
+
+ // And finally mark filled chunk done and release it.
+ filled->MarkDone();
+ mChunkManager->ReleaseChunk(std::move(filled));
+
+ // Request another chunk if needed.
+ // In most cases, here we should have one current chunk and no next
+ // chunk, so we want to do a request so there hopefully will be a next
+ // chunk available when the current one gets filled.
+ // But we also for a request if we don't even have a current chunk (if
+ // it's too late, it's ok because the next `ReserveAndPutRaw` wil just
+ // allocate one on the spot.)
+ // And if we already have a next chunk, there's no need for more now.
+ if (!mCurrentChunk || !mNextChunks) {
+ RequestChunk(aLock);
+ }
+ }
+ });
+
+ return std::forward<Callback>(aCallback)(maybeEntryWriter);
+ }
+
+ // Reserve a block of `aBlockBytes` size, and invoke and return
+ // `aCallback(Maybe<ProfileBufferEntryWriter>&)`. Note that this is the "raw"
+ // version that doesn't write the entry size at the beginning of the block.
+ template <typename Callback>
+ auto ReserveAndPutRaw(Length aBlockBytes, Callback&& aCallback,
+ uint64_t aBlockCount) {
+ baseprofiler::detail::BaseProfilerMaybeAutoLock lock(mMutex);
+ return ReserveAndPutRaw([aBlockBytes]() { return aBlockBytes; },
+ std::forward<Callback>(aCallback), lock,
+ aBlockCount);
+ }
+
+ // Mutex guarding the following members.
+ mutable baseprofiler::detail::BaseProfilerMaybeMutex mMutex;
+
+ // Pointer to the current Chunk Manager (or null when out-of-session.)
+ // It may be owned locally (see below) or externally.
+ ProfileBufferChunkManager* mChunkManager = nullptr;
+
+ // Only non-null when we own the current Chunk Manager.
+ UniquePtr<ProfileBufferChunkManager> mOwnedChunkManager;
+
+ UniquePtr<ProfileBufferChunk> mCurrentChunk;
+
+ UniquePtr<ProfileBufferChunk> mNextChunks;
+
+ // Class used to transfer requested chunks from a `ChunkManager` to a
+ // `ProfileChunkedBuffer`.
+ // It needs to be ref-counted because the request may be fulfilled
+ // asynchronously, and either side may be destroyed during the request.
+ // It cannot use the `ProfileChunkedBuffer` mutex, because that buffer and its
+ // mutex could be destroyed during the request.
+ class RequestedChunkRefCountedHolder {
+ public:
+ enum class State { Unused, Requested, Fulfilled };
+
+ // Get the current state. Note that it may change after the function
+ // returns, so it should be used carefully, e.g., `ProfileChunkedBuffer` can
+ // see if a request is pending or fulfilled, to avoid starting another
+ // request.
+ [[nodiscard]] State GetState() const {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mRequestMutex);
+ return mState;
+ }
+
+ // Must be called by `ProfileChunkedBuffer` when it requests a chunk.
+ // There cannot be more than one request in-flight.
+ void StartRequest() {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mRequestMutex);
+ MOZ_ASSERT(mState == State::Unused, "Already requested or fulfilled");
+ mState = State::Requested;
+ }
+
+ // Must be called by the `ChunkManager` with a chunk.
+ // If the `ChunkManager` cannot provide a chunk (because of memory limits,
+ // or it gets destroyed), it must call this anyway with a nullptr.
+ void AddRequestedChunk(UniquePtr<ProfileBufferChunk>&& aChunk) {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mRequestMutex);
+ MOZ_ASSERT(mState == State::Requested);
+ mState = State::Fulfilled;
+ mRequestedChunk = std::move(aChunk);
+ }
+
+ // The `ProfileChunkedBuffer` can try to extract the provided chunk after a
+ // request:
+ // - Nothing -> Request is not fulfilled yet.
+ // - Some(nullptr) -> The `ChunkManager` was not able to provide a chunk.
+ // - Some(chunk) -> Requested chunk.
+ [[nodiscard]] Maybe<UniquePtr<ProfileBufferChunk>> GetChunkIfFulfilled() {
+ Maybe<UniquePtr<ProfileBufferChunk>> maybeChunk;
+ baseprofiler::detail::BaseProfilerAutoLock lock(mRequestMutex);
+ MOZ_ASSERT(mState == State::Requested || mState == State::Fulfilled);
+ if (mState == State::Fulfilled) {
+ mState = State::Unused;
+ maybeChunk.emplace(std::move(mRequestedChunk));
+ }
+ return maybeChunk;
+ }
+
+ // Ref-counting implementation. Hand-rolled, because mozilla::RefCounted
+ // logs AddRefs and Releases in xpcom, but this object could be AddRef'd
+ // by the Base Profiler before xpcom starts, then Release'd by the Gecko
+ // Profiler in xpcom, leading to apparent negative leaks.
+
+ void AddRef() {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mRequestMutex);
+ ++mRefCount;
+ }
+
+ void Release() {
+ {
+ baseprofiler::detail::BaseProfilerAutoLock lock(mRequestMutex);
+ if (--mRefCount > 0) {
+ return;
+ }
+ }
+ delete this;
+ }
+
+ private:
+ ~RequestedChunkRefCountedHolder() = default;
+
+ // Mutex guarding the following members.
+ mutable baseprofiler::detail::BaseProfilerMutex mRequestMutex;
+ int mRefCount = 0;
+ State mState = State::Unused;
+ UniquePtr<ProfileBufferChunk> mRequestedChunk;
+ };
+
+ // Requested-chunk holder, kept alive when in-session, but may also live
+ // longer if a request is in-flight.
+ RefPtr<RequestedChunkRefCountedHolder> mRequestedChunkHolder;
+
+ // Range start of the next chunk to become current. Starting at 1 because
+ // 0 is a reserved index similar to nullptr.
+ ProfileBufferIndex mNextChunkRangeStart = 1;
+
+ // Index to the first block.
+ // Atomic because it may be increased when a Chunk is destroyed, and the
+ // callback may be invoked from anywhere, including from inside one of our
+ // locked section, so we cannot protect it with a mutex.
+ Atomic<ProfileBufferIndex, MemoryOrdering::ReleaseAcquire> mRangeStart{1};
+
+ // Index past the last block. Equals mRangeStart if empty.
+ ProfileBufferIndex mRangeEnd = 1;
+
+ // Number of blocks that have been pushed into this buffer.
+ uint64_t mPushedBlockCount = 0;
+
+ // Number of blocks that have been removed from this buffer.
+ // Note: Live entries = pushed - cleared.
+ // Atomic because it may be updated when a Chunk is destroyed, and the
+ // callback may be invoked from anywhere, including from inside one of our
+ // locked section, so we cannot protect it with a mutex.
+ Atomic<uint64_t, MemoryOrdering::ReleaseAcquire> mClearedBlockCount{0};
+
+ // Number of bytes that could not be put into this buffer.
+ uint64_t mFailedPutBytes = 0;
+};
+
+// ----------------------------------------------------------------------------
+// ProfileChunkedBuffer serialization
+
+// A ProfileChunkedBuffer can hide another one!
+// This will be used to store marker backtraces; They can be read back into a
+// UniquePtr<ProfileChunkedBuffer>.
+// Format: len (ULEB128) | start | end | buffer (len bytes) | pushed | cleared
+// len==0 marks an out-of-session buffer, or empty buffer.
+template <>
+struct ProfileBufferEntryWriter::Serializer<ProfileChunkedBuffer> {
+ static Length Bytes(const ProfileChunkedBuffer& aBuffer) {
+ return aBuffer.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ if (!aReader) {
+ // Out-of-session, we only need 1 byte to store a length of 0.
+ return ULEB128Size<Length>(0);
+ }
+ ProfileBufferEntryReader reader = aReader->SingleChunkDataAsEntry();
+ const ProfileBufferIndex start =
+ reader.CurrentBlockIndex().ConvertToProfileBufferIndex();
+ const ProfileBufferIndex end =
+ reader.NextBlockIndex().ConvertToProfileBufferIndex();
+ MOZ_ASSERT(end - start <= std::numeric_limits<Length>::max());
+ const Length len = static_cast<Length>(end - start);
+ if (len == 0) {
+ // In-session but empty, also store a length of 0.
+ return ULEB128Size<Length>(0);
+ }
+ // In-session.
+ return static_cast<Length>(ULEB128Size(len) + sizeof(start) + len +
+ sizeof(aBuffer.mPushedBlockCount) +
+ sizeof(aBuffer.mClearedBlockCount));
+ });
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const ProfileChunkedBuffer& aBuffer) {
+ aBuffer.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ if (!aReader) {
+ // Out-of-session, only store a length of 0.
+ aEW.WriteULEB128<Length>(0);
+ return;
+ }
+ ProfileBufferEntryReader reader = aReader->SingleChunkDataAsEntry();
+ const ProfileBufferIndex start =
+ reader.CurrentBlockIndex().ConvertToProfileBufferIndex();
+ const ProfileBufferIndex end =
+ reader.NextBlockIndex().ConvertToProfileBufferIndex();
+ MOZ_ASSERT(end - start <= std::numeric_limits<Length>::max());
+ const Length len = static_cast<Length>(end - start);
+ MOZ_ASSERT(len <= aEW.RemainingBytes());
+ if (len == 0) {
+ // In-session but empty, only store a length of 0.
+ aEW.WriteULEB128<Length>(0);
+ return;
+ }
+ // In-session.
+ // Store buffer length, and start index.
+ aEW.WriteULEB128(len);
+ aEW.WriteObject(start);
+ // Write all the bytes.
+ aEW.WriteFromReader(reader, reader.RemainingBytes());
+ // And write stats.
+ aEW.WriteObject(static_cast<uint64_t>(aBuffer.mPushedBlockCount));
+ aEW.WriteObject(static_cast<uint64_t>(aBuffer.mClearedBlockCount));
+ // Note: Failed pushes are not important to serialize.
+ });
+ }
+};
+
+// A serialized ProfileChunkedBuffer can be read into an empty buffer (either
+// out-of-session, or in-session with enough room).
+template <>
+struct ProfileBufferEntryReader::Deserializer<ProfileChunkedBuffer> {
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ ProfileChunkedBuffer& aBuffer) {
+ // Expect an empty buffer, as we're going to overwrite it.
+ MOZ_ASSERT(aBuffer.GetState().mRangeStart == aBuffer.GetState().mRangeEnd);
+ // Read the stored buffer length.
+ const auto len = aER.ReadULEB128<ProfileChunkedBuffer::Length>();
+ if (len == 0) {
+ // 0-length means an "uninteresting" buffer, just return now.
+ return;
+ }
+ // We have a non-empty buffer to read.
+
+ // Read start and end indices.
+ const auto start = aER.ReadObject<ProfileBufferIndex>();
+ aBuffer.mRangeStart = start;
+ // For now, set the end to be the start (the buffer is still empty). It will
+ // be updated in `ReserveAndPutRaw()` below.
+ aBuffer.mRangeEnd = start;
+
+ if (aBuffer.IsInSession()) {
+ // Output buffer is in-session (i.e., it already has a memory buffer
+ // attached). Make sure the caller allocated enough space.
+ MOZ_RELEASE_ASSERT(aBuffer.BufferLength().value() >= len);
+ } else {
+ // Output buffer is out-of-session, set a new chunk manager that will
+ // provide a single chunk of just the right size.
+ aBuffer.SetChunkManager(MakeUnique<ProfileBufferChunkManagerSingle>(len));
+ MOZ_ASSERT(aBuffer.BufferLength().value() >= len);
+ }
+
+ // Copy bytes into the buffer.
+ aBuffer.ReserveAndPutRaw(
+ len,
+ [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ aEW->WriteFromReader(aER, len);
+ },
+ 0);
+ // Finally copy stats.
+ aBuffer.mPushedBlockCount = aER.ReadObject<uint64_t>();
+ aBuffer.mClearedBlockCount = aER.ReadObject<uint64_t>();
+ // Failed puts are not important to keep.
+ aBuffer.mFailedPutBytes = 0;
+ }
+
+ // We cannot output a ProfileChunkedBuffer object (not copyable), use
+ // `ReadInto()` or `aER.ReadObject<UniquePtr<BlocksRinbBuffer>>()` instead.
+ static ProfileChunkedBuffer Read(ProfileBufferEntryReader& aER) = delete;
+};
+
+// A ProfileChunkedBuffer is usually refererenced through a UniquePtr, for
+// convenience we support (de)serializing that UniquePtr directly.
+// This is compatible with the non-UniquePtr serialization above, with a null
+// pointer being treated like an out-of-session or empty buffer; and any of
+// these would be deserialized into a null pointer.
+template <>
+struct ProfileBufferEntryWriter::Serializer<UniquePtr<ProfileChunkedBuffer>> {
+ static Length Bytes(const UniquePtr<ProfileChunkedBuffer>& aBufferUPtr) {
+ if (!aBufferUPtr) {
+ // Null pointer, treat it like an empty buffer, i.e., write length of 0.
+ return ULEB128Size<Length>(0);
+ }
+ // Otherwise write the pointed-at ProfileChunkedBuffer (which could be
+ // out-of-session or empty.)
+ return SumBytes(*aBufferUPtr);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ const UniquePtr<ProfileChunkedBuffer>& aBufferUPtr) {
+ if (!aBufferUPtr) {
+ // Null pointer, treat it like an empty buffer, i.e., write length of 0.
+ aEW.WriteULEB128<Length>(0);
+ return;
+ }
+ // Otherwise write the pointed-at ProfileChunkedBuffer (which could be
+ // out-of-session or empty.)
+ aEW.WriteObject(*aBufferUPtr);
+ }
+};
+
+// Serialization of a raw pointer to ProfileChunkedBuffer.
+// Use Deserializer<UniquePtr<ProfileChunkedBuffer>> to read it back.
+template <>
+struct ProfileBufferEntryWriter::Serializer<ProfileChunkedBuffer*> {
+ static Length Bytes(ProfileChunkedBuffer* aBufferUPtr) {
+ if (!aBufferUPtr) {
+ // Null pointer, treat it like an empty buffer, i.e., write length of 0.
+ return ULEB128Size<Length>(0);
+ }
+ // Otherwise write the pointed-at ProfileChunkedBuffer (which could be
+ // out-of-session or empty.)
+ return SumBytes(*aBufferUPtr);
+ }
+
+ static void Write(ProfileBufferEntryWriter& aEW,
+ ProfileChunkedBuffer* aBufferUPtr) {
+ if (!aBufferUPtr) {
+ // Null pointer, treat it like an empty buffer, i.e., write length of 0.
+ aEW.WriteULEB128<Length>(0);
+ return;
+ }
+ // Otherwise write the pointed-at ProfileChunkedBuffer (which could be
+ // out-of-session or empty.)
+ aEW.WriteObject(*aBufferUPtr);
+ }
+};
+
+template <>
+struct ProfileBufferEntryReader::Deserializer<UniquePtr<ProfileChunkedBuffer>> {
+ static void ReadInto(ProfileBufferEntryReader& aER,
+ UniquePtr<ProfileChunkedBuffer>& aBuffer) {
+ aBuffer = Read(aER);
+ }
+
+ static UniquePtr<ProfileChunkedBuffer> Read(ProfileBufferEntryReader& aER) {
+ UniquePtr<ProfileChunkedBuffer> bufferUPtr;
+ // Keep a copy of the reader before reading the length, so we can restart
+ // from here below.
+ ProfileBufferEntryReader readerBeforeLen = aER;
+ // Read the stored buffer length.
+ const auto len = aER.ReadULEB128<ProfileChunkedBuffer::Length>();
+ if (len == 0) {
+ // 0-length means an "uninteresting" buffer, just return nullptr.
+ return bufferUPtr;
+ }
+ // We have a non-empty buffer.
+ // allocate an empty ProfileChunkedBuffer without mutex.
+ bufferUPtr = MakeUnique<ProfileChunkedBuffer>(
+ ProfileChunkedBuffer::ThreadSafety::WithoutMutex);
+ // Rewind the reader before the length and deserialize the contents, using
+ // the non-UniquePtr Deserializer.
+ aER = readerBeforeLen;
+ aER.ReadIntoObject(*bufferUPtr);
+ return bufferUPtr;
+ }
+};
+
+} // namespace mozilla
+
+#endif // ProfileChunkedBuffer_h
diff --git a/mozglue/baseprofiler/public/ProfileChunkedBufferDetail.h b/mozglue/baseprofiler/public/ProfileChunkedBufferDetail.h
new file mode 100644
index 0000000000..9828822aaf
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProfileChunkedBufferDetail.h
@@ -0,0 +1,400 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef ProfileChunkedBufferDetail_h
+#define ProfileChunkedBufferDetail_h
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Likely.h"
+#include "mozilla/ProfileBufferChunk.h"
+#include "mozilla/ProfileBufferEntrySerialization.h"
+
+namespace mozilla::profiler::detail {
+
+// Internal accessor pointing at a position inside a chunk.
+// It can handle two groups of chunks (typically the extant chunks stored in
+// the store manager, and the current chunk).
+// The main operations are:
+// - ReadEntrySize() to read an entry size, 0 means failure.
+// - operator+=(Length) to skip a number of bytes.
+// - EntryReader() creates an entry reader at the current position for a given
+// size (it may fail with an empty reader), and skips the entry.
+// Note that there is no "past-the-end" position -- as soon as InChunkPointer
+// reaches the end, it becomes effectively null.
+class InChunkPointer {
+ public:
+ using Byte = ProfileBufferChunk::Byte;
+ using Length = ProfileBufferChunk::Length;
+
+ // Nullptr-like InChunkPointer, may be used as end iterator.
+ InChunkPointer()
+ : mChunk(nullptr), mNextChunkGroup(nullptr), mOffsetInChunk(0) {}
+
+ // InChunkPointer over one or two chunk groups, pointing at the given
+ // block index (if still in range).
+ // This constructor should only be used with *trusted* block index values!
+ InChunkPointer(const ProfileBufferChunk* aChunk,
+ const ProfileBufferChunk* aNextChunkGroup,
+ ProfileBufferBlockIndex aBlockIndex)
+ : mChunk(aChunk), mNextChunkGroup(aNextChunkGroup) {
+ if (mChunk) {
+ mOffsetInChunk = mChunk->OffsetFirstBlock();
+ Adjust();
+ } else if (mNextChunkGroup) {
+ mChunk = mNextChunkGroup;
+ mNextChunkGroup = nullptr;
+ mOffsetInChunk = mChunk->OffsetFirstBlock();
+ Adjust();
+ } else {
+ mOffsetInChunk = 0;
+ }
+
+ // Try to advance to given position.
+ if (!AdvanceToGlobalRangePosition(aBlockIndex)) {
+ // Block does not exist anymore (or block doesn't look valid), reset the
+ // in-chunk pointer.
+ mChunk = nullptr;
+ mNextChunkGroup = nullptr;
+ }
+ }
+
+ // InChunkPointer over one or two chunk groups, will start at the first
+ // block (if any). This may be slow, so avoid using it too much.
+ InChunkPointer(const ProfileBufferChunk* aChunk,
+ const ProfileBufferChunk* aNextChunkGroup,
+ ProfileBufferIndex aIndex = ProfileBufferIndex(0))
+ : mChunk(aChunk), mNextChunkGroup(aNextChunkGroup) {
+ if (mChunk) {
+ mOffsetInChunk = mChunk->OffsetFirstBlock();
+ Adjust();
+ } else if (mNextChunkGroup) {
+ mChunk = mNextChunkGroup;
+ mNextChunkGroup = nullptr;
+ mOffsetInChunk = mChunk->OffsetFirstBlock();
+ Adjust();
+ } else {
+ mOffsetInChunk = 0;
+ }
+
+ // Try to advance to given position.
+ if (!AdvanceToGlobalRangePosition(aIndex)) {
+ // Block does not exist anymore, reset the in-chunk pointer.
+ mChunk = nullptr;
+ mNextChunkGroup = nullptr;
+ }
+ }
+
+ // Compute the current position in the global range.
+ // 0 if null (including if we're reached the end).
+ [[nodiscard]] ProfileBufferIndex GlobalRangePosition() const {
+ if (IsNull()) {
+ return 0;
+ }
+ return mChunk->RangeStart() + mOffsetInChunk;
+ }
+
+ // Move InChunkPointer forward to the block at the given global block
+ // position, which is assumed to be valid exactly -- but it may be obsolete.
+ // 0 stays where it is (if valid already).
+ // MOZ_ASSERTs if the index is invalid.
+ [[nodiscard]] bool AdvanceToGlobalRangePosition(
+ ProfileBufferBlockIndex aBlockIndex) {
+ if (IsNull()) {
+ // Pointer is null already. (Not asserting because it's acceptable.)
+ return false;
+ }
+ if (!aBlockIndex) {
+ // Special null position, just stay where we are.
+ return ShouldPointAtValidBlock();
+ }
+ if (aBlockIndex.ConvertToProfileBufferIndex() < GlobalRangePosition()) {
+ // Past the requested position, stay where we are (assuming the current
+ // position was valid).
+ return ShouldPointAtValidBlock();
+ }
+ for (;;) {
+ if (aBlockIndex.ConvertToProfileBufferIndex() <
+ mChunk->RangeStart() + mChunk->OffsetPastLastBlock()) {
+ // Target position is in this chunk's written space, move to it.
+ mOffsetInChunk =
+ aBlockIndex.ConvertToProfileBufferIndex() - mChunk->RangeStart();
+ return ShouldPointAtValidBlock();
+ }
+ // Position is after this chunk, try next chunk.
+ GoToNextChunk();
+ if (IsNull()) {
+ return false;
+ }
+ // Skip whatever block tail there is, we don't allow pointing in the
+ // middle of a block.
+ mOffsetInChunk = mChunk->OffsetFirstBlock();
+ if (aBlockIndex.ConvertToProfileBufferIndex() < GlobalRangePosition()) {
+ // Past the requested position, meaning that the given position was in-
+ // between blocks -> Failure.
+ MOZ_ASSERT(false, "AdvanceToGlobalRangePosition - In-between blocks");
+ return false;
+ }
+ }
+ }
+
+ // Move InChunkPointer forward to the block at or after the given global
+ // range position.
+ // 0 stays where it is (if valid already).
+ [[nodiscard]] bool AdvanceToGlobalRangePosition(
+ ProfileBufferIndex aPosition) {
+ if (aPosition == 0) {
+ // Special position '0', just stay where we are.
+ // Success if this position is already valid.
+ return !IsNull();
+ }
+ for (;;) {
+ ProfileBufferIndex currentPosition = GlobalRangePosition();
+ if (currentPosition == 0) {
+ // Pointer is null.
+ return false;
+ }
+ if (aPosition <= currentPosition) {
+ // At or past the requested position, stay where we are.
+ return true;
+ }
+ if (aPosition < mChunk->RangeStart() + mChunk->OffsetPastLastBlock()) {
+ // Target position is in this chunk's written space, move to it.
+ for (;;) {
+ // Skip the current block.
+ mOffsetInChunk += ReadEntrySize();
+ if (mOffsetInChunk >= mChunk->OffsetPastLastBlock()) {
+ // Reached the end of the chunk, this can happen for the last
+ // block, let's just continue to the next chunk.
+ break;
+ }
+ if (aPosition <= mChunk->RangeStart() + mOffsetInChunk) {
+ // We're at or after the position, return at this block position.
+ return true;
+ }
+ }
+ }
+ // Position is after this chunk, try next chunk.
+ GoToNextChunk();
+ if (IsNull()) {
+ return false;
+ }
+ // Skip whatever block tail there is, we don't allow pointing in the
+ // middle of a block.
+ mOffsetInChunk = mChunk->OffsetFirstBlock();
+ }
+ }
+
+ [[nodiscard]] Byte ReadByte() {
+ MOZ_ASSERT(!IsNull());
+ MOZ_ASSERT(mOffsetInChunk < mChunk->OffsetPastLastBlock());
+ Byte byte = mChunk->ByteAt(mOffsetInChunk);
+ if (MOZ_UNLIKELY(++mOffsetInChunk == mChunk->OffsetPastLastBlock())) {
+ Adjust();
+ }
+ return byte;
+ }
+
+ // Read and skip a ULEB128-encoded size.
+ // 0 means failure (0-byte entries are not allowed.)
+ // Note that this doesn't guarantee that there are actually that many bytes
+ // available to read! (EntryReader() below may gracefully fail.)
+ [[nodiscard]] Length ReadEntrySize() {
+ ULEB128Reader<Length> reader;
+ if (IsNull()) {
+ return 0;
+ }
+ for (;;) {
+ const bool isComplete = reader.FeedByteIsComplete(ReadByte());
+ if (MOZ_UNLIKELY(IsNull())) {
+ // End of chunks, so there's no actual entry after this anyway.
+ return 0;
+ }
+ if (MOZ_LIKELY(isComplete)) {
+ if (MOZ_UNLIKELY(reader.Value() > mChunk->BufferBytes())) {
+ // Don't allow entries larger than a chunk.
+ return 0;
+ }
+ return reader.Value();
+ }
+ }
+ }
+
+ InChunkPointer& operator+=(Length aLength) {
+ MOZ_ASSERT(!IsNull());
+ mOffsetInChunk += aLength;
+ Adjust();
+ return *this;
+ }
+
+ [[nodiscard]] ProfileBufferEntryReader EntryReader(Length aLength) {
+ if (IsNull() || aLength == 0) {
+ return ProfileBufferEntryReader();
+ }
+
+ MOZ_ASSERT(mOffsetInChunk < mChunk->OffsetPastLastBlock());
+
+ // We should be pointing at the entry, past the entry size.
+ const ProfileBufferIndex entryIndex = GlobalRangePosition();
+ // Verify that there's enough space before for the size (starting at index
+ // 1 at least).
+ MOZ_ASSERT(entryIndex >= 1u + ULEB128Size(aLength));
+
+ const Length remaining = mChunk->OffsetPastLastBlock() - mOffsetInChunk;
+ Span<const Byte> mem0 = mChunk->BufferSpan();
+ mem0 = mem0.From(mOffsetInChunk);
+ if (aLength <= remaining) {
+ // Move to the end of this block, which could make this null if we have
+ // reached the end of all buffers.
+ *this += aLength;
+ return ProfileBufferEntryReader(
+ mem0.To(aLength),
+ // Block starts before the entry size.
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ entryIndex - ULEB128Size(aLength)),
+ // Block ends right after the entry (could be null for last entry).
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ GlobalRangePosition()));
+ }
+
+ // We need to go to the next chunk for the 2nd part of this block.
+ GoToNextChunk();
+ if (IsNull()) {
+ return ProfileBufferEntryReader();
+ }
+
+ Span<const Byte> mem1 = mChunk->BufferSpan();
+ const Length tail = aLength - remaining;
+ MOZ_ASSERT(tail <= mChunk->BufferBytes());
+ MOZ_ASSERT(tail == mChunk->OffsetFirstBlock());
+ // We are in the correct chunk, move the offset to the end of the block.
+ mOffsetInChunk = tail;
+ // And adjust as needed, which could make this null if we have reached the
+ // end of all buffers.
+ Adjust();
+ return ProfileBufferEntryReader(
+ mem0, mem1.To(tail),
+ // Block starts before the entry size.
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ entryIndex - ULEB128Size(aLength)),
+ // Block ends right after the entry (could be null for last entry).
+ ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ GlobalRangePosition()));
+ }
+
+ [[nodiscard]] bool IsNull() const { return !mChunk; }
+
+ [[nodiscard]] bool operator==(const InChunkPointer& aOther) const {
+ if (IsNull() || aOther.IsNull()) {
+ return IsNull() && aOther.IsNull();
+ }
+ return mChunk == aOther.mChunk && mOffsetInChunk == aOther.mOffsetInChunk;
+ }
+
+ [[nodiscard]] bool operator!=(const InChunkPointer& aOther) const {
+ return !(*this == aOther);
+ }
+
+ [[nodiscard]] Byte operator*() const {
+ MOZ_ASSERT(!IsNull());
+ MOZ_ASSERT(mOffsetInChunk < mChunk->OffsetPastLastBlock());
+ return mChunk->ByteAt(mOffsetInChunk);
+ }
+
+ InChunkPointer& operator++() {
+ MOZ_ASSERT(!IsNull());
+ MOZ_ASSERT(mOffsetInChunk < mChunk->OffsetPastLastBlock());
+ if (MOZ_UNLIKELY(++mOffsetInChunk == mChunk->OffsetPastLastBlock())) {
+ mOffsetInChunk = 0;
+ GoToNextChunk();
+ Adjust();
+ }
+ return *this;
+ }
+
+ private:
+ void GoToNextChunk() {
+ MOZ_ASSERT(!IsNull());
+ const ProfileBufferIndex expectedNextRangeStart =
+ mChunk->RangeStart() + mChunk->BufferBytes();
+
+ mChunk = mChunk->GetNext();
+ if (!mChunk) {
+ // Reached the end of the current chunk group, try the next one (which
+ // may be null too, especially on the 2nd try).
+ mChunk = mNextChunkGroup;
+ mNextChunkGroup = nullptr;
+ }
+
+ if (mChunk && mChunk->RangeStart() == 0) {
+ // Reached a chunk without a valid (non-null) range start, assume there
+ // are only unused chunks from here on.
+ mChunk = nullptr;
+ }
+
+ MOZ_ASSERT(!mChunk || mChunk->RangeStart() == expectedNextRangeStart,
+ "We don't handle discontinuous buffers (yet)");
+ // Non-DEBUG fallback: Stop reading past discontinuities.
+ // (They should be rare, only happening on temporary OOMs.)
+ // TODO: Handle discontinuities (by skipping over incomplete blocks).
+ if (mChunk && mChunk->RangeStart() != expectedNextRangeStart) {
+ mChunk = nullptr;
+ }
+ }
+
+ // We want `InChunkPointer` to always point at a valid byte (or be null).
+ // After some operations, `mOffsetInChunk` may point past the end of the
+ // current `mChunk`, in which case we need to adjust our position to be inside
+ // the appropriate chunk. E.g., if we're 10 bytes after the end of the current
+ // chunk, we should end up at offset 10 in the next chunk.
+ // Note that we may "fall off" the last chunk and make this `InChunkPointer`
+ // effectively null.
+ void Adjust() {
+ while (mChunk && mOffsetInChunk >= mChunk->OffsetPastLastBlock()) {
+ // TODO: Try to adjust offset between chunks relative to mRangeStart
+ // differences. But we don't handle discontinuities yet.
+ if (mOffsetInChunk < mChunk->BufferBytes()) {
+ mOffsetInChunk -= mChunk->BufferBytes();
+ } else {
+ mOffsetInChunk -= mChunk->OffsetPastLastBlock();
+ }
+ GoToNextChunk();
+ }
+ }
+
+ // Check if the current position is likely to point at a valid block.
+ // (Size should be reasonable, and block should fully fit inside buffer.)
+ // MOZ_ASSERTs on failure, to catch incorrect uses of block indices (which
+ // should only point at valid blocks if still in range). Non-asserting build
+ // fallback should still be handled.
+ [[nodiscard]] bool ShouldPointAtValidBlock() const {
+ if (IsNull()) {
+ // Pointer is null, no blocks here.
+ MOZ_ASSERT(false, "ShouldPointAtValidBlock - null pointer");
+ return false;
+ }
+ // Use a copy, so we don't modify `*this`.
+ InChunkPointer pointer = *this;
+ // Try to read the entry size.
+ Length entrySize = pointer.ReadEntrySize();
+ if (entrySize == 0) {
+ // Entry size of zero means we read 0 or a way-too-big value.
+ MOZ_ASSERT(false, "ShouldPointAtValidBlock - invalid size");
+ return false;
+ }
+ // See if the last byte of the entry is still inside the buffer.
+ pointer += entrySize - 1;
+ MOZ_ASSERT(!IsNull(), "ShouldPointAtValidBlock - past end of buffer");
+ return !IsNull();
+ }
+
+ const ProfileBufferChunk* mChunk;
+ const ProfileBufferChunk* mNextChunkGroup;
+ Length mOffsetInChunk;
+};
+
+} // namespace mozilla::profiler::detail
+
+#endif // ProfileChunkedBufferDetail_h
diff --git a/mozglue/baseprofiler/public/ProgressLogger.h b/mozglue/baseprofiler/public/ProgressLogger.h
new file mode 100644
index 0000000000..e15095faaa
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProgressLogger.h
@@ -0,0 +1,500 @@
+/* -*- 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/. */
+
+#ifndef ProgressLogger_h
+#define ProgressLogger_h
+
+#include "mozilla/Assertions.h"
+#include "mozilla/ProportionValue.h"
+#include "mozilla/RefCounted.h"
+#include "mozilla/RefPtr.h"
+
+#include <atomic>
+
+// Uncomment to printf ProcessLogger updates.
+// #define DEBUG_PROCESSLOGGER
+
+#ifdef DEBUG_PROCESSLOGGER
+# include "mozilla/BaseProfilerUtils.h"
+# include <cstdio>
+#endif // DEBUG_PROCESSLOGGER
+
+namespace mozilla {
+
+// A `ProgressLogger` is used to update a referenced atomic `ProportionValue`,
+// and can recursively create a sub-logger corresponding to a subset of their
+// own range, but that sub-logger's updates are done in its local 0%-100% range.
+// The typical usage is for multi-level tasks, where each level can estimate its
+// own work and the work delegated to a next-level function, without knowing how
+// this local work relates to the higher-level total work. See
+// `CreateSubLoggerFromTo` for details.
+// Note that this implementation is single-threaded, it does not support logging
+// progress from multiple threads at the same time.
+class ProgressLogger {
+ public:
+ // An RefPtr'd object of this class is used as the target of all
+ // ProgressLogger updates, and it may be shared to make these updates visible
+ // from other code in any thread.
+ class SharedProgress : public external::AtomicRefCounted<SharedProgress> {
+ public:
+ MOZ_DECLARE_REFCOUNTED_TYPENAME(SharedProgress)
+
+ SharedProgress() = default;
+
+ SharedProgress(const SharedProgress&) = delete;
+ SharedProgress& operator=(const SharedProgress&) = delete;
+
+ // This constant is used to indicate that an update may change the progress
+ // value, but should not modify the previously-recorded location.
+ static constexpr const char* NO_LOCATION_UPDATE = nullptr;
+
+ // Set the current progress and location, but the previous location is not
+ // overwritten if the new one is null or empty.
+ // The location and then the progress are atomically "released", so that all
+ // preceding writes on this thread will be visible to other threads reading
+ // these values; most importantly when reaching 100% progress, the reader
+ // can be confident that the location is final and the operation being
+ // watched has completed.
+ void SetProgress(
+ ProportionValue aProgress,
+ const char* aLocationOrNullEmptyToIgnore = NO_LOCATION_UPDATE) {
+ if (aLocationOrNullEmptyToIgnore &&
+ *aLocationOrNullEmptyToIgnore != '\0') {
+ mLastLocation.store(aLocationOrNullEmptyToIgnore,
+ std::memory_order_release);
+ }
+ mProgress.store(aProgress, std::memory_order_release);
+ }
+
+ // Read the current progress value. Atomically "acquired", so that writes
+ // from the thread that stored this value are all visible to the reader
+ // here; most importantly when reaching 100%, we can be confident that the
+ // location is final and the operation being watched has completed.
+ [[nodiscard]] ProportionValue Progress() const {
+ return mProgress.load(std::memory_order_acquire);
+ }
+
+ // Read the current progress value. Atomically "acquired".
+ [[nodiscard]] const char* LastLocation() const {
+ return mLastLocation.load(std::memory_order_acquire);
+ }
+
+ private:
+ friend mozilla::detail::RefCounted<SharedProgress,
+ mozilla::detail::AtomicRefCount>;
+ ~SharedProgress() = default;
+
+ // Progress and last-known location.
+ // Beware that these two values are not strongly tied: Reading one then the
+ // other may give mismatched information; but it should be fine for
+ // informational usage.
+ // They are stored using atomic acquire-release ordering, to guarantee that
+ // when read, all writes preceding these values are visible.
+ std::atomic<ProportionValue> mProgress = ProportionValue{0.0};
+ std::atomic<const char*> mLastLocation = nullptr;
+ };
+
+ static constexpr const char* NO_LOCATION_UPDATE =
+ SharedProgress::NO_LOCATION_UPDATE;
+
+ ProgressLogger() = default;
+
+ // Construct a top-level logger, starting at 0% and expected to end at 100%.
+ explicit ProgressLogger(
+ RefPtr<SharedProgress> aGlobalProgressOrNull,
+ const char* aLocationOrNullEmptyToIgnoreAtStart = NO_LOCATION_UPDATE,
+ const char* aLocationOrNullEmptyToIgnoreAtEnd = NO_LOCATION_UPDATE)
+ : ProgressLogger{std::move(aGlobalProgressOrNull),
+ /* Start */ ProportionValue{0.0},
+ /* Multiplier */ ProportionValue{1.0},
+ aLocationOrNullEmptyToIgnoreAtStart,
+ aLocationOrNullEmptyToIgnoreAtEnd} {}
+
+ // Don't make copies, it would be confusing!
+ // TODO: Copies could one day be allowed to track multi-threaded work, but it
+ // is outside the scope of this implementation; Please update if needed.
+ ProgressLogger(const ProgressLogger&) = delete;
+ ProgressLogger& operator&(const ProgressLogger&) = delete;
+
+ // Move-construct is allowed, to return from CreateSubLoggerFromTo, and
+ // forward straight into a function. Note that moved-from ProgressLoggers must
+ // not be used anymore! Use `CreateSubLoggerFromTo` to pass a sub-logger to
+ // functions.
+ ProgressLogger(ProgressLogger&& aOther)
+ : mGlobalProgressOrNull(std::move(aOther.mGlobalProgressOrNull)),
+ mLocalStartInGlobalSpace(aOther.mLocalStartInGlobalSpace),
+ mLocalToGlobalMultiplier(aOther.mLocalToGlobalMultiplier),
+ mLocationAtDestruction(aOther.mLocationAtDestruction) {
+ aOther.MarkMovedFrom();
+#ifdef DEBUG_PROCESSLOGGER
+ if (mGlobalProgressOrNull) {
+ printf("[%d] Moved (staying globally at %.2f in [%.2f, %.2f])\n",
+ int(baseprofiler::profiler_current_process_id().ToNumber()),
+ GetGlobalProgress().ToDouble() * 100.0,
+ mLocalStartInGlobalSpace.ToDouble() * 100.0,
+ (mLocalStartInGlobalSpace + mLocalToGlobalMultiplier).ToDouble() *
+ 100.0);
+ }
+#endif // DEBUG_PROCESSLOGGER
+ }
+
+ // Move-assign. This may be useful when starting with a default (empty) logger
+ // and later assigning it a progress value to start updating.
+ ProgressLogger& operator=(ProgressLogger&& aOther) {
+ mGlobalProgressOrNull = std::move(aOther.mGlobalProgressOrNull);
+ mLocalStartInGlobalSpace = aOther.mLocalStartInGlobalSpace;
+ mLocalToGlobalMultiplier = aOther.mLocalToGlobalMultiplier;
+ mLocationAtDestruction = aOther.mLocationAtDestruction;
+ aOther.MarkMovedFrom();
+#ifdef DEBUG_PROCESSLOGGER
+ if (mGlobalProgressOrNull) {
+ printf("[%d] Re-assigned (globally at %.2f in [%.2f, %.2f])\n",
+ int(baseprofiler::profiler_current_process_id().ToNumber()),
+ GetGlobalProgress().ToDouble() * 100.0,
+ mLocalStartInGlobalSpace.ToDouble() * 100.0,
+ (mLocalStartInGlobalSpace + mLocalToGlobalMultiplier).ToDouble() *
+ 100.0);
+ }
+#endif // DEBUG_PROCESSLOGGER
+ return *this;
+ }
+
+ // Destruction sets the local update value to 100% unless empty or moved-from.
+ ~ProgressLogger() {
+ if (!IsMovedFrom()) {
+#ifdef DEBUG_PROCESSLOGGER
+ if (mGlobalProgressOrNull) {
+ printf("[%d] Destruction:\n",
+ int(baseprofiler::profiler_current_process_id().ToNumber()));
+ }
+#endif // DEBUG_PROCESSLOGGER
+ SetLocalProgress(ProportionValue{1.0}, mLocationAtDestruction);
+ }
+ }
+
+ // Retrieve the current progress in the global space. May be invalid.
+ [[nodiscard]] ProportionValue GetGlobalProgress() const {
+ return mGlobalProgressOrNull ? mGlobalProgressOrNull->Progress()
+ : ProportionValue::MakeInvalid();
+ }
+
+ // Retrieve the last known global location. May be null.
+ [[nodiscard]] const char* GetLastGlobalLocation() const {
+ return mGlobalProgressOrNull ? mGlobalProgressOrNull->LastLocation()
+ : nullptr;
+ }
+
+ // Set the current progress in the local space.
+ void SetLocalProgress(ProportionValue aLocalProgress,
+ const char* aLocationOrNullEmptyToIgnore) {
+ MOZ_ASSERT(!IsMovedFrom());
+ if (mGlobalProgressOrNull && !mLocalToGlobalMultiplier.IsExactlyZero()) {
+ mGlobalProgressOrNull->SetProgress(LocalToGlobal(aLocalProgress),
+ aLocationOrNullEmptyToIgnore);
+#ifdef DEBUG_PROCESSLOGGER
+ printf("[%d] - local %.0f%% ~ global %.2f%% \"%s\"\n",
+ int(baseprofiler::profiler_current_process_id().ToNumber()),
+ aLocalProgress.ToDouble() * 100.0,
+ LocalToGlobal(aLocalProgress).ToDouble() * 100.0,
+ aLocationOrNullEmptyToIgnore ? aLocationOrNullEmptyToIgnore
+ : "<null>");
+#endif // DEBUG_PROCESSLOGGER
+ }
+ }
+
+ // Create a sub-logger that will record progress in the given local range.
+ // E.g.: `f(pl.CreateSubLoggerFromTo(0.2, "f...", 0.4, "f done"));` expects
+ // that `f` will produce work in the local range 0.2 (when starting) to 0.4
+ // (when returning); `f` itself will update this provided logger from 0.0
+ // to 1.0 (local to that `f` function), which will effectively be converted to
+ // 0.2-0.4 (local to the calling function).
+ // This can cascade multiple levels, each deeper level affecting a smaller and
+ // smaller range in the global output.
+ [[nodiscard]] ProgressLogger CreateSubLoggerFromTo(
+ ProportionValue aSubStartInLocalSpace,
+ const char* aLocationOrNullEmptyToIgnoreAtStart,
+ ProportionValue aSubEndInLocalSpace,
+ const char* aLocationOrNullEmptyToIgnoreAtEnd = NO_LOCATION_UPDATE) {
+ MOZ_ASSERT(!IsMovedFrom());
+ if (!mGlobalProgressOrNull) {
+ return ProgressLogger{};
+ }
+ const ProportionValue subStartInGlobalSpace =
+ LocalToGlobal(aSubStartInLocalSpace);
+ const ProportionValue subEndInGlobalSpace =
+ LocalToGlobal(aSubEndInLocalSpace);
+ if (subStartInGlobalSpace.IsInvalid() || subEndInGlobalSpace.IsInvalid()) {
+ return ProgressLogger{mGlobalProgressOrNull,
+ /* Start */ ProportionValue::MakeInvalid(),
+ /* Multiplier */ ProportionValue{0.0},
+ aLocationOrNullEmptyToIgnoreAtStart,
+ aLocationOrNullEmptyToIgnoreAtEnd};
+ }
+#ifdef DEBUG_PROCESSLOGGER
+ if (mGlobalProgressOrNull) {
+ printf("[%d] * Sub: local [%.0f%%, %.0f%%] ~ global [%.2f%%, %.2f%%]\n",
+ int(baseprofiler::profiler_current_process_id().ToNumber()),
+ aSubStartInLocalSpace.ToDouble() * 100.0,
+ aSubEndInLocalSpace.ToDouble() * 100.0,
+ subStartInGlobalSpace.ToDouble() * 100.0,
+ subEndInGlobalSpace.ToDouble() * 100.0);
+ }
+#endif // DEBUG_PROCESSLOGGER
+ return ProgressLogger{
+ mGlobalProgressOrNull,
+ /* Start */ subStartInGlobalSpace,
+ /* Multipler */ subEndInGlobalSpace - subStartInGlobalSpace,
+ aLocationOrNullEmptyToIgnoreAtStart, aLocationOrNullEmptyToIgnoreAtEnd};
+ }
+
+ // Helper with no start location.
+ [[nodiscard]] ProgressLogger CreateSubLoggerFromTo(
+ ProportionValue aSubStartInLocalSpace,
+ ProportionValue aSubEndInLocalSpace,
+ const char* aLocationOrNullEmptyToIgnoreAtEnd = NO_LOCATION_UPDATE) {
+ return CreateSubLoggerFromTo(aSubStartInLocalSpace, NO_LOCATION_UPDATE,
+ aSubEndInLocalSpace,
+ aLocationOrNullEmptyToIgnoreAtEnd);
+ }
+
+ // Helper using the current progress as start.
+ [[nodiscard]] ProgressLogger CreateSubLoggerTo(
+ const char* aLocationOrNullEmptyToIgnoreAtStart,
+ ProportionValue aSubEndInLocalSpace,
+ const char* aLocationOrNullEmptyToIgnoreAtEnd = NO_LOCATION_UPDATE) {
+ MOZ_ASSERT(!IsMovedFrom());
+ if (!mGlobalProgressOrNull) {
+ return ProgressLogger{};
+ }
+ const ProportionValue subStartInGlobalSpace = GetGlobalProgress();
+ const ProportionValue subEndInGlobalSpace =
+ LocalToGlobal(aSubEndInLocalSpace);
+ if (subStartInGlobalSpace.IsInvalid() || subEndInGlobalSpace.IsInvalid()) {
+ return ProgressLogger{mGlobalProgressOrNull,
+ /* Start */ ProportionValue::MakeInvalid(),
+ /* Multiplier */ ProportionValue{0.0},
+ aLocationOrNullEmptyToIgnoreAtStart,
+ aLocationOrNullEmptyToIgnoreAtEnd};
+ }
+#ifdef DEBUG_PROCESSLOGGER
+ if (mGlobalProgressOrNull) {
+ printf("[%d] * Sub: local [(here), %.0f%%] ~ global [%.2f%%, %.2f%%]\n",
+ int(baseprofiler::profiler_current_process_id().ToNumber()),
+ aSubEndInLocalSpace.ToDouble() * 100.0,
+ subStartInGlobalSpace.ToDouble() * 100.0,
+ subEndInGlobalSpace.ToDouble() * 100.0);
+ }
+#endif // DEBUG_PROCESSLOGGER
+ return ProgressLogger{
+ mGlobalProgressOrNull,
+ /* Start */ subStartInGlobalSpace,
+ /* Multiplier */ subEndInGlobalSpace - subStartInGlobalSpace,
+ aLocationOrNullEmptyToIgnoreAtStart, aLocationOrNullEmptyToIgnoreAtEnd};
+ }
+
+ // Helper using the current progress as start, no start location.
+ [[nodiscard]] ProgressLogger CreateSubLoggerTo(
+ ProportionValue aSubEndInLocalSpace,
+ const char* aLocationOrNullEmptyToIgnoreAtEnd = NO_LOCATION_UPDATE) {
+ return CreateSubLoggerTo(NO_LOCATION_UPDATE, aSubEndInLocalSpace,
+ aLocationOrNullEmptyToIgnoreAtEnd);
+ }
+
+ class IndexAndProgressLoggerRange;
+
+ [[nodiscard]] inline IndexAndProgressLoggerRange CreateLoopSubLoggersFromTo(
+ ProportionValue aLoopStartInLocalSpace,
+ ProportionValue aLoopEndInLocalSpace, uint32_t aLoopCount,
+ const char* aLocationOrNullEmptyToIgnoreAtEdges =
+ ProgressLogger::NO_LOCATION_UPDATE);
+ [[nodiscard]] inline IndexAndProgressLoggerRange CreateLoopSubLoggersTo(
+ ProportionValue aLoopEndInLocalSpace, uint32_t aLoopCount,
+ const char* aLocationOrNullEmptyToIgnoreAtEdges =
+ ProgressLogger::NO_LOCATION_UPDATE);
+
+ private:
+ // All constructions start at the local 0%.
+ ProgressLogger(RefPtr<SharedProgress> aGlobalProgressOrNull,
+ ProportionValue aLocalStartInGlobalSpace,
+ ProportionValue aLocalToGlobalMultiplier,
+ const char* aLocationOrNullEmptyToIgnoreAtConstruction,
+ const char* aLocationOrNullEmptyToIgnoreAtDestruction)
+ : mGlobalProgressOrNull(std::move(aGlobalProgressOrNull)),
+ mLocalStartInGlobalSpace(aLocalStartInGlobalSpace),
+ mLocalToGlobalMultiplier(aLocalToGlobalMultiplier),
+ mLocationAtDestruction(aLocationOrNullEmptyToIgnoreAtDestruction) {
+ MOZ_ASSERT(!IsMovedFrom(), "Don't construct a moved-from object!");
+ SetLocalProgress(ProportionValue{0.0},
+ aLocationOrNullEmptyToIgnoreAtConstruction);
+ }
+
+ void MarkMovedFrom() {
+ mLocalToGlobalMultiplier = ProportionValue::MakeInvalid();
+ }
+ [[nodiscard]] bool IsMovedFrom() const {
+ return mLocalToGlobalMultiplier.IsInvalid();
+ }
+
+ [[nodiscard]] ProportionValue LocalToGlobal(
+ ProportionValue aLocalProgress) const {
+ return aLocalProgress * mLocalToGlobalMultiplier + mLocalStartInGlobalSpace;
+ }
+
+ // Global progress value to update from local changes.
+ RefPtr<SharedProgress> mGlobalProgressOrNull;
+
+ // How much to multiply and add to a local [0, 100%] value, to get the
+ // corresponding value in the global space.
+ // If mLocalToGlobalMultiplier is invalid, this ProgressLogger is moved-from,
+ // functions should not be used, and destructor won't update progress.
+ ProportionValue mLocalStartInGlobalSpace;
+ ProportionValue mLocalToGlobalMultiplier;
+
+ const char* mLocationAtDestruction = nullptr;
+};
+
+// Helper class for range-for loop, e.g., with `aProgressLogger`:
+// for (auto [index, loopProgressLogger] :
+// IndexAndProgressLoggerRange{aProgressLogger, 30_pc, 50_pc, 10,
+// "looping..."}) {
+// // This will loop 10 times.
+// // `index` is the loop index, from 0 to 9.
+// // The overall loop will start at 30% and end at 50% of aProgressLogger.
+// // `loopProgressLogger` is the progress logger for each iteration,
+// // covering 1/10th of the range, therefore: [30%,32%], then [32%,34%],
+// // etc. until [48%,50%].
+// // Progress is automatically updated before/after each loop.
+// }
+// Note that this implementation is single-threaded, it does not support logging
+// progress from parallel loops.
+class ProgressLogger::IndexAndProgressLoggerRange {
+ public:
+ struct IndexAndProgressLogger {
+ uint32_t index;
+ ProgressLogger progressLogger;
+ };
+
+ class IndexAndProgressLoggerEndIterator {
+ public:
+ explicit IndexAndProgressLoggerEndIterator(uint32_t aIndex)
+ : mIndex(aIndex) {}
+
+ [[nodiscard]] uint32_t Index() const { return mIndex; }
+
+ private:
+ uint32_t mIndex;
+ };
+
+ class IndexAndProgressLoggerIterator {
+ public:
+ IndexAndProgressLoggerIterator(
+ RefPtr<ProgressLogger::SharedProgress> aGlobalProgressOrNull,
+ ProportionValue aLoopStartInGlobalSpace,
+ ProportionValue aLoopIncrementInGlobalSpace,
+ const char* aLocationOrNullEmptyToIgnoreAtEdges)
+ : mGlobalProgressOrNull(aGlobalProgressOrNull),
+ mLoopStartInGlobalSpace(aLoopStartInGlobalSpace),
+ mLoopIncrementInGlobalSpace(aLoopIncrementInGlobalSpace),
+ mIndex(0u),
+ mLocationOrNullEmptyToIgnoreAtEdges(
+ aLocationOrNullEmptyToIgnoreAtEdges) {
+ if (mGlobalProgressOrNull) {
+ mGlobalProgressOrNull->SetProgress(mLoopStartInGlobalSpace,
+ mLocationOrNullEmptyToIgnoreAtEdges);
+ }
+ }
+
+ [[nodiscard]] IndexAndProgressLogger operator*() {
+ return IndexAndProgressLogger{
+ mIndex,
+ mGlobalProgressOrNull
+ ? ProgressLogger{mGlobalProgressOrNull, mLoopStartInGlobalSpace,
+ mLoopIncrementInGlobalSpace,
+ ProgressLogger::NO_LOCATION_UPDATE,
+ ProgressLogger::NO_LOCATION_UPDATE}
+ : ProgressLogger{}};
+ }
+
+ [[nodiscard]] bool operator!=(
+ const IndexAndProgressLoggerEndIterator& aEnd) const {
+ return mIndex != aEnd.Index();
+ }
+
+ IndexAndProgressLoggerIterator& operator++() {
+ ++mIndex;
+ mLoopStartInGlobalSpace =
+ mLoopStartInGlobalSpace + mLoopIncrementInGlobalSpace;
+ if (mGlobalProgressOrNull) {
+ mGlobalProgressOrNull->SetProgress(mLoopStartInGlobalSpace,
+ mLocationOrNullEmptyToIgnoreAtEdges);
+ }
+ return *this;
+ }
+
+ private:
+ RefPtr<ProgressLogger::SharedProgress> mGlobalProgressOrNull;
+ ProportionValue mLoopStartInGlobalSpace;
+ ProportionValue mLoopIncrementInGlobalSpace;
+ uint32_t mIndex;
+ const char* mLocationOrNullEmptyToIgnoreAtEdges;
+ };
+
+ [[nodiscard]] IndexAndProgressLoggerIterator begin() {
+ return IndexAndProgressLoggerIterator{
+ mGlobalProgressOrNull, mLoopStartInGlobalSpace,
+ mLoopIncrementInGlobalSpace, mLocationOrNullEmptyToIgnoreAtEdges};
+ }
+
+ [[nodiscard]] IndexAndProgressLoggerEndIterator end() {
+ return IndexAndProgressLoggerEndIterator{mLoopCount};
+ }
+
+ private:
+ friend class ProgressLogger;
+ IndexAndProgressLoggerRange(ProgressLogger& aProgressLogger,
+ ProportionValue aLoopStartInGlobalSpace,
+ ProportionValue aLoopEndInGlobalSpace,
+ uint32_t aLoopCount,
+ const char* aLocationOrNullEmptyToIgnoreAtEdges =
+ ProgressLogger::NO_LOCATION_UPDATE)
+ : mGlobalProgressOrNull(aProgressLogger.mGlobalProgressOrNull),
+ mLoopStartInGlobalSpace(aLoopStartInGlobalSpace),
+ mLoopIncrementInGlobalSpace(
+ (aLoopEndInGlobalSpace - aLoopStartInGlobalSpace) / aLoopCount),
+ mLoopCount(aLoopCount),
+ mLocationOrNullEmptyToIgnoreAtEdges(
+ aLocationOrNullEmptyToIgnoreAtEdges) {}
+
+ RefPtr<ProgressLogger::SharedProgress> mGlobalProgressOrNull;
+ ProportionValue mLoopStartInGlobalSpace;
+ ProportionValue mLoopIncrementInGlobalSpace;
+ uint32_t mLoopCount;
+ const char* mLocationOrNullEmptyToIgnoreAtEdges;
+};
+
+[[nodiscard]] ProgressLogger::IndexAndProgressLoggerRange
+ProgressLogger::CreateLoopSubLoggersFromTo(
+ ProportionValue aLoopStartInLocalSpace,
+ ProportionValue aLoopEndInLocalSpace, uint32_t aLoopCount,
+ const char* aLocationOrNullEmptyToIgnoreAtEdges) {
+ return IndexAndProgressLoggerRange{
+ *this, LocalToGlobal(aLoopStartInLocalSpace),
+ LocalToGlobal(aLoopEndInLocalSpace), aLoopCount,
+ aLocationOrNullEmptyToIgnoreAtEdges};
+}
+
+[[nodiscard]] ProgressLogger::IndexAndProgressLoggerRange
+ProgressLogger::CreateLoopSubLoggersTo(
+ ProportionValue aLoopEndInLocalSpace, uint32_t aLoopCount,
+ const char* aLocationOrNullEmptyToIgnoreAtEdges) {
+ return IndexAndProgressLoggerRange{
+ *this, GetGlobalProgress(), LocalToGlobal(aLoopEndInLocalSpace),
+ aLoopCount, aLocationOrNullEmptyToIgnoreAtEdges};
+}
+
+} // namespace mozilla
+
+#endif // ProgressLogger_h
diff --git a/mozglue/baseprofiler/public/ProportionValue.h b/mozglue/baseprofiler/public/ProportionValue.h
new file mode 100644
index 0000000000..61eb2766ec
--- /dev/null
+++ b/mozglue/baseprofiler/public/ProportionValue.h
@@ -0,0 +1,235 @@
+/* -*- 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/. */
+
+#ifndef ProportionValue_h
+#define ProportionValue_h
+
+#include "mozilla/Attributes.h"
+
+#include <algorithm>
+#include <limits>
+
+namespace mozilla {
+
+// Class storing a proportion value between 0 and 1, effectively 0% to 100%.
+// The public interface deals with doubles, but internally the value is encoded
+// in an integral type, so arithmetic operations are fast.
+// It also supports an invalid value: Use MakeInvalid() to construct, it infects
+// any operation, and gets converted to a signaling NaN.
+class ProportionValue {
+ public:
+ using UnderlyingType = uint32_t;
+
+ // Default-construct at 0%.
+ constexpr ProportionValue()
+ // This `noexcept` is necessary to avoid a build error when encapsulating
+ // `ProportionValue` in `std::Atomic`:
+ // "use of deleted function
+ // 'constexpr std::atomic<mozilla::ProportionValue>::atomic()"
+ // because the default `std::atomic<T>::atomic()` constructor is marked:
+ // `noexcept(std::is_nothrow_default_constructible_v<T>)`
+ // and therefore this default constructor here must be explicitly marked
+ // `noexcept` as well.
+ noexcept
+ : mIntegralValue(0u) {}
+
+ // Construct a ProportionValue with the given value, clamped to 0..1.
+ // Note that it's constexpr, so construction from literal numbers should incur
+ // no runtime costs.
+ // If `aValue` is NaN, behavior is undefined! Use `MakeInvalid()` instead.
+ constexpr explicit ProportionValue(double aValue)
+ : mIntegralValue(UnderlyingType(std::clamp(aValue, 0.0, 1.0) * scMaxD)) {}
+
+ [[nodiscard]] static constexpr ProportionValue MakeInvalid() {
+ return ProportionValue(scInvalidU, Internal{});
+ }
+
+ [[nodiscard]] constexpr double ToDouble() const {
+ return IsInvalid() ? std::numeric_limits<double>::signaling_NaN()
+ : (double(mIntegralValue) * scInvMaxD);
+ }
+
+ // Retrieve the underlying integral value, for storage or testing purposes.
+ [[nodiscard]] constexpr UnderlyingType ToUnderlyingType() const {
+ return mIntegralValue;
+ };
+
+ // Re-construct a ProportionValue from an underlying integral value.
+ [[nodiscard]] static constexpr ProportionValue FromUnderlyingType(
+ UnderlyingType aUnderlyingType) {
+ return ProportionValue(
+ (aUnderlyingType <= scMaxU) ? aUnderlyingType : scInvalidU, Internal{});
+ }
+
+ [[nodiscard]] constexpr bool IsExactlyZero() const {
+ return mIntegralValue == 0u;
+ }
+
+ [[nodiscard]] constexpr bool IsExactlyOne() const {
+ return mIntegralValue == scMaxU;
+ }
+
+ [[nodiscard]] constexpr bool IsValid() const {
+ // Compare to the maximum value, not just exactly scInvalidU, to catch any
+ // kind of invalid state.
+ return mIntegralValue <= scMaxU;
+ }
+ [[nodiscard]] constexpr bool IsInvalid() const {
+ // Compare to the maximum value, not just exactly scInvalidU, to catch any
+ // kind of invalid state.
+ return mIntegralValue > scMaxU;
+ }
+
+ // Strict comparisons based on the underlying integral value. Use
+ // `CompareWithin` instead to make fuzzy comparisons.
+ // `ProportionValue::MakeInvalid()`s are equal, and greater than anything
+ // else; Best to avoid comparisons, and first use IsInvalid() instead.
+#define OPERATOR_COMPARISON(CMP) \
+ [[nodiscard]] constexpr friend bool operator CMP( \
+ const ProportionValue& aLHS, const ProportionValue& aRHS) { \
+ return aLHS.mIntegralValue CMP aRHS.mIntegralValue; \
+ }
+ OPERATOR_COMPARISON(==)
+ OPERATOR_COMPARISON(!=)
+ OPERATOR_COMPARISON(<)
+ OPERATOR_COMPARISON(<=)
+ OPERATOR_COMPARISON(>)
+ OPERATOR_COMPARISON(>=)
+#undef OPERATOR_COMPARISON
+
+ // Arithmetic operations + - *, all working on the underlying integral values
+ // (i.e, no expensive floating-point operations are used), and always clamping
+ // to 0..1 range. Invalid values are poisonous.
+
+ [[nodiscard]] constexpr ProportionValue operator+(
+ ProportionValue aRHS) const {
+ return ProportionValue(
+ (IsInvalid() || aRHS.IsInvalid())
+ ? scInvalidU
+ // Adding fixed-point values keep the same scale, so there is no
+ // adjustment needed for that. [0,1]+[0,1]=[0,2], so we only need to
+ // ensure that the result is capped at max 1, aka scMaxU:
+ // a+b<=max <=> b<=max-a, so b is at maximum max-a.
+ : (mIntegralValue +
+ std::min(aRHS.mIntegralValue, scMaxU - mIntegralValue)),
+ Internal{});
+ }
+
+ [[nodiscard]] constexpr ProportionValue operator-(
+ ProportionValue aRHS) const {
+ return ProportionValue(
+ (IsInvalid() || aRHS.IsInvalid())
+ ? scInvalidU
+ // Subtracting fixed-point values keep the same scale, so there is
+ // no adjustment needed for that. [0,1]-[0,1]=[-1,1], so we only
+ // need to ensure that the value is positive:
+ // a-b>=0 <=> b<=a, so b is at maximum a.
+ : (mIntegralValue - std::min(aRHS.mIntegralValue, mIntegralValue)),
+ Internal{});
+ }
+
+ [[nodiscard]] constexpr ProportionValue operator*(
+ ProportionValue aRHS) const {
+ // Type to hold the full result of multiplying two maximum numbers.
+ using DoublePrecisionType = uint64_t;
+ static_assert(sizeof(DoublePrecisionType) >= 2 * sizeof(UnderlyingType));
+ return ProportionValue(
+ (IsInvalid() || aRHS.IsInvalid())
+ ? scInvalidU
+ // Multiplying fixed-point values doubles the scale (2^31 -> 2^62),
+ // so we need to adjust the result by dividing it by one scale
+ // (which is optimized into a binary right-shift).
+ : (UnderlyingType((DoublePrecisionType(mIntegralValue) *
+ DoublePrecisionType(aRHS.mIntegralValue)) /
+ DoublePrecisionType(scMaxU))),
+ Internal{});
+ }
+
+ // Explicitly forbid divisions, they make little sense, and would almost
+ // always return a clamped 100% (E.g.: 50% / 10% = 0.5 / 0.1 = 5 = 500%).
+ [[nodiscard]] constexpr ProportionValue operator/(
+ ProportionValue aRHS) const = delete;
+
+ // Division by a positive integer value, useful to split an interval in equal
+ // parts (with maybe some spare space at the end, because it is rounded down).
+ // Division by 0 produces an invalid value.
+ [[nodiscard]] constexpr ProportionValue operator/(uint32_t aDivisor) const {
+ return ProportionValue((IsInvalid() || aDivisor == 0u)
+ ? scInvalidU
+ : (mIntegralValue / aDivisor),
+ Internal{});
+ }
+
+ // Multiplication by a positive integer value, useful as inverse of the
+ // integer division above. But it may be lossy because the division is rounded
+ // down, therefore: PV - u < (PV / u) * u <= PV.
+ // Clamped to 100% max.
+ [[nodiscard]] constexpr ProportionValue operator*(
+ uint32_t aMultiplier) const {
+ return ProportionValue(IsInvalid()
+ ? scInvalidU
+ : ((aMultiplier > scMaxU / mIntegralValue)
+ ? scMaxU
+ : (mIntegralValue * aMultiplier)),
+ Internal{});
+ }
+
+ private:
+ // Tagged constructor for internal construction from the UnderlyingType, so
+ // that it is never ambiguously considered in constructions from one number.
+ struct Internal {};
+ constexpr ProportionValue(UnderlyingType aIntegralValue, Internal)
+ : mIntegralValue(aIntegralValue) {}
+
+ // Use all but 1 bit for the fractional part.
+ // Valid values can go from 0b0 (0%) up to 0b1000...00 (scMaxU aka 100%).
+ static constexpr unsigned scFractionalBits = sizeof(UnderlyingType) * 8 - 1;
+ // Maximum value corresponding to 1.0 or 100%.
+ static constexpr UnderlyingType scMaxU = UnderlyingType(1u)
+ << scFractionalBits;
+ // This maximum value corresponding to 1.0 can also be seen as the scaling
+ // factor from any [0,1] `double` value to the internal integral value.
+ static constexpr double scMaxD = double(scMaxU);
+ // The inverse can be used to convert the internal value back to [0,1].
+ static constexpr double scInvMaxD = 1.0 / scMaxD;
+
+ // Special value outside [0,max], used to construct invalid values.
+ static constexpr UnderlyingType scInvalidU = ~UnderlyingType(0u);
+
+ // Internal integral value, guaranteed to always be <= scMaxU, or scInvalidU.
+ // This is effectively a fixed-point value using 1 bit for the integer part
+ // and 31 bits for the fractional part.
+ // It is roughly equal to the `double` value [0,1] multiplied by scMaxD.
+ UnderlyingType mIntegralValue;
+};
+
+namespace literals {
+inline namespace ProportionValue_literals {
+
+// User-defined literal for integer percentages, e.g.: `10_pc`, `100_pc`
+// (equivalent to `ProportionValue{0.1}` and `ProportionValue{1.0}`).
+// Clamped to [0, 100]_pc.
+[[nodiscard]] constexpr ProportionValue operator""_pc(
+ unsigned long long int aPercentage) {
+ return ProportionValue{
+ double(std::clamp<unsigned long long int>(aPercentage, 0u, 100u)) /
+ 100.0};
+}
+
+// User-defined literal for non-integer percentages, e.g.: `12.3_pc`, `100.0_pc`
+// (equivalent to `ProportionValue{0.123}` and `ProportionValue{1.0}`).
+// Clamped to [0.0, 100.0]_pc.
+[[nodiscard]] constexpr ProportionValue operator""_pc(long double aPercentage) {
+ return ProportionValue{
+ double(std::clamp<long double>(aPercentage, 0.0, 100.0)) / 100.0};
+}
+
+} // namespace ProportionValue_literals
+} // namespace literals
+
+} // namespace mozilla
+
+#endif // ProportionValue_h
diff --git a/mozglue/baseprofiler/public/leb128iterator.h b/mozglue/baseprofiler/public/leb128iterator.h
new file mode 100644
index 0000000000..636baf916f
--- /dev/null
+++ b/mozglue/baseprofiler/public/leb128iterator.h
@@ -0,0 +1,207 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+// LEB128 utilities that can read/write unsigned LEB128 numbers from/to
+// iterators.
+//
+// LEB128 = Little Endian Base 128, where small numbers take few bytes, but
+// large numbers are still allowed, which is ideal when serializing numbers that
+// are likely to be small.
+// Each byte contains 7 bits from the number, starting at the "little end", the
+// top bit is 0 for the last byte, 1 otherwise.
+// Numbers 0-127 only take 1 byte. 128-16383 take 2 bytes. Etc.
+//
+// Iterators only need to provide:
+// - `*it` to return a reference to the next byte to be read from or written to.
+// - `++it` to advance the iterator after a byte is written.
+//
+// The caller must always provide sufficient space to write any number, by:
+// - pre-allocating a large enough buffer, or
+// - allocating more space when `++it` reaches the end and/or `*it` is invoked
+// after the end, or
+// - moving the underlying pointer to an appropriate location (e.g., wrapping
+// around a circular buffer).
+// The caller must also provide enough bytes to read a full value (i.e., at
+// least one byte should have its top bit unset), and a type large enough to
+// hold the stored value.
+//
+// Note: There are insufficient checks for validity! These functions are
+// intended to be used together, i.e., the user should only `ReadULEB128()` from
+// a sufficiently-large buffer that the same user filled with `WriteULEB128()`.
+// Using with externally-sourced data (e.g., DWARF) is *not* recommended.
+//
+// https://en.wikipedia.org/wiki/LEB128
+
+#ifndef leb128iterator_h
+#define leb128iterator_h
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Likely.h"
+
+#include <climits>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+namespace mozilla {
+
+// Number of bytes needed to represent `aValue`.
+template <typename T>
+constexpr uint_fast8_t ULEB128Size(T aValue) {
+ static_assert(!std::numeric_limits<T>::is_signed,
+ "ULEB128Size only takes unsigned types");
+ // We need one output byte per 7 bits of non-zero value. So we just remove
+ // 7 least significant bits at a time until the value becomes zero.
+ // Note the special case of 0, which still needs 1 output byte; this is done
+ // by starting the first loop before we check for 0.
+ uint_fast8_t size = 0;
+ for (;;) {
+ size += 1;
+ aValue >>= 7;
+ // Expecting small values, so it should be more likely that `aValue == 0`.
+ if (MOZ_LIKELY(aValue == 0)) {
+ return size;
+ }
+ }
+}
+
+// Maximum number of bytes needed to represent any value of type `T`.
+template <typename T>
+constexpr uint_fast8_t ULEB128MaxSize() {
+ return ULEB128Size<T>(std::numeric_limits<T>::max());
+}
+
+// Write `aValue` in LEB128 to `aIterator`.
+// The iterator will be moved past the last byte.
+template <typename T, typename It>
+void WriteULEB128(T aValue, It& aIterator) {
+ static_assert(!std::numeric_limits<T>::is_signed,
+ "WriteULEB128 only takes unsigned types");
+ using IteratorValue = std::remove_reference_t<decltype(*aIterator)>;
+ static_assert(sizeof(IteratorValue) == 1,
+ "WriteULEB128 expects an iterator to single bytes");
+ // 0. Don't test for 0 yet, as we want to output one byte for it.
+ for (;;) {
+ // 1. Extract the 7 least significant bits.
+ const uint_fast8_t byte = aValue & 0x7Fu;
+ // 2. Remove them from `aValue`.
+ aValue >>= 7;
+ // 3. Write the 7 bits, and set the 8th bit if `aValue` is not 0 yet
+ // (meaning there will be more bytes after this one.)
+ // Expecting small values, so it should be more likely that `aValue == 0`.
+ // Note: No absolute need to force-cast to IteratorValue, because we have
+ // only changed the bottom 8 bits above. However the compiler could warn
+ // about a narrowing conversion from potentially-multibyte uint_fast8_t down
+ // to whatever single-byte type `*iterator* expects, so we make it explicit.
+ *aIterator = static_cast<IteratorValue>(
+ MOZ_LIKELY(aValue == 0) ? byte : (byte | 0x80u));
+ // 4. Always advance the iterator to the next byte.
+ ++aIterator;
+ // 5. We're done if `aValue` is 0.
+ // Expecting small values, so it should be more likely that `aValue == 0`.
+ if (MOZ_LIKELY(aValue == 0)) {
+ return;
+ }
+ }
+}
+
+// Read an LEB128 value from `aIterator`.
+// The iterator will be moved past the last byte.
+template <typename T, typename It>
+T ReadULEB128(It& aIterator) {
+ static_assert(!std::numeric_limits<T>::is_signed,
+ "ReadULEB128 must return an unsigned type");
+ using IteratorValue = std::remove_reference_t<decltype(*aIterator)>;
+ static_assert(sizeof(IteratorValue) == 1,
+ "ReadULEB128 expects an iterator to single bytes");
+ // Incoming bits will be added to `result`...
+ T result = 0;
+ // ... starting with the least significant bits.
+ uint_fast8_t shift = 0;
+ for (;;) {
+ // 1. Read one byte from the iterator.
+ // `static_cast` just in case IteratorValue is not implicitly convertible to
+ // uint_fast8_t. It wouldn't matter if the sign was extended, we're only
+ // dealing with the bottom 8 bits below.
+ const uint_fast8_t byte = static_cast<uint_fast8_t>(*aIterator);
+ // 2. Always advance the iterator.
+ ++aIterator;
+ // 3. Extract the 7 bits of value, and shift them in place into `result`.
+ result |= static_cast<T>(byte & 0x7fu) << shift;
+ // 4. If the 8th bit is *not* set, this was the last byte.
+ // Expecting small values, so it should be more likely that the bit is off.
+ if (MOZ_LIKELY((byte & 0x80u) == 0)) {
+ return result;
+ }
+ // There are more bytes to read.
+ // 5. Next byte will contain more significant bits above the past 7.
+ shift += 7;
+ // Safety check that we're not going to shift by >= than the type size,
+ // which is Undefined Behavior in C++.
+ MOZ_ASSERT(shift < CHAR_BIT * sizeof(T));
+ }
+}
+
+// constexpr ULEB128 reader class.
+// Mostly useful when dealing with non-trivial byte feeds.
+template <typename T>
+class ULEB128Reader {
+ static_assert(!std::numeric_limits<T>::is_signed,
+ "ULEB128Reader must handle an unsigned type");
+
+ public:
+ constexpr ULEB128Reader() = default;
+
+ // Don't allow copy/assignment, it doesn't make sense for a stateful parser.
+ constexpr ULEB128Reader(const ULEB128Reader&) = delete;
+ constexpr ULEB128Reader& operator=(const ULEB128Reader&) = delete;
+
+ // Feed a byte into the parser.
+ // Returns true if this was the last byte.
+ [[nodiscard]] constexpr bool FeedByteIsComplete(unsigned aByte) {
+ MOZ_ASSERT(!IsComplete());
+ // Extract the 7 bits of value, and shift them in place into the value.
+ mValue |= static_cast<T>(aByte & 0x7fu) << mShift;
+ // If the 8th bit is *not* set, this was the last byte.
+ // Expecting small values, so it should be more likely that the bit is off.
+ if (MOZ_LIKELY((aByte & 0x80u) == 0)) {
+ mShift = mCompleteShift;
+ return true;
+ }
+ // There are more bytes to read.
+ // Next byte will contain more significant bits above the past 7.
+ mShift += 7;
+ // Safety check that we're not going to shift by >= than the type size,
+ // which is Undefined Behavior in C++.
+ MOZ_ASSERT(mShift < CHAR_BIT * sizeof(T));
+ return false;
+ }
+
+ constexpr void Reset() {
+ mValue = 0;
+ mShift = 0;
+ }
+
+ [[nodiscard]] constexpr bool IsComplete() const {
+ return mShift == mCompleteShift;
+ }
+
+ [[nodiscard]] constexpr T Value() const {
+ MOZ_ASSERT(IsComplete());
+ return mValue;
+ }
+
+ private:
+ // Special value of `mShift` indicating that parsing is complete.
+ constexpr static unsigned mCompleteShift = 0x10000u;
+
+ T mValue = 0;
+ unsigned mShift = 0;
+};
+
+} // namespace mozilla
+
+#endif // leb128iterator_h
diff --git a/mozglue/build/AsanOptions.cpp b/mozglue/build/AsanOptions.cpp
new file mode 100644
index 0000000000..a96e6bd840
--- /dev/null
+++ b/mozglue/build/AsanOptions.cpp
@@ -0,0 +1,197 @@
+/* -*- 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 "mozilla/Attributes.h"
+
+#ifndef _MSC_VER // Not supported by clang-cl yet
+
+// When running with AddressSanitizer, we need to explicitly set some
+// options specific to our codebase to prevent errors during runtime.
+// To override these, set the ASAN_OPTIONS environment variable.
+//
+// Currently, these are:
+//
+// allow_user_segv_handler=1 - Tell ASan to allow our code to use its
+// own SIGSEGV handlers. This is required by ASM.js internally.
+//
+// alloc_dealloc_mismatch=0 - Disable alloc-dealloc mismatch checking
+// in ASan. This is required because we define our own new/delete
+// operators that are backed by malloc/free. If one of them gets inlined
+// while the other doesn't, ASan will report false positives.
+//
+// detect_leaks=0 - Disable LeakSanitizer. This is required because
+// otherwise leak checking will be enabled for various building and
+// testing executables where we don't care much about leaks.
+//
+// allocator_may_return_null=1 - Tell ASan to return NULL when an allocation
+// fails instead of aborting the program. This allows us to handle failing
+// allocations the same way we would handle them with a regular allocator and
+// also uncovers potential bugs that might occur in these situations.
+//
+// max_malloc_fill_size - Tell ASan to initialize memory to a certain value
+// when it is allocated. This option specifies the maximum allocation size
+// for which ASan should still initialize the memory. The value we specify
+// here is exactly 256MiB.
+//
+// max_free_fill_size - Similar to max_malloc_fill_size, tell ASan to
+// overwrite memory with a certain value when it is freed. Again, the value
+// here specifies the maximum allocation size, larger allocations will
+// skipped.
+//
+// malloc_fill_byte / free_fill_byte - These values specify the byte values
+// used to initialize/overwrite memory in conjunction with the previous
+// options max_malloc_fill_size and max_free_fill_size. The values used here
+// are 0xe4 and 0xe5 to match the kAllocPoison and kAllocJunk constants used
+// by mozjemalloc.
+//
+// malloc_context_size - This value specifies how many stack frames are
+// stored for each malloc and free call. Since Firefox can have lots of deep
+// stacks with allocations, we limit the default size here further to save
+// some memory.
+//
+// fast_unwind_on_check - Use the fast (frame-pointer-based) stack unwinder
+// for internal CHECK failures. The slow unwinder doesn't work on Android.
+//
+// fast_unwind_on_fatal - Use the fast (frame-pointer-based) stack unwinder
+// to print fatal error reports. The slow unwinder doesn't work on Android.
+//
+// detect_stack_use_after_return=0 - Work around bug 1768099.
+//
+// intercept_tls_get_addr=0 - Work around
+// https://github.com/google/sanitizers/issues/1322 (bug 1635327).
+//
+// !! Note: __asan_default_options is not used on Android! (bug 1576213)
+// These should be updated in:
+// mobile/android/geckoview/src/asan/resources/lib/*/wrap.sh
+//
+extern "C" MOZ_ASAN_IGNORE const char* __asan_default_options() {
+ return "allow_user_segv_handler=1:alloc_dealloc_mismatch=0:detect_leaks=0"
+# ifdef MOZ_ASAN_REPORTER
+ ":malloc_context_size=20"
+# endif
+# ifdef __ANDROID__
+ ":fast_unwind_on_check=1:fast_unwind_on_fatal=1"
+# endif
+ ":max_free_fill_size=268435456:max_malloc_fill_size=268435456"
+ ":malloc_fill_byte=228:free_fill_byte=229"
+ ":handle_sigill=1"
+ ":allocator_may_return_null=1"
+ ":detect_stack_use_after_return=0"
+ ":intercept_tls_get_addr=0";
+}
+
+// !!! Please do not add suppressions for new leaks in Gecko code, unless they
+// are intentional !!!
+extern "C" const char* __lsan_default_suppressions() {
+ return "# Add your suppressions below\n"
+
+ // LSan runs with a shallow stack depth and no debug symbols, so some
+ // small intentional leaks in system libraries show up with this. You
+ // do not want this enabled when running locally with a deep stack, as
+ // it can catch too much.
+ "leak:libc.so\n"
+
+ // nsComponentManagerImpl intentionally leaks factory entries, and
+ // probably some other stuff.
+ "leak:nsComponentManagerImpl\n"
+
+ // Bug 981220 - Pixman fails to free TLS memory.
+ "leak:pixman_implementation_lookup_composite\n"
+
+ // Bug 987918 - Font shutdown leaks when CLEANUP_MEMORY is not enabled.
+ "leak:libfontconfig.so\n"
+ "leak:libfreetype.so\n"
+ "leak:GI___strdup\n"
+ // The symbol is really __GI___strdup, but if you have the leading _,
+ // it doesn't suppress it.
+
+ // xdg_mime_init() is leaked by Gtk3 library
+ "leak:xdg_mime_init\n"
+
+ // Bug 1078015 - If the process terminates during a PR_Sleep, LSAN
+ // detects a leak
+ "leak:PR_Sleep\n"
+
+ // Bug 1363976 - Stylo holds some global data alive forever.
+ "leak:style::global_style_data\n"
+ "leak:style::sharing::SHARING_CACHE_KEY\n"
+ "leak:style::bloom::BLOOM_KEY\n"
+
+ //
+ // Many leaks only affect some test suites. The suite annotations are
+ // not checked.
+ //
+
+ // Bug 979928 - WebRTC leaks in different mochitest suites.
+ "leak:NR_reg_init\n"
+ // nr_reg_local_init should be redundant with NR_reg_init, but on
+ // Aurora we get fewer stack frames for some reason.
+ "leak:nr_reg_local_init\n"
+ "leak:r_log_register\n"
+ "leak:nr_reg_set\n"
+
+ // This is a one-time leak in mochitest-bc, so it is probably okay to
+ // ignore.
+ "leak:GlobalPrinters::InitializeGlobalPrinters\n"
+ "leak:nsPSPrinterList::GetPrinterList\n"
+
+ // Bug 1028456 - Various NSPR fd-related leaks in different mochitest
+ // suites.
+ "leak:_PR_Getfd\n"
+
+ // Bug 1028483 - The XML parser sometimes leaks an object. Mostly
+ // happens in toolkit/components/thumbnails.
+ "leak:processInternalEntity\n"
+
+ // Bug 1187421 - NSS does not always free the error stack in different
+ // mochitest suites.
+ "leak:nss_ClearErrorStack\n"
+
+ // Bug 1602689 - leak at mozilla::NotNull, RacyRegisteredThread,
+ // RegisteredThread::RegisteredThread, mozilla::detail::UniqueSelector
+ "leak:RegisteredThread::RegisteredThread\n"
+
+ //
+ // Leaks with system libraries in their stacks. These show up across a
+ // number of tests. Better symbols and disabling fast stackwalking may
+ // help diagnose these.
+ //
+ "leak:libcairo.so\n"
+ // https://github.com/OpenPrinting/cups/pull/317
+ "leak:libcups.so\n"
+ "leak:libdl.so\n"
+ "leak:libdricore.so\n"
+ "leak:libdricore9.2.1.so\n"
+ "leak:libGL.so\n"
+ "leak:libEGL_mesa.so\n"
+ "leak:libglib-2.0.so\n"
+ "leak:libglsl.so\n"
+ "leak:libp11-kit.so\n"
+ "leak:libpixman-1.so\n"
+ "leak:libpulse.so\n"
+ // lubpulsecommon 1.1 is Ubuntu 12.04
+ "leak:libpulsecommon-1.1.so\n"
+ // lubpulsecommon 1.1 is Ubuntu 16.04
+ "leak:libpulsecommon-8.0.so\n"
+ "leak:libresolv.so\n"
+ "leak:libstdc++.so\n"
+ "leak:libXrandr.so\n"
+ "leak:libX11.so\n"
+ "leak:pthread_setspecific_internal\n"
+ "leak:swrast_dri.so\n"
+
+ "leak:js::frontend::BytecodeEmitter:\n"
+ "leak:js::frontend::GeneralParser\n"
+ "leak:js::frontend::Parse\n"
+ "leak:xpc::CIGSHelper\n"
+ "leak:mozJSModuleLoader\n"
+ "leak:mozilla::xpcom::ConstructJSMComponent\n"
+ "leak:XPCWrappedNativeJSOps\n"
+
+ // End of suppressions.
+ ; // Please keep this semicolon.
+}
+
+#endif // _MSC_VER
diff --git a/mozglue/build/BionicGlue.cpp b/mozglue/build/BionicGlue.cpp
new file mode 100644
index 0000000000..8cc21b54e5
--- /dev/null
+++ b/mozglue/build/BionicGlue.cpp
@@ -0,0 +1,37 @@
+/* -*- 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 <sys/types.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+
+#define NS_EXPORT __attribute__((visibility("default")))
+
+extern "C" NS_EXPORT int raise(int sig) {
+ // Bug 741272: Bionic incorrectly uses kill(), which signals the
+ // process, and thus could signal another thread (and let this one
+ // return "successfully" from raising a fatal signal).
+ //
+ // Bug 943170: POSIX specifies pthread_kill(pthread_self(), sig) as
+ // equivalent to raise(sig), but Bionic also has a bug with these
+ // functions, where a forked child will kill its parent instead.
+
+ extern pid_t gettid(void);
+ return syscall(__NR_tgkill, getpid(), gettid(), sig);
+}
+
+/* Flash plugin uses symbols that are not present in Android >= 4.4 */
+namespace android {
+namespace VectorImpl {
+NS_EXPORT void reservedVectorImpl1(void) {}
+NS_EXPORT void reservedVectorImpl2(void) {}
+NS_EXPORT void reservedVectorImpl3(void) {}
+NS_EXPORT void reservedVectorImpl4(void) {}
+NS_EXPORT void reservedVectorImpl5(void) {}
+NS_EXPORT void reservedVectorImpl6(void) {}
+NS_EXPORT void reservedVectorImpl7(void) {}
+NS_EXPORT void reservedVectorImpl8(void) {}
+} // namespace VectorImpl
+} // namespace android
diff --git a/mozglue/build/Makefile.in b/mozglue/build/Makefile.in
new file mode 100644
index 0000000000..558ceba066
--- /dev/null
+++ b/mozglue/build/Makefile.in
@@ -0,0 +1,15 @@
+#
+# 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/.
+
+# For FORCE_SHARED_LIB
+include $(topsrcdir)/config/config.mk
+
+ifeq (WINNT,$(OS_TARGET))
+# Rebuild mozglue.dll if the manifest changes - it's included by mozglue.rc.
+# (this dependency should really be just for mozglue.dll, not other targets)
+# Note the manifest file exists in the tree, so we use the explicit filename
+# here.
+EXTRA_DEPS += $(srcdir)/mozglue.dll.manifest
+endif
diff --git a/mozglue/build/TsanOptions.cpp b/mozglue/build/TsanOptions.cpp
new file mode 100644
index 0000000000..eab90d4351
--- /dev/null
+++ b/mozglue/build/TsanOptions.cpp
@@ -0,0 +1,314 @@
+/* -*- 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 "mozilla/Attributes.h"
+#include "mozilla/TsanOptions.h"
+
+#ifndef _MSC_VER // Not supported by clang-cl yet
+
+//
+// When running with ThreadSanitizer, we sometimes need to suppress existing
+// races. However, in any case, it should be either because
+//
+// 1) a bug is on file. In this case, the bug number should always be
+// included with the suppression.
+//
+// or 2) this is an intentional race. Please be very careful with judging
+// races as intentional and benign. Races in C++ are undefined behavior
+// and compilers increasingly rely on exploiting this for optimizations.
+// Hence, many seemingly benign races cause harmful or unexpected
+// side-effects.
+//
+// See also:
+// https://software.intel.com/en-us/blogs/2013/01/06/benign-data-races-what-could-possibly-go-wrong
+//
+//
+// Also, when adding any race suppressions here, make sure to always add
+// a signature for each of the two race stacks. Sometimes, TSan fails to
+// symbolize one of the two traces and this can cause suppressed races to
+// show up intermittently.
+//
+// clang-format off
+extern "C" const char* __tsan_default_suppressions() {
+ return "# Add your suppressions below\n"
+
+ // External uninstrumented libraries
+ MOZ_TSAN_DEFAULT_EXTLIB_SUPPRESSIONS
+
+ // TSan internals
+ "race:__tsan::ProcessPendingSignals\n"
+ "race:__tsan::CallUserSignalHandler\n"
+
+
+
+
+
+ // Uninstrumented code causing false positives
+
+ // These libraries are uninstrumented and cause mutex false positives.
+ // However, they can be unloaded by GTK early which we cannot avoid.
+ "mutex:libGL.so\n"
+ "mutex:libGLdispatch\n"
+ "mutex:libGLX\n"
+ // Bug 1637707 - permanent
+ "mutex:libEGL_mesa.so\n"
+ // ~GLContextGLX unlocks a libGL mutex.
+ "mutex:GLContextGLX::~GLContextGLX\n"
+ // Bug 1825171
+ "mutex:libffi.so\n"
+ "mutex:wl_registry_destroy\n"
+ // Bug 1651446 - permanent (ffmpeg)
+ "race:libavcodec.so*\n"
+ "race:libavutil.so*\n"
+ // For some reason, the suppressions on libpulse.so
+ // through `called_from_lib` only work partially.
+ "race:libpulse.so\n"
+ "race:pa_context_suspend_source_by_index\n"
+ "race:pa_context_unref\n"
+ "race:pa_format_info_set_prop_string_array\n"
+ "race:pa_stream_get_index\n"
+ "race:pa_stream_update_timing_info\n"
+ // This is a callback from libglib-2 that is apparently
+ // not fully suppressed through `called_from_lib`.
+ "race:g_main_context_dispatch\n"
+ // This is likely a false positive involving a mutex from GTK.
+ // See also bug 1642653 - permanent.
+ "mutex:GetMaiAtkType\n"
+ // Bug 1688716 - Failure due to fire_glxtest_process
+ // calling into uninstrumented external graphics driver code.
+ // For example: iris_dri.so and swrast_dri.so.
+ "race:fire_glxtest_process\n"
+ // Bug 1722721 - WebRender using uninstrumented Mesa drivers
+ "race:swrast_dri.so\n"
+ // Bug 1825171
+ "race:libffi.so\n"
+ "race:mozilla::widget::WaylandBuffer::BufferReleaseCallbackHandler\n"
+
+
+
+
+ // Deadlock reports on single-threaded runtime.
+ //
+ // This is a known false positive from TSan where it reports
+ // a potential deadlock even though all mutexes are only
+ // taken by a single thread. For applications/tasks where we
+ // are absolutely sure that no second thread will be involved
+ // we should suppress these issues.
+ //
+ // See also https://github.com/google/sanitizers/issues/488
+
+ // Bug 1614605 - permanent
+ "deadlock:SanctionsTestServer\n"
+ "deadlock:OCSPStaplingServer\n"
+ // Bug 1643087 - permanent
+ "deadlock:BadCertAndPinningServer\n"
+ // Bug 1606804 - permanent
+ "deadlock:cert_storage::SecurityState::open_db\n"
+ "deadlock:cert_storage::SecurityState::add_certs\n"
+ // Bug 1651770 - permanent
+ "deadlock:mozilla::camera::LockAndDispatch\n"
+ // Bug 1606804 - permanent
+ "deadlock:third_party/rust/rkv/src/env.rs\n"
+ // Bug 1680655 - permanent
+ "deadlock:EncryptedClientHelloServer\n"
+ // Bug 1682861 - permanent
+ "deadlock:nsDOMWindowUtils::CompareCanvases\n"
+
+
+
+
+
+ // Benign races in third-party code (should be fixed upstream)
+
+ // No Bug - permanent
+ // No Upstream Bug Filed!
+ //
+ // SIMD Initialization in libjpeg, potentially runs
+ // initialization twice, but otherwise benign. Init
+ // routine itself is in native assembler.
+ "race:init_simd\n"
+ "race:simd_support\n"
+ "race:jsimd_can_ycc_rgb\n"
+ // Bug 1615228 - permanent
+ // No Upstream Bug Filed!
+ //
+ // Likely benign race in ipc/chromium/ where we set
+ // `message_loop_` to `NULL` on two threads when stopping
+ // a thread at the same time it is already finishing.
+ "race:base::Thread::Stop\n"
+ // Bug 1615569 - permanent
+ // No Upstream Bug Filed!
+ //
+ // NSS is using freebl from two different threads but freebl isn't
+ // that threadsafe.
+ "race:mp_exptmod.max_window_bits\n"
+ // Bug 1652499 - permanent
+ // No Upstream Bug Filed!
+ //
+ // Likely benign race in webrtc.org code - race while updating the
+ // minimum log severity.
+ "race:Loggable\n"
+ "race:UpdateMinLogSeverity\n"
+ // Bug 1652174 - permanent
+ // Upstream Bug: https://github.com/libevent/libevent/issues/777
+ //
+ // Likely benign write-write race in libevent to set a sticky boolean
+ // flag to true.
+ "race:event_debug_mode_too_late\n"
+
+ // Bug 1653618 - permanent
+ // Upstream Bug: https://github.com/sctplab/usrsctp/issues/507
+ //
+ // Might lead to scheduled timers in libusrsctp getting dropped?
+ "race:sctp_handle_tick\n"
+ "race:sctp_handle_sack\n"
+ // Bug 1648604 - permanent
+ // Upstream Bug: https://github.com/sctplab/usrsctp/issues/482
+ //
+ // Likely benign race in libusrsctp allocator during a free.
+ "race:system_base_info\n"
+ // Benign lock-order-inversion in libusrsctp
+ // No upstream bug filed!
+ "deadlock:sctp_add_to_readq\n"
+
+ // Bug 1153409 - permanent
+ // No Upstream Bug Filed!
+ //
+ // Probably benign - sqlite has a few optimizations where it does
+ // racy reads and then does properly synchronized integrity checks
+ // afterwards. Some concern of compiler optimizations messing this
+ // up due to "volatile" being too weak for this.
+ "race:third_party/sqlite3/*\n"
+ "deadlock:third_party/sqlite3/*\n"
+ // Bug 1674770 - permanent
+ // Upstream Bug: https://github.com/Amanieu/parking_lot/issues/257
+ //
+ // parking_lot using incorrect atomic orderings in RwLock, upstream
+ // fix already up for review.
+ "race:StrongRuleNode::ensure_child\n"
+ // No Bug - permanent
+ // Upstream Bugs:
+ //
+ // * https://github.com/rayon-rs/rayon/issues/812
+ // * https://github.com/crossbeam-rs/crossbeam/issues/589
+ //
+ // Probably a false-positive from crossbeam's deque not being
+ // understood by tsan.
+ "race:crossbeam_deque*::resize\n"
+ "race:crossbeam_deque*::push\n"
+ "race:crossbeam_deque*::write\n"
+ "race:crossbeam_deque*::read\n"
+ "race:crossbeam_deque*::steal\n"
+ // Bug 1805819 - permanent
+ // No Upstream Bug Filed!
+ //
+ // False positive in libc's tzset_internal
+ // See https://crbug.com/379738 also
+ "race:tzset_internal\n"
+
+
+
+
+
+ // The rest of these suppressions are miscellaneous issues in gecko
+ // that should be investigated and ideally fixed.
+
+ // Bug 1671574 - Permanent
+ // The StartupCache thread intentionally races with the main thread to
+ // trigger OS-level paging. It is never joined with the main thread.
+ "thread:StartupCache\n"
+
+ // Bug 1734262 - Permanent
+ // When spawning async processes, we create a helper thread to wait for
+ // the process to terminate in order to asynchronously report the exit
+ // code to Gecko. This thread waits on a syscall for the process to end,
+ // which means there's no easy way to cancel and join it during Gecko
+ // shutdown. Suppress thread leak reports for this thread.
+ "thread:CreateMonitorThread\n"
+
+ // Bug 1601600
+ "race:SkARGB32_Blitter\n"
+ "race:SkARGB32_Shader_Blitter\n"
+ "race:SkARGB32_Opaque_Blitter\n"
+ "race:SkRasterPipelineBlitter\n"
+ "race:Clamp_S32_D32_nofilter_trans_shaderproc\n"
+ "race:SkSpriteBlitter_Memcpy\n"
+
+ // Bug 1606800
+ "race:CallInitFunc\n"
+
+ // Bug 1606803
+ "race:ipv6_is_present\n"
+
+ // Bug 1615123
+ "race:_dl_deallocate_tls\n"
+ "race:__libc_memalign\n"
+
+ // Bug 1664803
+ "race:Sampler::sSigHandlerCoordinator\n"
+
+ // Bug 1656068
+ "race:WebRtcAec_Create\n"
+
+ // No Bug - Logging bug in Mochitests
+ "race:mochitest/ssltunnel/ssltunnel.cpp\n"
+
+ // This thread does not seem to be stopped/joined.
+ // ImageBridgeChild should be turned back into a background
+ // task queue in bug 1647628, in which case these suppressions
+ // can be removed.
+ "race:mozilla::layers::ImageBridgeChild::ShutDown\n"
+
+ // Bug 1652530
+ "mutex:XErrorTrap\n"
+
+ // Bug 1671601
+ "race:CamerasParent::ActorDestroy\n"
+ "race:CamerasParent::DispatchToVideoCaptureThread\n"
+
+ // Bug 1623541
+ "race:VRShMem::PullSystemState\n"
+ "race:VRShMem::PushSystemState\n"
+ "race:VRShMem::PullBrowserState\n"
+ "race:VRShMem::PushBrowserState\n"
+
+ // Bug 1682951
+ "race:storage::Connection::Release\n"
+
+ // Bug 1683357
+ "race:image::ImageSurfaceCache::SuggestedSizeInternal\n"
+ "race:image::RasterImage::SetMetadata\n"
+ "race:image::RasterImage::GetWidth\n"
+
+ // Bug 1722721 - This is a benign race creating worker/SW compositor threads.
+ "race:webrender::profiler::register_thread\n"
+
+ // Bug 1722721 - This is a false positive during SW-WR rendering.
+ "race:scale_blit\n"
+
+ "race:mozilla::gl::MesaMemoryLeakWorkaround\n"
+
+ // Bug 1733908
+ "race:js::wasm::Code::bestTier\n"
+ "race:js::wasm::Code::commitTier2\n"
+ "race:js::wasm::Code::setTier2\n"
+ "race:js::wasm::Code::setAndBorrowTier2\n"
+
+ // Bug 1755449
+ // The Glean init thread is used to perform I/O and other blocking operations.
+ // It is never joined with the main thread, but this is being re-evaluated.
+ "thread:glean::initialize\n"
+
+ // Bug 1822605 - permanent
+ // A race exists in libvulkan_lvp.so. This was previously addressed in bug
+ // 1816713. However, libvulkan_lvp.so is unloaded so a called_from_lib
+ // suppression cannot be used.
+ "race:libvulkan_lvp.so\n"
+
+ // End of suppressions.
+ ; // Please keep this semicolon.
+}
+// clang-format on
+#endif // _MSC_VER
diff --git a/mozglue/build/UbsanOptions.cpp b/mozglue/build/UbsanOptions.cpp
new file mode 100644
index 0000000000..547baa790c
--- /dev/null
+++ b/mozglue/build/UbsanOptions.cpp
@@ -0,0 +1,16 @@
+/* -*- 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 "mozilla/Attributes.h"
+
+#ifndef _MSC_VER // Not supported by clang-cl yet
+
+extern "C" const char* __ubsan_default_options() {
+ return "print_stacktrace=1";
+}
+
+extern "C" const char* __ubsan_default_suppressions() { return ""; }
+
+#endif
diff --git a/mozglue/build/arm-eabi-filter b/mozglue/build/arm-eabi-filter
new file mode 100644
index 0000000000..401454ee88
--- /dev/null
+++ b/mozglue/build/arm-eabi-filter
@@ -0,0 +1,4 @@
+{
+ local:
+ __aeabi*;
+};
diff --git a/mozglue/build/arm.cpp b/mozglue/build/arm.cpp
new file mode 100644
index 0000000000..a74a41f6c0
--- /dev/null
+++ b/mozglue/build/arm.cpp
@@ -0,0 +1,131 @@
+/* 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/. */
+
+/* compile-time and runtime tests for whether to use various ARM extensions */
+
+#include "arm.h"
+
+#if defined(MOZILLA_ARM_HAVE_CPUID_DETECTION)
+
+// arm.h has parallel #ifs which declare MOZILLA_ARM_HAVE_CPUID_DETECTION.
+// We don't check it here so that we get compile errors if it's defined, but
+// we don't compile one of these detection methods. The detection code here is
+// based on the CPU detection in libtheora.
+
+# if defined(__linux__) || defined(ANDROID)
+# include <stdio.h>
+# include <stdlib.h>
+# include <string.h>
+
+enum {
+ MOZILLA_HAS_EDSP_FLAG = 1,
+ MOZILLA_HAS_ARMV6_FLAG = 2,
+ MOZILLA_HAS_ARMV7_FLAG = 4,
+ MOZILLA_HAS_NEON_FLAG = 8
+};
+
+static unsigned get_arm_cpu_flags(void) {
+ unsigned flags;
+ FILE* fin;
+ bool armv6_processor = false;
+ flags = 0;
+ /*Reading /proc/self/auxv would be easier, but that doesn't work reliably on
+ Android. This also means that detection will fail in Scratchbox, which is
+ desirable, as NEON does not work in the qemu shipped with the Maemo 5 SDK.
+ I don't know if /proc/self/auxv would do any better in that case, anyway,
+ or if it would return random flags from the host CPU.*/
+ fin = fopen("/proc/cpuinfo", "r");
+ if (fin != nullptr) {
+ /*512 should be enough for anybody (it's even enough for all the flags that
+ x86 has accumulated... so far).*/
+ char buf[512];
+ while (fgets(buf, 511, fin) != nullptr) {
+ if (memcmp(buf, "Features", 8) == 0) {
+ char* p;
+ p = strstr(buf, " edsp");
+ if (p != nullptr && (p[5] == ' ' || p[5] == '\n'))
+ flags |= MOZILLA_HAS_EDSP_FLAG;
+ p = strstr(buf, " neon");
+ if (p != nullptr && (p[5] == ' ' || p[5] == '\n'))
+ flags |= MOZILLA_HAS_NEON_FLAG;
+ }
+ if (memcmp(buf, "CPU architecture:", 17) == 0) {
+ int version;
+ version = atoi(buf + 17);
+ if (version >= 6) flags |= MOZILLA_HAS_ARMV6_FLAG;
+ if (version >= 7) flags |= MOZILLA_HAS_ARMV7_FLAG;
+ }
+ /* media/webrtc/trunk/src/system_wrappers/source/cpu_features_arm.c
+ * Unfortunately, it seems that certain ARMv6-based CPUs
+ * report an incorrect architecture number of 7!
+ *
+ * We try to correct this by looking at the 'elf_format'
+ * field reported by the 'Processor' field, which is of the
+ * form of "(v7l)" for an ARMv7-based CPU, and "(v6l)" for
+ * an ARMv6-one.
+ */
+ if (memcmp(buf, "Processor\t:", 11) == 0) {
+ if (strstr(buf, "(v6l)") != 0) {
+ armv6_processor = true;
+ }
+ }
+ }
+ fclose(fin);
+ }
+ if (armv6_processor) {
+ // ARMv6 pretending to be ARMv7? clear flag
+ if (flags & MOZILLA_HAS_ARMV7_FLAG) {
+ flags &= ~MOZILLA_HAS_ARMV7_FLAG;
+ }
+ }
+ return flags;
+}
+
+// Cache a local copy so we only have to read /proc/cpuinfo once.
+static unsigned arm_cpu_flags = get_arm_cpu_flags();
+
+# if !defined(MOZILLA_PRESUME_EDSP)
+static bool check_edsp(void) {
+ return (arm_cpu_flags & MOZILLA_HAS_EDSP_FLAG) != 0;
+}
+# endif
+
+# if !defined(MOZILLA_PRESUME_ARMV6)
+static bool check_armv6(void) {
+ return (arm_cpu_flags & MOZILLA_HAS_ARMV6_FLAG) != 0;
+}
+# endif
+
+# if !defined(MOZILLA_PRESUME_ARMV7)
+static bool check_armv7(void) {
+ return (arm_cpu_flags & MOZILLA_HAS_ARMV7_FLAG) != 0;
+}
+# endif
+
+# if !defined(MOZILLA_PRESUME_NEON)
+static bool check_neon(void) {
+ return (arm_cpu_flags & MOZILLA_HAS_NEON_FLAG) != 0;
+}
+# endif
+
+# endif // defined(__linux__) || defined(ANDROID)
+
+namespace mozilla {
+namespace arm_private {
+# if !defined(MOZILLA_PRESUME_EDSP)
+bool edsp_enabled = check_edsp();
+# endif
+# if !defined(MOZILLA_PRESUME_ARMV6)
+bool armv6_enabled = check_armv6();
+# endif
+# if !defined(MOZILLA_PRESUME_ARMV7)
+bool armv7_enabled = check_armv7();
+# endif
+# if !defined(MOZILLA_PRESUME_NEON)
+bool neon_enabled = check_neon();
+# endif
+} // namespace arm_private
+} // namespace mozilla
+
+#endif // MOZILLA_ARM_HAVE_CPUID_DETECTION
diff --git a/mozglue/build/arm.h b/mozglue/build/arm.h
new file mode 100644
index 0000000000..8600329931
--- /dev/null
+++ b/mozglue/build/arm.h
@@ -0,0 +1,145 @@
+/* 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/. */
+
+/* compile-time and runtime tests for whether to use SSE instructions */
+
+#ifndef mozilla_arm_h_
+#define mozilla_arm_h_
+
+// for definition of MFBT_DATA
+#include "mozilla/Types.h"
+
+/* This is patterned after SSE.h, but provides ARMv5E, ARMv6, and NEON
+ detection. For reasons similar to the SSE code, code using NEON (even just
+ in inline asm) needs to be in a separate compilation unit from the regular
+ code, because it requires an ".fpu neon" directive which can't be undone.
+ ARMv5E and ARMv6 code may also require an .arch directive, since by default
+ the assembler refuses to generate code for opcodes outside of its current
+ .arch setting.
+
+ TODO: Add Thumb, Thumb2, VFP, iwMMX, etc. detection, if we need it. */
+
+#if defined(__GNUC__) && defined(__arm__)
+
+# define MOZILLA_ARM_ARCH 3
+
+# if defined(__ARM_ARCH_4__) || defined(__ARM_ARCH_4T__) || \
+ defined(_ARM_ARCH_4)
+# undef MOZILLA_ARM_ARCH
+# define MOZILLA_ARM_ARCH 4
+# endif
+
+# if defined(__ARM_ARCH_5__) || defined(__ARM_ARCH_5T__) || \
+ defined(__ARM_ARCH_5E__) || defined(__ARM_ARCH_5TE__) || \
+ defined(__ARM_ARCH_5TEJ__) || defined(_ARM_ARCH_5)
+# undef MOZILLA_ARM_ARCH
+# define MOZILLA_ARM_ARCH 5
+# endif
+
+# if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || \
+ defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || \
+ defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) || \
+ defined(__ARM_ARCH_6M__) || defined(_ARM_ARCH_6)
+# undef MOZILLA_ARM_ARCH
+# define MOZILLA_ARM_ARCH 6
+# endif
+
+# if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || \
+ defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || \
+ defined(__ARM_ARCH_7EM__) || defined(_ARM_ARCH_7)
+# undef MOZILLA_ARM_ARCH
+# define MOZILLA_ARM_ARCH 7
+# endif
+
+# ifdef __GNUC__
+# define MOZILLA_MAY_SUPPORT_EDSP 1
+
+# if defined(HAVE_ARM_SIMD)
+# define MOZILLA_MAY_SUPPORT_ARMV6 1
+# endif
+
+# if defined(HAVE_ARM_NEON)
+# define MOZILLA_MAY_SUPPORT_NEON 1
+# endif
+
+# if defined(HAVE_ARM_SIMD)
+# define MOZILLA_MAY_SUPPORT_ARMV7 1
+# endif
+# endif
+
+// Currently we only have CPU detection for Linux via /proc/cpuinfo
+# if defined(__linux__) || defined(ANDROID)
+# define MOZILLA_ARM_HAVE_CPUID_DETECTION 1
+# endif
+
+#endif
+
+// When using -mfpu=neon on arm gcc, or using default on aarch64,
+// the compiler generates neon instructions.
+#if defined(__ARM_NEON)
+# define MOZILLA_PRESUME_NEON 1
+#endif
+
+namespace mozilla {
+
+namespace arm_private {
+#if defined(MOZILLA_ARM_HAVE_CPUID_DETECTION)
+# if !defined(MOZILLA_PRESUME_EDSP)
+extern bool MFBT_DATA edsp_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_ARMV6)
+extern bool MFBT_DATA armv6_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_ARMV7)
+extern bool MFBT_DATA armv7_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_NEON)
+extern bool MFBT_DATA neon_enabled;
+# endif
+#endif
+} // namespace arm_private
+
+#if defined(MOZILLA_PRESUME_EDSP)
+# define MOZILLA_MAY_SUPPORT_EDSP 1
+inline bool supports_edsp() { return true; }
+#elif defined(MOZILLA_MAY_SUPPORT_EDSP) && \
+ defined(MOZILLA_ARM_HAVE_CPUID_DETECTION)
+inline bool supports_edsp() { return arm_private::edsp_enabled; }
+#else
+inline bool supports_edsp() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_ARMV6)
+# define MOZILLA_MAY_SUPPORT_ARMV6 1
+inline bool supports_armv6() { return true; }
+#elif defined(MOZILLA_MAY_SUPPORT_ARMV6) && \
+ defined(MOZILLA_ARM_HAVE_CPUID_DETECTION)
+inline bool supports_armv6() { return arm_private::armv6_enabled; }
+#else
+inline bool supports_armv6() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_ARMV7)
+# define MOZILLA_MAY_SUPPORT_ARMV7 1
+inline bool supports_armv7() { return true; }
+#elif defined(MOZILLA_MAY_SUPPORT_ARMV7) && \
+ defined(MOZILLA_ARM_HAVE_CPUID_DETECTION)
+inline bool supports_armv7() { return arm_private::armv7_enabled; }
+#else
+inline bool supports_armv7() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_NEON)
+# define MOZILLA_MAY_SUPPORT_NEON 1
+inline bool supports_neon() { return true; }
+#elif defined(MOZILLA_MAY_SUPPORT_NEON) && \
+ defined(MOZILLA_ARM_HAVE_CPUID_DETECTION)
+inline bool supports_neon() { return arm_private::neon_enabled; }
+#else
+inline bool supports_neon() { return false; }
+#endif
+
+} // namespace mozilla
+
+#endif /* !defined(mozilla_arm_h_) */
diff --git a/mozglue/build/dummy.cpp b/mozglue/build/dummy.cpp
new file mode 100644
index 0000000000..c6b1ccd808
--- /dev/null
+++ b/mozglue/build/dummy.cpp
@@ -0,0 +1,5 @@
+/* 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/. */
+
+void _dummy(void) {}
diff --git a/mozglue/build/mips.cpp b/mozglue/build/mips.cpp
new file mode 100644
index 0000000000..7166080f5e
--- /dev/null
+++ b/mozglue/build/mips.cpp
@@ -0,0 +1,42 @@
+/* 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/. */
+
+/* compile-time and runtime tests for whether to use MIPS-specific extensions */
+
+#include "mips.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+ MIPS_FLAG_LOONGSON3 = 1,
+};
+
+static unsigned get_mips_cpu_flags(void) {
+ unsigned flags = 0;
+ FILE* fin;
+
+ fin = fopen("/proc/cpuinfo", "r");
+ if (fin != nullptr) {
+ char buf[1024];
+ memset(buf, 0, sizeof(buf));
+ fread(buf, sizeof(char), sizeof(buf) - 1, fin);
+ fclose(fin);
+ if (strstr(buf, "Loongson-3")) flags |= MIPS_FLAG_LOONGSON3;
+ }
+ return flags;
+}
+
+static bool check_loongson3(void) {
+ // Cache a local copy so we only have to read /proc/cpuinfo once.
+ static unsigned mips_cpu_flags = get_mips_cpu_flags();
+ return (mips_cpu_flags & MIPS_FLAG_LOONGSON3) != 0;
+}
+
+namespace mozilla {
+namespace mips_private {
+bool isLoongson3 = check_loongson3();
+} // namespace mips_private
+} // namespace mozilla
diff --git a/mozglue/build/mips.h b/mozglue/build/mips.h
new file mode 100644
index 0000000000..a7c3ed5416
--- /dev/null
+++ b/mozglue/build/mips.h
@@ -0,0 +1,29 @@
+/* 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/. */
+
+/* compile-time and runtime tests for whether to use MIPS-specific extensions */
+
+#ifndef mozilla_mips_h_
+#define mozilla_mips_h_
+
+// for definition of MFBT_DATA
+#include "mozilla/Types.h"
+
+namespace mozilla {
+
+namespace mips_private {
+extern bool MFBT_DATA isLoongson3;
+} // namespace mips_private
+
+inline bool supports_mmi() {
+#ifdef __mips__
+ return mips_private::isLoongson3;
+#else
+ return false;
+#endif
+}
+
+} // namespace mozilla
+
+#endif /* !defined(mozilla_mips_h_) */
diff --git a/mozglue/build/moz.build b/mozglue/build/moz.build
new file mode 100644
index 0000000000..fe195739e2
--- /dev/null
+++ b/mozglue/build/moz.build
@@ -0,0 +1,115 @@
+# -*- Mode: python; 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/.
+
+# Build mozglue as a shared lib on Windows, OSX and Android. But not for
+# embedders!
+# If this is ever changed, update MOZ_SHARED_MOZGLUE in browser/installer/Makefile.in
+if CONFIG["JS_STANDALONE"] and not CONFIG["MOZ_MEMORY"]:
+ Library("mozglue")
+elif CONFIG["OS_TARGET"] in ("WINNT", "Darwin", "Android"):
+ SharedLibrary("mozglue")
+else:
+ Library("mozglue")
+
+if CONFIG["OS_TARGET"] == "Android":
+ LDFLAGS += ["-Wl,--version-script,%s/mozglue.ver" % SRCDIR]
+ SOURCES += [
+ "BionicGlue.cpp",
+ ]
+
+if CONFIG["MOZ_ASAN"]:
+ SOURCES += [
+ "AsanOptions.cpp",
+ ]
+
+if CONFIG["MOZ_UBSAN"]:
+ SOURCES += [
+ "UbsanOptions.cpp",
+ ]
+
+if CONFIG["MOZ_TSAN"]:
+ SOURCES += [
+ "TsanOptions.cpp",
+ ]
+
+if CONFIG["OS_TARGET"] == "WINNT":
+ if CONFIG["MOZ_MEMORY"]:
+ DEFFILE = "mozglue.def"
+ OS_LIBS += [
+ "advapi32",
+ "user32",
+ "winmm",
+ "uuid",
+ ]
+ # We'll break the DLL blocklist if we immediately load user32.dll.
+ # For the same reason, we delayload these other DLLs to avoid eager
+ # dependencies on user32.dll.
+ DELAYLOAD_DLLS += [
+ "advapi32.dll",
+ "dbghelp.dll",
+ "oleaut32.dll",
+ "ole32.dll",
+ "user32.dll",
+ "version.dll",
+ "winmm.dll",
+ ]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"]:
+
+ if CONFIG["MOZ_MEMORY"] and FORCE_SHARED_LIB:
+ pass
+ # TODO: SHARED_LIBRARY_LIBS go here
+ else:
+ # Temporary, until bug 662814 lands
+ NoVisibilityFlags()
+ SOURCES += [
+ "dummy.cpp",
+ ]
+
+ if CONFIG["OS_TARGET"] == "WINNT":
+ LOCAL_INCLUDES += [
+ "/memory/build",
+ ]
+
+ EXPORTS.mozilla += [
+ "arm.h",
+ "mips.h",
+ "ppc.h",
+ ]
+
+ if CONFIG["CPU_ARCH"] == "arm":
+ SOURCES += [
+ "arm.cpp",
+ ]
+
+ if CONFIG["CPU_ARCH"].startswith("mips"):
+ SOURCES += [
+ "mips.cpp",
+ ]
+
+ if CONFIG["CPU_ARCH"].startswith("ppc"):
+ SOURCES += [
+ "ppc.cpp",
+ ]
+
+ if CONFIG["MOZ_LINKER"]:
+ USE_LIBS += [
+ "zlib",
+ ]
+
+USE_LIBS += [
+ "mfbt",
+]
+
+LIBRARY_DEFINES["IMPL_MFBT"] = True
+LIBRARY_DEFINES["MOZ_HAS_MOZGLUE"] = True
+
+if CONFIG["MOZ_LINKER"] and CONFIG["CPU_ARCH"] == "arm":
+ LDFLAGS += ["-Wl,-version-script,%s/arm-eabi-filter" % SRCDIR]
+
+DIST_INSTALL = True
+
+include("replace_malloc.mozbuild")
diff --git a/mozglue/build/mozglue.def b/mozglue/build/mozglue.def
new file mode 100644
index 0000000000..188037b9f1
--- /dev/null
+++ b/mozglue/build/mozglue.def
@@ -0,0 +1,22 @@
+; 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 mozglue.dll
+
+EXPORTS
+ ; symbols that are actually useful
+ malloc=je_malloc
+ calloc=je_calloc
+ realloc=je_realloc
+ free=je_free
+ posix_memalign=je_posix_memalign
+ malloc_usable_size=je_malloc_usable_size
+ malloc_good_size=je_malloc_good_size
+ _aligned_free=je_free
+ _aligned_malloc=wrap__aligned_malloc
+ strndup=wrap_strndup
+ strdup=wrap_strdup
+ _strdup=wrap_strdup
+ wcsdup=wrap_wcsdup
+ _wcsdup=wrap_wcsdup
diff --git a/mozglue/build/mozglue.dll.manifest b/mozglue/build/mozglue.dll.manifest
new file mode 100644
index 0000000000..037eae4f77
--- /dev/null
+++ b/mozglue/build/mozglue.dll.manifest
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assemblyIdentity
+ version="1.0.0.0"
+ name="mozglue"
+ type="win32"
+/>
+<file name="mozglue.dll"/>
+</assembly>
diff --git a/mozglue/build/mozglue.ver b/mozglue/build/mozglue.ver
new file mode 100644
index 0000000000..433d820b36
--- /dev/null
+++ b/mozglue/build/mozglue.ver
@@ -0,0 +1,4 @@
+libmozglue.so {
+global:
+ *;
+};
diff --git a/mozglue/build/ppc.cpp b/mozglue/build/ppc.cpp
new file mode 100644
index 0000000000..20ef121386
--- /dev/null
+++ b/mozglue/build/ppc.cpp
@@ -0,0 +1,64 @@
+/* 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/. */
+
+/* compile-time and runtime tests for whether to use Power ISA-specific
+ * extensions */
+
+#include "ppc.h"
+#include "mozilla/Unused.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(XP_LINUX)
+// Use the getauxval() function if available.
+// ARCH_3_00 wasn't defined until glibc 2.23, so include just in case.
+# include <sys/auxv.h>
+# ifndef PPC_FEATURE2_ARCH_3_00
+# define PPC_FEATURE2_ARCH_3_00 0x00800000
+# endif
+#endif
+
+const unsigned PPC_FLAG_VMX = 1;
+const unsigned PPC_FLAG_VSX = 2;
+const unsigned PPC_FLAG_VSX3 = 4;
+
+static signed get_ppc_cpu_flags(void) {
+ // This could be expensive, so cache the result.
+ static signed cpu_flags = -1;
+
+ if (cpu_flags > -1) { // already checked
+ return cpu_flags;
+ }
+ cpu_flags = 0;
+
+#if defined(XP_LINUX)
+ // Try getauxval().
+ unsigned long int cap = getauxval(AT_HWCAP);
+ unsigned long int cap2 = getauxval(AT_HWCAP2);
+
+ if (cap & PPC_FEATURE_HAS_ALTIVEC) {
+ cpu_flags |= PPC_FLAG_VMX;
+ }
+ if (cap & PPC_FEATURE_HAS_VSX) {
+ cpu_flags |= PPC_FLAG_VSX;
+ }
+ if (cap2 & PPC_FEATURE2_ARCH_3_00) {
+ cpu_flags |= PPC_FLAG_VSX3;
+ }
+#else
+ // Non-Linux detection here. Currently, on systems other than Linux,
+ // no CPU SIMD features will be detected.
+#endif
+
+ return cpu_flags;
+}
+
+namespace mozilla {
+namespace ppc_private {
+bool vmx_enabled = !!(get_ppc_cpu_flags() & PPC_FLAG_VMX);
+bool vsx_enabled = !!(get_ppc_cpu_flags() & PPC_FLAG_VSX);
+bool vsx3_enabled = !!(get_ppc_cpu_flags() & PPC_FLAG_VSX3);
+} // namespace ppc_private
+} // namespace mozilla
diff --git a/mozglue/build/ppc.h b/mozglue/build/ppc.h
new file mode 100644
index 0000000000..9527d8dadd
--- /dev/null
+++ b/mozglue/build/ppc.h
@@ -0,0 +1,47 @@
+/* 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/. */
+
+/* compile-time and runtime tests for whether to use Power ISA-specific
+ extensions */
+
+#ifndef mozilla_ppc_h_
+#define mozilla_ppc_h_
+
+// for definition of MFBT_DATA
+#include "mozilla/Types.h"
+
+namespace mozilla {
+namespace ppc_private {
+extern bool MFBT_DATA vmx_enabled;
+extern bool MFBT_DATA vsx_enabled;
+extern bool MFBT_DATA vsx3_enabled;
+} // namespace ppc_private
+
+inline bool supports_vmx() {
+#ifdef __powerpc__
+ return ppc_private::vmx_enabled;
+#else
+ return false;
+#endif
+}
+
+inline bool supports_vsx() {
+#ifdef __powerpc__
+ return ppc_private::vsx_enabled;
+#else
+ return false;
+#endif
+}
+
+inline bool supports_vsx3() {
+#ifdef __powerpc__
+ return ppc_private::vsx3_enabled;
+#else
+ return false;
+#endif
+}
+
+} // namespace mozilla
+
+#endif /* !defined(mozilla_ppc_h_) */
diff --git a/mozglue/build/replace_malloc.mozbuild b/mozglue/build/replace_malloc.mozbuild
new file mode 100644
index 0000000000..16c8b7271f
--- /dev/null
+++ b/mozglue/build/replace_malloc.mozbuild
@@ -0,0 +1,6 @@
+# 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['OS_TARGET'] == 'Darwin' and CONFIG['MOZ_REPLACE_MALLOC']:
+ LDFLAGS += ['-Wl,-U,_replace_init']
diff --git a/mozglue/interposers/InterposerHelper.h b/mozglue/interposers/InterposerHelper.h
new file mode 100644
index 0000000000..fddc05a163
--- /dev/null
+++ b/mozglue/interposers/InterposerHelper.h
@@ -0,0 +1,79 @@
+/* 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 InterposerHelper_h
+#define InterposerHelper_h
+
+#include <type_traits>
+
+#ifdef MOZ_LINKER
+# include "Linker.h"
+#else
+# include <dlfcn.h>
+#endif
+
+#include "mozilla/Assertions.h"
+
+template <typename T>
+static inline T dlsym_wrapper(void* aHandle, const char* aName) {
+#ifdef MOZ_LINKER
+ return reinterpret_cast<T>(__wrap_dlsym(aHandle, aName));
+#else
+ return reinterpret_cast<T>(dlsym(aHandle, aName));
+#endif // MOZ_LINKER
+}
+
+static inline void* dlopen_wrapper(const char* aPath, int flags) {
+#ifdef MOZ_LINKER
+ return __wrap_dlopen(aPath, flags);
+#else
+ return dlopen(aPath, flags);
+#endif // MOZ_LINKER
+}
+
+template <typename T>
+static T get_real_symbol(const char* aName, T aReplacementSymbol) {
+ // T can only be a function pointer
+ static_assert(std::is_function<typename std::remove_pointer<T>::type>::value);
+
+ // Find the corresponding function in the linked libraries
+ T real_symbol = dlsym_wrapper<T>(RTLD_NEXT, aName);
+
+#if defined(ANDROID)
+ if (real_symbol == nullptr) {
+ // On old versions of Android the application runtime links in libc before
+ // we get a chance to link libmozglue, so its symbols don't appear when
+ // resolving them with RTLD_NEXT. This behavior differ between the
+ // different versions of Android so we'll just look for them directly into
+ // libc.so. Note that this won't work if we're trying to interpose
+ // functions that are in other libraries, but hopefully we'll never have
+ // to do that.
+ void* handle = dlopen_wrapper("libc.so", RTLD_LAZY);
+
+ if (handle) {
+ real_symbol = dlsym_wrapper<T>(handle, aName);
+ }
+ }
+#endif
+
+ if (real_symbol == nullptr) {
+ MOZ_CRASH_UNSAFE_PRINTF(
+ "%s() interposition failed but the interposer function is "
+ "still being called, this won't work!",
+ aName);
+ }
+
+ if (real_symbol == aReplacementSymbol) {
+ MOZ_CRASH_UNSAFE_PRINTF(
+ "We could not obtain the real %s(). Calling the symbol we "
+ "got would make us enter an infinite loop so stop here instead.",
+ aName);
+ }
+
+ return real_symbol;
+}
+
+#define GET_REAL_SYMBOL(name) get_real_symbol(#name, name)
+
+#endif // InterposerHelper_h
diff --git a/mozglue/interposers/env_interposer.cpp b/mozglue/interposers/env_interposer.cpp
new file mode 100644
index 0000000000..d8c11b5d35
--- /dev/null
+++ b/mozglue/interposers/env_interposer.cpp
@@ -0,0 +1,79 @@
+/* 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 <pthread.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "InterposerHelper.h"
+
+// The interposers in this file cover all the functions used to access the
+// environment (getenv(), putenv(), setenv(), unsetenv() and clearenv()). They
+// all use the mutex below for synchronization to prevent races that caused
+// startup crashes, see bug 1752703.
+static pthread_mutex_t gEnvLock = PTHREAD_MUTEX_INITIALIZER;
+
+static char* internal_getenv(const char* aName) {
+ if (environ == nullptr || aName[0] == '\0') {
+ return nullptr;
+ }
+
+ size_t len = strlen(aName);
+ for (char** env_ptr = environ; *env_ptr != nullptr; ++env_ptr) {
+ if ((aName[0] == (*env_ptr)[0]) && (strncmp(aName, *env_ptr, len) == 0) &&
+ ((*env_ptr)[len] == '=')) {
+ return *env_ptr + len + 1;
+ }
+ }
+
+ return nullptr;
+}
+
+extern "C" {
+
+MFBT_API char* getenv(const char* name) {
+ pthread_mutex_lock(&gEnvLock);
+ char* result = internal_getenv(name);
+ pthread_mutex_unlock(&gEnvLock);
+
+ return result;
+}
+
+MFBT_API int putenv(char* string) {
+ static const auto real_putenv = GET_REAL_SYMBOL(putenv);
+
+ pthread_mutex_lock(&gEnvLock);
+ int result = real_putenv(string);
+ pthread_mutex_unlock(&gEnvLock);
+ return result;
+}
+
+MFBT_API int setenv(const char* name, const char* value, int replace) {
+ static const auto real_setenv = GET_REAL_SYMBOL(setenv);
+
+ pthread_mutex_lock(&gEnvLock);
+ int result = real_setenv(name, value, replace);
+ pthread_mutex_unlock(&gEnvLock);
+ return result;
+}
+
+MFBT_API int unsetenv(const char* name) {
+ static const auto real_unsetenv = GET_REAL_SYMBOL(unsetenv);
+
+ pthread_mutex_lock(&gEnvLock);
+ int result = real_unsetenv(name);
+ pthread_mutex_unlock(&gEnvLock);
+ return result;
+}
+
+MFBT_API int clearenv(void) {
+ static const auto real_clearenv = GET_REAL_SYMBOL(clearenv);
+
+ pthread_mutex_lock(&gEnvLock);
+ int result = real_clearenv();
+ pthread_mutex_unlock(&gEnvLock);
+ return result;
+}
+
+} // extern "C"
diff --git a/mozglue/interposers/moz.build b/mozglue/interposers/moz.build
new file mode 100644
index 0000000000..f191deff8f
--- /dev/null
+++ b/mozglue/interposers/moz.build
@@ -0,0 +1,24 @@
+# -*- Mode: python; 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("interposers")
+
+DEFINES["IMPL_MFBT"] = True
+
+UNIFIED_SOURCES += [
+ "env_interposer.cpp",
+]
+
+if CONFIG["MOZ_CRASHREPORTER"]:
+ UNIFIED_SOURCES += [
+ "pthread_create_interposer.cpp",
+ ]
+
+if CONFIG["MOZ_LINKER"] and CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+ LOCAL_INCLUDES += [
+ "/mozglue/linker",
+ ]
+
+FINAL_LIBRARY = "mozglue"
diff --git a/mozglue/interposers/pthread_create_interposer.cpp b/mozglue/interposers/pthread_create_interposer.cpp
new file mode 100644
index 0000000000..65f60c2d1b
--- /dev/null
+++ b/mozglue/interposers/pthread_create_interposer.cpp
@@ -0,0 +1,108 @@
+/* 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 <algorithm>
+
+#include <pthread.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/DebugOnly.h"
+
+#include "InterposerHelper.h"
+
+using mozilla::DebugOnly;
+
+struct SigAltStack {
+ void* mem;
+ size_t size;
+};
+
+struct PthreadCreateParams {
+ void* (*start_routine)(void*);
+ void* arg;
+};
+
+// Install the alternate signal stack, returns a pointer to the memory area we
+// mapped to store the stack only if it was installed successfully, otherwise
+// returns NULL.
+static void* install_sig_alt_stack(size_t size) {
+ void* alt_stack_mem = mmap(nullptr, size, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (alt_stack_mem) {
+ stack_t alt_stack = {
+ .ss_sp = alt_stack_mem,
+ .ss_flags = 0,
+ .ss_size = size,
+ };
+
+ int rv = sigaltstack(&alt_stack, nullptr);
+ if (rv == 0) {
+ return alt_stack_mem;
+ }
+
+ rv = munmap(alt_stack_mem, size);
+ MOZ_ASSERT(rv == 0);
+ }
+
+ return nullptr;
+}
+
+// Uninstall the alternate signal handler and unmaps it. Does nothing if
+// alt_stack_mem is NULL.
+static void uninstall_sig_alt_stack(void* alt_stack_ptr) {
+ SigAltStack* alt_stack = static_cast<SigAltStack*>(alt_stack_ptr);
+ if (alt_stack->mem) {
+ stack_t disable_alt_stack = {};
+ disable_alt_stack.ss_flags = SS_DISABLE;
+ DebugOnly<int> rv = sigaltstack(&disable_alt_stack, nullptr);
+ MOZ_ASSERT(rv == 0);
+ rv = munmap(alt_stack->mem, alt_stack->size);
+ MOZ_ASSERT(rv == 0);
+ }
+}
+
+// This replaces the routine passed to pthread_create() when a thread is
+// started, it handles the alternate signal stack and calls the thread's
+// actual routine.
+void* set_alt_signal_stack_and_start(PthreadCreateParams* params) {
+ void* (*start_routine)(void*) = params->start_routine;
+ void* arg = params->arg;
+ free(params);
+
+ void* thread_rv = nullptr;
+ static const size_t kSigStackSize = std::max(size_t(16384), size_t(SIGSTKSZ));
+ void* alt_stack_mem = install_sig_alt_stack(kSigStackSize);
+ SigAltStack alt_stack{alt_stack_mem, kSigStackSize};
+ pthread_cleanup_push(uninstall_sig_alt_stack, &alt_stack);
+ thread_rv = start_routine(arg);
+ pthread_cleanup_pop(1);
+
+ return thread_rv;
+}
+
+extern "C" {
+// This interposer replaces libpthread's pthread_create() so that we can
+// inject an alternate signal stack in every new thread.
+MFBT_API int pthread_create(pthread_t* thread, const pthread_attr_t* attr,
+ void* (*start_routine)(void*), void* arg) {
+ static const auto real_pthread_create = GET_REAL_SYMBOL(pthread_create);
+
+ PthreadCreateParams* params =
+ (PthreadCreateParams*)malloc(sizeof(PthreadCreateParams));
+ params->start_routine = start_routine;
+ params->arg = arg;
+
+ int result = real_pthread_create(
+ thread, attr, (void* (*)(void*))set_alt_signal_stack_and_start, params);
+
+ if (result != 0) {
+ free(params);
+ }
+
+ return result;
+}
+}
diff --git a/mozglue/linker/BaseElf.cpp b/mozglue/linker/BaseElf.cpp
new file mode 100644
index 0000000000..78542b3875
--- /dev/null
+++ b/mozglue/linker/BaseElf.cpp
@@ -0,0 +1,190 @@
+/* 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 "BaseElf.h"
+#include "Elfxx.h"
+#include "Logging.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/RefPtr.h"
+
+using namespace Elf;
+
+unsigned long BaseElf::Hash(const char* symbol) {
+ const unsigned char* sym = reinterpret_cast<const unsigned char*>(symbol);
+ unsigned long h = 0, g;
+ while (*sym) {
+ h = (h << 4) + *sym++;
+ g = h & 0xf0000000;
+ h ^= g;
+ h ^= g >> 24;
+ }
+ return h;
+}
+
+void* BaseElf::GetSymbolPtr(const char* symbol) const {
+ return GetSymbolPtr(symbol, Hash(symbol));
+}
+
+void* BaseElf::GetSymbolPtr(const char* symbol, unsigned long hash) const {
+ const Sym* sym = GetSymbol(symbol, hash);
+ void* ptr = nullptr;
+ if (sym && sym->st_shndx != SHN_UNDEF) ptr = GetPtr(sym->st_value);
+ DEBUG_LOG("BaseElf::GetSymbolPtr(%p [\"%s\"], \"%s\") = %p",
+ reinterpret_cast<const void*>(this), GetPath(), symbol, ptr);
+ return ptr;
+}
+
+const Sym* BaseElf::GetSymbol(const char* symbol, unsigned long hash) const {
+ /* Search symbol with the buckets and chains tables.
+ * The hash computed from the symbol name gives an index in the buckets
+ * table. The corresponding value in the bucket table is an index in the
+ * symbols table and in the chains table.
+ * If the corresponding symbol in the symbols table matches, we're done.
+ * Otherwise, the corresponding value in the chains table is a new index
+ * in both tables, which corresponding symbol is tested and so on and so
+ * forth */
+ size_t bucket = hash % buckets.numElements();
+ for (size_t y = buckets[bucket]; y != STN_UNDEF; y = chains[y]) {
+ if (strcmp(symbol, strtab.GetStringAt(symtab[y].st_name))) continue;
+ return &symtab[y];
+ }
+ return nullptr;
+}
+
+bool BaseElf::Contains(void* addr) const { return base.Contains(addr); }
+
+#ifdef __ARM_EABI__
+const void* BaseElf::FindExidx(int* pcount) const {
+ if (arm_exidx) {
+ *pcount = arm_exidx.numElements();
+ return arm_exidx;
+ }
+ *pcount = 0;
+ return nullptr;
+}
+#endif
+
+already_AddRefed<LibHandle> LoadedElf::Create(const char* path,
+ void* base_addr) {
+ DEBUG_LOG("LoadedElf::Create(\"%s\", %p) = ...", path, base_addr);
+
+ uint8_t mapped;
+ /* If the page is not mapped, mincore returns an error. If base_addr is
+ * nullptr, as would happen if the corresponding binary is prelinked with
+ * the prelink look (but not with the android apriori tool), no page being
+ * mapped there (right?), mincore returns an error, too, which makes
+ * prelinked libraries on glibc unsupported. This is not an interesting
+ * use case for now, so don't try supporting that case.
+ */
+ if (mincore(const_cast<void*>(base_addr), PageSize(), &mapped))
+ return nullptr;
+
+ RefPtr<LoadedElf> elf = new LoadedElf(path);
+
+ const Ehdr* ehdr = Ehdr::validate(base_addr);
+ if (!ehdr) return nullptr;
+
+ Addr min_vaddr = (Addr)-1; // We want to find the lowest and biggest
+ Addr max_vaddr = 0; // virtual address used by this Elf.
+ const Phdr* dyn = nullptr;
+#ifdef __ARM_EABI__
+ const Phdr* arm_exidx_phdr = nullptr;
+#endif
+
+ Array<Phdr> phdrs(reinterpret_cast<const char*>(ehdr) + ehdr->e_phoff,
+ ehdr->e_phnum);
+ for (auto phdr = phdrs.begin(); phdr < phdrs.end(); ++phdr) {
+ switch (phdr->p_type) {
+ case PT_LOAD:
+ if (phdr->p_vaddr < min_vaddr) min_vaddr = phdr->p_vaddr;
+ if (max_vaddr < phdr->p_vaddr + phdr->p_memsz)
+ max_vaddr = phdr->p_vaddr + phdr->p_memsz;
+ break;
+ case PT_DYNAMIC:
+ dyn = &*phdr;
+ break;
+#ifdef __ARM_EABI__
+ case PT_ARM_EXIDX:
+ /* We cannot initialize arm_exidx here
+ because we don't have a base yet */
+ arm_exidx_phdr = &*phdr;
+ break;
+#endif
+ }
+ }
+
+ /* If the lowest PT_LOAD virtual address in headers is not 0, then the ELF
+ * is either prelinked or a non-PIE executable. The former case is not
+ * possible, because base_addr would be nullptr and the mincore test above
+ * would already have made us return.
+ * For a non-PIE executable, PT_LOADs contain absolute addresses, so in
+ * practice, this means min_vaddr should be equal to base_addr. max_vaddr
+ * can thus be adjusted accordingly.
+ */
+ if (min_vaddr != 0) {
+ void* min_vaddr_ptr =
+ reinterpret_cast<void*>(static_cast<uintptr_t>(min_vaddr));
+ if (min_vaddr_ptr != base_addr) {
+ LOG("%s: %p != %p", elf->GetPath(), min_vaddr_ptr, base_addr);
+ return nullptr;
+ }
+ max_vaddr -= min_vaddr;
+ }
+ if (!dyn) {
+ LOG("%s: No PT_DYNAMIC segment found", elf->GetPath());
+ return nullptr;
+ }
+
+ elf->base.Assign(base_addr, max_vaddr);
+
+ if (!elf->InitDyn(dyn)) return nullptr;
+
+#ifdef __ARM_EABI__
+ if (arm_exidx_phdr)
+ elf->arm_exidx.InitSize(elf->GetPtr(arm_exidx_phdr->p_vaddr),
+ arm_exidx_phdr->p_memsz);
+#endif
+
+ DEBUG_LOG("LoadedElf::Create(\"%s\", %p) = %p", path, base_addr,
+ static_cast<void*>(elf));
+
+ ElfLoader::Singleton.Register(elf);
+ return elf.forget();
+}
+
+bool LoadedElf::InitDyn(const Phdr* pt_dyn) {
+ Array<Dyn> dyns;
+ dyns.InitSize(GetPtr<Dyn>(pt_dyn->p_vaddr), pt_dyn->p_filesz);
+
+ size_t symnum = 0;
+ for (auto dyn = dyns.begin(); dyn < dyns.end() && dyn->d_tag; ++dyn) {
+ switch (dyn->d_tag) {
+ case DT_HASH: {
+ DEBUG_LOG("%s 0x%08" PRIxPTR, "DT_HASH", uintptr_t(dyn->d_un.d_val));
+ const Elf::Word* hash_table_header = GetPtr<Elf::Word>(dyn->d_un.d_ptr);
+ symnum = hash_table_header[1];
+ buckets.Init(&hash_table_header[2], hash_table_header[0]);
+ chains.Init(&*buckets.end());
+ } break;
+ case DT_STRTAB:
+ DEBUG_LOG("%s 0x%08" PRIxPTR, "DT_STRTAB", uintptr_t(dyn->d_un.d_val));
+ strtab.Init(GetPtr(dyn->d_un.d_ptr));
+ break;
+ case DT_SYMTAB:
+ DEBUG_LOG("%s 0x%08" PRIxPTR, "DT_SYMTAB", uintptr_t(dyn->d_un.d_val));
+ symtab.Init(GetPtr(dyn->d_un.d_ptr));
+ break;
+ }
+ }
+ if (!buckets || !symnum) {
+ ERROR("%s: Missing or broken DT_HASH", GetPath());
+ } else if (!strtab) {
+ ERROR("%s: Missing DT_STRTAB", GetPath());
+ } else if (!symtab) {
+ ERROR("%s: Missing DT_SYMTAB", GetPath());
+ } else {
+ return true;
+ }
+ return false;
+}
diff --git a/mozglue/linker/BaseElf.h b/mozglue/linker/BaseElf.h
new file mode 100644
index 0000000000..9569dbc579
--- /dev/null
+++ b/mozglue/linker/BaseElf.h
@@ -0,0 +1,128 @@
+/* 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 BaseElf_h
+#define BaseElf_h
+
+#include "ElfLoader.h"
+#include "Elfxx.h"
+
+/**
+ * Base class for ELF libraries. This class includes things that will be
+ * common between SystemElfs and CustomElfs.
+ */
+class BaseElf : public LibHandle {
+ public:
+ /**
+ * Hash function for symbol lookup, as defined in ELF standard for System V.
+ */
+ static unsigned long Hash(const char* symbol);
+
+ /**
+ * Returns the address corresponding to the given symbol name (with a
+ * pre-computed hash).
+ */
+ void* GetSymbolPtr(const char* symbol, unsigned long hash) const;
+
+ /**
+ * Returns a pointer to the Elf Symbol in the Dynamic Symbol table
+ * corresponding to the given symbol name (with a pre-computed hash).
+ */
+ const Elf::Sym* GetSymbol(const char* symbol, unsigned long hash) const;
+
+ explicit BaseElf(const char* path, Mappable* mappable = nullptr)
+ : LibHandle(path), mappable(mappable) {}
+
+ protected:
+ /**
+ * Inherited from LibHandle. Those are temporary and are not supposed to
+ * be used.
+ */
+ virtual void* GetSymbolPtr(const char* symbol) const;
+ virtual bool Contains(void* addr) const;
+ virtual void* GetBase() const { return GetPtr(0); }
+
+#ifdef __ARM_EABI__
+ virtual const void* FindExidx(int* pcount) const;
+#endif
+
+ virtual Mappable* GetMappable() const { return NULL; };
+
+ public:
+ /* private: */
+ /**
+ * Returns a pointer relative to the base address where the library is
+ * loaded.
+ */
+ void* GetPtr(const Elf::Addr offset) const {
+ if (reinterpret_cast<void*>(offset) > base)
+ return reinterpret_cast<void*>(offset);
+ return base + offset;
+ }
+
+ /**
+ * Like the above, but returns a typed (const) pointer
+ */
+ template <typename T>
+ const T* GetPtr(const Elf::Addr offset) const {
+ if (reinterpret_cast<void*>(offset) > base)
+ return reinterpret_cast<const T*>(offset);
+ return reinterpret_cast<const T*>(base + offset);
+ }
+
+ /* Appropriated Mappable */
+ /* /!\ we rely on this being nullptr for BaseElf instances, but not
+ * CustomElf instances. */
+ RefPtr<Mappable> mappable;
+
+ /* Base address where the library is loaded */
+ MappedPtr base;
+
+ /* Buckets and chains for the System V symbol hash table */
+ Array<Elf::Word> buckets;
+ UnsizedArray<Elf::Word> chains;
+
+ /* protected: */
+ /* String table */
+ Elf::Strtab strtab;
+
+ /* Symbol table */
+ UnsizedArray<Elf::Sym> symtab;
+
+#ifdef __ARM_EABI__
+ /* ARM.exidx information used by FindExidx */
+ Array<uint32_t[2]> arm_exidx;
+#endif
+};
+
+/**
+ * Class for ELF libraries that already loaded in memory.
+ */
+class LoadedElf : public BaseElf {
+ public:
+ /**
+ * Returns a LoadedElf corresponding to the already loaded ELF
+ * at the given base address.
+ */
+ static already_AddRefed<LibHandle> Create(const char* path, void* base_addr);
+
+ private:
+ explicit LoadedElf(const char* path) : BaseElf(path) {}
+
+ ~LoadedElf() {
+ /* Avoid base's destructor unmapping something that doesn't actually
+ * belong to it. */
+ base.release();
+ ElfLoader::Singleton.Forget(this);
+ }
+
+ /**
+ * Initializes the library according to information found in the given
+ * PT_DYNAMIC header.
+ * Returns whether this succeeded or failed.
+ */
+ bool InitDyn(const Elf::Phdr* pt_dyn);
+};
+
+#endif /* BaseElf_h */
diff --git a/mozglue/linker/CustomElf.cpp b/mozglue/linker/CustomElf.cpp
new file mode 100644
index 0000000000..5d44b34d22
--- /dev/null
+++ b/mozglue/linker/CustomElf.cpp
@@ -0,0 +1,680 @@
+/* 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 <cstring>
+#include <sys/mman.h>
+#include <vector>
+#include <dlfcn.h>
+#include <signal.h>
+#include <string.h>
+#include "CustomElf.h"
+#include "BaseElf.h"
+#include "Mappable.h"
+#include "Logging.h"
+#include "mozilla/IntegerPrintfMacros.h"
+
+using namespace Elf;
+
+/* TODO: Fill ElfLoader::Singleton.lastError on errors. */
+
+const Ehdr* Ehdr::validate(const void* buf) {
+ if (!buf || buf == MAP_FAILED) return nullptr;
+
+ const Ehdr* ehdr = reinterpret_cast<const Ehdr*>(buf);
+
+ /* Only support ELF executables or libraries for the host system */
+ if (memcmp(ELFMAG, &ehdr->e_ident, SELFMAG) ||
+ ehdr->e_ident[EI_CLASS] != ELFCLASS ||
+ ehdr->e_ident[EI_DATA] != ELFDATA || ehdr->e_ident[EI_VERSION] != 1 ||
+ (ehdr->e_ident[EI_OSABI] != ELFOSABI &&
+ ehdr->e_ident[EI_OSABI] != ELFOSABI_NONE) ||
+#ifdef EI_ABIVERSION
+ ehdr->e_ident[EI_ABIVERSION] != ELFABIVERSION ||
+#endif
+ (ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN) ||
+ ehdr->e_machine != ELFMACHINE || ehdr->e_version != 1 ||
+ ehdr->e_phentsize != sizeof(Phdr))
+ return nullptr;
+
+ return ehdr;
+}
+
+namespace {
+
+void debug_phdr(const char* type, const Phdr* phdr) {
+ DEBUG_LOG("%s @0x%08" PRIxPTR
+ " ("
+ "filesz: 0x%08" PRIxPTR
+ ", "
+ "memsz: 0x%08" PRIxPTR
+ ", "
+ "offset: 0x%08" PRIxPTR
+ ", "
+ "flags: %c%c%c)",
+ type, uintptr_t(phdr->p_vaddr), uintptr_t(phdr->p_filesz),
+ uintptr_t(phdr->p_memsz), uintptr_t(phdr->p_offset),
+ phdr->p_flags & PF_R ? 'r' : '-', phdr->p_flags & PF_W ? 'w' : '-',
+ phdr->p_flags & PF_X ? 'x' : '-');
+}
+
+static int p_flags_to_mprot(Word flags) {
+ return ((flags & PF_X) ? PROT_EXEC : 0) | ((flags & PF_W) ? PROT_WRITE : 0) |
+ ((flags & PF_R) ? PROT_READ : 0);
+}
+
+} /* anonymous namespace */
+
+/**
+ * RAII wrapper for a mapping of the first page off a Mappable object.
+ * This calls Mappable::munmap instead of system munmap.
+ */
+class Mappable1stPagePtr : public GenericMappedPtr<Mappable1stPagePtr> {
+ public:
+ explicit Mappable1stPagePtr(Mappable* mappable)
+ : GenericMappedPtr<Mappable1stPagePtr>(
+ mappable->mmap(nullptr, PageSize(), PROT_READ, MAP_PRIVATE, 0)),
+ mappable(mappable) {}
+
+ private:
+ friend class GenericMappedPtr<Mappable1stPagePtr>;
+ void munmap(void* buf, size_t length) { mappable->munmap(buf, length); }
+
+ RefPtr<Mappable> mappable;
+};
+
+already_AddRefed<LibHandle> CustomElf::Load(Mappable* mappable,
+ const char* path, int flags) {
+ DEBUG_LOG("CustomElf::Load(\"%s\", 0x%x) = ...", path, flags);
+ if (!mappable) return nullptr;
+ /* Keeping a RefPtr of the CustomElf is going to free the appropriate
+ * resources when returning nullptr */
+ RefPtr<CustomElf> elf = new CustomElf(mappable, path);
+ /* Map the first page of the Elf object to access Elf and program headers */
+ Mappable1stPagePtr ehdr_raw(mappable);
+ if (ehdr_raw == MAP_FAILED) return nullptr;
+
+ const Ehdr* ehdr = Ehdr::validate(ehdr_raw);
+ if (!ehdr) return nullptr;
+
+ /* Scan Elf Program Headers and gather some information about them */
+ std::vector<const Phdr*> pt_loads;
+ Addr min_vaddr = (Addr)-1; // We want to find the lowest and biggest
+ Addr max_vaddr = 0; // virtual address used by this Elf.
+ const Phdr* dyn = nullptr;
+
+ const Phdr* first_phdr = reinterpret_cast<const Phdr*>(
+ reinterpret_cast<const char*>(ehdr) + ehdr->e_phoff);
+ const Phdr* end_phdr = &first_phdr[ehdr->e_phnum];
+#ifdef __ARM_EABI__
+ const Phdr* arm_exidx_phdr = nullptr;
+#endif
+
+ for (const Phdr* phdr = first_phdr; phdr < end_phdr; phdr++) {
+ switch (phdr->p_type) {
+ case PT_LOAD:
+ debug_phdr("PT_LOAD", phdr);
+ pt_loads.push_back(phdr);
+ if (phdr->p_vaddr < min_vaddr) min_vaddr = phdr->p_vaddr;
+ if (max_vaddr < phdr->p_vaddr + phdr->p_memsz)
+ max_vaddr = phdr->p_vaddr + phdr->p_memsz;
+ break;
+ case PT_DYNAMIC:
+ debug_phdr("PT_DYNAMIC", phdr);
+ if (!dyn) {
+ dyn = phdr;
+ } else {
+ ERROR("%s: Multiple PT_DYNAMIC segments detected", elf->GetPath());
+ return nullptr;
+ }
+ break;
+ case PT_TLS:
+ debug_phdr("PT_TLS", phdr);
+ if (phdr->p_memsz) {
+ ERROR("%s: TLS is not supported", elf->GetPath());
+ return nullptr;
+ }
+ break;
+ case PT_GNU_STACK:
+ debug_phdr("PT_GNU_STACK", phdr);
+// Skip on Android until bug 706116 is fixed
+#ifndef ANDROID
+ if (phdr->p_flags & PF_X) {
+ ERROR("%s: Executable stack is not supported", elf->GetPath());
+ return nullptr;
+ }
+#endif
+ break;
+#ifdef __ARM_EABI__
+ case PT_ARM_EXIDX:
+ /* We cannot initialize arm_exidx here
+ because we don't have a base yet */
+ arm_exidx_phdr = phdr;
+ break;
+#endif
+ default:
+ DEBUG_LOG("%s: Program header type #%d not handled", elf->GetPath(),
+ phdr->p_type);
+ }
+ }
+
+ if (min_vaddr != 0) {
+ ERROR("%s: Unsupported minimal virtual address: 0x%08" PRIxPTR,
+ elf->GetPath(), uintptr_t(min_vaddr));
+ return nullptr;
+ }
+ if (!dyn) {
+ ERROR("%s: No PT_DYNAMIC segment found", elf->GetPath());
+ return nullptr;
+ }
+
+ /* Reserve enough memory to map the complete virtual address space for this
+ * library.
+ * As we are using the base address from here to mmap something else with
+ * MAP_FIXED | MAP_SHARED, we need to make sure these mmaps will work. For
+ * instance, on armv6, MAP_SHARED mappings require a 16k alignment, but mmap
+ * MAP_PRIVATE only returns a 4k aligned address. So we first get a base
+ * address with MAP_SHARED, which guarantees the kernel returns an address
+ * that we'll be able to use with MAP_FIXED, and then remap MAP_PRIVATE at
+ * the same address, because of some bad side effects of keeping it as
+ * MAP_SHARED. */
+ elf->base.Assign(MemoryRange::mmap(nullptr, max_vaddr, PROT_NONE,
+ MAP_SHARED | MAP_ANONYMOUS, -1, 0));
+ if ((elf->base == MAP_FAILED) ||
+ (mmap(elf->base, max_vaddr, PROT_NONE,
+ MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0) != elf->base)) {
+ ERROR("%s: Failed to mmap", elf->GetPath());
+ return nullptr;
+ }
+
+ /* Load and initialize library */
+ for (std::vector<const Phdr*>::iterator it = pt_loads.begin();
+ it < pt_loads.end(); ++it)
+ if (!elf->LoadSegment(*it)) return nullptr;
+
+ /* We're not going to mmap anymore */
+ mappable->finalize();
+
+ elf->l_addr = elf->base;
+ elf->l_name = elf->GetPath();
+ elf->l_ld = elf->GetPtr<Dyn>(dyn->p_vaddr);
+ ElfLoader::Singleton.Register(elf);
+
+ if (!elf->InitDyn(dyn)) return nullptr;
+
+ if (elf->has_text_relocs) {
+ for (std::vector<const Phdr*>::iterator it = pt_loads.begin();
+ it < pt_loads.end(); ++it)
+ mprotect(PageAlignedPtr(elf->GetPtr((*it)->p_vaddr)),
+ PageAlignedEndPtr((*it)->p_memsz),
+ p_flags_to_mprot((*it)->p_flags) | PROT_WRITE);
+ }
+
+ if (!elf->Relocate() || !elf->RelocateJumps()) return nullptr;
+
+ if (elf->has_text_relocs) {
+ for (std::vector<const Phdr*>::iterator it = pt_loads.begin();
+ it < pt_loads.end(); ++it)
+ mprotect(PageAlignedPtr(elf->GetPtr((*it)->p_vaddr)),
+ PageAlignedEndPtr((*it)->p_memsz),
+ p_flags_to_mprot((*it)->p_flags));
+ }
+
+ if (!elf->CallInit()) return nullptr;
+
+#ifdef __ARM_EABI__
+ if (arm_exidx_phdr)
+ elf->arm_exidx.InitSize(elf->GetPtr(arm_exidx_phdr->p_vaddr),
+ arm_exidx_phdr->p_memsz);
+#endif
+
+ DEBUG_LOG("CustomElf::Load(\"%s\", 0x%x) = %p", path, flags,
+ static_cast<void*>(elf));
+ return elf.forget();
+}
+
+CustomElf::~CustomElf() {
+ DEBUG_LOG("CustomElf::~CustomElf(%p [\"%s\"])", reinterpret_cast<void*>(this),
+ GetPath());
+ CallFini();
+ /* Normally, __cxa_finalize is called by the .fini function. However,
+ * Android NDK before r6b doesn't do that. Our wrapped cxa_finalize only
+ * calls destructors once, so call it in all cases. */
+ ElfLoader::__wrap_cxa_finalize(this);
+ ElfLoader::Singleton.Forget(this);
+}
+
+void* CustomElf::GetSymbolPtrInDeps(const char* symbol) const {
+ /* Resolve dlopen and related functions to point to ours */
+ if (symbol[0] == 'd' && symbol[1] == 'l') {
+ if (strcmp(symbol + 2, "open") == 0) return FunctionPtr(__wrap_dlopen);
+ if (strcmp(symbol + 2, "error") == 0) return FunctionPtr(__wrap_dlerror);
+ if (strcmp(symbol + 2, "close") == 0) return FunctionPtr(__wrap_dlclose);
+ if (strcmp(symbol + 2, "sym") == 0) return FunctionPtr(__wrap_dlsym);
+ if (strcmp(symbol + 2, "addr") == 0) return FunctionPtr(__wrap_dladdr);
+ if (strcmp(symbol + 2, "_iterate_phdr") == 0)
+ return FunctionPtr(__wrap_dl_iterate_phdr);
+ } else if (symbol[0] == '_' && symbol[1] == '_') {
+ /* Resolve a few C++ ABI specific functions to point to ours */
+#ifdef __ARM_EABI__
+ if (strcmp(symbol + 2, "aeabi_atexit") == 0)
+ return FunctionPtr(&ElfLoader::__wrap_aeabi_atexit);
+#else
+ if (strcmp(symbol + 2, "cxa_atexit") == 0)
+ return FunctionPtr(&ElfLoader::__wrap_cxa_atexit);
+#endif
+ if (strcmp(symbol + 2, "cxa_finalize") == 0)
+ return FunctionPtr(&ElfLoader::__wrap_cxa_finalize);
+ if (strcmp(symbol + 2, "dso_handle") == 0)
+ return const_cast<CustomElf*>(this);
+#ifdef __ARM_EABI__
+ if (strcmp(symbol + 2, "gnu_Unwind_Find_exidx") == 0)
+ return FunctionPtr(__wrap___gnu_Unwind_Find_exidx);
+#endif
+ } else if (symbol[0] == 's' && symbol[1] == 'i') {
+ if (strcmp(symbol + 2, "gnal") == 0) return FunctionPtr(signal);
+ if (strcmp(symbol + 2, "gaction") == 0) return FunctionPtr(sigaction);
+ }
+
+ void* sym;
+
+ unsigned long hash = Hash(symbol);
+
+ /* self_elf should never be NULL, but better safe than sorry. */
+ if (ElfLoader::Singleton.self_elf) {
+ /* We consider the library containing this code a permanent LD_PRELOAD,
+ * so, check if the symbol exists here first. */
+ sym = static_cast<BaseElf*>(ElfLoader::Singleton.self_elf.get())
+ ->GetSymbolPtr(symbol, hash);
+ if (sym) return sym;
+ }
+
+ /* Then search the symbol in our dependencies. Since we already searched in
+ * libraries the system linker loaded, skip those (on glibc systems). We
+ * also assume the symbol is to be found in one of the dependent libraries
+ * directly, not in their own dependent libraries. Building libraries with
+ * --no-allow-shlib-undefined ensures such indirect symbol dependency don't
+ * happen. */
+ for (std::vector<RefPtr<LibHandle> >::const_iterator it =
+ dependencies.begin();
+ it < dependencies.end(); ++it) {
+ /* Skip if it's the library containing this code, since we've already
+ * looked at it above. */
+ if (*it == ElfLoader::Singleton.self_elf) continue;
+ if (BaseElf* be = (*it)->AsBaseElf()) {
+ sym = be->GetSymbolPtr(symbol, hash);
+ } else {
+ sym = (*it)->GetSymbolPtr(symbol);
+ }
+ if (sym) return sym;
+ }
+ return nullptr;
+}
+
+bool CustomElf::LoadSegment(const Phdr* pt_load) const {
+ if (pt_load->p_type != PT_LOAD) {
+ DEBUG_LOG("%s: Elf::LoadSegment only takes PT_LOAD program headers",
+ GetPath());
+ return false;
+ ;
+ }
+
+ int prot = p_flags_to_mprot(pt_load->p_flags);
+
+ /* Mmap at page boundary */
+ Addr align = PageSize();
+ Addr align_offset;
+ void *mapped, *where;
+ do {
+ align_offset = pt_load->p_vaddr - AlignedPtr(pt_load->p_vaddr, align);
+ where = GetPtr(pt_load->p_vaddr - align_offset);
+ DEBUG_LOG("%s: Loading segment @%p %c%c%c", GetPath(), where,
+ prot & PROT_READ ? 'r' : '-', prot & PROT_WRITE ? 'w' : '-',
+ prot & PROT_EXEC ? 'x' : '-');
+ mapped = mappable->mmap(where, pt_load->p_filesz + align_offset, prot,
+ MAP_PRIVATE | MAP_FIXED,
+ pt_load->p_offset - align_offset);
+ if ((mapped != MAP_FAILED) || (pt_load->p_vaddr == 0) ||
+ (pt_load->p_align == align))
+ break;
+ /* The virtual address space for the library is properly aligned at
+ * 16k on ARMv6 (see CustomElf::Load), and so is the first segment
+ * (p_vaddr == 0). But subsequent segments may not be 16k aligned
+ * and fail to mmap. In such case, try to mmap again at the p_align
+ * boundary instead of page boundary. */
+ DEBUG_LOG("%s: Failed to mmap, retrying", GetPath());
+ align = pt_load->p_align;
+ } while (1);
+
+ if (mapped != where) {
+ if (mapped == MAP_FAILED) {
+ ERROR("%s: Failed to mmap", GetPath());
+ } else {
+ ERROR("%s: Didn't map at the expected location (wanted: %p, got: %p)",
+ GetPath(), where, mapped);
+ }
+ return false;
+ }
+
+ /* When p_memsz is greater than p_filesz, we need to have nulled out memory
+ * after p_filesz and before p_memsz.
+ * Above the end of the last page, and up to p_memsz, we already have nulled
+ * out memory because we mapped anonymous memory on the whole library virtual
+ * address space. We just need to adjust this anonymous memory protection
+ * flags. */
+ if (pt_load->p_memsz > pt_load->p_filesz) {
+ Addr file_end = pt_load->p_vaddr + pt_load->p_filesz;
+ Addr mem_end = pt_load->p_vaddr + pt_load->p_memsz;
+ Addr next_page = PageAlignedEndPtr(file_end);
+ if (next_page > file_end) {
+ void* ptr = GetPtr(file_end);
+ memset(ptr, 0, next_page - file_end);
+ }
+ if (mem_end > next_page) {
+ if (mprotect(GetPtr(next_page), mem_end - next_page, prot) < 0) {
+ ERROR("%s: Failed to mprotect", GetPath());
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+namespace {
+
+void debug_dyn(const char* type, const Dyn* dyn) {
+ DEBUG_LOG("%s 0x%08" PRIxPTR, type, uintptr_t(dyn->d_un.d_val));
+}
+
+} /* anonymous namespace */
+
+bool CustomElf::InitDyn(const Phdr* pt_dyn) {
+ /* Scan PT_DYNAMIC segment and gather some information */
+ const Dyn* first_dyn = GetPtr<Dyn>(pt_dyn->p_vaddr);
+ const Dyn* end_dyn = GetPtr<Dyn>(pt_dyn->p_vaddr + pt_dyn->p_filesz);
+ std::vector<Word> dt_needed;
+ size_t symnum = 0;
+ for (const Dyn* dyn = first_dyn; dyn < end_dyn && dyn->d_tag; dyn++) {
+ switch (dyn->d_tag) {
+ case DT_NEEDED:
+ debug_dyn("DT_NEEDED", dyn);
+ dt_needed.push_back(dyn->d_un.d_val);
+ break;
+ case DT_HASH: {
+ debug_dyn("DT_HASH", dyn);
+ const Word* hash_table_header = GetPtr<Word>(dyn->d_un.d_ptr);
+ symnum = hash_table_header[1];
+ buckets.Init(&hash_table_header[2], hash_table_header[0]);
+ chains.Init(&*buckets.end());
+ } break;
+ case DT_STRTAB:
+ debug_dyn("DT_STRTAB", dyn);
+ strtab.Init(GetPtr(dyn->d_un.d_ptr));
+ break;
+ case DT_SYMTAB:
+ debug_dyn("DT_SYMTAB", dyn);
+ symtab.Init(GetPtr(dyn->d_un.d_ptr));
+ break;
+ case DT_SYMENT:
+ debug_dyn("DT_SYMENT", dyn);
+ if (dyn->d_un.d_val != sizeof(Sym)) {
+ ERROR("%s: Unsupported DT_SYMENT", GetPath());
+ return false;
+ }
+ break;
+ case DT_TEXTREL:
+ if (strcmp("libflashplayer.so", GetName()) == 0) {
+ has_text_relocs = true;
+ } else {
+ ERROR("%s: Text relocations are not supported", GetPath());
+ return false;
+ }
+ break;
+ case DT_STRSZ: /* Ignored */
+ debug_dyn("DT_STRSZ", dyn);
+ break;
+ case UNSUPPORTED_RELOC():
+ case UNSUPPORTED_RELOC(SZ):
+ case UNSUPPORTED_RELOC(ENT):
+ ERROR("%s: Unsupported relocations", GetPath());
+ return false;
+ case RELOC():
+ debug_dyn(STR_RELOC(), dyn);
+ relocations.Init(GetPtr(dyn->d_un.d_ptr));
+ break;
+ case RELOC(SZ):
+ debug_dyn(STR_RELOC(SZ), dyn);
+ relocations.InitSize(dyn->d_un.d_val);
+ break;
+ case RELOC(ENT):
+ debug_dyn(STR_RELOC(ENT), dyn);
+ if (dyn->d_un.d_val != sizeof(Reloc)) {
+ ERROR("%s: Unsupported DT_RELENT", GetPath());
+ return false;
+ }
+ break;
+ case DT_JMPREL:
+ debug_dyn("DT_JMPREL", dyn);
+ jumprels.Init(GetPtr(dyn->d_un.d_ptr));
+ break;
+ case DT_PLTRELSZ:
+ debug_dyn("DT_PLTRELSZ", dyn);
+ jumprels.InitSize(dyn->d_un.d_val);
+ break;
+ case DT_PLTGOT:
+ debug_dyn("DT_PLTGOT", dyn);
+ break;
+ case DT_INIT:
+ debug_dyn("DT_INIT", dyn);
+ init = dyn->d_un.d_ptr;
+ break;
+ case DT_INIT_ARRAY:
+ debug_dyn("DT_INIT_ARRAY", dyn);
+ init_array.Init(GetPtr(dyn->d_un.d_ptr));
+ break;
+ case DT_INIT_ARRAYSZ:
+ debug_dyn("DT_INIT_ARRAYSZ", dyn);
+ init_array.InitSize(dyn->d_un.d_val);
+ break;
+ case DT_FINI:
+ debug_dyn("DT_FINI", dyn);
+ fini = dyn->d_un.d_ptr;
+ break;
+ case DT_FINI_ARRAY:
+ debug_dyn("DT_FINI_ARRAY", dyn);
+ fini_array.Init(GetPtr(dyn->d_un.d_ptr));
+ break;
+ case DT_FINI_ARRAYSZ:
+ debug_dyn("DT_FINI_ARRAYSZ", dyn);
+ fini_array.InitSize(dyn->d_un.d_val);
+ break;
+ case DT_PLTREL:
+ if (dyn->d_un.d_val != RELOC()) {
+ ERROR("%s: Error: DT_PLTREL is not " STR_RELOC(), GetPath());
+ return false;
+ }
+ break;
+ case DT_FLAGS: {
+ Addr flags = dyn->d_un.d_val;
+ /* Treat as a DT_TEXTREL tag */
+ if (flags & DF_TEXTREL) {
+ if (strcmp("libflashplayer.so", GetName()) == 0) {
+ has_text_relocs = true;
+ } else {
+ ERROR("%s: Text relocations are not supported", GetPath());
+ return false;
+ }
+ }
+ /* we can treat this like having a DT_SYMBOLIC tag */
+ flags &= ~DF_SYMBOLIC;
+ if (flags)
+ WARN("%s: unhandled flags #%" PRIxPTR " not handled", GetPath(),
+ uintptr_t(flags));
+ } break;
+ case DT_SONAME: /* Should match GetName(), but doesn't matter */
+ case DT_SYMBOLIC: /* Indicates internal symbols should be looked up in
+ * the library itself first instead of the executable,
+ * which is actually what this linker does by default */
+ case RELOC(COUNT): /* Indicates how many relocations are relative, which
+ * is usually used to skip relocations on prelinked
+ * libraries. They are not supported anyways. */
+ case UNSUPPORTED_RELOC(COUNT): /* This should error out, but it doesn't
+ * really matter. */
+ case DT_FLAGS_1: /* Additional linker-internal flags that we don't care
+ * about. See DF_1_* values in src/include/elf/common.h
+ * in binutils. */
+ case DT_VERSYM: /* DT_VER* entries are used for symbol versioning, which
+ */
+ case DT_VERDEF: /* this linker doesn't support yet. */
+ case DT_VERDEFNUM:
+ case DT_VERNEED:
+ case DT_VERNEEDNUM:
+ /* Ignored */
+ break;
+ default:
+ WARN("%s: dynamic header type #%" PRIxPTR " not handled", GetPath(),
+ uintptr_t(dyn->d_tag));
+ }
+ }
+
+ if (!buckets || !symnum) {
+ ERROR("%s: Missing or broken DT_HASH", GetPath());
+ return false;
+ }
+ if (!strtab) {
+ ERROR("%s: Missing DT_STRTAB", GetPath());
+ return false;
+ }
+ if (!symtab) {
+ ERROR("%s: Missing DT_SYMTAB", GetPath());
+ return false;
+ }
+
+ /* Load dependent libraries */
+ for (size_t i = 0; i < dt_needed.size(); i++) {
+ const char* name = strtab.GetStringAt(dt_needed[i]);
+ RefPtr<LibHandle> handle =
+ ElfLoader::Singleton.Load(name, RTLD_GLOBAL | RTLD_LAZY, this);
+ if (!handle) return false;
+ dependencies.push_back(handle);
+ }
+
+ return true;
+}
+
+bool CustomElf::Relocate() {
+ DEBUG_LOG("Relocate %s @%p", GetPath(), static_cast<void*>(base));
+ uint32_t symtab_index = (uint32_t)-1;
+ void* symptr = nullptr;
+ for (Array<Reloc>::iterator rel = relocations.begin();
+ rel < relocations.end(); ++rel) {
+ /* Location of the relocation */
+ void* ptr = GetPtr(rel->r_offset);
+
+ /* R_*_RELATIVE relocations apply directly at the given location */
+ if (ELF_R_TYPE(rel->r_info) == R_RELATIVE) {
+ *(void**)ptr = GetPtr(rel->GetAddend(base));
+ continue;
+ }
+ /* Other relocation types need a symbol resolution */
+ /* Avoid symbol resolution when it's the same symbol as last iteration */
+ if (symtab_index != ELF_R_SYM(rel->r_info)) {
+ symtab_index = ELF_R_SYM(rel->r_info);
+ const Sym sym = symtab[symtab_index];
+ if (sym.st_shndx != SHN_UNDEF) {
+ symptr = GetPtr(sym.st_value);
+ } else {
+ /* TODO: handle symbol resolving to nullptr vs. being undefined. */
+ symptr = GetSymbolPtrInDeps(strtab.GetStringAt(sym.st_name));
+ }
+ }
+
+ if (symptr == nullptr)
+ WARN("%s: Relocation to NULL @0x%08" PRIxPTR, GetPath(),
+ uintptr_t(rel->r_offset));
+
+ /* Apply relocation */
+ switch (ELF_R_TYPE(rel->r_info)) {
+ case R_GLOB_DAT:
+ /* R_*_GLOB_DAT relocations simply use the symbol value */
+ *(void**)ptr = symptr;
+ break;
+ case R_ABS:
+ /* R_*_ABS* relocations add the relocation added to the symbol value */
+ *(const char**)ptr = (const char*)symptr + rel->GetAddend(base);
+ break;
+ default:
+ ERROR("%s: Unsupported relocation type: 0x%" PRIxPTR, GetPath(),
+ uintptr_t(ELF_R_TYPE(rel->r_info)));
+ return false;
+ }
+ }
+ return true;
+}
+
+bool CustomElf::RelocateJumps() {
+ /* TODO: Dynamic symbol resolution */
+ for (Array<Reloc>::iterator rel = jumprels.begin(); rel < jumprels.end();
+ ++rel) {
+ /* Location of the relocation */
+ void* ptr = GetPtr(rel->r_offset);
+
+ /* Only R_*_JMP_SLOT relocations are expected */
+ if (ELF_R_TYPE(rel->r_info) != R_JMP_SLOT) {
+ ERROR("%s: Jump relocation type mismatch", GetPath());
+ return false;
+ }
+
+ /* TODO: Avoid code duplication with the relocations above */
+ const Sym sym = symtab[ELF_R_SYM(rel->r_info)];
+ void* symptr;
+ if (sym.st_shndx != SHN_UNDEF)
+ symptr = GetPtr(sym.st_value);
+ else
+ symptr = GetSymbolPtrInDeps(strtab.GetStringAt(sym.st_name));
+
+ if (symptr == nullptr) {
+ if (ELF_ST_BIND(sym.st_info) == STB_WEAK) {
+ WARN("%s: Relocation to NULL @0x%08" PRIxPTR " for symbol \"%s\"",
+ GetPath(), uintptr_t(rel->r_offset),
+ strtab.GetStringAt(sym.st_name));
+ } else {
+ ERROR("%s: Relocation to NULL @0x%08" PRIxPTR " for symbol \"%s\"",
+ GetPath(), uintptr_t(rel->r_offset),
+ strtab.GetStringAt(sym.st_name));
+ return false;
+ }
+ }
+ /* Apply relocation */
+ *(void**)ptr = symptr;
+ }
+ return true;
+}
+
+bool CustomElf::CallInit() {
+ if (init) CallFunction(init);
+
+ for (Array<void*>::iterator it = init_array.begin(); it < init_array.end();
+ ++it) {
+ /* Android x86 NDK wrongly puts 0xffffffff in INIT_ARRAY */
+ if (*it && *it != reinterpret_cast<void*>(-1)) CallFunction(*it);
+ }
+ initialized = true;
+ return true;
+}
+
+void CustomElf::CallFini() {
+ if (!initialized) return;
+ for (Array<void*>::reverse_iterator it = fini_array.rbegin();
+ it < fini_array.rend(); ++it) {
+ /* Android x86 NDK wrongly puts 0xffffffff in FINI_ARRAY */
+ if (*it && *it != reinterpret_cast<void*>(-1)) CallFunction(*it);
+ }
+ if (fini) CallFunction(fini);
+}
+
+Mappable* CustomElf::GetMappable() const {
+ if (!mappable) return nullptr;
+ if (mappable->GetKind() == Mappable::MAPPABLE_EXTRACT_FILE) return mappable;
+ return ElfLoader::GetMappableFromPath(GetPath());
+}
diff --git a/mozglue/linker/CustomElf.h b/mozglue/linker/CustomElf.h
new file mode 100644
index 0000000000..f7b116e9d3
--- /dev/null
+++ b/mozglue/linker/CustomElf.h
@@ -0,0 +1,147 @@
+/* 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 CustomElf_h
+#define CustomElf_h
+
+#include "ElfLoader.h"
+#include "BaseElf.h"
+#include "Logging.h"
+#include "Elfxx.h"
+
+/**
+ * Library Handle class for ELF libraries we don't let the system linker
+ * handle.
+ */
+class CustomElf : public BaseElf, private ElfLoader::link_map {
+ friend class ElfLoader;
+ friend class SEGVHandler;
+
+ public:
+ /**
+ * Returns a new CustomElf using the given file descriptor to map ELF
+ * content. The file descriptor ownership is stolen, and it will be closed
+ * in CustomElf's destructor if an instance is created, or by the Load
+ * method otherwise. The path corresponds to the file descriptor, and flags
+ * are the same kind of flags that would be given to dlopen(), though
+ * currently, none are supported and the behaviour is more or less that of
+ * RTLD_GLOBAL | RTLD_BIND_NOW.
+ */
+ static already_AddRefed<LibHandle> Load(Mappable* mappable, const char* path,
+ int flags);
+
+ /**
+ * Inherited from LibHandle/BaseElf
+ */
+ virtual ~CustomElf();
+
+ protected:
+ virtual Mappable* GetMappable() const;
+
+ public:
+ /**
+ * Returns the instance, casted as BaseElf. (short of a better way to do
+ * this without RTTI)
+ */
+ virtual BaseElf* AsBaseElf() { return this; }
+
+ private:
+ /**
+ * Scan dependent libraries to find the address corresponding to the
+ * given symbol name. This is used to find symbols that are undefined
+ * in the Elf object.
+ */
+ void* GetSymbolPtrInDeps(const char* symbol) const;
+
+ /**
+ * Private constructor
+ */
+ CustomElf(Mappable* mappable, const char* path)
+ : BaseElf(path, mappable),
+ link_map(),
+ init(0),
+ fini(0),
+ initialized(false),
+ has_text_relocs(false) {}
+
+ /**
+ * Loads an Elf segment defined by the given PT_LOAD header.
+ * Returns whether this succeeded or failed.
+ */
+ bool LoadSegment(const Elf::Phdr* pt_load) const;
+
+ /**
+ * Initializes the library according to information found in the given
+ * PT_DYNAMIC header.
+ * Returns whether this succeeded or failed.
+ */
+ bool InitDyn(const Elf::Phdr* pt_dyn);
+
+ /**
+ * Apply .rel.dyn/.rela.dyn relocations.
+ * Returns whether this succeeded or failed.
+ */
+ bool Relocate();
+
+ /**
+ * Apply .rel.plt/.rela.plt relocations.
+ * Returns whether this succeeded or failed.
+ */
+ bool RelocateJumps();
+
+ /**
+ * Call initialization functions (.init/.init_array)
+ * Returns true;
+ */
+ bool CallInit();
+
+ /**
+ * Call destructor functions (.fini_array/.fini)
+ * Returns whether this succeeded or failed.
+ */
+ void CallFini();
+
+ /**
+ * Call a function given a pointer to its location.
+ */
+ void CallFunction(void* ptr) const {
+ /* C++ doesn't allow direct conversion between pointer-to-object
+ * and pointer-to-function. */
+ union {
+ void* ptr;
+ void (*func)(void);
+ } f;
+ f.ptr = ptr;
+ DEBUG_LOG("%s: Calling function @%p", GetPath(), ptr);
+ f.func();
+ }
+
+ /**
+ * Call a function given a an address relative to the library base
+ */
+ void CallFunction(Elf::Addr addr) const { return CallFunction(GetPtr(addr)); }
+
+ /* List of dependent libraries */
+ std::vector<RefPtr<LibHandle> > dependencies;
+
+ /* List of .rel.dyn/.rela.dyn relocations */
+ Array<Elf::Reloc> relocations;
+
+ /* List of .rel.plt/.rela.plt relocation */
+ Array<Elf::Reloc> jumprels;
+
+ /* Relative address of the initialization and destruction functions
+ * (.init/.fini) */
+ Elf::Addr init, fini;
+
+ /* List of initialization and destruction functions
+ * (.init_array/.fini_array) */
+ Array<void*> init_array, fini_array;
+
+ bool initialized;
+
+ bool has_text_relocs;
+};
+
+#endif /* CustomElf_h */
diff --git a/mozglue/linker/ElfLoader.cpp b/mozglue/linker/ElfLoader.cpp
new file mode 100644
index 0000000000..55b113467a
--- /dev/null
+++ b/mozglue/linker/ElfLoader.cpp
@@ -0,0 +1,1360 @@
+/* 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 <string>
+#include <cstring>
+#include <cstdlib>
+#include <cstdio>
+#include <dlfcn.h>
+#include <unistd.h>
+#include <errno.h>
+#include <algorithm>
+#include <fcntl.h>
+#include "ElfLoader.h"
+#include "BaseElf.h"
+#include "CustomElf.h"
+#include "Mappable.h"
+#include "Logging.h"
+#include "Utils.h"
+#include <inttypes.h>
+
+// From Utils.h
+mozilla::Atomic<size_t, mozilla::ReleaseAcquire> gPageSize;
+
+#if defined(ANDROID)
+# include <sys/syscall.h>
+# include <sys/system_properties.h>
+# include <math.h>
+
+# include <android/api-level.h>
+
+/**
+ * Return the current Android version, or 0 on failure.
+ */
+static int GetAndroidSDKVersion() {
+ static int version = 0;
+ if (version) {
+ return version;
+ }
+
+ char version_string[PROP_VALUE_MAX] = {'\0'};
+ int len = __system_property_get("ro.build.version.sdk", version_string);
+ if (len) {
+ version = static_cast<int>(strtol(version_string, nullptr, 10));
+ }
+ return version;
+}
+
+# if __ANDROID_API__ < 8
+/* Android API < 8 doesn't provide sigaltstack */
+
+extern "C" {
+
+inline int sigaltstack(const stack_t* ss, stack_t* oss) {
+ return syscall(__NR_sigaltstack, ss, oss);
+}
+
+} /* extern "C" */
+# endif /* __ANDROID_API__ */
+#endif /* ANDROID */
+
+#ifdef __ARM_EABI__
+extern "C" MOZ_EXPORT const void* __gnu_Unwind_Find_exidx(void* pc, int* pcount)
+ __attribute__((weak));
+#endif
+
+/* Ideally we'd #include <link.h>, but that's a world of pain
+ * Moreover, not all versions of android support it, so we need a weak
+ * reference. */
+extern "C" MOZ_EXPORT int dl_iterate_phdr(dl_phdr_cb callback, void* data)
+ __attribute__((weak));
+
+/* Pointer to the PT_DYNAMIC section of the executable or library
+ * containing this code. */
+extern "C" Elf::Dyn _DYNAMIC[];
+
+/**
+ * dlfcn.h replacements functions
+ */
+
+void* __wrap_dlopen(const char* path, int flags) {
+#if defined(ANDROID)
+ if (GetAndroidSDKVersion() >= 23) {
+ return dlopen(path, flags);
+ }
+#endif
+
+ RefPtr<LibHandle> handle = ElfLoader::Singleton.Load(path, flags);
+ if (handle) handle->AddDirectRef();
+ return handle;
+}
+
+const char* __wrap_dlerror(void) {
+#if defined(ANDROID)
+ if (GetAndroidSDKVersion() >= 23) {
+ return dlerror();
+ }
+#endif
+
+ const char* error = ElfLoader::Singleton.lastError.exchange(nullptr);
+ if (error) {
+ // Return a custom error if available.
+ return error;
+ }
+ // Or fallback to the system error.
+ return dlerror();
+}
+
+void* __wrap_dlsym(void* handle, const char* symbol) {
+#if defined(ANDROID)
+ if (GetAndroidSDKVersion() >= 23) {
+ return dlsym(handle, symbol);
+ }
+#endif
+
+ if (!handle) {
+ ElfLoader::Singleton.lastError = "dlsym(NULL, sym) unsupported";
+ return nullptr;
+ }
+ if (handle != RTLD_DEFAULT && handle != RTLD_NEXT) {
+ LibHandle* h = reinterpret_cast<LibHandle*>(handle);
+ return h->GetSymbolPtr(symbol);
+ }
+
+ ElfLoader::Singleton.lastError = nullptr; // Use system dlerror.
+ return dlsym(handle, symbol);
+}
+
+int __wrap_dlclose(void* handle) {
+#if defined(ANDROID)
+ if (GetAndroidSDKVersion() >= 23) {
+ return dlclose(handle);
+ }
+#endif
+
+ if (!handle) {
+ ElfLoader::Singleton.lastError = "No handle given to dlclose()";
+ return -1;
+ }
+ reinterpret_cast<LibHandle*>(handle)->ReleaseDirectRef();
+ return 0;
+}
+
+int __wrap_dladdr(const void* addr, Dl_info* info) {
+#if defined(ANDROID)
+ if (GetAndroidSDKVersion() >= 23) {
+ return dladdr(addr, info);
+ }
+#endif
+
+ RefPtr<LibHandle> handle =
+ ElfLoader::Singleton.GetHandleByPtr(const_cast<void*>(addr));
+ if (!handle) {
+ return dladdr(addr, info);
+ }
+ info->dli_fname = handle->GetPath();
+ info->dli_fbase = handle->GetBase();
+ return 1;
+}
+
+class DlIteratePhdrHelper {
+ public:
+ DlIteratePhdrHelper() {
+ int pipefd[2];
+ valid_pipe = (pipe(pipefd) == 0);
+ read_fd.reset(pipefd[0]);
+ write_fd.reset(pipefd[1]);
+ }
+
+ int fill_and_call(dl_phdr_cb callback, const void* l_addr, const char* l_name,
+ void* data);
+
+ private:
+ bool valid_pipe;
+ AutoCloseFD read_fd;
+ AutoCloseFD write_fd;
+};
+
+// This function is called for each shared library iterated over by
+// dl_iterate_phdr, and is used to fill a dl_phdr_info which is then
+// sent through to the dl_iterate_phdr callback.
+int DlIteratePhdrHelper::fill_and_call(dl_phdr_cb callback, const void* l_addr,
+ const char* l_name, void* data) {
+ dl_phdr_info info;
+ info.dlpi_addr = reinterpret_cast<Elf::Addr>(l_addr);
+ info.dlpi_name = l_name;
+ info.dlpi_phdr = nullptr;
+ info.dlpi_phnum = 0;
+
+ // Assuming l_addr points to Elf headers (in most cases, this is true),
+ // get the Phdr location from there.
+ // Unfortunately, when l_addr doesn't point to Elf headers, it may point
+ // to unmapped memory, or worse, unreadable memory. The only way to detect
+ // the latter without causing a SIGSEGV is to use the pointer in a system
+ // call that will try to read from there, and return an EFAULT error if
+ // it can't. One such system call is write(). It used to be possible to
+ // use a file descriptor on /dev/null for these kind of things, but recent
+ // Linux kernels never return an EFAULT error when using /dev/null.
+ // So instead, we use a self pipe. We do however need to read() from the
+ // read end of the pipe as well so as to not fill up the pipe buffer and
+ // block on subsequent writes.
+ // In the unlikely event reads from or write to the pipe fail for some
+ // other reason than EFAULT, we don't try any further and just skip setting
+ // the Phdr location for all subsequent libraries, rather than trying to
+ // start over with a new pipe.
+ int can_read = true;
+ if (valid_pipe) {
+ int ret;
+ char raw_ehdr[sizeof(Elf::Ehdr)];
+ static_assert(sizeof(raw_ehdr) < PIPE_BUF, "PIPE_BUF is too small");
+ do {
+ // writes are atomic when smaller than PIPE_BUF, per POSIX.1-2008.
+ ret = write(write_fd, l_addr, sizeof(raw_ehdr));
+ } while (ret == -1 && errno == EINTR);
+ if (ret != sizeof(raw_ehdr)) {
+ if (ret == -1 && errno == EFAULT) {
+ can_read = false;
+ } else {
+ valid_pipe = false;
+ }
+ } else {
+ size_t nbytes = 0;
+ do {
+ // Per POSIX.1-2008, interrupted reads can return a length smaller
+ // than the given one instead of failing with errno EINTR.
+ ret = read(read_fd, raw_ehdr + nbytes, sizeof(raw_ehdr) - nbytes);
+ if (ret > 0) nbytes += ret;
+ } while ((nbytes != sizeof(raw_ehdr) && ret > 0) ||
+ (ret == -1 && errno == EINTR));
+ if (nbytes != sizeof(raw_ehdr)) {
+ valid_pipe = false;
+ }
+ }
+ }
+
+ if (valid_pipe && can_read) {
+ const Elf::Ehdr* ehdr = Elf::Ehdr::validate(l_addr);
+ if (ehdr) {
+ info.dlpi_phdr = reinterpret_cast<const Elf::Phdr*>(
+ reinterpret_cast<const char*>(ehdr) + ehdr->e_phoff);
+ info.dlpi_phnum = ehdr->e_phnum;
+ }
+ }
+
+ return callback(&info, sizeof(dl_phdr_info), data);
+}
+
+int __wrap_dl_iterate_phdr(dl_phdr_cb callback, void* data) {
+#if defined(ANDROID)
+ if (GetAndroidSDKVersion() >= 23) {
+ return dl_iterate_phdr(callback, data);
+ }
+#endif
+
+ DlIteratePhdrHelper helper;
+ AutoLock lock(&ElfLoader::Singleton.handlesMutex);
+
+ if (dl_iterate_phdr) {
+ for (ElfLoader::LibHandleList::reverse_iterator it =
+ ElfLoader::Singleton.handles.rbegin();
+ it < ElfLoader::Singleton.handles.rend(); ++it) {
+ BaseElf* elf = (*it)->AsBaseElf();
+ if (!elf) {
+ continue;
+ }
+ int ret = helper.fill_and_call(callback, (*it)->GetBase(),
+ (*it)->GetPath(), data);
+ if (ret) return ret;
+ }
+ return dl_iterate_phdr(callback, data);
+ }
+
+ /* For versions of Android that don't support dl_iterate_phdr (< 5.0),
+ * we go through the debugger helper data, which is known to be racy, but
+ * there's not much we can do about this :( . */
+ if (!ElfLoader::Singleton.dbg) return -1;
+
+ for (ElfLoader::DebuggerHelper::iterator it =
+ ElfLoader::Singleton.dbg.begin();
+ it < ElfLoader::Singleton.dbg.end(); ++it) {
+ int ret = helper.fill_and_call(callback, it->l_addr, it->l_name, data);
+ if (ret) return ret;
+ }
+ return 0;
+}
+
+#ifdef __ARM_EABI__
+const void* __wrap___gnu_Unwind_Find_exidx(void* pc, int* pcount) {
+ RefPtr<LibHandle> handle = ElfLoader::Singleton.GetHandleByPtr(pc);
+ if (handle) return handle->FindExidx(pcount);
+ if (__gnu_Unwind_Find_exidx) return __gnu_Unwind_Find_exidx(pc, pcount);
+ *pcount = 0;
+ return nullptr;
+}
+#endif
+
+/**
+ * faulty.lib public API
+ */
+
+MFBT_API size_t __dl_get_mappable_length(void* handle) {
+ if (!handle) return 0;
+ return reinterpret_cast<LibHandle*>(handle)->GetMappableLength();
+}
+
+MFBT_API void* __dl_mmap(void* handle, void* addr, size_t length,
+ off_t offset) {
+ if (!handle) return nullptr;
+ return reinterpret_cast<LibHandle*>(handle)->MappableMMap(addr, length,
+ offset);
+}
+
+MFBT_API void __dl_munmap(void* handle, void* addr, size_t length) {
+ if (!handle) return;
+ return reinterpret_cast<LibHandle*>(handle)->MappableMUnmap(addr, length);
+}
+
+MFBT_API bool IsSignalHandlingBroken() {
+ return ElfLoader::Singleton.isSignalHandlingBroken();
+}
+
+namespace {
+
+/**
+ * Returns the part after the last '/' for the given path
+ */
+const char* LeafName(const char* path) {
+ const char* lastSlash = strrchr(path, '/');
+ if (lastSlash) return lastSlash + 1;
+ return path;
+}
+
+/**
+ * Run the given lambda while holding the internal lock of the system linker.
+ * To take the lock, we call the system dl_iterate_phdr and invoke the lambda
+ * from the callback, which is called while the lock is held. Return true on
+ * success.
+ */
+template <class Lambda>
+static bool RunWithSystemLinkerLock(Lambda&& aLambda) {
+ if (!dl_iterate_phdr) {
+ // No dl_iterate_phdr support.
+ return false;
+ }
+
+#if defined(ANDROID)
+ if (GetAndroidSDKVersion() < 23) {
+ // dl_iterate_phdr is _not_ protected by a lock on Android < 23.
+ // Also return false here if we failed to get the version.
+ return false;
+ }
+#endif
+
+ dl_iterate_phdr(
+ [](dl_phdr_info*, size_t, void* lambda) -> int {
+ (*static_cast<Lambda*>(lambda))();
+ // Return 1 to stop iterating.
+ return 1;
+ },
+ &aLambda);
+ return true;
+}
+
+} /* Anonymous namespace */
+
+/**
+ * LibHandle
+ */
+LibHandle::~LibHandle() { free(path); }
+
+const char* LibHandle::GetName() const {
+ return path ? LeafName(path) : nullptr;
+}
+
+size_t LibHandle::GetMappableLength() const {
+ if (!mappable) mappable = GetMappable();
+ if (!mappable) return 0;
+ return mappable->GetLength();
+}
+
+void* LibHandle::MappableMMap(void* addr, size_t length, off_t offset) const {
+ if (!mappable) mappable = GetMappable();
+ if (!mappable) return MAP_FAILED;
+ void* mapped = mappable->mmap(addr, length, PROT_READ, MAP_PRIVATE, offset);
+ return mapped;
+}
+
+void LibHandle::MappableMUnmap(void* addr, size_t length) const {
+ if (mappable) mappable->munmap(addr, length);
+}
+
+/**
+ * SystemElf
+ */
+already_AddRefed<LibHandle> SystemElf::Load(const char* path, int flags) {
+ /* The Android linker returns a handle when the file name matches an
+ * already loaded library, even when the full path doesn't exist */
+ if (path && path[0] == '/' && (access(path, F_OK) == -1)) {
+ DEBUG_LOG("dlopen(\"%s\", 0x%x) = %p", path, flags, (void*)nullptr);
+ ElfLoader::Singleton.lastError = "Specified file does not exist";
+ return nullptr;
+ }
+
+ ElfLoader::Singleton.lastError = nullptr; // Use system dlerror.
+ void* handle = dlopen(path, flags);
+ DEBUG_LOG("dlopen(\"%s\", 0x%x) = %p", path, flags, handle);
+ if (handle) {
+ SystemElf* elf = new SystemElf(path, handle);
+ ElfLoader::Singleton.Register(elf);
+ RefPtr<LibHandle> lib(elf);
+ return lib.forget();
+ }
+ return nullptr;
+}
+
+SystemElf::~SystemElf() {
+ if (!dlhandle) return;
+ DEBUG_LOG("dlclose(%p [\"%s\"])", dlhandle, GetPath());
+ ElfLoader::Singleton.lastError = nullptr; // Use system dlerror.
+ dlclose(dlhandle);
+ ElfLoader::Singleton.Forget(this);
+}
+
+void* SystemElf::GetSymbolPtr(const char* symbol) const {
+ ElfLoader::Singleton.lastError = nullptr; // Use system dlerror.
+ void* sym = dlsym(dlhandle, symbol);
+ DEBUG_LOG("dlsym(%p [\"%s\"], \"%s\") = %p", dlhandle, GetPath(), symbol,
+ sym);
+ return sym;
+}
+
+Mappable* SystemElf::GetMappable() const {
+ const char* path = GetPath();
+ if (!path) return nullptr;
+#ifdef ANDROID
+ /* On Android, if we don't have the full path, try in /system/lib */
+ const char* name = LeafName(path);
+ std::string systemPath;
+ if (name == path) {
+ systemPath = "/system/lib/";
+ systemPath += path;
+ path = systemPath.c_str();
+ }
+#endif
+
+ return MappableFile::Create(path);
+}
+
+#ifdef __ARM_EABI__
+const void* SystemElf::FindExidx(int* pcount) const {
+ /* TODO: properly implement when ElfLoader::GetHandleByPtr
+ does return SystemElf handles */
+ *pcount = 0;
+ return nullptr;
+}
+#endif
+
+/**
+ * ElfLoader
+ */
+
+/* Unique ElfLoader instance */
+ElfLoader ElfLoader::Singleton;
+
+already_AddRefed<LibHandle> ElfLoader::Load(const char* path, int flags,
+ LibHandle* parent) {
+ /* Ensure logging is initialized or refresh if environment changed. */
+ Logging::Init();
+
+ /* Ensure self_elf initialization. */
+ if (!self_elf) Init();
+
+ RefPtr<LibHandle> handle;
+
+ /* Handle dlopen(nullptr) directly. */
+ if (!path) {
+ handle = SystemElf::Load(nullptr, flags);
+ return handle.forget();
+ }
+
+ /* TODO: Handle relative paths correctly */
+ const char* name = LeafName(path);
+
+ /* Search the list of handles we already have for a match. When the given
+ * path is not absolute, compare file names, otherwise compare full paths. */
+ if (name == path) {
+ AutoLock lock(&handlesMutex);
+ for (LibHandleList::iterator it = handles.begin(); it < handles.end(); ++it)
+ if ((*it)->GetName() && (strcmp((*it)->GetName(), name) == 0)) {
+ handle = *it;
+ return handle.forget();
+ }
+ } else {
+ AutoLock lock(&handlesMutex);
+ for (LibHandleList::iterator it = handles.begin(); it < handles.end(); ++it)
+ if ((*it)->GetPath() && (strcmp((*it)->GetPath(), path) == 0)) {
+ handle = *it;
+ return handle.forget();
+ }
+ }
+
+ char* abs_path = nullptr;
+ const char* requested_path = path;
+
+ /* When the path is not absolute and the library is being loaded for
+ * another, first try to load the library from the directory containing
+ * that parent library. */
+ if ((name == path) && parent) {
+ const char* parentPath = parent->GetPath();
+ abs_path = new char[strlen(parentPath) + strlen(path)];
+ strcpy(abs_path, parentPath);
+ char* slash = strrchr(abs_path, '/');
+ strcpy(slash + 1, path);
+ path = abs_path;
+ }
+
+ Mappable* mappable = GetMappableFromPath(path);
+
+ /* Try loading with the custom linker if we have a Mappable */
+ if (mappable) handle = CustomElf::Load(mappable, path, flags);
+
+ /* Try loading with the system linker if everything above failed */
+ if (!handle) handle = SystemElf::Load(path, flags);
+
+ /* If we didn't have an absolute path and haven't been able to load
+ * a library yet, try in the system search path */
+ if (!handle && abs_path) handle = SystemElf::Load(name, flags);
+
+ delete[] abs_path;
+ DEBUG_LOG("ElfLoader::Load(\"%s\", 0x%x, %p [\"%s\"]) = %p", requested_path,
+ flags, reinterpret_cast<void*>(parent),
+ parent ? parent->GetPath() : "", static_cast<void*>(handle));
+
+ return handle.forget();
+}
+
+already_AddRefed<LibHandle> ElfLoader::GetHandleByPtr(void* addr) {
+ AutoLock lock(&handlesMutex);
+ /* Scan the list of handles we already have for a match */
+ for (LibHandleList::iterator it = handles.begin(); it < handles.end(); ++it) {
+ if ((*it)->Contains(addr)) {
+ RefPtr<LibHandle> lib = *it;
+ return lib.forget();
+ }
+ }
+ return nullptr;
+}
+
+Mappable* ElfLoader::GetMappableFromPath(const char* path) {
+ const char* name = LeafName(path);
+ Mappable* mappable = nullptr;
+ RefPtr<Zip> zip;
+ const char* subpath;
+ if ((subpath = strchr(path, '!'))) {
+ char* zip_path = strndup(path, subpath - path);
+ while (*(++subpath) == '/') {
+ }
+ zip = ZipCollection::GetZip(zip_path);
+ free(zip_path);
+ Zip::Stream s;
+ if (zip && zip->GetStream(subpath, &s)) {
+ /* When the MOZ_LINKER_EXTRACT environment variable is set to "1",
+ * compressed libraries are going to be (temporarily) extracted as
+ * files, in the directory pointed by the MOZ_LINKER_CACHE
+ * environment variable. */
+ const char* extract = getenv("MOZ_LINKER_EXTRACT");
+ if (extract && !strncmp(extract, "1", 2 /* Including '\0' */))
+ mappable = MappableExtractFile::Create(name, zip, &s);
+ if (!mappable) {
+ if (s.GetType() == Zip::Stream::DEFLATE) {
+ mappable = MappableDeflate::Create(name, zip, &s);
+ }
+ }
+ }
+ }
+ /* If we couldn't load above, try with a MappableFile */
+ if (!mappable && !zip) mappable = MappableFile::Create(path);
+
+ return mappable;
+}
+
+void ElfLoader::Register(LibHandle* handle) {
+ AutoLock lock(&handlesMutex);
+ handles.push_back(handle);
+}
+
+void ElfLoader::Register(CustomElf* handle) {
+ Register(static_cast<LibHandle*>(handle));
+ if (dbg) {
+ // We could race with the system linker when modifying the debug map, so
+ // only do so while holding the system linker's internal lock.
+ RunWithSystemLinkerLock([this, handle] { dbg.Add(handle); });
+ }
+}
+
+void ElfLoader::Forget(LibHandle* handle) {
+ /* Ensure logging is initialized or refresh if environment changed. */
+ Logging::Init();
+
+ AutoLock lock(&handlesMutex);
+ LibHandleList::iterator it =
+ std::find(handles.begin(), handles.end(), handle);
+ if (it != handles.end()) {
+ DEBUG_LOG("ElfLoader::Forget(%p [\"%s\"])", reinterpret_cast<void*>(handle),
+ handle->GetPath());
+ handles.erase(it);
+ } else {
+ DEBUG_LOG("ElfLoader::Forget(%p [\"%s\"]): Handle not found",
+ reinterpret_cast<void*>(handle), handle->GetPath());
+ }
+}
+
+void ElfLoader::Forget(CustomElf* handle) {
+ Forget(static_cast<LibHandle*>(handle));
+ if (dbg) {
+ // We could race with the system linker when modifying the debug map, so
+ // only do so while holding the system linker's internal lock.
+ RunWithSystemLinkerLock([this, handle] { dbg.Remove(handle); });
+ }
+}
+
+void ElfLoader::Init() {
+ Dl_info info;
+ /* On Android < 4.1 can't reenter dl* functions. So when the library
+ * containing this code is dlopen()ed, it can't call dladdr from a
+ * static initializer. */
+ if (dladdr(_DYNAMIC, &info) != 0) {
+ self_elf = LoadedElf::Create(info.dli_fname, info.dli_fbase);
+ }
+#if defined(ANDROID)
+ // On Android < 5.0, resolving weak symbols via dlsym doesn't work.
+ // The weak symbols Gecko uses are in either libc or libm, so we
+ // wrap those such that this linker does symbol resolution for them.
+ if (GetAndroidSDKVersion() < 21) {
+ if (dladdr(FunctionPtr(syscall), &info) != 0) {
+ libc = LoadedElf::Create(info.dli_fname, info.dli_fbase);
+ }
+ if (dladdr(FunctionPtr<int (*)(double)>(isnan), &info) != 0) {
+ libm = LoadedElf::Create(info.dli_fname, info.dli_fbase);
+ }
+ }
+#endif
+}
+
+ElfLoader::~ElfLoader() {
+ LibHandleList list;
+
+ if (!Singleton.IsShutdownExpected()) {
+ MOZ_CRASH("Unexpected shutdown");
+ }
+
+ /* Release self_elf and libc */
+ self_elf = nullptr;
+#if defined(ANDROID)
+ libc = nullptr;
+ libm = nullptr;
+#endif
+
+ AutoLock lock(&handlesMutex);
+ /* Build up a list of all library handles with direct (external) references.
+ * We actually skip system library handles because we want to keep at least
+ * some of these open. Most notably, Mozilla codebase keeps a few libgnome
+ * libraries deliberately open because of the mess that libORBit destruction
+ * is. dlclose()ing these libraries actually leads to problems. */
+ for (LibHandleList::reverse_iterator it = handles.rbegin();
+ it < handles.rend(); ++it) {
+ if ((*it)->DirectRefCount()) {
+ if (SystemElf* se = (*it)->AsSystemElf()) {
+ se->Forget();
+ } else {
+ list.push_back(*it);
+ }
+ }
+ }
+ /* Force release all external references to the handles collected above */
+ for (LibHandleList::iterator it = list.begin(); it < list.end(); ++it) {
+ while ((*it)->ReleaseDirectRef()) {
+ }
+ }
+ /* Remove the remaining system handles. */
+ if (handles.size()) {
+ list = handles;
+ for (LibHandleList::reverse_iterator it = list.rbegin(); it < list.rend();
+ ++it) {
+ if ((*it)->AsSystemElf()) {
+ DEBUG_LOG(
+ "ElfLoader::~ElfLoader(): Remaining handle for \"%s\" "
+ "[%" PRIdPTR " direct refs, %" PRIdPTR " refs total]",
+ (*it)->GetPath(), (*it)->DirectRefCount(), (*it)->refCount());
+ } else {
+ DEBUG_LOG(
+ "ElfLoader::~ElfLoader(): Unexpected remaining handle for \"%s\" "
+ "[%" PRIdPTR " direct refs, %" PRIdPTR " refs total]",
+ (*it)->GetPath(), (*it)->DirectRefCount(), (*it)->refCount());
+ /* Not removing, since it could have references to other libraries,
+ * destroying them as a side effect, and possibly leaving dangling
+ * pointers in the handle list we're scanning */
+ }
+ }
+ }
+ pthread_mutex_destroy(&handlesMutex);
+}
+
+#ifdef __ARM_EABI__
+int ElfLoader::__wrap_aeabi_atexit(void* that, ElfLoader::Destructor destructor,
+ void* dso_handle) {
+ Singleton.destructors.push_back(
+ DestructorCaller(destructor, that, dso_handle));
+ return 0;
+}
+#else
+int ElfLoader::__wrap_cxa_atexit(ElfLoader::Destructor destructor, void* that,
+ void* dso_handle) {
+ Singleton.destructors.push_back(
+ DestructorCaller(destructor, that, dso_handle));
+ return 0;
+}
+#endif
+
+void ElfLoader::__wrap_cxa_finalize(void* dso_handle) {
+ /* Call all destructors for the given DSO handle in reverse order they were
+ * registered. */
+ std::vector<DestructorCaller>::reverse_iterator it;
+ for (it = Singleton.destructors.rbegin(); it < Singleton.destructors.rend();
+ ++it) {
+ if (it->IsForHandle(dso_handle)) {
+ it->Call();
+ }
+ }
+}
+
+void ElfLoader::DestructorCaller::Call() {
+ if (destructor) {
+ DEBUG_LOG("ElfLoader::DestructorCaller::Call(%p, %p, %p)",
+ FunctionPtr(destructor), object, dso_handle);
+ destructor(object);
+ destructor = nullptr;
+ }
+}
+
+ElfLoader::DebuggerHelper::DebuggerHelper()
+ : dbg(nullptr), firstAdded(nullptr) {
+ /* Find ELF auxiliary vectors.
+ *
+ * The kernel stores the following data on the stack when starting a
+ * program:
+ * argc
+ * argv[0] (pointer into argv strings defined below)
+ * argv[1] (likewise)
+ * ...
+ * argv[argc - 1] (likewise)
+ * nullptr
+ * envp[0] (pointer into environment strings defined below)
+ * envp[1] (likewise)
+ * ...
+ * envp[n] (likewise)
+ * nullptr
+ * ... (more NULLs on some platforms such as Android 4.3)
+ * auxv[0] (first ELF auxiliary vector)
+ * auxv[1] (second ELF auxiliary vector)
+ * ...
+ * auxv[p] (last ELF auxiliary vector)
+ * (AT_NULL, nullptr)
+ * padding
+ * argv strings, separated with '\0'
+ * environment strings, separated with '\0'
+ * nullptr
+ *
+ * What we are after are the auxv values defined by the following struct.
+ */
+ struct AuxVector {
+ Elf::Addr type;
+ Elf::Addr value;
+ };
+
+ /* Pointer to the environment variables list */
+ extern char** environ;
+
+ /* The environment may have changed since the program started, in which
+ * case the environ variables list isn't the list the kernel put on stack
+ * anymore. But in this new list, variables that didn't change still point
+ * to the strings the kernel put on stack. It is quite unlikely that two
+ * modified environment variables point to two consecutive strings in memory,
+ * so we assume that if two consecutive environment variables point to two
+ * consecutive strings, we found strings the kernel put on stack. */
+ char** env;
+ for (env = environ; *env; env++)
+ if (*env + strlen(*env) + 1 == env[1]) break;
+ if (!*env) return;
+
+ /* Next, we scan the stack backwards to find a pointer to one of those
+ * strings we found above, which will give us the location of the original
+ * envp list. As we are looking for pointers, we need to look at 32-bits or
+ * 64-bits aligned values, depening on the architecture. */
+ char** scan = reinterpret_cast<char**>(reinterpret_cast<uintptr_t>(*env) &
+ ~(sizeof(void*) - 1));
+ while (*env != *scan) scan--;
+
+ /* Finally, scan forward to find the last environment variable pointer and
+ * thus the first auxiliary vector. */
+ while (*scan++)
+ ;
+
+ /* Some platforms have more NULLs here, so skip them if we encounter them */
+ while (!*scan) scan++;
+
+ AuxVector* auxv = reinterpret_cast<AuxVector*>(scan);
+
+ /* The two values of interest in the auxiliary vectors are AT_PHDR and
+ * AT_PHNUM, which gives us the the location and size of the ELF program
+ * headers. */
+ Array<Elf::Phdr> phdrs;
+ char* base = nullptr;
+ while (auxv->type) {
+ if (auxv->type == AT_PHDR) {
+ phdrs.Init(reinterpret_cast<Elf::Phdr*>(auxv->value));
+ /* Assume the base address is the first byte of the same page */
+ base = reinterpret_cast<char*>(PageAlignedPtr(auxv->value));
+ }
+ if (auxv->type == AT_PHNUM) phdrs.Init(auxv->value);
+ auxv++;
+ }
+
+ if (!phdrs) {
+ DEBUG_LOG("Couldn't find program headers");
+ return;
+ }
+
+ /* In some cases, the address for the program headers we get from the
+ * auxiliary vectors is not mapped, because of the PT_LOAD segments
+ * definitions in the program executable. Trying to map anonymous memory
+ * with a hint giving the base address will return a different address
+ * if something is mapped there, and the base address otherwise. */
+ MappedPtr mem(MemoryRange::mmap(base, PageSize(), PROT_NONE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+ if (mem == base) {
+ /* If program headers aren't mapped, try to map them */
+ int fd = open("/proc/self/exe", O_RDONLY);
+ if (fd == -1) {
+ DEBUG_LOG("Failed to open /proc/self/exe");
+ return;
+ }
+ mem.Assign(
+ MemoryRange::mmap(base, PageSize(), PROT_READ, MAP_PRIVATE, fd, 0));
+ /* If we don't manage to map at the right address, just give up. */
+ if (mem != base) {
+ DEBUG_LOG("Couldn't read program headers");
+ return;
+ }
+ }
+ /* Sanity check: the first bytes at the base address should be an ELF
+ * header. */
+ if (!Elf::Ehdr::validate(base)) {
+ DEBUG_LOG("Couldn't find program base");
+ return;
+ }
+
+ /* Search for the program PT_DYNAMIC segment */
+ Array<Elf::Dyn> dyns;
+ for (Array<Elf::Phdr>::iterator phdr = phdrs.begin(); phdr < phdrs.end();
+ ++phdr) {
+ /* While the program headers are expected within the first mapped page of
+ * the program executable, the executable PT_LOADs may actually make them
+ * loaded at an address that is not the wanted base address of the
+ * library. We thus need to adjust the base address, compensating for the
+ * virtual address of the PT_LOAD segment corresponding to offset 0. */
+ if (phdr->p_type == PT_LOAD && phdr->p_offset == 0) base -= phdr->p_vaddr;
+ if (phdr->p_type == PT_DYNAMIC)
+ dyns.Init(base + phdr->p_vaddr, phdr->p_filesz);
+ }
+ if (!dyns) {
+ DEBUG_LOG("Failed to find PT_DYNAMIC section in program");
+ return;
+ }
+
+ /* Search for the DT_DEBUG information */
+ for (Array<Elf::Dyn>::iterator dyn = dyns.begin(); dyn < dyns.end(); ++dyn) {
+ if (dyn->d_tag == DT_DEBUG) {
+ dbg = reinterpret_cast<r_debug*>(dyn->d_un.d_ptr);
+ break;
+ }
+ }
+ DEBUG_LOG("DT_DEBUG points at %p", static_cast<void*>(dbg));
+}
+
+/**
+ * Helper class to ensure the given pointer is writable within the scope of
+ * an instance. Permissions to the memory page where the pointer lies are
+ * restored to their original value when the instance is destroyed.
+ */
+class EnsureWritable {
+ public:
+ template <typename T>
+ explicit EnsureWritable(T* ptr, size_t length_ = sizeof(T)) {
+ MOZ_ASSERT(length_ < PageSize());
+ prot = -1;
+ page = MAP_FAILED;
+
+ char* firstPage = PageAlignedPtr(reinterpret_cast<char*>(ptr));
+ char* lastPageEnd =
+ PageAlignedEndPtr(reinterpret_cast<char*>(ptr) + length_);
+ length = lastPageEnd - firstPage;
+ uintptr_t start = reinterpret_cast<uintptr_t>(firstPage);
+ uintptr_t end;
+
+ prot = getProt(start, &end);
+ if (prot == -1 || (start + length) > end) MOZ_CRASH();
+
+ if (prot & PROT_WRITE) {
+ success = true;
+ return;
+ }
+
+ page = firstPage;
+ int ret = mprotect(page, length, prot | PROT_WRITE);
+ success = ret == 0;
+ if (!success) {
+ ERROR("mprotect(%p, %zu, %d) = %d (errno=%d; %s)", page, length,
+ prot | PROT_WRITE, ret, errno, strerror(errno));
+ }
+ }
+
+ bool IsWritable() const { return success; }
+
+ ~EnsureWritable() {
+ if (success && page != MAP_FAILED) {
+ mprotect(page, length, prot);
+ }
+ }
+
+ private:
+ int getProt(uintptr_t addr, uintptr_t* end) {
+ /* The interesting part of the /proc/self/maps format looks like:
+ * startAddr-endAddr rwxp */
+ int result = 0;
+ AutoCloseFILE f(fopen("/proc/self/maps", "r"));
+ while (f) {
+ unsigned long long startAddr, endAddr;
+ char perms[5];
+ if (fscanf(f, "%llx-%llx %4s %*1024[^\n] ", &startAddr, &endAddr,
+ perms) != 3)
+ return -1;
+ if (addr < startAddr || addr >= endAddr) continue;
+ if (perms[0] == 'r')
+ result |= PROT_READ;
+ else if (perms[0] != '-')
+ return -1;
+ if (perms[1] == 'w')
+ result |= PROT_WRITE;
+ else if (perms[1] != '-')
+ return -1;
+ if (perms[2] == 'x')
+ result |= PROT_EXEC;
+ else if (perms[2] != '-')
+ return -1;
+ *end = endAddr;
+ return result;
+ }
+ return -1;
+ }
+
+ int prot;
+ void* page;
+ size_t length;
+ bool success;
+};
+
+/**
+ * The system linker maintains a doubly linked list of library it loads
+ * for use by the debugger. Unfortunately, it also uses the list pointers
+ * in a lot of operations and adding our data in the list is likely to
+ * trigger crashes when the linker tries to use data we don't provide or
+ * that fall off the amount data we allocated. Fortunately, the linker only
+ * traverses the list forward and accesses the head of the list from a
+ * private pointer instead of using the value in the r_debug structure.
+ * This means we can safely add members at the beginning of the list.
+ * Unfortunately, gdb checks the coherency of l_prev values, so we have
+ * to adjust the l_prev value for the first element the system linker
+ * knows about. Fortunately, it doesn't use l_prev, and the first element
+ * is not ever going to be released before our elements, since it is the
+ * program executable, so the system linker should not be changing
+ * r_debug::r_map.
+ */
+void ElfLoader::DebuggerHelper::Add(ElfLoader::link_map* map) {
+ if (!dbg->r_brk) return;
+
+ dbg->r_state = r_debug::RT_ADD;
+ dbg->r_brk();
+
+ if (!firstAdded) {
+ /* When adding a library for the first time, r_map points to data
+ * handled by the system linker, and that data may be read-only */
+ EnsureWritable w(&dbg->r_map->l_prev);
+ if (!w.IsWritable()) {
+ dbg->r_state = r_debug::RT_CONSISTENT;
+ dbg->r_brk();
+ return;
+ }
+
+ firstAdded = map;
+ dbg->r_map->l_prev = map;
+ } else
+ dbg->r_map->l_prev = map;
+
+ map->l_prev = nullptr;
+ map->l_next = dbg->r_map;
+
+ dbg->r_map = map;
+ dbg->r_state = r_debug::RT_CONSISTENT;
+ dbg->r_brk();
+}
+
+void ElfLoader::DebuggerHelper::Remove(ElfLoader::link_map* map) {
+ if (!dbg->r_brk) return;
+
+ dbg->r_state = r_debug::RT_DELETE;
+ dbg->r_brk();
+
+ if (map == firstAdded) {
+ /* When removing the first added library, its l_next is going to be
+ * data handled by the system linker, and that data may be read-only */
+ EnsureWritable w(&map->l_next->l_prev);
+ if (!w.IsWritable()) {
+ dbg->r_state = r_debug::RT_CONSISTENT;
+ dbg->r_brk();
+ return;
+ }
+
+ firstAdded = map->l_prev;
+ map->l_next->l_prev = map->l_prev;
+ } else if (map->l_next) {
+ map->l_next->l_prev = map->l_prev;
+ }
+
+ if (dbg->r_map == map)
+ dbg->r_map = map->l_next;
+ else if (map->l_prev) {
+ map->l_prev->l_next = map->l_next;
+ }
+ dbg->r_state = r_debug::RT_CONSISTENT;
+ dbg->r_brk();
+}
+
+#if defined(ANDROID) && defined(__NR_sigaction)
+/* As some system libraries may be calling signal() or sigaction() to
+ * set a SIGSEGV handler, effectively breaking MappableSeekableZStream,
+ * or worse, restore our SIGSEGV handler with wrong flags (which using
+ * signal() will do), we want to hook into the system's sigaction() to
+ * replace it with our own wrapper instead, so that our handler is never
+ * replaced. We used to only do that with libraries this linker loads,
+ * but it turns out at least one system library does call signal() and
+ * breaks us (libsc-a3xx.so on the Samsung Galaxy S4).
+ * As libc's signal (bsd_signal/sysv_signal, really) calls sigaction
+ * under the hood, instead of calling the signal system call directly,
+ * we only need to hook sigaction. This is true for both bionic and
+ * glibc.
+ */
+
+/* libc's sigaction */
+extern "C" int sigaction(int signum, const struct sigaction* act,
+ struct sigaction* oldact);
+
+/* Simple reimplementation of sigaction. This is roughly equivalent
+ * to the assembly that comes in bionic, but not quite equivalent to
+ * glibc's implementation, so we only use this on Android. */
+int sys_sigaction(int signum, const struct sigaction* act,
+ struct sigaction* oldact) {
+ return syscall(__NR_sigaction, signum, act, oldact);
+}
+
+/* Replace the first instructions of the given function with a jump
+ * to the given new function. */
+template <typename T>
+static bool Divert(T func, T new_func) {
+ void* ptr = FunctionPtr(func);
+ uintptr_t addr = reinterpret_cast<uintptr_t>(ptr);
+
+# if defined(__i386__)
+ // A 32-bit jump is a 5 bytes instruction.
+ EnsureWritable w(ptr, 5);
+ *reinterpret_cast<unsigned char*>(addr) = 0xe9; // jmp
+ *reinterpret_cast<intptr_t*>(addr + 1) =
+ reinterpret_cast<uintptr_t>(new_func) - addr - 5; // target displacement
+ return true;
+# elif defined(__arm__) || defined(__aarch64__)
+ const unsigned char trampoline[] = {
+# ifdef __arm__
+ // .thumb
+ 0x46, 0x04, // nop
+ 0x78, 0x47, // bx pc
+ 0x46, 0x04, // nop
+ // .arm
+ 0x04, 0xf0, 0x1f, 0xe5, // ldr pc, [pc, #-4]
+ // .word <new_func>
+# else // __aarch64__
+ 0x50, 0x00,
+ 0x00, 0x58, // ldr x16, [pc, #8] ; x16 (aka ip0) is the first
+ 0x00, 0x02,
+ 0x1f, 0xd6, // br x16 ; intra-procedure-call
+ // .word <new_func.lo> ; scratch register.
+ // .word <new_func.hi>
+# endif
+ };
+ const unsigned char* start;
+# ifdef __arm__
+ if (addr & 0x01) {
+ /* Function is thumb, the actual address of the code is without the
+ * least significant bit. */
+ addr--;
+ /* The arm part of the trampoline needs to be 32-bit aligned */
+ if (addr & 0x02)
+ start = trampoline;
+ else
+ start = trampoline + 2;
+ } else {
+ /* Function is arm, we only need the arm part of the trampoline */
+ start = trampoline + 6;
+ }
+# else // __aarch64__
+ start = trampoline;
+# endif
+
+ size_t len = sizeof(trampoline) - (start - trampoline);
+ EnsureWritable w(reinterpret_cast<void*>(addr), len + sizeof(void*));
+ memcpy(reinterpret_cast<void*>(addr), start, len);
+ *reinterpret_cast<void**>(addr + len) = FunctionPtr(new_func);
+ __builtin___clear_cache(reinterpret_cast<char*>(addr),
+ reinterpret_cast<char*>(addr + len + sizeof(void*)));
+ return true;
+# else
+ return false;
+# endif
+}
+#else
+# define sys_sigaction sigaction
+template <typename T>
+static bool Divert(T func, T new_func) {
+ return false;
+}
+#endif
+
+namespace {
+
+/* Clock that only accounts for time spent in the current process. */
+static uint64_t ProcessTimeStamp_Now() {
+ struct timespec ts;
+ int rv = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
+
+ if (rv != 0) {
+ return 0;
+ }
+
+ uint64_t baseNs = (uint64_t)ts.tv_sec * 1000000000;
+ return baseNs + (uint64_t)ts.tv_nsec;
+}
+
+} // namespace
+
+/* Data structure used to pass data to the temporary signal handler,
+ * as well as triggering a test crash. */
+struct TmpData {
+ volatile int crash_int;
+ volatile uint64_t crash_timestamp;
+};
+
+SEGVHandler::SEGVHandler()
+ : initialized(false),
+ registeredHandler(false),
+ signalHandlingBroken(true),
+ signalHandlingSlow(true) {
+ /* Ensure logging is initialized before the DEBUG_LOG in the test_handler.
+ * As this constructor runs before the ElfLoader constructor (by effect
+ * of ElfLoader inheriting from this class), this also initializes on behalf
+ * of ElfLoader and DebuggerHelper. */
+ Logging::Init();
+
+ /* Initialize oldStack.ss_flags to an invalid value when used to set
+ * an alternative stack, meaning we haven't got information about the
+ * original alternative stack and thus don't mean to restore it in
+ * the destructor. */
+ oldStack.ss_flags = SS_ONSTACK;
+
+ /* Get the current segfault signal handler. */
+ struct sigaction old_action;
+ sys_sigaction(SIGSEGV, nullptr, &old_action);
+
+ /* Some devices don't provide useful information to their SIGSEGV handlers,
+ * making it impossible for on-demand decompression to work. To check if
+ * we're on such a device, setup a temporary handler and deliberately
+ * trigger a segfault. The handler will set signalHandlingBroken if the
+ * provided information is bogus.
+ * Some other devices have a kernel option enabled that makes SIGSEGV handler
+ * have an overhead so high that it affects how on-demand decompression
+ * performs. The handler will also set signalHandlingSlow if the triggered
+ * SIGSEGV took too much time. */
+ struct sigaction action;
+ action.sa_sigaction = &SEGVHandler::test_handler;
+ sigemptyset(&action.sa_mask);
+ action.sa_flags = SA_SIGINFO | SA_NODEFER;
+ action.sa_restorer = nullptr;
+ stackPtr.Assign(MemoryRange::mmap(nullptr, PageSize(), PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+ if (stackPtr.get() == MAP_FAILED) return;
+ if (sys_sigaction(SIGSEGV, &action, nullptr)) return;
+
+ TmpData* data = reinterpret_cast<TmpData*>(stackPtr.get());
+ data->crash_timestamp = ProcessTimeStamp_Now();
+ mprotect(stackPtr, stackPtr.GetLength(), PROT_NONE);
+ data->crash_int = 123;
+ /* Restore the original segfault signal handler. */
+ sys_sigaction(SIGSEGV, &old_action, nullptr);
+ stackPtr.Assign(MAP_FAILED, 0);
+}
+
+void SEGVHandler::FinishInitialization() {
+ /* Ideally, we'd need some locking here, but in practice, we're not
+ * going to race with another thread. */
+ initialized = true;
+
+ if (signalHandlingBroken || signalHandlingSlow) return;
+
+ typedef int (*sigaction_func)(int, const struct sigaction*,
+ struct sigaction*);
+
+ sigaction_func libc_sigaction;
+
+#if defined(ANDROID)
+ /* Android > 4.4 comes with a sigaction wrapper in a LD_PRELOADed library
+ * (libsigchain) for ART. That wrapper kind of does the same trick as we
+ * do, so we need extra care in handling it.
+ * - Divert the libc's sigaction, assuming the LD_PRELOADed library uses
+ * it under the hood (which is more or less true according to the source
+ * of that library, since it's doing a lookup in RTLD_NEXT)
+ * - With the LD_PRELOADed library in place, all calls to sigaction from
+ * from system libraries will go to the LD_PRELOADed library.
+ * - The LD_PRELOADed library calls to sigaction go to our __wrap_sigaction.
+ * - The calls to sigaction from libraries faulty.lib loads are sent to
+ * the LD_PRELOADed library.
+ * In practice, for signal handling, this means:
+ * - The signal handler registered to the kernel is ours.
+ * - Our handler redispatches to the LD_PRELOADed library's if there's a
+ * segfault we don't handle.
+ * - The LD_PRELOADed library redispatches according to whatever system
+ * library or faulty.lib-loaded library set with sigaction.
+ *
+ * When there is no sigaction wrapper in place:
+ * - Divert the libc's sigaction.
+ * - Calls to sigaction from system library and faulty.lib-loaded libraries
+ * all go to the libc's sigaction, which end up in our __wrap_sigaction.
+ * - The signal handler registered to the kernel is ours.
+ * - Our handler redispatches according to whatever system library or
+ * faulty.lib-loaded library set with sigaction.
+ */
+ void* libc = dlopen("libc.so", RTLD_GLOBAL | RTLD_LAZY);
+ if (libc) {
+ /*
+ * Lollipop bionic only has a small trampoline in sigaction, with the real
+ * work happening in __sigaction. Divert there instead of sigaction if it
+ * exists. Bug 1154803
+ */
+ libc_sigaction =
+ reinterpret_cast<sigaction_func>(dlsym(libc, "__sigaction"));
+
+ if (!libc_sigaction) {
+ libc_sigaction =
+ reinterpret_cast<sigaction_func>(dlsym(libc, "sigaction"));
+ }
+ } else
+#endif
+ {
+ libc_sigaction = sigaction;
+ }
+
+ if (!Divert(libc_sigaction, __wrap_sigaction)) return;
+
+ /* Setup an alternative stack if the already existing one is not big
+ * enough, or if there is none. */
+ if (sigaltstack(nullptr, &oldStack) == 0) {
+ if (oldStack.ss_flags == SS_ONSTACK) oldStack.ss_flags = 0;
+ if (!oldStack.ss_sp || oldStack.ss_size < stackSize) {
+ stackPtr.Assign(MemoryRange::mmap(nullptr, stackSize,
+ PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+ if (stackPtr.get() == MAP_FAILED) return;
+ stack_t stack;
+ stack.ss_sp = stackPtr;
+ stack.ss_size = stackSize;
+ stack.ss_flags = 0;
+ if (sigaltstack(&stack, nullptr) != 0) return;
+ }
+ }
+ /* Register our own handler, and store the already registered one in
+ * SEGVHandler's struct sigaction member */
+ action.sa_sigaction = &SEGVHandler::handler;
+ action.sa_flags = SA_SIGINFO | SA_NODEFER | SA_ONSTACK;
+ registeredHandler = !sys_sigaction(SIGSEGV, &action, &this->action);
+}
+
+SEGVHandler::~SEGVHandler() {
+ /* Restore alternative stack for signals */
+ if (oldStack.ss_flags != SS_ONSTACK) sigaltstack(&oldStack, nullptr);
+ /* Restore original signal handler */
+ if (registeredHandler) sys_sigaction(SIGSEGV, &this->action, nullptr);
+}
+
+/* Test handler for a deliberately triggered SIGSEGV that determines whether
+ * useful information is provided to signal handlers, particularly whether
+ * si_addr is filled in properly, and whether the segfault handler is called
+ * quickly enough. */
+void SEGVHandler::test_handler(int signum, siginfo_t* info, void* context) {
+ SEGVHandler& that = ElfLoader::Singleton;
+ if (signum == SIGSEGV && info && info->si_addr == that.stackPtr.get())
+ that.signalHandlingBroken = false;
+ mprotect(that.stackPtr, that.stackPtr.GetLength(), PROT_READ | PROT_WRITE);
+ TmpData* data = reinterpret_cast<TmpData*>(that.stackPtr.get());
+ uint64_t latency = ProcessTimeStamp_Now() - data->crash_timestamp;
+ DEBUG_LOG("SEGVHandler latency: %" PRIu64, latency);
+ /* See bug 886736 for timings on different devices, 150 µs is reasonably above
+ * the latency on "working" devices and seems to be short enough to not incur
+ * a huge overhead to on-demand decompression. */
+ if (latency <= 150000) that.signalHandlingSlow = false;
+}
+
+/* TODO: "properly" handle signal masks and flags */
+void SEGVHandler::handler(int signum, siginfo_t* info, void* context) {
+ // ASSERT(signum == SIGSEGV);
+ DEBUG_LOG("Caught segmentation fault @%p", info->si_addr);
+
+ /* Redispatch to the registered handler */
+ SEGVHandler& that = ElfLoader::Singleton;
+ if (that.action.sa_flags & SA_SIGINFO) {
+ DEBUG_LOG("Redispatching to registered handler @%p",
+ FunctionPtr(that.action.sa_sigaction));
+ that.action.sa_sigaction(signum, info, context);
+ } else if (that.action.sa_handler == SIG_DFL) {
+ DEBUG_LOG("Redispatching to default handler");
+ /* Reset the handler to the default one, and trigger it. */
+ sys_sigaction(signum, &that.action, nullptr);
+ raise(signum);
+ } else if (that.action.sa_handler != SIG_IGN) {
+ DEBUG_LOG("Redispatching to registered handler @%p",
+ FunctionPtr(that.action.sa_handler));
+ that.action.sa_handler(signum);
+ } else {
+ DEBUG_LOG("Ignoring");
+ }
+}
+
+int SEGVHandler::__wrap_sigaction(int signum, const struct sigaction* act,
+ struct sigaction* oldact) {
+ SEGVHandler& that = ElfLoader::Singleton;
+
+ /* Use system sigaction() function for all but SIGSEGV signals. */
+ if (!that.registeredHandler || (signum != SIGSEGV))
+ return sys_sigaction(signum, act, oldact);
+
+ if (oldact) *oldact = that.action;
+ if (act) that.action = *act;
+ return 0;
+}
diff --git a/mozglue/linker/ElfLoader.h b/mozglue/linker/ElfLoader.h
new file mode 100644
index 0000000000..059c092f6d
--- /dev/null
+++ b/mozglue/linker/ElfLoader.h
@@ -0,0 +1,634 @@
+/* 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 ElfLoader_h
+#define ElfLoader_h
+
+#include <vector>
+#include <dlfcn.h>
+#include <signal.h>
+#include "mozilla/Atomics.h"
+#include "mozilla/RefCounted.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "Zip.h"
+#include "Elfxx.h"
+#include "Mappable.h"
+
+/**
+ * dlfcn.h replacement functions
+ */
+extern "C" {
+void* __wrap_dlopen(const char* path, int flags);
+const char* __wrap_dlerror(void);
+void* __wrap_dlsym(void* handle, const char* symbol);
+int __wrap_dlclose(void* handle);
+
+#ifndef HAVE_DLADDR
+typedef struct {
+ const char* dli_fname;
+ void* dli_fbase;
+ const char* dli_sname;
+ void* dli_saddr;
+} Dl_info;
+#endif
+int __wrap_dladdr(const void* addr, Dl_info* info);
+
+struct dl_phdr_info {
+ Elf::Addr dlpi_addr;
+ const char* dlpi_name;
+ const Elf::Phdr* dlpi_phdr;
+ Elf::Half dlpi_phnum;
+};
+
+typedef int (*dl_phdr_cb)(struct dl_phdr_info*, size_t, void*);
+int __wrap_dl_iterate_phdr(dl_phdr_cb callback, void* data);
+
+#ifdef __ARM_EABI__
+const void* __wrap___gnu_Unwind_Find_exidx(void* pc, int* pcount);
+#endif
+
+/**
+ * faulty.lib public API
+ */
+MFBT_API size_t __dl_get_mappable_length(void* handle);
+
+MFBT_API void* __dl_mmap(void* handle, void* addr, size_t length, off_t offset);
+
+MFBT_API void __dl_munmap(void* handle, void* addr, size_t length);
+
+MFBT_API bool IsSignalHandlingBroken();
+}
+
+/* Forward declarations for use in LibHandle */
+class BaseElf;
+class CustomElf;
+class SystemElf;
+
+/**
+ * Specialize RefCounted template for LibHandle. We may get references to
+ * LibHandles during the execution of their destructor, so we need
+ * RefCounted<LibHandle>::Release to support some reentrancy. See further
+ * below.
+ */
+class LibHandle;
+
+namespace mozilla {
+namespace detail {
+
+template <>
+inline void RefCounted<LibHandle, AtomicRefCount>::Release() const;
+
+#ifdef DEBUG
+template <>
+inline RefCounted<LibHandle, AtomicRefCount>::~RefCounted() {
+ MOZ_ASSERT(mRefCnt == 0x7fffdead);
+}
+#endif
+
+} /* namespace detail */
+} /* namespace mozilla */
+
+/**
+ * Abstract class for loaded libraries. Libraries may be loaded through the
+ * system linker or this linker, both cases will be derived from this class.
+ */
+class LibHandle : public mozilla::external::AtomicRefCounted<LibHandle> {
+ public:
+ MOZ_DECLARE_REFCOUNTED_TYPENAME(LibHandle)
+ /**
+ * Constructor. Takes the path of the loaded library and will store a copy
+ * of the leaf name.
+ */
+ LibHandle(const char* path)
+ : directRefCnt(0),
+ path(path ? strdup(path) : nullptr),
+ mappable(nullptr) {}
+
+ /**
+ * Destructor.
+ */
+ virtual ~LibHandle();
+
+ /**
+ * Returns the pointer to the address to which the given symbol resolves
+ * inside the library. It is not supposed to resolve the symbol in other
+ * libraries, although in practice, it will for system libraries.
+ */
+ virtual void* GetSymbolPtr(const char* symbol) const = 0;
+
+ /**
+ * Returns whether the given address is part of the virtual address space
+ * covered by the loaded library.
+ */
+ virtual bool Contains(void* addr) const = 0;
+
+ /**
+ * Returns the base address of the loaded library.
+ */
+ virtual void* GetBase() const = 0;
+
+ /**
+ * Returns the file name of the library without the containing directory.
+ */
+ const char* GetName() const;
+
+ /**
+ * Returns the full path of the library, when available. Otherwise, returns
+ * the file name.
+ */
+ const char* GetPath() const { return path; }
+
+ /**
+ * Library handles can be referenced from other library handles or
+ * externally (when dlopen()ing using this linker). We need to be
+ * able to distinguish between the two kind of referencing for better
+ * bookkeeping.
+ */
+ void AddDirectRef() {
+ mozilla::external::AtomicRefCounted<LibHandle>::AddRef();
+ ++directRefCnt;
+ }
+
+ /**
+ * Releases a direct reference, and returns whether there are any direct
+ * references left.
+ */
+ bool ReleaseDirectRef() {
+ const MozRefCountType count = --directRefCnt;
+ MOZ_ASSERT(count + 1 > 0);
+ MOZ_ASSERT(count + 1 <=
+ mozilla::external::AtomicRefCounted<LibHandle>::refCount());
+ mozilla::external::AtomicRefCounted<LibHandle>::Release();
+ return !!count;
+ }
+
+ /**
+ * Returns the number of direct references
+ */
+ MozRefCountType DirectRefCount() { return directRefCnt; }
+
+ /**
+ * Returns the complete size of the file or stream behind the library
+ * handle.
+ */
+ size_t GetMappableLength() const;
+
+ /**
+ * Returns a memory mapping of the file or stream behind the library
+ * handle.
+ */
+ void* MappableMMap(void* addr, size_t length, off_t offset) const;
+
+ /**
+ * Unmaps a memory mapping of the file or stream behind the library
+ * handle.
+ */
+ void MappableMUnmap(void* addr, size_t length) const;
+
+#ifdef __ARM_EABI__
+ /**
+ * Find the address and entry count of the ARM.exidx section
+ * associated with the library
+ */
+ virtual const void* FindExidx(int* pcount) const = 0;
+#endif
+
+ protected:
+ /**
+ * Returns a mappable object for use by MappableMMap and related functions.
+ */
+ virtual Mappable* GetMappable() const = 0;
+
+ /**
+ * Returns the instance, casted as the wanted type. Returns nullptr if
+ * that's not the actual type. (short of a better way to do this without
+ * RTTI)
+ */
+ friend class ElfLoader;
+ friend class CustomElf;
+ friend class SEGVHandler;
+ friend int __wrap_dl_iterate_phdr(dl_phdr_cb callback, void* data);
+ virtual BaseElf* AsBaseElf() { return nullptr; }
+ virtual SystemElf* AsSystemElf() { return nullptr; }
+
+ private:
+ mozilla::Atomic<MozRefCountType> directRefCnt;
+ char* path;
+
+ /* Mappable object keeping the result of GetMappable() */
+ mutable RefPtr<Mappable> mappable;
+};
+
+/**
+ * Specialized RefCounted<LibHandle>::Release. Under normal operation, when
+ * mRefCnt reaches 0, the LibHandle is deleted. Its mRefCnt is however
+ * increased to 1 on normal builds, and 0x7fffdead on debug builds so that the
+ * LibHandle can still be referenced while the destructor is executing. The
+ * mRefCnt is allowed to grow > 0x7fffdead, but not to decrease under that
+ * value, which would mean too many Releases from within the destructor.
+ */
+namespace mozilla {
+namespace detail {
+
+template <>
+inline void RefCounted<LibHandle, AtomicRefCount>::Release() const {
+#ifdef DEBUG
+ if (mRefCnt > 0x7fff0000) MOZ_ASSERT(mRefCnt > 0x7fffdead);
+#endif
+ MOZ_ASSERT(mRefCnt > 0);
+ if (mRefCnt > 0) {
+ if (0 == --mRefCnt) {
+#ifdef DEBUG
+ mRefCnt = 0x7fffdead;
+#else
+ ++mRefCnt;
+#endif
+ delete static_cast<const LibHandle*>(this);
+ }
+ }
+}
+
+} /* namespace detail */
+} /* namespace mozilla */
+
+/**
+ * Class handling libraries loaded by the system linker
+ */
+class SystemElf : public LibHandle {
+ public:
+ /**
+ * Returns a new SystemElf for the given path. The given flags are passed
+ * to dlopen().
+ */
+ static already_AddRefed<LibHandle> Load(const char* path, int flags);
+
+ /**
+ * Inherited from LibHandle
+ */
+ virtual ~SystemElf();
+ virtual void* GetSymbolPtr(const char* symbol) const;
+ virtual bool Contains(void* addr) const { return false; /* UNIMPLEMENTED */ }
+ virtual void* GetBase() const { return nullptr; /* UNIMPLEMENTED */ }
+
+#ifdef __ARM_EABI__
+ virtual const void* FindExidx(int* pcount) const;
+#endif
+
+ protected:
+ virtual Mappable* GetMappable() const;
+
+ /**
+ * Returns the instance, casted as SystemElf. (short of a better way to do
+ * this without RTTI)
+ */
+ friend class ElfLoader;
+ virtual SystemElf* AsSystemElf() { return this; }
+
+ /**
+ * Remove the reference to the system linker handle. This avoids dlclose()
+ * being called when the instance is destroyed.
+ */
+ void Forget() { dlhandle = nullptr; }
+
+ private:
+ /**
+ * Private constructor
+ */
+ SystemElf(const char* path, void* handle)
+ : LibHandle(path), dlhandle(handle) {}
+
+ /* Handle as returned by system dlopen() */
+ void* dlhandle;
+};
+
+/**
+ * The ElfLoader registers its own SIGSEGV handler to handle segmentation
+ * faults within the address space of the loaded libraries. It however
+ * allows a handler to be set for faults in other places, and redispatches
+ * to the handler set through signal() or sigaction().
+ */
+class SEGVHandler {
+ public:
+ bool hasRegisteredHandler() {
+ if (!initialized) FinishInitialization();
+ return registeredHandler;
+ }
+
+ bool isSignalHandlingBroken() { return signalHandlingBroken; }
+
+ static int __wrap_sigaction(int signum, const struct sigaction* act,
+ struct sigaction* oldact);
+
+ protected:
+ SEGVHandler();
+ ~SEGVHandler();
+
+ private:
+ /**
+ * The constructor doesn't do all initialization, and the tail is done
+ * at a later time.
+ */
+ void FinishInitialization();
+
+ /**
+ * SIGSEGV handler registered with __wrap_signal or __wrap_sigaction.
+ */
+ struct sigaction action;
+
+ /**
+ * ElfLoader SIGSEGV handler.
+ */
+ static void handler(int signum, siginfo_t* info, void* context);
+
+ /**
+ * Temporary test handler.
+ */
+ static void test_handler(int signum, siginfo_t* info, void* context);
+
+ /**
+ * Size of the alternative stack. The printf family requires more than 8KB
+ * of stack, and our signal handler may print a few things.
+ */
+ static const size_t stackSize = 12 * 1024;
+
+ /**
+ * Alternative stack information used before initialization.
+ */
+ stack_t oldStack;
+
+ /**
+ * Pointer to an alternative stack for signals. Only set if oldStack is
+ * not set or not big enough.
+ */
+ MappedPtr stackPtr;
+
+ bool initialized;
+ bool registeredHandler;
+ bool signalHandlingBroken;
+ bool signalHandlingSlow;
+};
+
+/**
+ * Elf Loader class in charge of loading and bookkeeping libraries.
+ */
+class ElfLoader : public SEGVHandler {
+ public:
+ /**
+ * The Elf Loader instance
+ */
+ static ElfLoader Singleton;
+
+ /**
+ * Loads the given library with the given flags. Equivalent to dlopen()
+ * The extra "parent" argument optionally gives the handle of the library
+ * requesting the given library to be loaded. The loader may look in the
+ * directory containing that parent library for the library to load.
+ */
+ already_AddRefed<LibHandle> Load(const char* path, int flags,
+ LibHandle* parent = nullptr);
+
+ /**
+ * Returns the handle of the library containing the given address in
+ * its virtual address space, i.e. the library handle for which
+ * LibHandle::Contains returns true. Its purpose is to allow to
+ * implement dladdr().
+ */
+ already_AddRefed<LibHandle> GetHandleByPtr(void* addr);
+
+ /**
+ * Returns a Mappable object for the path. Paths in the form
+ * /foo/bar/baz/archive!/directory/lib.so
+ * try to load the directory/lib.so in /foo/bar/baz/archive, provided
+ * that file is a Zip archive.
+ */
+ static Mappable* GetMappableFromPath(const char* path);
+
+ void ExpectShutdown(bool val) { expect_shutdown = val; }
+ bool IsShutdownExpected() { return expect_shutdown; }
+
+ private:
+ bool expect_shutdown;
+
+ protected:
+ /**
+ * Registers the given handle. This method is meant to be called by
+ * LibHandle subclass creators.
+ */
+ void Register(LibHandle* handle);
+ void Register(CustomElf* handle);
+
+ /**
+ * Forget about the given handle. This method is meant to be called by
+ * LibHandle subclass destructors.
+ */
+ void Forget(LibHandle* handle);
+ void Forget(CustomElf* handle);
+
+ friend class SystemElf;
+ friend const char* __wrap_dlerror(void);
+ friend void* __wrap_dlsym(void* handle, const char* symbol);
+ friend int __wrap_dlclose(void* handle);
+ /* __wrap_dlerror() returns this custom last error if non-null or the system
+ * dlerror() value if this is null. Must refer to a string constant. */
+ mozilla::Atomic<const char*, mozilla::Relaxed> lastError;
+
+ private:
+ ElfLoader() : expect_shutdown(true), lastError(nullptr) {
+ pthread_mutex_init(&handlesMutex, nullptr);
+ }
+
+ ~ElfLoader();
+
+ /* Initialization code that can't run during static initialization. */
+ void Init();
+
+ /* System loader handle for the library/program containing our code. This
+ * is used to resolve wrapped functions. */
+ RefPtr<LibHandle> self_elf;
+
+#if defined(ANDROID)
+ /* System loader handle for the libc. This is used to resolve weak symbols
+ * that some libcs contain that the Android linker won't dlsym(). Normally,
+ * we wouldn't treat non-Android differently, but glibc uses versioned
+ * symbols which this linker doesn't support. */
+ RefPtr<LibHandle> libc;
+
+ /* And for libm. */
+ RefPtr<LibHandle> libm;
+#endif
+
+ /* Bookkeeping */
+ typedef std::vector<LibHandle*> LibHandleList;
+ LibHandleList handles;
+
+ pthread_mutex_t handlesMutex;
+
+ protected:
+ friend class CustomElf;
+ friend class LoadedElf;
+
+ /* Definition of static destructors as to be used for C++ ABI compatibility */
+ typedef void (*Destructor)(void* object);
+
+ /**
+ * C++ ABI makes static initializers register destructors through a specific
+ * atexit interface. On glibc/linux systems, the dso_handle is a pointer
+ * within a given library. On bionic/android systems, it is an undefined
+ * symbol. Making sense of the value is not really important, and all that
+ * is really important is that it is different for each loaded library, so
+ * that they can be discriminated when shutting down. For convenience, on
+ * systems where the dso handle is a symbol, that symbol is resolved to
+ * point at corresponding CustomElf.
+ *
+ * Destructors are registered with __*_atexit with an associated object to
+ * be passed as argument when it is called.
+ *
+ * When __cxa_finalize is called, destructors registered for the given
+ * DSO handle are called in the reverse order they were registered.
+ */
+#ifdef __ARM_EABI__
+ static int __wrap_aeabi_atexit(void* that, Destructor destructor,
+ void* dso_handle);
+#else
+ static int __wrap_cxa_atexit(Destructor destructor, void* that,
+ void* dso_handle);
+#endif
+
+ static void __wrap_cxa_finalize(void* dso_handle);
+
+ /**
+ * Registered destructor. Keeps track of the destructor function pointer,
+ * associated object to call it with, and DSO handle.
+ */
+ class DestructorCaller {
+ public:
+ DestructorCaller(Destructor destructor, void* object, void* dso_handle)
+ : destructor(destructor), object(object), dso_handle(dso_handle) {}
+
+ /**
+ * Call the destructor function with the associated object.
+ * Call only once, see CustomElf::~CustomElf.
+ */
+ void Call();
+
+ /**
+ * Returns whether the destructor is associated to the given DSO handle
+ */
+ bool IsForHandle(void* handle) const { return handle == dso_handle; }
+
+ private:
+ Destructor destructor;
+ void* object;
+ void* dso_handle;
+ };
+
+ private:
+ /* Keep track of all registered destructors */
+ std::vector<DestructorCaller> destructors;
+
+ /* Forward declaration, see further below */
+ class DebuggerHelper;
+
+ public:
+ /* Loaded object descriptor for the debugger interface below*/
+ struct link_map {
+ /* Base address of the loaded object. */
+ const void* l_addr;
+ /* File name */
+ const char* l_name;
+ /* Address of the PT_DYNAMIC segment. */
+ const void* l_ld;
+
+ private:
+ friend class ElfLoader::DebuggerHelper;
+ /* Double linked list of loaded objects. */
+ link_map *l_next, *l_prev;
+ };
+
+ private:
+ /* Data structure used by the linker to give details about shared objects it
+ * loaded to debuggers. This is normally defined in link.h, but Android
+ * headers lack this file. */
+ struct r_debug {
+ /* Version number of the protocol. */
+ int r_version;
+
+ /* Head of the linked list of loaded objects. */
+ link_map* r_map;
+
+ /* Function to be called when updates to the linked list of loaded objects
+ * are going to occur. The function is to be called before and after
+ * changes. */
+ void (*r_brk)(void);
+
+ /* Indicates to the debugger what state the linked list of loaded objects
+ * is in when the function above is called. */
+ enum {
+ RT_CONSISTENT, /* Changes are complete */
+ RT_ADD, /* Beginning to add a new object */
+ RT_DELETE /* Beginning to remove an object */
+ } r_state;
+ };
+
+ /* Memory representation of ELF Auxiliary Vectors */
+ struct AuxVector {
+ Elf::Addr type;
+ Elf::Addr value;
+ };
+
+ /* Helper class used to integrate libraries loaded by this linker in
+ * r_debug */
+ class DebuggerHelper {
+ public:
+ DebuggerHelper();
+
+ void Init(AuxVector* auvx);
+
+ explicit operator bool() { return dbg; }
+
+ /* Make the debugger aware of a new loaded object */
+ void Add(link_map* map);
+
+ /* Make the debugger aware of the unloading of an object */
+ void Remove(link_map* map);
+
+ /* Iterates over all link_maps */
+ class iterator {
+ public:
+ const link_map* operator->() const { return item; }
+
+ const link_map& operator++() {
+ item = item->l_next;
+ return *item;
+ }
+
+ bool operator<(const iterator& other) const {
+ if (other.item == nullptr) return item ? true : false;
+ MOZ_CRASH(
+ "DebuggerHelper::iterator::operator< called with something else "
+ "than DebuggerHelper::end()");
+ }
+
+ protected:
+ friend class DebuggerHelper;
+ explicit iterator(const link_map* item) : item(item) {}
+
+ private:
+ const link_map* item;
+ };
+
+ iterator begin() const { return iterator(dbg ? dbg->r_map : nullptr); }
+
+ iterator end() const { return iterator(nullptr); }
+
+ private:
+ r_debug* dbg;
+ link_map* firstAdded;
+ };
+ friend int __wrap_dl_iterate_phdr(dl_phdr_cb callback, void* data);
+ DebuggerHelper dbg;
+};
+
+#endif /* ElfLoader_h */
diff --git a/mozglue/linker/Elfxx.h b/mozglue/linker/Elfxx.h
new file mode 100644
index 0000000000..4baf923b55
--- /dev/null
+++ b/mozglue/linker/Elfxx.h
@@ -0,0 +1,246 @@
+/* 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 Elfxx_h
+#define Elfxx_h
+
+#include "Utils.h"
+
+/**
+ * Android system headers have two different elf.h file. The one under linux/
+ * is the most complete on older Android API versions without unified headers.
+ */
+#if defined(ANDROID) && __ANDROID_API__ < 21 && !defined(__ANDROID_API_L__)
+# include <linux/elf.h>
+#else
+# include <elf.h>
+#endif
+#include <endian.h>
+
+#if defined(__ARM_EABI__) && !defined(PT_ARM_EXIDX)
+# define PT_ARM_EXIDX 0x70000001
+#endif
+
+/**
+ * Generic ELF macros for the target system
+ */
+#ifdef __LP64__
+# define Elf_(type) Elf64_##type
+# define ELFCLASS ELFCLASS64
+# define ELF_R_TYPE ELF64_R_TYPE
+# define ELF_R_SYM ELF64_R_SYM
+# ifndef ELF_ST_BIND
+# define ELF_ST_BIND ELF64_ST_BIND
+# endif
+#else
+# define Elf_(type) Elf32_##type
+# define ELFCLASS ELFCLASS32
+# define ELF_R_TYPE ELF32_R_TYPE
+# define ELF_R_SYM ELF32_R_SYM
+# ifndef ELF_ST_BIND
+# define ELF_ST_BIND ELF32_ST_BIND
+# endif
+#endif
+
+#ifndef __BYTE_ORDER
+# error Cannot find endianness
+#endif
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+# define ELFDATA ELFDATA2LSB
+#elif __BYTE_ORDER == __BIG_ENDIAN
+# define ELFDATA ELFDATA2MSB
+#endif
+
+#ifdef __linux__
+# define ELFOSABI ELFOSABI_LINUX
+# ifdef EI_ABIVERSION
+# define ELFABIVERSION 0
+# endif
+#else
+# error Unknown ELF OSABI
+#endif
+
+#if defined(__i386__)
+# define ELFMACHINE EM_386
+
+// Doing this way probably doesn't scale to other architectures
+# define R_ABS R_386_32
+# define R_GLOB_DAT R_386_GLOB_DAT
+# define R_JMP_SLOT R_386_JMP_SLOT
+# define R_RELATIVE R_386_RELATIVE
+# define RELOC(n) DT_REL##n
+# define UNSUPPORTED_RELOC(n) DT_RELA##n
+# define STR_RELOC(n) "DT_REL" #n
+# define Reloc Rel
+
+#elif defined(__x86_64__)
+# define ELFMACHINE EM_X86_64
+
+# define R_ABS R_X86_64_64
+# define R_GLOB_DAT R_X86_64_GLOB_DAT
+# define R_JMP_SLOT R_X86_64_JUMP_SLOT
+# define R_RELATIVE R_X86_64_RELATIVE
+# define RELOC(n) DT_RELA##n
+# define UNSUPPORTED_RELOC(n) DT_REL##n
+# define STR_RELOC(n) "DT_RELA" #n
+# define Reloc Rela
+
+#elif defined(__arm__)
+# define ELFMACHINE EM_ARM
+
+# ifndef R_ARM_ABS32
+# define R_ARM_ABS32 2
+# endif
+# ifndef R_ARM_GLOB_DAT
+# define R_ARM_GLOB_DAT 21
+# endif
+# ifndef R_ARM_JUMP_SLOT
+# define R_ARM_JUMP_SLOT 22
+# endif
+# ifndef R_ARM_RELATIVE
+# define R_ARM_RELATIVE 23
+# endif
+
+# define R_ABS R_ARM_ABS32
+# define R_GLOB_DAT R_ARM_GLOB_DAT
+# define R_JMP_SLOT R_ARM_JUMP_SLOT
+# define R_RELATIVE R_ARM_RELATIVE
+# define RELOC(n) DT_REL##n
+# define UNSUPPORTED_RELOC(n) DT_RELA##n
+# define STR_RELOC(n) "DT_REL" #n
+# define Reloc Rel
+
+#elif defined(__aarch64__)
+# define ELFMACHINE EM_AARCH64
+
+# define R_ABS R_AARCH64_ABS64
+# define R_GLOB_DAT R_AARCH64_GLOB_DAT
+# define R_JMP_SLOT R_AARCH64_JUMP_SLOT
+# define R_RELATIVE R_AARCH64_RELATIVE
+# define RELOC(n) DT_RELA##n
+# define UNSUPPORTED_RELOC(n) DT_REL##n
+# define STR_RELOC(n) "DT_RELA" #n
+# define Reloc Rela
+
+#else
+# error Unknown ELF machine type
+#endif
+
+/**
+ * Android system headers don't have all definitions
+ */
+#ifndef STN_UNDEF
+# define STN_UNDEF 0
+#endif
+#ifndef DT_INIT_ARRAY
+# define DT_INIT_ARRAY 25
+#endif
+#ifndef DT_FINI_ARRAY
+# define DT_FINI_ARRAY 26
+#endif
+#ifndef DT_INIT_ARRAYSZ
+# define DT_INIT_ARRAYSZ 27
+#endif
+#ifndef DT_FINI_ARRAYSZ
+# define DT_FINI_ARRAYSZ 28
+#endif
+#ifndef DT_RELACOUNT
+# define DT_RELACOUNT 0x6ffffff9
+#endif
+#ifndef DT_RELCOUNT
+# define DT_RELCOUNT 0x6ffffffa
+#endif
+#ifndef DT_VERSYM
+# define DT_VERSYM 0x6ffffff0
+#endif
+#ifndef DT_VERDEF
+# define DT_VERDEF 0x6ffffffc
+#endif
+#ifndef DT_VERDEFNUM
+# define DT_VERDEFNUM 0x6ffffffd
+#endif
+#ifndef DT_VERNEED
+# define DT_VERNEED 0x6ffffffe
+#endif
+#ifndef DT_VERNEEDNUM
+# define DT_VERNEEDNUM 0x6fffffff
+#endif
+#ifndef DT_FLAGS_1
+# define DT_FLAGS_1 0x6ffffffb
+#endif
+#ifndef DT_FLAGS
+# define DT_FLAGS 30
+#endif
+#ifndef DF_SYMBOLIC
+# define DF_SYMBOLIC 0x00000002
+#endif
+#ifndef DF_TEXTREL
+# define DF_TEXTREL 0x00000004
+#endif
+
+namespace Elf {
+
+/**
+ * Define a few basic Elf Types
+ */
+typedef Elf_(Phdr) Phdr;
+typedef Elf_(Dyn) Dyn;
+typedef Elf_(Sym) Sym;
+typedef Elf_(Addr) Addr;
+typedef Elf_(Word) Word;
+typedef Elf_(Half) Half;
+
+/**
+ * Helper class around the standard Elf header struct
+ */
+struct Ehdr : public Elf_(Ehdr) {
+ /**
+ * Equivalent to reinterpret_cast<const Ehdr *>(buf), but additionally
+ * checking that this is indeed an Elf header and that the Elf type
+ * corresponds to that of the system
+ */
+ static const Ehdr* validate(const void* buf);
+};
+
+/**
+ * Elf String table
+ */
+class Strtab : public UnsizedArray<const char> {
+ public:
+ /**
+ * Returns the string at the given index in the table
+ */
+ const char* GetStringAt(off_t index) const {
+ return &UnsizedArray<const char>::operator[](index);
+ }
+};
+
+/**
+ * Helper class around Elf relocation.
+ */
+struct Rel : public Elf_(Rel) {
+ /**
+ * Returns the addend for the relocation, which is the value stored
+ * at r_offset.
+ */
+ Addr GetAddend(void* base) const {
+ return *(reinterpret_cast<const Addr*>(reinterpret_cast<const char*>(base) +
+ r_offset));
+ }
+};
+
+/**
+ * Helper class around Elf relocation with addend.
+ */
+struct Rela : public Elf_(Rela) {
+ /**
+ * Returns the addend for the relocation.
+ */
+ Addr GetAddend(void* base) const { return r_addend; }
+};
+
+} /* namespace Elf */
+
+#endif /* Elfxx_h */
diff --git a/mozglue/linker/Linker.h b/mozglue/linker/Linker.h
new file mode 100644
index 0000000000..77ddb06ecc
--- /dev/null
+++ b/mozglue/linker/Linker.h
@@ -0,0 +1,24 @@
+/* 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 Linker_h
+#define Linker_h
+
+#ifdef MOZ_LINKER
+# include "ElfLoader.h"
+# define __wrap_sigaction SEGVHandler::__wrap_sigaction
+#else
+# include <dlfcn.h>
+# include <link.h>
+# include <signal.h>
+# define __wrap_sigaction sigaction
+# define __wrap_dlopen dlopen
+# define __wrap_dlerror dlerror
+# define __wrap_dlsym dlsym
+# define __wrap_dlclose dlclose
+# define __wrap_dladdr dladdr
+# define __wrap_dl_iterate_phdr dl_iterate_phdr
+#endif
+
+#endif
diff --git a/mozglue/linker/Logging.cpp b/mozglue/linker/Logging.cpp
new file mode 100644
index 0000000000..e61c7835d2
--- /dev/null
+++ b/mozglue/linker/Logging.cpp
@@ -0,0 +1,7 @@
+/* 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 "Logging.h"
+
+Logging Logging::Singleton;
diff --git a/mozglue/linker/Logging.h b/mozglue/linker/Logging.h
new file mode 100644
index 0000000000..1e66ea41de
--- /dev/null
+++ b/mozglue/linker/Logging.h
@@ -0,0 +1,72 @@
+/* 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 Logging_h
+#define Logging_h
+
+#include <cstdlib>
+#include "mozilla/Likely.h"
+#include "mozilla/MacroArgs.h"
+
+#ifdef ANDROID
+# include <android/log.h>
+# define LOG(...) \
+ __android_log_print(ANDROID_LOG_INFO, "GeckoLinker", __VA_ARGS__)
+# define WARN(...) \
+ __android_log_print(ANDROID_LOG_WARN, "GeckoLinker", __VA_ARGS__)
+# define ERROR(...) \
+ __android_log_print(ANDROID_LOG_ERROR, "GeckoLinker", __VA_ARGS__)
+#else
+# include <cstdio>
+
+/* Expand to 1 or m depending on whether there is one argument or more
+ * given. */
+# define MOZ_ONE_OR_MORE_ARGS_IMPL2(_1, _2, _3, _4, _5, _6, _7, _8, _9, N, \
+ ...) \
+ N
+# define MOZ_ONE_OR_MORE_ARGS_IMPL(args) MOZ_ONE_OR_MORE_ARGS_IMPL2 args
+# define MOZ_ONE_OR_MORE_ARGS(...) \
+ MOZ_ONE_OR_MORE_ARGS_IMPL((__VA_ARGS__, m, m, m, m, m, m, m, m, 1, 0))
+
+# define MOZ_MACRO_GLUE(a, b) a b
+
+/* Some magic to choose between LOG1 and LOGm depending on the number of
+ * arguments */
+# define MOZ_CHOOSE_LOG(...) \
+ MOZ_MACRO_GLUE(MOZ_CONCAT(LOG, MOZ_ONE_OR_MORE_ARGS(__VA_ARGS__)), \
+ (__VA_ARGS__))
+
+# define LOG1(format) fprintf(stderr, format "\n")
+# define LOGm(format, ...) fprintf(stderr, format "\n", __VA_ARGS__)
+# define LOG(...) MOZ_CHOOSE_LOG(__VA_ARGS__)
+# define WARN(...) MOZ_CHOOSE_LOG("Warning: " __VA_ARGS__)
+# define ERROR(...) MOZ_CHOOSE_LOG("Error: " __VA_ARGS__)
+
+#endif
+
+class Logging {
+ public:
+ static bool isVerbose() { return Singleton.verbose; }
+
+ private:
+ bool verbose;
+
+ public:
+ static void Init() {
+ const char* env = getenv("MOZ_DEBUG_LINKER");
+ if (env && *env == '1') Singleton.verbose = true;
+ }
+
+ private:
+ static Logging Singleton;
+};
+
+#define DEBUG_LOG(...) \
+ do { \
+ if (MOZ_UNLIKELY(Logging::isVerbose())) { \
+ LOG(__VA_ARGS__); \
+ } \
+ } while (0)
+
+#endif /* Logging_h */
diff --git a/mozglue/linker/Mappable.cpp b/mozglue/linker/Mappable.cpp
new file mode 100644
index 0000000000..cacd6a46f6
--- /dev/null
+++ b/mozglue/linker/Mappable.cpp
@@ -0,0 +1,376 @@
+/* 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 <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <cstring>
+#include <cstdlib>
+#include <cstdio>
+#include <string>
+
+#include "Mappable.h"
+
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/UniquePtr.h"
+
+#ifdef ANDROID
+# include "mozilla/Ashmem.h"
+#endif
+#include <sys/stat.h>
+#include <errno.h>
+#include "ElfLoader.h"
+#include "XZStream.h"
+#include "Logging.h"
+
+using mozilla::MakeUnique;
+using mozilla::UniquePtr;
+
+class CacheValidator {
+ public:
+ CacheValidator(const char* aCachedLibPath, Zip* aZip, Zip::Stream* aStream)
+ : mCachedLibPath(aCachedLibPath) {
+ static const char kChecksumSuffix[] = ".crc";
+
+ mCachedChecksumPath =
+ MakeUnique<char[]>(strlen(aCachedLibPath) + sizeof(kChecksumSuffix));
+ sprintf(mCachedChecksumPath.get(), "%s%s", aCachedLibPath, kChecksumSuffix);
+ DEBUG_LOG("mCachedChecksumPath: %s", mCachedChecksumPath.get());
+
+ mChecksum = aStream->GetCRC32();
+ DEBUG_LOG("mChecksum: %x", mChecksum);
+ }
+
+ // Returns whether the cache is valid and up-to-date.
+ bool IsValid() const {
+ // Validate based on checksum.
+ RefPtr<Mappable> checksumMap =
+ MappableFile::Create(mCachedChecksumPath.get());
+ if (!checksumMap) {
+ // Force caching if checksum is missing in cache.
+ return false;
+ }
+
+ DEBUG_LOG("Comparing %x with %s", mChecksum, mCachedChecksumPath.get());
+ MappedPtr checksumBuf = checksumMap->mmap(nullptr, checksumMap->GetLength(),
+ PROT_READ, MAP_PRIVATE, 0);
+ if (checksumBuf == MAP_FAILED) {
+ WARN("Couldn't map %s to validate checksum", mCachedChecksumPath.get());
+ return false;
+ }
+ if (memcmp(checksumBuf, &mChecksum, sizeof(mChecksum))) {
+ return false;
+ }
+ return !access(mCachedLibPath.c_str(), R_OK);
+ }
+
+ // Caches the APK-provided checksum used in future cache validations.
+ void CacheChecksum() const {
+ AutoCloseFD fd(open(mCachedChecksumPath.get(),
+ O_TRUNC | O_RDWR | O_CREAT | O_NOATIME,
+ S_IRUSR | S_IWUSR));
+ if (fd == -1) {
+ WARN("Couldn't open %s to update checksum", mCachedChecksumPath.get());
+ return;
+ }
+
+ DEBUG_LOG("Updating checksum %s", mCachedChecksumPath.get());
+
+ const size_t size = sizeof(mChecksum);
+ size_t written = 0;
+ while (written < size) {
+ ssize_t ret =
+ write(fd, reinterpret_cast<const uint8_t*>(&mChecksum) + written,
+ size - written);
+ if (ret >= 0) {
+ written += ret;
+ } else if (errno != EINTR) {
+ WARN("Writing checksum %s failed with errno %d",
+ mCachedChecksumPath.get(), errno);
+ break;
+ }
+ }
+ }
+
+ private:
+ const std::string mCachedLibPath;
+ UniquePtr<char[]> mCachedChecksumPath;
+ uint32_t mChecksum;
+};
+
+Mappable* MappableFile::Create(const char* path) {
+ int fd = open(path, O_RDONLY);
+ if (fd != -1) return new MappableFile(fd);
+ return nullptr;
+}
+
+MemoryRange MappableFile::mmap(const void* addr, size_t length, int prot,
+ int flags, off_t offset) {
+ MOZ_ASSERT(fd != -1);
+ MOZ_ASSERT(!(flags & MAP_SHARED));
+ flags |= MAP_PRIVATE;
+
+ return MemoryRange::mmap(const_cast<void*>(addr), length, prot, flags, fd,
+ offset);
+}
+
+void MappableFile::finalize() {
+ /* Close file ; equivalent to close(fd.forget()) */
+ fd = -1;
+}
+
+size_t MappableFile::GetLength() const {
+ struct stat st;
+ return fstat(fd, &st) ? 0 : st.st_size;
+}
+
+Mappable* MappableExtractFile::Create(const char* name, Zip* zip,
+ Zip::Stream* stream) {
+ MOZ_ASSERT(zip && stream);
+
+ const char* cachePath = getenv("MOZ_LINKER_CACHE");
+ if (!cachePath || !*cachePath) {
+ WARN(
+ "MOZ_LINKER_EXTRACT is set, but not MOZ_LINKER_CACHE; "
+ "not extracting");
+ return nullptr;
+ }
+
+ // Ensure that the cache dir is private.
+ chmod(cachePath, 0770);
+
+ UniquePtr<char[]> path =
+ MakeUnique<char[]>(strlen(cachePath) + strlen(name) + 2);
+ sprintf(path.get(), "%s/%s", cachePath, name);
+
+ CacheValidator validator(path.get(), zip, stream);
+ if (validator.IsValid()) {
+ DEBUG_LOG("Reusing %s", static_cast<char*>(path.get()));
+ return MappableFile::Create(path.get());
+ }
+ DEBUG_LOG("Extracting to %s", static_cast<char*>(path.get()));
+ AutoCloseFD fd;
+ fd = open(path.get(), O_TRUNC | O_RDWR | O_CREAT | O_NOATIME,
+ S_IRUSR | S_IWUSR);
+ if (fd == -1) {
+ ERROR("Couldn't open %s to decompress library", path.get());
+ return nullptr;
+ }
+ AutoUnlinkFile file(path.release());
+ if (stream->GetType() == Zip::Stream::DEFLATE) {
+ if (ftruncate(fd, stream->GetUncompressedSize()) == -1) {
+ ERROR("Couldn't ftruncate %s to decompress library", file.get());
+ return nullptr;
+ }
+ /* Map the temporary file for use as inflate buffer */
+ MappedPtr buffer(MemoryRange::mmap(nullptr, stream->GetUncompressedSize(),
+ PROT_WRITE, MAP_SHARED, fd, 0));
+ if (buffer == MAP_FAILED) {
+ ERROR("Couldn't map %s to decompress library", file.get());
+ return nullptr;
+ }
+
+ z_stream zStream = stream->GetZStream(buffer);
+
+ /* Decompress */
+ if (inflateInit2(&zStream, -MAX_WBITS) != Z_OK) {
+ ERROR("inflateInit failed: %s", zStream.msg);
+ return nullptr;
+ }
+ if (inflate(&zStream, Z_FINISH) != Z_STREAM_END) {
+ ERROR("inflate failed: %s", zStream.msg);
+ return nullptr;
+ }
+ if (inflateEnd(&zStream) != Z_OK) {
+ ERROR("inflateEnd failed: %s", zStream.msg);
+ return nullptr;
+ }
+ if (zStream.total_out != stream->GetUncompressedSize()) {
+ ERROR("File not fully uncompressed! %ld / %d", zStream.total_out,
+ static_cast<unsigned int>(stream->GetUncompressedSize()));
+ return nullptr;
+ }
+ } else if (XZStream::IsXZ(stream->GetBuffer(), stream->GetSize())) {
+ XZStream xzStream(stream->GetBuffer(), stream->GetSize());
+
+ if (!xzStream.Init()) {
+ ERROR("Couldn't initialize XZ decoder");
+ return nullptr;
+ }
+ DEBUG_LOG("XZStream created, compressed=%" PRIuPTR
+ ", uncompressed=%" PRIuPTR,
+ xzStream.Size(), xzStream.UncompressedSize());
+
+ if (ftruncate(fd, xzStream.UncompressedSize()) == -1) {
+ ERROR("Couldn't ftruncate %s to decompress library", file.get());
+ return nullptr;
+ }
+ MappedPtr buffer(MemoryRange::mmap(nullptr, xzStream.UncompressedSize(),
+ PROT_WRITE, MAP_SHARED, fd, 0));
+ if (buffer == MAP_FAILED) {
+ ERROR("Couldn't map %s to decompress library", file.get());
+ return nullptr;
+ }
+ const size_t written = xzStream.Decode(buffer, buffer.GetLength());
+ DEBUG_LOG("XZStream decoded %" PRIuPTR, written);
+ if (written != buffer.GetLength()) {
+ ERROR("Error decoding XZ file %s", file.get());
+ return nullptr;
+ }
+ } else {
+ return nullptr;
+ }
+
+ validator.CacheChecksum();
+ return new MappableExtractFile(fd.forget(), file.release());
+}
+
+/**
+ * _MappableBuffer is a buffer which content can be mapped at different
+ * locations in the virtual address space.
+ * On Linux, uses a (deleted) temporary file on a tmpfs for sharable content.
+ * On Android, uses ashmem.
+ */
+class _MappableBuffer : public MappedPtr {
+ public:
+ /**
+ * Returns a _MappableBuffer instance with the given name and the given
+ * length.
+ */
+ static _MappableBuffer* Create(const char* name, size_t length) {
+ AutoCloseFD fd;
+ const char* ident;
+#ifdef ANDROID
+ /* On Android, initialize an ashmem region with the given length */
+ fd = mozilla::android::ashmem_create(name, length);
+ ident = name;
+#else
+ /* On Linux, use /dev/shm as base directory for temporary files, assuming
+ * it's on tmpfs */
+ /* TODO: check that /dev/shm is tmpfs */
+ char path[256];
+ sprintf(path, "/dev/shm/%s.XXXXXX", name);
+ fd = mkstemp(path);
+ if (fd == -1) return nullptr;
+ unlink(path);
+ ftruncate(fd, length);
+ ident = path;
+#endif
+
+ void* buf =
+ ::mmap(nullptr, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ if (buf != MAP_FAILED) {
+ DEBUG_LOG("Decompression buffer of size 0x%" PRIxPTR
+ " in "
+#ifdef ANDROID
+ "ashmem "
+#endif
+ "\"%s\", mapped @%p",
+ length, ident, buf);
+ return new _MappableBuffer(fd.forget(), buf, length);
+ }
+ return nullptr;
+ }
+
+ void* mmap(const void* addr, size_t length, int prot, int flags,
+ off_t offset) {
+ MOZ_ASSERT(fd != -1);
+#ifdef ANDROID
+ /* Mapping ashmem MAP_PRIVATE is like mapping anonymous memory, even when
+ * there is content in the ashmem */
+ if (flags & MAP_PRIVATE) {
+ flags &= ~MAP_PRIVATE;
+ flags |= MAP_SHARED;
+ }
+#endif
+ return ::mmap(const_cast<void*>(addr), length, prot, flags, fd, offset);
+ }
+
+ private:
+ _MappableBuffer(int fd, void* buf, size_t length)
+ : MappedPtr(buf, length), fd(fd) {}
+
+ /* File descriptor for the temporary file or ashmem */
+ AutoCloseFD fd;
+};
+
+Mappable* MappableDeflate::Create(const char* name, Zip* zip,
+ Zip::Stream* stream) {
+ MOZ_ASSERT(stream->GetType() == Zip::Stream::DEFLATE);
+ _MappableBuffer* buf =
+ _MappableBuffer::Create(name, stream->GetUncompressedSize());
+ if (buf) return new MappableDeflate(buf, zip, stream);
+ return nullptr;
+}
+
+MappableDeflate::MappableDeflate(_MappableBuffer* buf, Zip* zip,
+ Zip::Stream* stream)
+ : zip(zip), buffer(buf), zStream(stream->GetZStream(*buf)) {}
+
+MappableDeflate::~MappableDeflate() {}
+
+MemoryRange MappableDeflate::mmap(const void* addr, size_t length, int prot,
+ int flags, off_t offset) {
+ MOZ_ASSERT(buffer);
+ MOZ_ASSERT(!(flags & MAP_SHARED));
+ flags |= MAP_PRIVATE;
+
+ /* The deflate stream is uncompressed up to the required offset + length, if
+ * it hasn't previously been uncompressed */
+ ssize_t missing = offset + length + zStream.avail_out - buffer->GetLength();
+ if (missing > 0) {
+ uInt avail_out = zStream.avail_out;
+ zStream.avail_out = missing;
+ if ((*buffer == zStream.next_out) &&
+ (inflateInit2(&zStream, -MAX_WBITS) != Z_OK)) {
+ ERROR("inflateInit failed: %s", zStream.msg);
+ return MemoryRange(MAP_FAILED, 0);
+ }
+ int ret = inflate(&zStream, Z_SYNC_FLUSH);
+ if (ret < 0) {
+ ERROR("inflate failed: %s", zStream.msg);
+ return MemoryRange(MAP_FAILED, 0);
+ }
+ if (ret == Z_NEED_DICT) {
+ ERROR("zstream requires a dictionary. %s", zStream.msg);
+ return MemoryRange(MAP_FAILED, 0);
+ }
+ zStream.avail_out = avail_out - missing + zStream.avail_out;
+ if (ret == Z_STREAM_END) {
+ if (inflateEnd(&zStream) != Z_OK) {
+ ERROR("inflateEnd failed: %s", zStream.msg);
+ return MemoryRange(MAP_FAILED, 0);
+ }
+ if (zStream.total_out != buffer->GetLength()) {
+ ERROR("File not fully uncompressed! %ld / %d", zStream.total_out,
+ static_cast<unsigned int>(buffer->GetLength()));
+ return MemoryRange(MAP_FAILED, 0);
+ }
+ }
+ }
+#if defined(ANDROID) && defined(__arm__)
+ if (prot & PROT_EXEC) {
+ /* We just extracted data that may be executed in the future.
+ * We thus need to ensure Instruction and Data cache coherency. */
+ DEBUG_LOG("cacheflush(%p, %p)", *buffer + offset,
+ *buffer + (offset + length));
+ cacheflush(reinterpret_cast<uintptr_t>(*buffer + offset),
+ reinterpret_cast<uintptr_t>(*buffer + (offset + length)), 0);
+ }
+#endif
+
+ return MemoryRange(buffer->mmap(addr, length, prot, flags, offset), length);
+}
+
+void MappableDeflate::finalize() {
+ /* Free zlib internal buffers */
+ inflateEnd(&zStream);
+ /* Free decompression buffer */
+ buffer = nullptr;
+ /* Remove reference to Zip archive */
+ zip = nullptr;
+}
+
+size_t MappableDeflate::GetLength() const { return buffer->GetLength(); }
diff --git a/mozglue/linker/Mappable.h b/mozglue/linker/Mappable.h
new file mode 100644
index 0000000000..8468aaaccb
--- /dev/null
+++ b/mozglue/linker/Mappable.h
@@ -0,0 +1,161 @@
+/* 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 Mappable_h
+#define Mappable_h
+
+#include "Zip.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "zlib.h"
+
+/**
+ * Abstract class to handle mmap()ing from various kind of entities, such as
+ * plain files or Zip entries. The virtual members are meant to act as the
+ * equivalent system functions, except mapped memory is always MAP_PRIVATE,
+ * even though a given implementation may use something different internally.
+ */
+class Mappable : public mozilla::RefCounted<Mappable> {
+ public:
+ MOZ_DECLARE_REFCOUNTED_TYPENAME(Mappable)
+ virtual ~Mappable() {}
+
+ virtual MemoryRange mmap(const void* addr, size_t length, int prot, int flags,
+ off_t offset) = 0;
+
+ enum Kind {
+ MAPPABLE_FILE,
+ MAPPABLE_EXTRACT_FILE,
+ MAPPABLE_DEFLATE,
+ MAPPABLE_SEEKABLE_ZSTREAM
+ };
+
+ virtual Kind GetKind() const = 0;
+
+ private:
+ virtual void munmap(void* addr, size_t length) { ::munmap(addr, length); }
+ /* Limit use of Mappable::munmap to classes that keep track of the address
+ * and size of the mapping. This allows to ignore ::munmap return value. */
+ friend class Mappable1stPagePtr;
+ friend class LibHandle;
+
+ public:
+ /**
+ * Indicate to a Mappable instance that no further mmap is going to happen.
+ */
+ virtual void finalize() = 0;
+
+ /**
+ * Returns the maximum length that can be mapped from this Mappable for
+ * offset = 0.
+ */
+ virtual size_t GetLength() const = 0;
+};
+
+/**
+ * Mappable implementation for plain files
+ */
+class MappableFile : public Mappable {
+ public:
+ ~MappableFile() {}
+
+ /**
+ * Create a MappableFile instance for the given file path.
+ */
+ static Mappable* Create(const char* path);
+
+ /* Inherited from Mappable */
+ virtual MemoryRange mmap(const void* addr, size_t length, int prot, int flags,
+ off_t offset);
+ virtual void finalize();
+ virtual size_t GetLength() const;
+
+ virtual Kind GetKind() const { return MAPPABLE_FILE; };
+
+ protected:
+ explicit MappableFile(int fd) : fd(fd) {}
+
+ private:
+ /* File descriptor */
+ AutoCloseFD fd;
+};
+
+/**
+ * Mappable implementation for deflated stream in a Zip archive
+ * Inflates the complete stream into a cache file.
+ */
+class MappableExtractFile : public MappableFile {
+ public:
+ ~MappableExtractFile() = default;
+
+ /**
+ * Create a MappableExtractFile instance for the given Zip stream. The name
+ * argument is used to create the cache file in the cache directory.
+ */
+ static Mappable* Create(const char* name, Zip* zip, Zip::Stream* stream);
+
+ /* Override finalize from MappableFile */
+ virtual void finalize() {}
+
+ virtual Kind GetKind() const { return MAPPABLE_EXTRACT_FILE; };
+
+ private:
+ /**
+ * AutoUnlinkFile keeps track of a file name and removes (unlinks) the file
+ * when the instance is destroyed.
+ */
+ struct UnlinkFile {
+ void operator()(char* value) {
+ unlink(value);
+ delete[] value;
+ }
+ };
+ typedef mozilla::UniquePtr<char[], UnlinkFile> AutoUnlinkFile;
+
+ MappableExtractFile(int fd, const char* path)
+ : MappableFile(fd), path(path) {}
+
+ /* Extracted file path */
+ mozilla::UniquePtr<const char[]> path;
+};
+
+class _MappableBuffer;
+
+/**
+ * Mappable implementation for deflated stream in a Zip archive.
+ * Inflates the mapped bits in a temporary buffer.
+ */
+class MappableDeflate : public Mappable {
+ public:
+ ~MappableDeflate();
+
+ /**
+ * Create a MappableDeflate instance for the given Zip stream. The name
+ * argument is used for an appropriately named temporary file, and the Zip
+ * instance is given for the MappableDeflate to keep a reference of it.
+ */
+ static Mappable* Create(const char* name, Zip* zip, Zip::Stream* stream);
+
+ /* Inherited from Mappable */
+ virtual MemoryRange mmap(const void* addr, size_t length, int prot, int flags,
+ off_t offset);
+ virtual void finalize();
+ virtual size_t GetLength() const;
+
+ virtual Kind GetKind() const { return MAPPABLE_DEFLATE; };
+
+ private:
+ MappableDeflate(_MappableBuffer* buf, Zip* zip, Zip::Stream* stream);
+
+ /* Zip reference */
+ RefPtr<Zip> zip;
+
+ /* Decompression buffer */
+ mozilla::UniquePtr<_MappableBuffer> buffer;
+
+ /* Zlib data */
+ z_stream zStream;
+};
+
+#endif /* Mappable_h */
diff --git a/mozglue/linker/Utils.h b/mozglue/linker/Utils.h
new file mode 100644
index 0000000000..d3827f1f41
--- /dev/null
+++ b/mozglue/linker/Utils.h
@@ -0,0 +1,532 @@
+/* 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 Utils_h
+#define Utils_h
+
+#include <pthread.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include "mozilla/Assertions.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/Scoped.h"
+
+/**
+ * On architectures that are little endian and that support unaligned reads,
+ * we can use direct type, but on others, we want to have a special class
+ * to handle conversion and alignment issues.
+ */
+#if !defined(DEBUG) && (defined(__i386__) || defined(__x86_64__))
+typedef uint16_t le_uint16;
+typedef uint32_t le_uint32;
+#else
+
+/**
+ * Template that allows to find an unsigned int type from a (computed) bit size
+ */
+template <int s>
+struct UInt {};
+template <>
+struct UInt<16> {
+ typedef uint16_t Type;
+};
+template <>
+struct UInt<32> {
+ typedef uint32_t Type;
+};
+
+/**
+ * Template to access 2 n-bit sized words as a 2*n-bit sized word, doing
+ * conversion from little endian and avoiding alignment issues.
+ */
+template <typename T>
+class le_to_cpu {
+ public:
+ typedef typename UInt<16 * sizeof(T)>::Type Type;
+
+ operator Type() const { return (b << (sizeof(T) * 8)) | a; }
+
+ const le_to_cpu& operator=(const Type& v) {
+ a = v & ((1 << (sizeof(T) * 8)) - 1);
+ b = v >> (sizeof(T) * 8);
+ return *this;
+ }
+
+ le_to_cpu() {}
+ explicit le_to_cpu(const Type& v) { operator=(v); }
+
+ const le_to_cpu& operator+=(const Type& v) {
+ return operator=(operator Type() + v);
+ }
+
+ const le_to_cpu& operator++(int) { return operator=(operator Type() + 1); }
+
+ private:
+ T a, b;
+};
+
+/**
+ * Type definitions
+ */
+typedef le_to_cpu<unsigned char> le_uint16;
+typedef le_to_cpu<le_uint16> le_uint32;
+#endif
+
+/**
+ * AutoCloseFD is a RAII wrapper for POSIX file descriptors
+ */
+struct AutoCloseFDTraits {
+ typedef int type;
+ static int empty() { return -1; }
+ static void release(int fd) {
+ if (fd != -1) close(fd);
+ }
+};
+typedef mozilla::Scoped<AutoCloseFDTraits> AutoCloseFD;
+
+/**
+ * AutoCloseFILE is a RAII wrapper for POSIX streams
+ */
+struct AutoCloseFILETraits {
+ typedef FILE* type;
+ static FILE* empty() { return nullptr; }
+ static void release(FILE* f) {
+ if (f) fclose(f);
+ }
+};
+typedef mozilla::Scoped<AutoCloseFILETraits> AutoCloseFILE;
+
+extern mozilla::Atomic<size_t, mozilla::ReleaseAcquire> gPageSize;
+
+/**
+ * Page alignment helpers
+ */
+static size_t PageSize() {
+ if (!gPageSize) {
+ gPageSize = sysconf(_SC_PAGESIZE);
+ }
+
+ return gPageSize;
+}
+
+static inline uintptr_t AlignedPtr(uintptr_t ptr, size_t alignment) {
+ return ptr & ~(alignment - 1);
+}
+
+template <typename T>
+static inline T* AlignedPtr(T* ptr, size_t alignment) {
+ return reinterpret_cast<T*>(
+ AlignedPtr(reinterpret_cast<uintptr_t>(ptr), alignment));
+}
+
+template <typename T>
+static inline T PageAlignedPtr(T ptr) {
+ return AlignedPtr(ptr, PageSize());
+}
+
+static inline uintptr_t AlignedEndPtr(uintptr_t ptr, size_t alignment) {
+ return AlignedPtr(ptr + alignment - 1, alignment);
+}
+
+template <typename T>
+static inline T* AlignedEndPtr(T* ptr, size_t alignment) {
+ return reinterpret_cast<T*>(
+ AlignedEndPtr(reinterpret_cast<uintptr_t>(ptr), alignment));
+}
+
+template <typename T>
+static inline T PageAlignedEndPtr(T ptr) {
+ return AlignedEndPtr(ptr, PageSize());
+}
+
+static inline size_t AlignedSize(size_t size, size_t alignment) {
+ return (size + alignment - 1) & ~(alignment - 1);
+}
+
+static inline size_t PageAlignedSize(size_t size) {
+ return AlignedSize(size, PageSize());
+}
+
+static inline bool IsAlignedPtr(uintptr_t ptr, size_t alignment) {
+ return ptr % alignment == 0;
+}
+
+template <typename T>
+static inline bool IsAlignedPtr(T* ptr, size_t alignment) {
+ return IsAlignedPtr(reinterpret_cast<uintptr_t>(ptr), alignment);
+}
+
+template <typename T>
+static inline bool IsPageAlignedPtr(T ptr) {
+ return IsAlignedPtr(ptr, PageSize());
+}
+
+static inline bool IsAlignedSize(size_t size, size_t alignment) {
+ return size % alignment == 0;
+}
+
+static inline bool IsPageAlignedSize(size_t size) {
+ return IsAlignedSize(size, PageSize());
+}
+
+static inline size_t PageNumber(size_t size) {
+ return (size + PageSize() - 1) / PageSize();
+}
+
+/**
+ * MemoryRange stores a pointer, size pair.
+ */
+class MemoryRange {
+ public:
+ MemoryRange(void* buf, size_t length) : buf(buf), length(length) {}
+
+ void Assign(void* b, size_t len) {
+ buf = b;
+ length = len;
+ }
+
+ void Assign(const MemoryRange& other) {
+ buf = other.buf;
+ length = other.length;
+ }
+
+ void* get() const { return buf; }
+
+ operator void*() const { return buf; }
+
+ operator unsigned char*() const {
+ return reinterpret_cast<unsigned char*>(buf);
+ }
+
+ bool operator==(void* ptr) const { return buf == ptr; }
+
+ bool operator==(unsigned char* ptr) const { return buf == ptr; }
+
+ void* operator+(off_t offset) const {
+ return reinterpret_cast<char*>(buf) + offset;
+ }
+
+ /**
+ * Returns whether the given address is within the mapped range
+ */
+ bool Contains(void* ptr) const {
+ return (ptr >= buf) && (ptr < reinterpret_cast<char*>(buf) + length);
+ }
+
+ /**
+ * Returns the length of the mapped range
+ */
+ size_t GetLength() const { return length; }
+
+ static MemoryRange mmap(void* addr, size_t length, int prot, int flags,
+ int fd, off_t offset) {
+ return MemoryRange(::mmap(addr, length, prot, flags, fd, offset), length);
+ }
+
+ private:
+ void* buf;
+ size_t length;
+};
+
+/**
+ * MappedPtr is a RAII wrapper for mmap()ed memory. It can be used as
+ * a simple void * or unsigned char *.
+ *
+ * It is defined as a derivative of a template that allows to use a
+ * different unmapping strategy.
+ */
+template <typename T>
+class GenericMappedPtr : public MemoryRange {
+ public:
+ GenericMappedPtr(void* buf, size_t length) : MemoryRange(buf, length) {}
+ explicit GenericMappedPtr(const MemoryRange& other) : MemoryRange(other) {}
+ GenericMappedPtr() : MemoryRange(MAP_FAILED, 0) {}
+
+ void Assign(void* b, size_t len) {
+ if (get() != MAP_FAILED) static_cast<T*>(this)->munmap(get(), GetLength());
+ MemoryRange::Assign(b, len);
+ }
+
+ void Assign(const MemoryRange& other) {
+ Assign(other.get(), other.GetLength());
+ }
+
+ ~GenericMappedPtr() {
+ if (get() != MAP_FAILED) static_cast<T*>(this)->munmap(get(), GetLength());
+ }
+
+ void release() { MemoryRange::Assign(MAP_FAILED, 0); }
+};
+
+struct MappedPtr : public GenericMappedPtr<MappedPtr> {
+ MappedPtr(void* buf, size_t length)
+ : GenericMappedPtr<MappedPtr>(buf, length) {}
+ MOZ_IMPLICIT MappedPtr(const MemoryRange& other)
+ : GenericMappedPtr<MappedPtr>(other) {}
+ MappedPtr() : GenericMappedPtr<MappedPtr>() {}
+
+ private:
+ friend class GenericMappedPtr<MappedPtr>;
+ void munmap(void* buf, size_t length) { ::munmap(buf, length); }
+};
+
+/**
+ * UnsizedArray is a way to access raw arrays of data in memory.
+ *
+ * struct S { ... };
+ * UnsizedArray<S> a(buf);
+ * UnsizedArray<S> b; b.Init(buf);
+ *
+ * This is roughly equivalent to
+ * const S *a = reinterpret_cast<const S *>(buf);
+ * const S *b = nullptr; b = reinterpret_cast<const S *>(buf);
+ *
+ * An UnsizedArray has no known length, and it's up to the caller to make
+ * sure the accessed memory is mapped and makes sense.
+ */
+template <typename T>
+class UnsizedArray {
+ public:
+ typedef size_t idx_t;
+
+ /**
+ * Constructors and Initializers
+ */
+ UnsizedArray() : contents(nullptr) {}
+ explicit UnsizedArray(const void* buf)
+ : contents(reinterpret_cast<const T*>(buf)) {}
+
+ void Init(const void* buf) {
+ MOZ_ASSERT(contents == nullptr);
+ contents = reinterpret_cast<const T*>(buf);
+ }
+
+ /**
+ * Returns the nth element of the array
+ */
+ const T& operator[](const idx_t index) const {
+ MOZ_ASSERT(contents);
+ return contents[index];
+ }
+
+ operator const T*() const { return contents; }
+ /**
+ * Returns whether the array points somewhere
+ */
+ explicit operator bool() const { return contents != nullptr; }
+
+ private:
+ const T* contents;
+};
+
+/**
+ * Array, like UnsizedArray, is a way to access raw arrays of data in memory.
+ * Unlike UnsizedArray, it has a known length, and is enumerable with an
+ * iterator.
+ *
+ * struct S { ... };
+ * Array<S> a(buf, len);
+ * UnsizedArray<S> b; b.Init(buf, len);
+ *
+ * In the above examples, len is the number of elements in the array. It is
+ * also possible to initialize an Array with the buffer size:
+ *
+ * Array<S> c; c.InitSize(buf, size);
+ *
+ * It is also possible to initialize an Array in two steps, only providing
+ * one data at a time:
+ *
+ * Array<S> d;
+ * d.Init(buf);
+ * d.Init(len); // or d.InitSize(size);
+ *
+ */
+template <typename T>
+class Array : public UnsizedArray<T> {
+ public:
+ typedef typename UnsizedArray<T>::idx_t idx_t;
+
+ /**
+ * Constructors and Initializers
+ */
+ Array() : UnsizedArray<T>(), length(0) {}
+ Array(const void* buf, const idx_t length)
+ : UnsizedArray<T>(buf), length(length) {}
+
+ void Init(const void* buf) { UnsizedArray<T>::Init(buf); }
+
+ void Init(const idx_t len) {
+ MOZ_ASSERT(length == 0);
+ length = len;
+ }
+
+ void InitSize(const idx_t size) { Init(size / sizeof(T)); }
+
+ void Init(const void* buf, const idx_t len) {
+ UnsizedArray<T>::Init(buf);
+ Init(len);
+ }
+
+ void InitSize(const void* buf, const idx_t size) {
+ UnsizedArray<T>::Init(buf);
+ InitSize(size);
+ }
+
+ /**
+ * Returns the nth element of the array
+ */
+ const T& operator[](const idx_t index) const {
+ MOZ_ASSERT(index < length);
+ MOZ_ASSERT(operator bool());
+ return UnsizedArray<T>::operator[](index);
+ }
+
+ /**
+ * Returns the number of elements in the array
+ */
+ idx_t numElements() const { return length; }
+
+ /**
+ * Returns whether the array points somewhere and has at least one element.
+ */
+ explicit operator bool() const {
+ return (length > 0) && UnsizedArray<T>::operator bool();
+ }
+
+ /**
+ * Iterator for an Array. Use is similar to that of STL const_iterators:
+ *
+ * struct S { ... };
+ * Array<S> a(buf, len);
+ * for (Array<S>::iterator it = a.begin(); it < a.end(); ++it) {
+ * // Do something with *it.
+ * }
+ */
+ class iterator {
+ public:
+ iterator() : item(nullptr) {}
+
+ const T& operator*() const { return *item; }
+
+ const T* operator->() const { return item; }
+
+ iterator& operator++() {
+ ++item;
+ return *this;
+ }
+
+ bool operator<(const iterator& other) const { return item < other.item; }
+
+ protected:
+ friend class Array<T>;
+ explicit iterator(const T& item) : item(&item) {}
+
+ private:
+ const T* item;
+ };
+
+ /**
+ * Returns an iterator pointing at the beginning of the Array
+ */
+ iterator begin() const {
+ if (length) return iterator(UnsizedArray<T>::operator[](0));
+ return iterator();
+ }
+
+ /**
+ * Returns an iterator pointing past the end of the Array
+ */
+ iterator end() const {
+ if (length) return iterator(UnsizedArray<T>::operator[](length));
+ return iterator();
+ }
+
+ /**
+ * Reverse iterator for an Array. Use is similar to that of STL
+ * const_reverse_iterators:
+ *
+ * struct S { ... };
+ * Array<S> a(buf, len);
+ * for (Array<S>::reverse_iterator it = a.rbegin(); it < a.rend(); ++it) {
+ * // Do something with *it.
+ * }
+ */
+ class reverse_iterator {
+ public:
+ reverse_iterator() : item(nullptr) {}
+
+ const T& operator*() const {
+ const T* tmp = item;
+ return *--tmp;
+ }
+
+ const T* operator->() const { return &operator*(); }
+
+ reverse_iterator& operator++() {
+ --item;
+ return *this;
+ }
+
+ bool operator<(const reverse_iterator& other) const {
+ return item > other.item;
+ }
+
+ protected:
+ friend class Array<T>;
+ explicit reverse_iterator(const T& item) : item(&item) {}
+
+ private:
+ const T* item;
+ };
+
+ /**
+ * Returns a reverse iterator pointing at the end of the Array
+ */
+ reverse_iterator rbegin() const {
+ if (length) return reverse_iterator(UnsizedArray<T>::operator[](length));
+ return reverse_iterator();
+ }
+
+ /**
+ * Returns a reverse iterator pointing past the beginning of the Array
+ */
+ reverse_iterator rend() const {
+ if (length) return reverse_iterator(UnsizedArray<T>::operator[](0));
+ return reverse_iterator();
+ }
+
+ private:
+ idx_t length;
+};
+
+/**
+ * Transforms a pointer-to-function to a pointer-to-object pointing at the
+ * same address.
+ */
+template <typename T>
+void* FunctionPtr(T func) {
+ union {
+ void* ptr;
+ T func;
+ } f;
+ f.func = func;
+ return f.ptr;
+}
+
+class AutoLock {
+ public:
+ explicit AutoLock(pthread_mutex_t* mutex) : mutex(mutex) {
+ if (pthread_mutex_lock(mutex)) MOZ_CRASH("pthread_mutex_lock failed");
+ }
+ ~AutoLock() {
+ if (pthread_mutex_unlock(mutex)) MOZ_CRASH("pthread_mutex_unlock failed");
+ }
+
+ private:
+ pthread_mutex_t* mutex;
+};
+
+#endif /* Utils_h */
diff --git a/mozglue/linker/XZStream.cpp b/mozglue/linker/XZStream.cpp
new file mode 100644
index 0000000000..db154d12aa
--- /dev/null
+++ b/mozglue/linker/XZStream.cpp
@@ -0,0 +1,221 @@
+/* -*- 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/. */
+
+#include "XZStream.h"
+
+#include <algorithm>
+#include <cstring>
+#include "mozilla/Assertions.h"
+#include "mozilla/CheckedInt.h"
+#include "Logging.h"
+
+// LZMA dictionary size, should have a minimum size for the given compression
+// rate, see XZ Utils docs for details.
+static const uint32_t kDictSize = 1 << 24;
+
+static const size_t kFooterSize = 12;
+
+// Parses a variable-length integer (VLI),
+// see http://tukaani.org/xz/xz-file-format.txt for details.
+static size_t ParseVarLenInt(const uint8_t* aBuf, size_t aBufSize,
+ uint64_t* aValue) {
+ if (!aBufSize) {
+ return 0;
+ }
+ aBufSize = std::min(size_t(9), aBufSize);
+
+ *aValue = aBuf[0] & 0x7F;
+ size_t i = 0;
+
+ while (aBuf[i++] & 0x80) {
+ if (i >= aBufSize || aBuf[i] == 0x0) {
+ return 0;
+ }
+ *aValue |= static_cast<uint64_t>(aBuf[i] & 0x7F) << (i * 7);
+ }
+ return i;
+}
+
+/* static */
+bool XZStream::IsXZ(const void* aBuf, size_t aBufSize) {
+ static const uint8_t kXzMagic[] = {0xfd, '7', 'z', 'X', 'Z', 0x0};
+ MOZ_ASSERT(aBuf);
+ return aBufSize > sizeof(kXzMagic) &&
+ !memcmp(reinterpret_cast<const void*>(kXzMagic), aBuf,
+ sizeof(kXzMagic));
+}
+
+XZStream::XZStream(const void* aInBuf, size_t aInSize)
+ : mInBuf(static_cast<const uint8_t*>(aInBuf)),
+ mUncompSize(0),
+ mDec(nullptr) {
+ mBuffers.in = mInBuf;
+ mBuffers.in_pos = 0;
+ mBuffers.in_size = aInSize;
+}
+
+XZStream::~XZStream() { xz_dec_end(mDec); }
+
+bool XZStream::Init() {
+#ifdef XZ_USE_CRC64
+ xz_crc64_init();
+#endif
+ xz_crc32_init();
+
+ mDec = xz_dec_init(XZ_DYNALLOC, kDictSize);
+
+ if (!mDec) {
+ return false;
+ }
+
+ mUncompSize = ParseUncompressedSize();
+ if (!mUncompSize) {
+ return false;
+ }
+
+ return true;
+}
+
+size_t XZStream::Decode(void* aOutBuf, size_t aOutSize) {
+ if (!mDec) {
+ return 0;
+ }
+
+ mBuffers.out = static_cast<uint8_t*>(aOutBuf);
+ mBuffers.out_pos = 0;
+ mBuffers.out_size = aOutSize;
+
+ while (mBuffers.in_pos < mBuffers.in_size &&
+ mBuffers.out_pos < mBuffers.out_size) {
+ const xz_ret ret = xz_dec_run(mDec, &mBuffers);
+
+ switch (ret) {
+ case XZ_STREAM_END:
+ // Stream ended, the next loop iteration should terminate.
+ MOZ_ASSERT(mBuffers.in_pos == mBuffers.in_size);
+ [[fallthrough]];
+#ifdef XZ_DEC_ANY_CHECK
+ case XZ_UNSUPPORTED_CHECK:
+ // Ignore unsupported check.
+ [[fallthrough]];
+#endif
+ case XZ_OK:
+ // Chunk decoded, proceed.
+ break;
+
+ case XZ_MEM_ERROR:
+ ERROR("XZ decoding: memory allocation failed");
+ return 0;
+
+ case XZ_MEMLIMIT_ERROR:
+ ERROR("XZ decoding: memory usage limit reached");
+ return 0;
+
+ case XZ_FORMAT_ERROR:
+ ERROR("XZ decoding: invalid stream format");
+ return 0;
+
+ case XZ_OPTIONS_ERROR:
+ ERROR("XZ decoding: unsupported header options");
+ return 0;
+
+ case XZ_DATA_ERROR:
+ [[fallthrough]];
+ case XZ_BUF_ERROR:
+ ERROR("XZ decoding: corrupt input stream");
+ return 0;
+
+ default:
+ MOZ_ASSERT_UNREACHABLE("XZ decoding: unknown error condition");
+ return 0;
+ }
+ }
+ return mBuffers.out_pos;
+}
+
+size_t XZStream::RemainingInput() const {
+ return mBuffers.in_size - mBuffers.in_pos;
+}
+
+size_t XZStream::Size() const { return mBuffers.in_size; }
+
+size_t XZStream::UncompressedSize() const { return mUncompSize; }
+
+size_t XZStream::ParseIndexSize() const {
+ static const uint8_t kFooterMagic[] = {'Y', 'Z'};
+
+ const uint8_t* footer = mInBuf + mBuffers.in_size - kFooterSize;
+ // The magic bytes are at the end of the footer.
+ if (memcmp(reinterpret_cast<const void*>(kFooterMagic),
+ footer + kFooterSize - sizeof(kFooterMagic),
+ sizeof(kFooterMagic))) {
+ // Not a valid footer at stream end.
+ ERROR("XZ parsing: Invalid footer at end of stream");
+ return 0;
+ }
+ // Backward size is a 32 bit LE integer field positioned after the 32 bit
+ // CRC32 code. It encodes the index size as a multiple of 4 bytes with a
+ // minimum size of 4 bytes.
+ const uint32_t backwardSizeRaw = *(footer + 4);
+ // Check for overflow.
+ mozilla::CheckedInt<size_t> backwardSizeBytes(backwardSizeRaw);
+ backwardSizeBytes = (backwardSizeBytes + 1) * 4;
+ if (!backwardSizeBytes.isValid()) {
+ ERROR("XZ parsing: Cannot parse index size");
+ return 0;
+ }
+ return backwardSizeBytes.value();
+}
+
+size_t XZStream::ParseUncompressedSize() const {
+ static const uint8_t kIndexIndicator[] = {0x0};
+
+ const size_t indexSize = ParseIndexSize();
+ if (!indexSize) {
+ return 0;
+ }
+ // The footer follows directly the index, so we can use it as a reference.
+ const uint8_t* end = mInBuf + mBuffers.in_size;
+ const uint8_t* index = end - kFooterSize - indexSize;
+
+ // The xz stream index consists of three concatenated elements:
+ // (1) 1 byte indicator (always OxOO)
+ // (2) a Variable Length Integer (VLI) field for the number of records
+ // (3) a list of records
+ // See https://tukaani.org/xz/xz-file-format-1.0.4.txt
+ // Each record contains a VLI field for unpadded size followed by a var field
+ // for uncompressed size. We only support xz streams with a single record.
+
+ if (memcmp(reinterpret_cast<const void*>(kIndexIndicator), index,
+ sizeof(kIndexIndicator))) {
+ ERROR("XZ parsing: Invalid stream index");
+ return 0;
+ }
+
+ index += sizeof(kIndexIndicator);
+ uint64_t numRecords = 0;
+ index += ParseVarLenInt(index, end - index, &numRecords);
+ // Only streams with a single record are supported.
+ if (numRecords != 1) {
+ ERROR("XZ parsing: Multiple records not supported");
+ return 0;
+ }
+ uint64_t unpaddedSize = 0;
+ index += ParseVarLenInt(index, end - index, &unpaddedSize);
+ if (!unpaddedSize) {
+ ERROR("XZ parsing: Unpadded size is 0");
+ return 0;
+ }
+ uint64_t uncompressedSize = 0;
+ index += ParseVarLenInt(index, end - index, &uncompressedSize);
+ mozilla::CheckedInt<size_t> checkedSize(uncompressedSize);
+ if (!checkedSize.isValid()) {
+ ERROR("XZ parsing: Uncompressed stream size is too large");
+ return 0;
+ }
+
+ return checkedSize.value();
+}
diff --git a/mozglue/linker/XZStream.h b/mozglue/linker/XZStream.h
new file mode 100644
index 0000000000..bab5520e37
--- /dev/null
+++ b/mozglue/linker/XZStream.h
@@ -0,0 +1,49 @@
+/* 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 XZSTREAM_h
+#define XZSTREAM_h
+
+#include <cstdlib>
+#include <stdint.h>
+
+#define XZ_DEC_DYNALLOC
+#include "xz.h"
+
+// Used to decode XZ stream buffers.
+class XZStream {
+ public:
+ // Returns whether the provided buffer is likely a XZ stream.
+ static bool IsXZ(const void* aBuf, size_t aBufSize);
+
+ // Creates a XZ stream object for the given input buffer.
+ XZStream(const void* aInBuf, size_t aInSize);
+ ~XZStream();
+
+ // Initializes the decoder and returns whether decoding may commence.
+ bool Init();
+ // Decodes the next chunk of input into the given output buffer.
+ size_t Decode(void* aOutBuf, size_t aOutSize);
+ // Returns the number of yet undecoded bytes in the input buffer.
+ size_t RemainingInput() const;
+ // Returns the total number of bytes in the input buffer (compressed size).
+ size_t Size() const;
+ // Returns the expected final number of bytes in the output buffer.
+ // Note: will return 0 before successful Init().
+ size_t UncompressedSize() const;
+
+ private:
+ // Parses the stream footer and returns the size of the index in bytes.
+ size_t ParseIndexSize() const;
+ // Parses the stream index and returns the expected uncompressed size in
+ // bytes.
+ size_t ParseUncompressedSize() const;
+
+ const uint8_t* mInBuf;
+ size_t mUncompSize;
+ xz_buf mBuffers;
+ xz_dec* mDec;
+};
+
+#endif // XZSTREAM_h
diff --git a/mozglue/linker/Zip.cpp b/mozglue/linker/Zip.cpp
new file mode 100644
index 0000000000..7ecc6b9a74
--- /dev/null
+++ b/mozglue/linker/Zip.cpp
@@ -0,0 +1,277 @@
+/* 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 <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <cstdlib>
+#include <algorithm>
+#include "Logging.h"
+#include "Zip.h"
+
+already_AddRefed<Zip> Zip::Create(const char* filename) {
+ /* Open and map the file in memory */
+ AutoCloseFD fd(open(filename, O_RDONLY));
+ if (fd == -1) {
+ ERROR("Error opening %s: %s", filename, strerror(errno));
+ return nullptr;
+ }
+ struct stat st;
+ if (fstat(fd, &st) == -1) {
+ ERROR("Error stating %s: %s", filename, strerror(errno));
+ return nullptr;
+ }
+ size_t size = st.st_size;
+ if (size <= sizeof(CentralDirectoryEnd)) {
+ ERROR("Error reading %s: too short", filename);
+ return nullptr;
+ }
+ void* mapped = mmap(nullptr, size, PROT_READ, MAP_SHARED, fd, 0);
+ if (mapped == MAP_FAILED) {
+ ERROR("Error mmapping %s: %s", filename, strerror(errno));
+ return nullptr;
+ }
+ DEBUG_LOG("Mapped %s @%p", filename, mapped);
+
+ return Create(filename, mapped, size);
+}
+
+already_AddRefed<Zip> Zip::Create(const char* filename, void* mapped,
+ size_t size) {
+ RefPtr<Zip> zip = new Zip(filename, mapped, size);
+
+ // If neither the first Local File entry nor central directory entries
+ // have been found, the zip was invalid.
+ if (!zip->nextFile && !zip->entries) {
+ ERROR("%s - Invalid zip", filename);
+ return nullptr;
+ }
+
+ ZipCollection::Singleton.Register(zip);
+ return zip.forget();
+}
+
+Zip::Zip(const char* filename, void* mapped, size_t size)
+ : name(filename ? strdup(filename) : nullptr),
+ mapped(mapped),
+ size(size),
+ nextFile(LocalFile::validate(mapped)) // first Local File entry
+ ,
+ nextDir(nullptr),
+ entries(nullptr) {
+ pthread_mutex_init(&mutex, nullptr);
+ // If the first local file entry couldn't be found (which can happen
+ // with optimized jars), check the first central directory entry.
+ if (!nextFile) GetFirstEntry();
+}
+
+Zip::~Zip() {
+ if (name) {
+ munmap(mapped, size);
+ DEBUG_LOG("Unmapped %s @%p", name, mapped);
+ free(name);
+ }
+ pthread_mutex_destroy(&mutex);
+}
+
+bool Zip::GetStream(const char* path, Zip::Stream* out) const {
+ AutoLock lock(&mutex);
+
+ DEBUG_LOG("%s - GetFile %s", name, path);
+ /* Fast path: if the Local File header on store matches, we can return the
+ * corresponding stream right away.
+ * However, the Local File header may not contain enough information, in
+ * which case the 3rd bit on the generalFlag is set. Unfortunately, this
+ * bit is also set in some archives even when we do have the data (most
+ * notably the android packages as built by the Mozilla build system).
+ * So instead of testing the generalFlag bit, only use the fast path when
+ * we haven't read the central directory entries yet, and when the
+ * compressed size as defined in the header is not filled (which is a
+ * normal condition for the bit to be set). */
+ if (nextFile && nextFile->GetName().Equals(path) && !entries &&
+ (nextFile->compressedSize != 0)) {
+ DEBUG_LOG("%s - %s was next file: fast path", name, path);
+ /* Fill Stream info from Local File header content */
+ const char* data = reinterpret_cast<const char*>(nextFile->GetData());
+ out->compressedBuf = data;
+ out->compressedSize = nextFile->compressedSize;
+ out->uncompressedSize = nextFile->uncompressedSize;
+ out->CRC32 = nextFile->CRC32;
+ out->type = static_cast<Stream::Type>(uint16_t(nextFile->compression));
+
+ /* Find the next Local File header. It is usually simply following the
+ * compressed stream, but in cases where the 3rd bit of the generalFlag
+ * is set, there is a Data Descriptor header before. */
+ data += nextFile->compressedSize;
+ if ((nextFile->generalFlag & 0x8) && DataDescriptor::validate(data)) {
+ data += sizeof(DataDescriptor);
+ }
+ nextFile = LocalFile::validate(data);
+ return true;
+ }
+
+ /* If the directory entry we have in store doesn't match, scan the Central
+ * Directory for the entry corresponding to the given path */
+ if (!nextDir || !nextDir->GetName().Equals(path)) {
+ const DirectoryEntry* entry = GetFirstEntry();
+ DEBUG_LOG("%s - Scan directory entries in search for %s", name, path);
+ while (entry && !entry->GetName().Equals(path)) {
+ entry = entry->GetNext();
+ }
+ nextDir = entry;
+ }
+ if (!nextDir) {
+ DEBUG_LOG("%s - Couldn't find %s", name, path);
+ return false;
+ }
+
+ /* Find the Local File header corresponding to the Directory entry that
+ * was found. */
+ nextFile =
+ LocalFile::validate(static_cast<const char*>(mapped) + nextDir->offset);
+ if (!nextFile) {
+ ERROR("%s - Couldn't find the Local File header for %s", name, path);
+ return false;
+ }
+
+ /* Fill Stream info from Directory entry content */
+ const char* data = reinterpret_cast<const char*>(nextFile->GetData());
+ out->compressedBuf = data;
+ out->compressedSize = nextDir->compressedSize;
+ out->uncompressedSize = nextDir->uncompressedSize;
+ out->CRC32 = nextDir->CRC32;
+ out->type = static_cast<Stream::Type>(uint16_t(nextDir->compression));
+
+ /* Store the next directory entry */
+ nextDir = nextDir->GetNext();
+ nextFile = nullptr;
+ return true;
+}
+
+const Zip::DirectoryEntry* Zip::GetFirstEntry() const {
+ if (entries) return entries;
+
+ const CentralDirectoryEnd* end = nullptr;
+ const char* _end =
+ static_cast<const char*>(mapped) + size - sizeof(CentralDirectoryEnd);
+
+ /* Scan for the Central Directory End */
+ for (; _end > mapped && !end; _end--)
+ end = CentralDirectoryEnd::validate(_end);
+ if (!end) {
+ ERROR("%s - Couldn't find end of central directory record", name);
+ return nullptr;
+ }
+
+ entries =
+ DirectoryEntry::validate(static_cast<const char*>(mapped) + end->offset);
+ if (!entries) {
+ ERROR("%s - Couldn't find central directory record", name);
+ }
+ return entries;
+}
+
+bool Zip::VerifyCRCs() const {
+ AutoLock lock(&mutex);
+
+ for (const DirectoryEntry* entry = GetFirstEntry(); entry;
+ entry = entry->GetNext()) {
+ const LocalFile* file =
+ LocalFile::validate(static_cast<const char*>(mapped) + entry->offset);
+ uint32_t crc = crc32(0, nullptr, 0);
+
+ DEBUG_LOG("%.*s: crc=%08x", int(entry->filenameSize),
+ reinterpret_cast<const char*>(entry) + sizeof(*entry),
+ uint32_t(entry->CRC32));
+
+ if (entry->compression == Stream::Type::STORE) {
+ crc = crc32(crc, static_cast<const uint8_t*>(file->GetData()),
+ entry->compressedSize);
+ DEBUG_LOG(" STORE size=%d crc=%08x", int(entry->compressedSize), crc);
+
+ } else if (entry->compression == Stream::Type::DEFLATE) {
+ z_stream zstream;
+ Bytef buffer[1024];
+ zstream.avail_in = entry->compressedSize;
+ zstream.next_in =
+ reinterpret_cast<Bytef*>(const_cast<void*>(file->GetData()));
+ zstream.zalloc = nullptr;
+ zstream.zfree = nullptr;
+ zstream.opaque = nullptr;
+
+ if (inflateInit2(&zstream, -MAX_WBITS) != Z_OK) {
+ return false;
+ }
+
+ for (;;) {
+ zstream.avail_out = sizeof(buffer);
+ zstream.next_out = buffer;
+
+ int ret = inflate(&zstream, Z_SYNC_FLUSH);
+ crc = crc32(crc, buffer, sizeof(buffer) - zstream.avail_out);
+
+ if (ret == Z_STREAM_END) {
+ break;
+ } else if (ret != Z_OK) {
+ return false;
+ }
+ }
+
+ inflateEnd(&zstream);
+ DEBUG_LOG(" DEFLATE size=%d crc=%08x", int(zstream.total_out), crc);
+
+ } else {
+ MOZ_ASSERT_UNREACHABLE("Unexpected stream type");
+ continue;
+ }
+
+ if (entry->CRC32 != crc) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+ZipCollection ZipCollection::Singleton;
+
+static pthread_mutex_t sZipCollectionMutex = PTHREAD_MUTEX_INITIALIZER;
+
+already_AddRefed<Zip> ZipCollection::GetZip(const char* path) {
+ {
+ AutoLock lock(&sZipCollectionMutex);
+ /* Search the list of Zips we already have for a match */
+ for (const auto& zip : Singleton.zips) {
+ if (zip->GetName() && (strcmp(zip->GetName(), path) == 0)) {
+ return RefPtr<Zip>(zip).forget();
+ }
+ }
+ }
+ return Zip::Create(path);
+}
+
+void ZipCollection::Register(Zip* zip) {
+ AutoLock lock(&sZipCollectionMutex);
+ DEBUG_LOG("ZipCollection::Register(\"%s\")", zip->GetName());
+ Singleton.zips.push_back(zip);
+}
+
+void ZipCollection::Forget(const Zip* zip) {
+ AutoLock lock(&sZipCollectionMutex);
+ if (zip->refCount() > 1) {
+ // Someone has acquired a reference before we had acquired the lock,
+ // ignore this request.
+ return;
+ }
+ DEBUG_LOG("ZipCollection::Forget(\"%s\")", zip->GetName());
+ const auto it = std::find(Singleton.zips.begin(), Singleton.zips.end(), zip);
+ if (*it == zip) {
+ Singleton.zips.erase(it);
+ } else {
+ DEBUG_LOG("ZipCollection::Forget: didn't find \"%s\" in bookkeeping",
+ zip->GetName());
+ }
+}
diff --git a/mozglue/linker/Zip.h b/mozglue/linker/Zip.h
new file mode 100644
index 0000000000..3e596c3c4c
--- /dev/null
+++ b/mozglue/linker/Zip.h
@@ -0,0 +1,388 @@
+/* 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 Zip_h
+#define Zip_h
+
+#include <cstring>
+#include <stdint.h>
+#include <vector>
+#include <zlib.h>
+#include <pthread.h>
+#include "Utils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/RefCounted.h"
+#include "mozilla/RefPtr.h"
+
+/**
+ * Forward declaration
+ */
+class ZipCollection;
+
+/**
+ * Class to handle access to Zip archive streams. The Zip archive is mapped
+ * in memory, and streams are direct references to that mapped memory.
+ * Zip files are assumed to be correctly formed. No boundary checks are
+ * performed, which means hand-crafted malicious Zip archives can make the
+ * code fail in bad ways. However, since the only intended use is to load
+ * libraries from Zip archives, there is no interest in making this code
+ * safe, since the libraries could contain malicious code anyways.
+ */
+class Zip : public mozilla::external::AtomicRefCounted<Zip> {
+ public:
+ MOZ_DECLARE_REFCOUNTED_TYPENAME(Zip)
+ /**
+ * Create a Zip instance for the given file name. Returns nullptr in case
+ * of failure.
+ */
+ static already_AddRefed<Zip> Create(const char* filename);
+
+ /**
+ * Create a Zip instance using the given buffer.
+ */
+ static already_AddRefed<Zip> Create(void* buffer, size_t size) {
+ return Create(nullptr, buffer, size);
+ }
+
+ private:
+ static already_AddRefed<Zip> Create(const char* filename, void* buffer,
+ size_t size);
+
+ /**
+ * Private constructor
+ */
+ Zip(const char* filename, void* buffer, size_t size);
+
+ public:
+ /**
+ * Destructor
+ */
+ ~Zip();
+
+ /**
+ * Class used to access Zip archive item streams
+ */
+ class Stream {
+ public:
+ /**
+ * Stream types
+ */
+ enum Type { STORE = 0, DEFLATE = 8 };
+
+ /**
+ * Constructor
+ */
+ Stream()
+ : compressedBuf(nullptr),
+ compressedSize(0),
+ uncompressedSize(0),
+ CRC32(0),
+ type(STORE) {}
+
+ /**
+ * Getters
+ */
+ const void* GetBuffer() { return compressedBuf; }
+ size_t GetSize() { return compressedSize; }
+ size_t GetUncompressedSize() { return uncompressedSize; }
+ size_t GetCRC32() { return CRC32; }
+ Type GetType() { return type; }
+
+ /**
+ * Returns a z_stream for use with inflate functions using the given
+ * buffer as inflate output. The caller is expected to allocate enough
+ * memory for the Stream uncompressed size.
+ */
+ z_stream GetZStream(void* buf) {
+ z_stream zStream;
+ zStream.avail_in = compressedSize;
+ zStream.next_in =
+ reinterpret_cast<Bytef*>(const_cast<void*>(compressedBuf));
+ zStream.avail_out = uncompressedSize;
+ zStream.next_out = static_cast<Bytef*>(buf);
+ zStream.zalloc = nullptr;
+ zStream.zfree = nullptr;
+ zStream.opaque = nullptr;
+ return zStream;
+ }
+
+ protected:
+ friend class Zip;
+ const void* compressedBuf;
+ size_t compressedSize;
+ size_t uncompressedSize;
+ size_t CRC32;
+ Type type;
+ };
+
+ /**
+ * Returns a stream from the Zip archive.
+ */
+ bool GetStream(const char* path, Stream* out) const;
+
+ /**
+ * Returns the file name of the archive
+ */
+ const char* GetName() const { return name; }
+
+ /**
+ * Returns whether all files have correct CRC checksum.
+ */
+ bool VerifyCRCs() const;
+
+ private:
+ /* File name of the archive */
+ char* name;
+ /* Address where the Zip archive is mapped */
+ void* mapped;
+ /* Size of the archive */
+ size_t size;
+
+ /**
+ * Strings (file names, comments, etc.) in the Zip headers are NOT zero
+ * terminated. This class is a helper around them.
+ */
+ class StringBuf {
+ public:
+ /**
+ * Constructor
+ */
+ StringBuf(const char* buf, size_t length) : buf(buf), length(length) {}
+
+ /**
+ * Returns whether the string has the same content as the given zero
+ * terminated string.
+ */
+ bool Equals(const char* str) const {
+ return (strncmp(str, buf, length) == 0 && str[length] == '\0');
+ }
+
+ private:
+ const char* buf;
+ size_t length;
+ };
+
+/* All the following types need to be packed */
+#pragma pack(1)
+ public:
+ /**
+ * A Zip archive is an aggregate of entities which all start with a
+ * signature giving their type. This template is to be used as a base
+ * class for these entities.
+ */
+ template <typename T>
+ class SignedEntity {
+ public:
+ /**
+ * Equivalent to reinterpret_cast<const T *>(buf), with an additional
+ * check of the signature.
+ */
+ static const T* validate(const void* buf) {
+ const T* ret = static_cast<const T*>(buf);
+ if (ret->signature == T::magic) return ret;
+ return nullptr;
+ }
+
+ explicit SignedEntity(uint32_t magic) : signature(magic) {}
+
+ private:
+ le_uint32 signature;
+ };
+
+ private:
+ /**
+ * Header used to describe a Local File entry. The header is followed by
+ * the file name and an extra field, then by the data stream.
+ */
+ struct LocalFile : public SignedEntity<LocalFile> {
+ /* Signature for a Local File header */
+ static const uint32_t magic = 0x04034b50;
+
+ /**
+ * Returns the file name
+ */
+ StringBuf GetName() const {
+ return StringBuf(reinterpret_cast<const char*>(this) + sizeof(*this),
+ filenameSize);
+ }
+
+ /**
+ * Returns a pointer to the data associated with this header
+ */
+ const void* GetData() const {
+ return reinterpret_cast<const char*>(this) + sizeof(*this) +
+ filenameSize + extraFieldSize;
+ }
+
+ le_uint16 minVersion;
+ le_uint16 generalFlag;
+ le_uint16 compression;
+ le_uint16 lastModifiedTime;
+ le_uint16 lastModifiedDate;
+ le_uint32 CRC32;
+ le_uint32 compressedSize;
+ le_uint32 uncompressedSize;
+ le_uint16 filenameSize;
+ le_uint16 extraFieldSize;
+ };
+
+ /**
+ * In some cases, when a zip archive is created, compressed size and CRC
+ * are not known when writing the Local File header. In these cases, the
+ * 3rd bit of the general flag in the Local File header is set, and there
+ * is an additional header following the compressed data.
+ */
+ struct DataDescriptor : public SignedEntity<DataDescriptor> {
+ /* Signature for a Data Descriptor header */
+ static const uint32_t magic = 0x08074b50;
+
+ le_uint32 CRC32;
+ le_uint32 compressedSize;
+ le_uint32 uncompressedSize;
+ };
+
+ /**
+ * Header used to describe a Central Directory Entry. The header is
+ * followed by the file name, an extra field, and a comment.
+ */
+ struct DirectoryEntry : public SignedEntity<DirectoryEntry> {
+ /* Signature for a Central Directory Entry header */
+ static const uint32_t magic = 0x02014b50;
+
+ /**
+ * Returns the file name
+ */
+ StringBuf GetName() const {
+ return StringBuf(reinterpret_cast<const char*>(this) + sizeof(*this),
+ filenameSize);
+ }
+
+ /**
+ * Returns the Central Directory Entry following this one.
+ */
+ const DirectoryEntry* GetNext() const {
+ return validate(reinterpret_cast<const char*>(this) + sizeof(*this) +
+ filenameSize + extraFieldSize + fileCommentSize);
+ }
+
+ le_uint16 creatorVersion;
+ le_uint16 minVersion;
+ le_uint16 generalFlag;
+ le_uint16 compression;
+ le_uint16 lastModifiedTime;
+ le_uint16 lastModifiedDate;
+ le_uint32 CRC32;
+ le_uint32 compressedSize;
+ le_uint32 uncompressedSize;
+ le_uint16 filenameSize;
+ le_uint16 extraFieldSize;
+ le_uint16 fileCommentSize;
+ le_uint16 diskNum;
+ le_uint16 internalAttributes;
+ le_uint32 externalAttributes;
+ le_uint32 offset;
+ };
+
+ /**
+ * Header used to describe the End of Central Directory Record.
+ */
+ struct CentralDirectoryEnd : public SignedEntity<CentralDirectoryEnd> {
+ /* Signature for the End of Central Directory Record */
+ static const uint32_t magic = 0x06054b50;
+
+ le_uint16 diskNum;
+ le_uint16 startDisk;
+ le_uint16 recordsOnDisk;
+ le_uint16 records;
+ le_uint32 size;
+ le_uint32 offset;
+ le_uint16 commentSize;
+ };
+#pragma pack()
+
+ /**
+ * Returns the first Directory entry
+ */
+ const DirectoryEntry* GetFirstEntry() const;
+
+ /* Pointer to the Local File Entry following the last one GetStream() used.
+ * This is used by GetStream to avoid scanning the Directory Entries when the
+ * requested entry is that one. */
+ mutable const LocalFile* nextFile;
+
+ /* Likewise for the next Directory entry */
+ mutable const DirectoryEntry* nextDir;
+
+ /* Pointer to the Directory entries */
+ mutable const DirectoryEntry* entries;
+
+ mutable pthread_mutex_t mutex;
+};
+
+/**
+ * Class for bookkeeping Zip instances
+ */
+class ZipCollection {
+ public:
+ static ZipCollection Singleton;
+
+ /**
+ * Get a Zip instance for the given path. If there is an existing one
+ * already, return that one, otherwise create a new one.
+ */
+ static already_AddRefed<Zip> GetZip(const char* path);
+
+ protected:
+ friend class Zip;
+ friend class mozilla::detail::RefCounted<Zip,
+ mozilla::detail::AtomicRefCount>;
+
+ /**
+ * Register the given Zip instance. This method is meant to be called
+ * by Zip::Create.
+ */
+ static void Register(Zip* zip);
+
+ /**
+ * Forget about the given Zip instance. This method is meant to be called
+ * by the Zip destructor.
+ */
+ static void Forget(const Zip* zip);
+
+ private:
+ /* Zip instances bookkept in this collection */
+ std::vector<RefPtr<Zip>> zips;
+};
+
+namespace mozilla {
+namespace detail {
+
+template <>
+inline void RefCounted<Zip, AtomicRefCount>::Release() const {
+ MOZ_ASSERT(static_cast<int32_t>(mRefCnt) > 0);
+ const auto count = --mRefCnt;
+ if (count == 1) {
+ // No external references are left, attempt to remove it from the
+ // collection. If it's successfully removed from the collection, Release()
+ // will be called with mRefCnt = 1, which will finally delete this zip.
+ ZipCollection::Forget(static_cast<const Zip*>(this));
+ } else if (count == 0) {
+#ifdef DEBUG
+ mRefCnt = detail::DEAD;
+#endif
+ delete static_cast<const Zip*>(this);
+ }
+}
+
+#ifdef DEBUG
+template <>
+inline RefCounted<Zip, AtomicRefCount>::~RefCounted() {
+ MOZ_ASSERT(mRefCnt == detail::DEAD);
+}
+#endif
+
+} // namespace detail
+} // namespace mozilla
+
+#endif /* Zip_h */
diff --git a/mozglue/linker/moz.build b/mozglue/linker/moz.build
new file mode 100644
index 0000000000..2eb2be9e35
--- /dev/null
+++ b/mozglue/linker/moz.build
@@ -0,0 +1,33 @@
+# -*- Mode: python; 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["MOZ_LINKER"]:
+ SOURCES += [
+ "BaseElf.cpp",
+ "CustomElf.cpp",
+ "ElfLoader.cpp",
+ "Mappable.cpp",
+ "XZStream.cpp",
+ ]
+
+# When the linker is disabled, we still need Zip for mozglue/android.
+# Logging is a required dependency.
+SOURCES += [
+ "Logging.cpp",
+ "Zip.cpp",
+]
+
+Library("linker")
+
+FINAL_LIBRARY = "mozglue"
+
+TEST_DIRS += ["tests"]
+
+DEFINES["XZ_USE_CRC64"] = 1
+
+USE_LIBS += [
+ "xz-embedded",
+]
diff --git a/mozglue/linker/tests/TestZip.cpp b/mozglue/linker/tests/TestZip.cpp
new file mode 100644
index 0000000000..a2d2b10bdd
--- /dev/null
+++ b/mozglue/linker/tests/TestZip.cpp
@@ -0,0 +1,61 @@
+/* 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 <cstdio>
+#include <unistd.h>
+#include "Zip.h"
+#include "mozilla/RefPtr.h"
+
+#include "gtest/gtest.h"
+
+Logging Logging::Singleton;
+
+/**
+ * test.zip is a basic test zip file with a central directory. It contains
+ * four entries, in the following order:
+ * "foo", "bar", "baz", "qux".
+ * The entries are going to be read out of order.
+ */
+extern const unsigned char TEST_ZIP[];
+extern const unsigned int TEST_ZIP_SIZE;
+const char* test_entries[] = {"baz", "foo", "bar", "qux"};
+
+/**
+ * no_central_dir.zip is a hand crafted test zip with no central directory
+ * entries. The Zip reader is expected to be able to traverse these entries
+ * if requested in order, without reading a central directory
+ * - First entry is a file "a", STOREd.
+ * - Second entry is a file "b", STOREd, using a data descriptor. CRC is
+ * unknown, but compressed and uncompressed sizes are known in the local
+ * file header.
+ * - Third entry is a file "c", DEFLATEd, using a data descriptor. CRC,
+ * compressed and uncompressed sizes are known in the local file header.
+ * This is the kind of entry that can be found in a zip that went through
+ * zipalign if it had a data descriptor originally.
+ * - Fourth entry is a file "d", STOREd.
+ */
+extern const unsigned char NO_CENTRAL_DIR_ZIP[];
+extern const unsigned int NO_CENTRAL_DIR_ZIP_SIZE;
+const char* no_central_dir_entries[] = {"a", "b", "c", "d"};
+
+TEST(Zip, TestZip)
+{
+ Zip::Stream s;
+ RefPtr<Zip> z = Zip::Create((void*)TEST_ZIP, TEST_ZIP_SIZE);
+ for (auto& entry : test_entries) {
+ ASSERT_TRUE(z->GetStream(entry, &s))
+ << "Could not get entry \"" << entry << "\"";
+ }
+}
+
+TEST(Zip, NoCentralDir)
+{
+ Zip::Stream s;
+ RefPtr<Zip> z =
+ Zip::Create((void*)NO_CENTRAL_DIR_ZIP, NO_CENTRAL_DIR_ZIP_SIZE);
+ for (auto& entry : no_central_dir_entries) {
+ ASSERT_TRUE(z->GetStream(entry, &s))
+ << "Could not get entry \"" << entry << "\"";
+ }
+}
diff --git a/mozglue/linker/tests/TestZipData.S b/mozglue/linker/tests/TestZipData.S
new file mode 100644
index 0000000000..5fbb825451
--- /dev/null
+++ b/mozglue/linker/tests/TestZipData.S
@@ -0,0 +1,17 @@
+.macro zip_data name, path
+ .global \name
+ .data
+ .balign 16
+ \name:
+ .incbin "\path"
+ .L\name\()_END:
+ .size \name, .L\name\()_END-\name
+ .global \name\()_SIZE
+ .data
+ .balign 4
+ \name\()_SIZE:
+ .int .L\name\()_END-\name
+.endm
+
+zip_data TEST_ZIP, "test.zip"
+zip_data NO_CENTRAL_DIR_ZIP, "no_central_dir.zip"
diff --git a/mozglue/linker/tests/moz.build b/mozglue/linker/tests/moz.build
new file mode 100644
index 0000000000..4ecc93b190
--- /dev/null
+++ b/mozglue/linker/tests/moz.build
@@ -0,0 +1,20 @@
+# -*- Mode: python; 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/.
+
+FINAL_LIBRARY = "xul-gtest"
+
+UNIFIED_SOURCES += [
+ "../Zip.cpp",
+ "TestZip.cpp",
+]
+
+SOURCES += [
+ "TestZipData.S",
+]
+
+LOCAL_INCLUDES += [".."]
+
+ASFLAGS += ["-I", SRCDIR]
diff --git a/mozglue/linker/tests/no_central_dir.zip b/mozglue/linker/tests/no_central_dir.zip
new file mode 100644
index 0000000000..df882220d1
--- /dev/null
+++ b/mozglue/linker/tests/no_central_dir.zip
Binary files differ
diff --git a/mozglue/linker/tests/test.zip b/mozglue/linker/tests/test.zip
new file mode 100644
index 0000000000..657835b0ca
--- /dev/null
+++ b/mozglue/linker/tests/test.zip
Binary files differ
diff --git a/mozglue/misc/AutoProfilerLabel.cpp b/mozglue/misc/AutoProfilerLabel.cpp
new file mode 100644
index 0000000000..eaa70fa335
--- /dev/null
+++ b/mozglue/misc/AutoProfilerLabel.cpp
@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "mozilla/AutoProfilerLabel.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/PlatformMutex.h"
+
+namespace mozilla {
+
+// RAII class that encapsulates all shared static data, and enforces locking
+// when accessing this data.
+class MOZ_RAII AutoProfilerLabelData {
+ public:
+ AutoProfilerLabelData() { sAPLMutex.Lock(); }
+
+ ~AutoProfilerLabelData() { sAPLMutex.Unlock(); }
+
+ AutoProfilerLabelData(const AutoProfilerLabelData&) = delete;
+ void operator=(const AutoProfilerLabelData&) = delete;
+
+ const ProfilerLabelEnter& EnterCRef() const { return sEnter; }
+ ProfilerLabelEnter& EnterRef() { return sEnter; }
+
+ const ProfilerLabelExit& ExitCRef() const { return sExit; }
+ ProfilerLabelExit& ExitRef() { return sExit; }
+
+ const uint32_t& GenerationCRef() const { return sGeneration; }
+ uint32_t& GenerationRef() { return sGeneration; }
+
+ static bool RacyIsProfilerPresent() { return !!sGeneration; }
+
+ private:
+ // Thin shell around mozglue PlatformMutex, for local internal use.
+ // Does not preserve behavior in JS record/replay.
+ class Mutex : private mozilla::detail::MutexImpl {
+ public:
+ Mutex() : mozilla::detail::MutexImpl() {}
+ void Lock() { mozilla::detail::MutexImpl::lock(); }
+ void Unlock() { mozilla::detail::MutexImpl::unlock(); }
+ };
+
+ // Mutex protecting access to the following static members.
+ static Mutex sAPLMutex MOZ_UNANNOTATED;
+
+ static ProfilerLabelEnter sEnter;
+ static ProfilerLabelExit sExit;
+
+ // Current "generation" of RegisterProfilerLabelEnterExit calls.
+ static uint32_t sGeneration;
+};
+
+/* static */ AutoProfilerLabelData::Mutex AutoProfilerLabelData::sAPLMutex;
+/* static */ ProfilerLabelEnter AutoProfilerLabelData::sEnter = nullptr;
+/* static */ ProfilerLabelExit AutoProfilerLabelData::sExit = nullptr;
+/* static */ uint32_t AutoProfilerLabelData::sGeneration = 0;
+
+void RegisterProfilerLabelEnterExit(ProfilerLabelEnter aEnter,
+ ProfilerLabelExit aExit) {
+ MOZ_ASSERT(!aEnter == !aExit, "Must provide both null or both non-null");
+
+ AutoProfilerLabelData data;
+ MOZ_ASSERT(!aEnter != !data.EnterRef(),
+ "Must go from null to non-null, or from non-null to null");
+ data.EnterRef() = aEnter;
+ data.ExitRef() = aExit;
+ ++data.GenerationRef();
+}
+
+bool IsProfilerPresent() {
+ return AutoProfilerLabelData::RacyIsProfilerPresent();
+}
+
+ProfilerLabel ProfilerLabelBegin(const char* aLabelName,
+ const char* aDynamicString, void* aSp) {
+ const AutoProfilerLabelData data;
+ void* entryContext = (data.EnterCRef())
+ ? data.EnterCRef()(aLabelName, aDynamicString, aSp)
+ : nullptr;
+ uint32_t generation = data.GenerationCRef();
+
+ return std::make_tuple(entryContext, generation);
+}
+
+void ProfilerLabelEnd(const ProfilerLabel& aLabel) {
+ if (!IsValidProfilerLabel(aLabel)) {
+ return;
+ }
+
+ const AutoProfilerLabelData data;
+ if (data.ExitCRef() && (std::get<1>(aLabel) == data.GenerationCRef())) {
+ data.ExitCRef()(std::get<0>(aLabel));
+ }
+}
+
+AutoProfilerLabel::AutoProfilerLabel(const char* aLabel,
+ const char* aDynamicString) {
+ std::tie(mEntryContext, mGeneration) =
+ ProfilerLabelBegin(aLabel, aDynamicString, this);
+}
+
+AutoProfilerLabel::~AutoProfilerLabel() {
+ ProfilerLabelEnd(std::make_tuple(mEntryContext, mGeneration));
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/AutoProfilerLabel.h b/mozglue/misc/AutoProfilerLabel.h
new file mode 100644
index 0000000000..82299c7b15
--- /dev/null
+++ b/mozglue/misc/AutoProfilerLabel.h
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#ifndef mozilla_AutoProfilerLabel_h
+#define mozilla_AutoProfilerLabel_h
+
+#include "mozilla/Attributes.h"
+
+#include "mozilla/Types.h"
+#include <tuple>
+
+// The Gecko Profiler defines AutoProfilerLabel, an RAII class for
+// pushing/popping frames to/from the ProfilingStack.
+//
+// This file defines a class of the same name that does much the same thing,
+// but which can be used in (and only in) mozglue. A different class is
+// necessary because mozglue cannot directly access sProfilingStack.
+//
+// Note that this class is slightly slower than the other AutoProfilerLabel,
+// and it lacks the macro wrappers. It also is effectively hardwired to use
+// JS::ProfilingCategory::OTHER as the category pair, because that's what
+// the callbacks provided by the profiler use. (Specifying the categories in
+// this file would require #including ProfilingCategory.h in mozglue, which we
+// don't want to do.)
+
+namespace mozilla {
+
+// Enter should return a pointer that will be given to Exit.
+typedef void* (*ProfilerLabelEnter)(const char* aLabel,
+ const char* aDynamicString, void* aSp);
+typedef void (*ProfilerLabelExit)(void* EntryContext);
+
+// Register callbacks that do the entry/exit work involving sProfilingStack.
+MFBT_API void RegisterProfilerLabelEnterExit(ProfilerLabelEnter aEnter,
+ ProfilerLabelExit aExit);
+
+// This #ifdef prevents this AutoProfilerLabel from being defined in libxul,
+// which would conflict with the one in the profiler.
+#ifdef IMPL_MFBT
+
+class MOZ_RAII AutoProfilerLabel {
+ public:
+ AutoProfilerLabel(const char* aLabel, const char* aDynamicString);
+ ~AutoProfilerLabel();
+
+ private:
+ void* mEntryContext;
+ // Number of RegisterProfilerLabelEnterExit calls, to avoid giving an entry
+ // context from one generation to the next.
+ uint32_t mGeneration;
+};
+
+using ProfilerLabel = std::tuple<void*, uint32_t>;
+
+bool IsProfilerPresent();
+ProfilerLabel ProfilerLabelBegin(const char* aLabelName,
+ const char* aDynamicString, void* aSp);
+void ProfilerLabelEnd(const ProfilerLabel& aLabel);
+
+inline bool IsValidProfilerLabel(const ProfilerLabel& aLabel) {
+ return !!std::get<0>(aLabel);
+}
+
+#endif
+
+} // namespace mozilla
+
+#endif // mozilla_AutoProfilerLabel_h
diff --git a/mozglue/misc/AwakeTimeStamp.cpp b/mozglue/misc/AwakeTimeStamp.cpp
new file mode 100644
index 0000000000..a5c8ed4abd
--- /dev/null
+++ b/mozglue/misc/AwakeTimeStamp.cpp
@@ -0,0 +1,93 @@
+/* -*- 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/. */
+
+#include "AwakeTimeStamp.h"
+
+#ifdef XP_WIN
+# include <windows.h>
+#endif
+
+#include "mozilla/Assertions.h"
+#include "mozilla/DebugOnly.h"
+
+namespace mozilla {
+
+static constexpr uint64_t kUSperS = 1000000;
+static constexpr uint64_t kUSperMS = 1000;
+#ifndef XP_WIN
+static constexpr uint64_t kNSperUS = 1000;
+#endif
+
+double AwakeTimeDuration::ToSeconds() const {
+ return static_cast<double>(mValueUs) / kUSperS;
+}
+double AwakeTimeDuration::ToMilliseconds() const {
+ return static_cast<double>(mValueUs) / kUSperMS;
+}
+double AwakeTimeDuration::ToMicroseconds() const {
+ return static_cast<double>(mValueUs);
+}
+
+AwakeTimeDuration AwakeTimeStamp::operator-(
+ AwakeTimeStamp const& aOther) const {
+ return AwakeTimeDuration(mValueUs - aOther.mValueUs);
+}
+
+AwakeTimeStamp AwakeTimeStamp::operator+(
+ const AwakeTimeDuration& aDuration) const {
+ return AwakeTimeStamp(mValueUs + aDuration.mValueUs);
+}
+
+void AwakeTimeStamp::operator+=(const AwakeTimeDuration& aOther) {
+ mValueUs += aOther.mValueUs;
+}
+
+void AwakeTimeStamp::operator-=(const AwakeTimeDuration& aOther) {
+ MOZ_ASSERT(mValueUs >= aOther.mValueUs);
+ mValueUs -= aOther.mValueUs;
+}
+
+// Apple things
+#if defined(__APPLE__) && defined(__MACH__)
+# include <time.h>
+# include <sys/time.h>
+# include <sys/types.h>
+# include <mach/mach_time.h>
+
+AwakeTimeStamp AwakeTimeStamp::NowLoRes() {
+ return AwakeTimeStamp(clock_gettime_nsec_np(CLOCK_UPTIME_RAW) / kNSperUS);
+}
+
+#elif defined(XP_WIN)
+
+// Number of hundreds of nanoseconds in a microsecond
+static constexpr uint64_t kHNSperUS = 10;
+
+AwakeTimeStamp AwakeTimeStamp::NowLoRes() {
+ ULONGLONG interrupt_time;
+ DebugOnly<bool> rv = QueryUnbiasedInterruptTime(&interrupt_time);
+ MOZ_ASSERT(rv);
+
+ return AwakeTimeStamp(interrupt_time / kHNSperUS);
+}
+
+#else // Linux and other POSIX but not macOS
+# include <time.h>
+
+uint64_t TimespecToMicroseconds(struct timespec aTs) {
+ return aTs.tv_sec * kUSperS + aTs.tv_nsec / kNSperUS;
+}
+
+AwakeTimeStamp AwakeTimeStamp::NowLoRes() {
+ struct timespec ts = {0};
+ DebugOnly<int> rv = clock_gettime(CLOCK_MONOTONIC, &ts);
+ MOZ_ASSERT(!rv);
+ return AwakeTimeStamp(TimespecToMicroseconds(ts));
+}
+
+#endif
+
+}; // namespace mozilla
diff --git a/mozglue/misc/AwakeTimeStamp.h b/mozglue/misc/AwakeTimeStamp.h
new file mode 100644
index 0000000000..b95ef9e77e
--- /dev/null
+++ b/mozglue/misc/AwakeTimeStamp.h
@@ -0,0 +1,118 @@
+/* -*- 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/. */
+
+#ifndef mozilla_AwakeTimeStamp_h
+#define mozilla_AwakeTimeStamp_h
+
+#include <stdint.h>
+#include <mozilla/Types.h>
+#include "mozilla/Assertions.h"
+
+namespace mozilla {
+
+class AwakeTimeDuration;
+
+// Conceptually like mozilla::TimeStamp, but only increments when the device is
+// awake, on all platforms, and with a restricted API.
+//
+// It is always valid, there is no way to acquire an AwakeTimeStamp that is not
+// valid, unlike TimeStamp that can be null.
+//
+// Some arithmetic and ordering operations are supported, when they make sense.
+//
+// This timestamp shouldn't be considered to be high-resolution, and is suitable
+// to measure time from a hundred of milliseconds (because of Windows
+// limitations).
+class AwakeTimeStamp {
+ public:
+ MFBT_API static AwakeTimeStamp NowLoRes();
+ MFBT_API void operator+=(const AwakeTimeDuration& aOther);
+ MFBT_API void operator-=(const AwakeTimeDuration& aOther);
+ MFBT_API bool operator<(const AwakeTimeStamp& aOther) const {
+ return mValueUs < aOther.mValueUs;
+ }
+ MFBT_API bool operator<=(const AwakeTimeStamp& aOther) const {
+ return mValueUs <= aOther.mValueUs;
+ }
+ MFBT_API bool operator>=(const AwakeTimeStamp& aOther) const {
+ return mValueUs >= aOther.mValueUs;
+ }
+ MFBT_API bool operator>(const AwakeTimeStamp& aOther) const {
+ return mValueUs > aOther.mValueUs;
+ }
+ MFBT_API bool operator==(const AwakeTimeStamp& aOther) const {
+ return mValueUs == aOther.mValueUs;
+ }
+ MFBT_API bool operator!=(const AwakeTimeStamp& aOther) const {
+ return !(*this == aOther);
+ }
+ MFBT_API AwakeTimeDuration operator-(AwakeTimeStamp const& aOther) const;
+ MFBT_API AwakeTimeStamp operator+(const AwakeTimeDuration& aDuration) const;
+
+ private:
+ explicit AwakeTimeStamp(uint64_t aValueUs) : mValueUs(aValueUs) {}
+
+ uint64_t mValueUs;
+};
+
+// A duration, only counting the time the computer was awake.
+//
+// Can be obtained via subtracting two AwakeTimeStamp, or default-contructed to
+// mean a empty duration.
+//
+// Arithmetic and ordering operations are defined when they make sense.
+class AwakeTimeDuration {
+ public:
+ MFBT_API AwakeTimeDuration() : mValueUs(0) {}
+
+ MFBT_API double ToSeconds() const;
+ MFBT_API double ToMilliseconds() const;
+ MFBT_API double ToMicroseconds() const;
+ MFBT_API void operator+=(const AwakeTimeDuration& aDuration) {
+ mValueUs += aDuration.mValueUs;
+ }
+ MFBT_API AwakeTimeDuration operator+(const AwakeTimeDuration& aOther) const {
+ return AwakeTimeDuration(mValueUs + aOther.mValueUs);
+ }
+ MFBT_API AwakeTimeDuration operator-(const AwakeTimeDuration& aOther) const {
+ MOZ_ASSERT(mValueUs >= aOther.mValueUs);
+ return AwakeTimeDuration(mValueUs - aOther.mValueUs);
+ }
+ MFBT_API void operator-=(const AwakeTimeDuration& aOther) {
+ MOZ_ASSERT(mValueUs >= aOther.mValueUs);
+ mValueUs -= aOther.mValueUs;
+ }
+ MFBT_API bool operator<(const AwakeTimeDuration& aOther) const {
+ return mValueUs < aOther.mValueUs;
+ }
+ MFBT_API bool operator<=(const AwakeTimeDuration& aOther) const {
+ return mValueUs <= aOther.mValueUs;
+ }
+ MFBT_API bool operator>=(const AwakeTimeDuration& aOther) const {
+ return mValueUs >= aOther.mValueUs;
+ }
+ MFBT_API bool operator>(const AwakeTimeDuration& aOther) const {
+ return mValueUs > aOther.mValueUs;
+ }
+ MFBT_API bool operator==(const AwakeTimeDuration& aOther) const {
+ return mValueUs == aOther.mValueUs;
+ }
+ MFBT_API bool operator!=(const AwakeTimeDuration& aOther) const {
+ return !(*this == aOther);
+ }
+
+ private:
+ friend AwakeTimeStamp;
+ // Not using a default value because we want this private, but allow creating
+ // duration that are empty.
+ explicit AwakeTimeDuration(uint64_t aValueUs) : mValueUs(aValueUs) {}
+
+ uint64_t mValueUs;
+};
+
+}; // namespace mozilla
+
+#endif // mozilla_AwakeTimeStamp_h
diff --git a/mozglue/misc/ConditionVariable_noop.cpp b/mozglue/misc/ConditionVariable_noop.cpp
new file mode 100644
index 0000000000..4b28861650
--- /dev/null
+++ b/mozglue/misc/ConditionVariable_noop.cpp
@@ -0,0 +1,40 @@
+/* -*- 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/. */
+
+#include "mozilla/Assertions.h"
+
+#include "mozilla/PlatformConditionVariable.h"
+#include "mozilla/PlatformMutex.h"
+#include "MutexPlatformData_noop.h"
+
+using mozilla::TimeDuration;
+
+struct mozilla::detail::ConditionVariableImpl::PlatformData {};
+
+mozilla::detail::ConditionVariableImpl::ConditionVariableImpl() {}
+
+mozilla::detail::ConditionVariableImpl::~ConditionVariableImpl() {}
+
+void mozilla::detail::ConditionVariableImpl::notify_one() {}
+
+void mozilla::detail::ConditionVariableImpl::notify_all() {}
+
+void mozilla::detail::ConditionVariableImpl::wait(MutexImpl&) {
+ // On WASI, there are no threads, so we never wait (either the condvar must
+ // be ready or there is a deadlock).
+}
+
+mozilla::CVStatus mozilla::detail::ConditionVariableImpl::wait_for(
+ MutexImpl&, const TimeDuration&) {
+ return CVStatus::NoTimeout;
+}
+
+mozilla::detail::ConditionVariableImpl::PlatformData*
+mozilla::detail::ConditionVariableImpl::platformData() {
+ static_assert(sizeof platformData_ >= sizeof(PlatformData),
+ "platformData_ is too small");
+ return reinterpret_cast<PlatformData*>(platformData_);
+}
diff --git a/mozglue/misc/ConditionVariable_posix.cpp b/mozglue/misc/ConditionVariable_posix.cpp
new file mode 100644
index 0000000000..5c98560551
--- /dev/null
+++ b/mozglue/misc/ConditionVariable_posix.cpp
@@ -0,0 +1,159 @@
+/* -*- 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/. */
+
+#include "mozilla/Assertions.h"
+#include "mozilla/CheckedInt.h"
+
+#include <errno.h>
+#include <pthread.h>
+#include <time.h>
+
+#include "mozilla/PlatformConditionVariable.h"
+#include "mozilla/PlatformMutex.h"
+#include "MutexPlatformData_posix.h"
+
+using mozilla::CheckedInt;
+using mozilla::TimeDuration;
+
+static const long NanoSecPerSec = 1000000000;
+
+// Android 4.4 or earlier & macOS 10.12 has the clock functions, but not
+// pthread_condattr_setclock.
+#if defined(HAVE_CLOCK_MONOTONIC) && \
+ !(defined(__ANDROID__) && __ANDROID_API__ < 21) && !defined(__APPLE__)
+# define CV_USE_CLOCK_API
+#endif
+
+#ifdef CV_USE_CLOCK_API
+// The C++ specification defines std::condition_variable::wait_for in terms of
+// std::chrono::steady_clock, which is closest to CLOCK_MONOTONIC.
+static const clockid_t WhichClock = CLOCK_MONOTONIC;
+
+// While timevaladd is widely available to work with timevals, the newer
+// timespec structure is largely lacking such conveniences. Thankfully, the
+// utilities available in MFBT make implementing our own quite easy.
+static void moz_timespecadd(struct timespec* lhs, struct timespec* rhs,
+ struct timespec* result) {
+ // Add nanoseconds. This may wrap, but not above 2 billion.
+ MOZ_RELEASE_ASSERT(lhs->tv_nsec < NanoSecPerSec);
+ MOZ_RELEASE_ASSERT(rhs->tv_nsec < NanoSecPerSec);
+ result->tv_nsec = lhs->tv_nsec + rhs->tv_nsec;
+
+ // Add seconds, checking for overflow in the platform specific time_t type.
+ CheckedInt<time_t> sec = CheckedInt<time_t>(lhs->tv_sec) + rhs->tv_sec;
+
+ // If nanoseconds overflowed, carry the result over into seconds.
+ if (result->tv_nsec >= NanoSecPerSec) {
+ MOZ_RELEASE_ASSERT(result->tv_nsec < 2 * NanoSecPerSec);
+ result->tv_nsec -= NanoSecPerSec;
+ sec += 1;
+ }
+
+ // Extracting the value asserts that there was no overflow.
+ MOZ_RELEASE_ASSERT(sec.isValid());
+ result->tv_sec = sec.value();
+}
+#endif
+
+struct mozilla::detail::ConditionVariableImpl::PlatformData {
+ pthread_cond_t ptCond;
+};
+
+mozilla::detail::ConditionVariableImpl::ConditionVariableImpl() {
+ pthread_cond_t* ptCond = &platformData()->ptCond;
+
+#ifdef CV_USE_CLOCK_API
+ pthread_condattr_t attr;
+ int r0 = pthread_condattr_init(&attr);
+ MOZ_RELEASE_ASSERT(!r0);
+
+ int r1 = pthread_condattr_setclock(&attr, WhichClock);
+ MOZ_RELEASE_ASSERT(!r1);
+
+ int r2 = pthread_cond_init(ptCond, &attr);
+ MOZ_RELEASE_ASSERT(!r2);
+
+ int r3 = pthread_condattr_destroy(&attr);
+ MOZ_RELEASE_ASSERT(!r3);
+#else
+ int r = pthread_cond_init(ptCond, NULL);
+ MOZ_RELEASE_ASSERT(!r);
+#endif
+}
+
+mozilla::detail::ConditionVariableImpl::~ConditionVariableImpl() {
+ int r = pthread_cond_destroy(&platformData()->ptCond);
+ MOZ_RELEASE_ASSERT(r == 0);
+}
+
+void mozilla::detail::ConditionVariableImpl::notify_one() {
+ int r = pthread_cond_signal(&platformData()->ptCond);
+ MOZ_RELEASE_ASSERT(r == 0);
+}
+
+void mozilla::detail::ConditionVariableImpl::notify_all() {
+ int r = pthread_cond_broadcast(&platformData()->ptCond);
+ MOZ_RELEASE_ASSERT(r == 0);
+}
+
+void mozilla::detail::ConditionVariableImpl::wait(MutexImpl& lock) {
+ pthread_cond_t* ptCond = &platformData()->ptCond;
+ pthread_mutex_t* ptMutex = &lock.platformData()->ptMutex;
+
+ int r = pthread_cond_wait(ptCond, ptMutex);
+ MOZ_RELEASE_ASSERT(r == 0);
+}
+
+mozilla::CVStatus mozilla::detail::ConditionVariableImpl::wait_for(
+ MutexImpl& lock, const TimeDuration& a_rel_time) {
+ if (a_rel_time == TimeDuration::Forever()) {
+ wait(lock);
+ return CVStatus::NoTimeout;
+ }
+
+ pthread_cond_t* ptCond = &platformData()->ptCond;
+ pthread_mutex_t* ptMutex = &lock.platformData()->ptMutex;
+ int r;
+
+ // Clamp to 0, as time_t is unsigned.
+ TimeDuration rel_time = a_rel_time < TimeDuration::FromSeconds(0)
+ ? TimeDuration::FromSeconds(0)
+ : a_rel_time;
+
+ // Convert the duration to a timespec.
+ struct timespec rel_ts;
+ rel_ts.tv_sec = static_cast<time_t>(rel_time.ToSeconds());
+ rel_ts.tv_nsec =
+ static_cast<uint64_t>(rel_time.ToMicroseconds() * 1000.0) % NanoSecPerSec;
+
+#ifdef CV_USE_CLOCK_API
+ struct timespec now_ts;
+ r = clock_gettime(WhichClock, &now_ts);
+ MOZ_RELEASE_ASSERT(!r);
+
+ struct timespec abs_ts;
+ moz_timespecadd(&now_ts, &rel_ts, &abs_ts);
+
+ r = pthread_cond_timedwait(ptCond, ptMutex, &abs_ts);
+#else
+ // Our non-clock-supporting platforms, OS X and Android, do support waiting
+ // on a condition variable with a relative timeout.
+ r = pthread_cond_timedwait_relative_np(ptCond, ptMutex, &rel_ts);
+#endif
+
+ if (r == 0) {
+ return CVStatus::NoTimeout;
+ }
+ MOZ_RELEASE_ASSERT(r == ETIMEDOUT);
+ return CVStatus::Timeout;
+}
+
+mozilla::detail::ConditionVariableImpl::PlatformData*
+mozilla::detail::ConditionVariableImpl::platformData() {
+ static_assert(sizeof platformData_ >= sizeof(PlatformData),
+ "platformData_ is too small");
+ return reinterpret_cast<PlatformData*>(platformData_);
+}
diff --git a/mozglue/misc/ConditionVariable_windows.cpp b/mozglue/misc/ConditionVariable_windows.cpp
new file mode 100644
index 0000000000..0c0151f1d3
--- /dev/null
+++ b/mozglue/misc/ConditionVariable_windows.cpp
@@ -0,0 +1,98 @@
+/* -*- 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/. */
+
+#include "mozilla/Assertions.h"
+
+#include <float.h>
+#include <intrin.h>
+#include <stdlib.h>
+#include <windows.h>
+
+#include "mozilla/PlatformConditionVariable.h"
+#include "mozilla/PlatformMutex.h"
+#include "MutexPlatformData_windows.h"
+
+// Some versions of the Windows SDK have a bug where some interlocked functions
+// are not redefined as compiler intrinsics. Fix that for the interlocked
+// functions that are used in this file.
+#if defined(_MSC_VER) && !defined(InterlockedExchangeAdd)
+# define InterlockedExchangeAdd(addend, value) \
+ _InterlockedExchangeAdd((volatile long*)(addend), (long)(value))
+#endif
+
+#if defined(_MSC_VER) && !defined(InterlockedIncrement)
+# define InterlockedIncrement(addend) \
+ _InterlockedIncrement((volatile long*)(addend))
+#endif
+
+// Wrapper for native condition variable APIs.
+struct mozilla::detail::ConditionVariableImpl::PlatformData {
+ CONDITION_VARIABLE cv_;
+};
+
+mozilla::detail::ConditionVariableImpl::ConditionVariableImpl() {
+ InitializeConditionVariable(&platformData()->cv_);
+}
+
+void mozilla::detail::ConditionVariableImpl::notify_one() {
+ WakeConditionVariable(&platformData()->cv_);
+}
+
+void mozilla::detail::ConditionVariableImpl::notify_all() {
+ WakeAllConditionVariable(&platformData()->cv_);
+}
+
+void mozilla::detail::ConditionVariableImpl::wait(MutexImpl& lock) {
+ SRWLOCK* srwlock = &lock.platformData()->lock;
+ bool r =
+ SleepConditionVariableSRW(&platformData()->cv_, srwlock, INFINITE, 0);
+ MOZ_RELEASE_ASSERT(r);
+}
+
+mozilla::CVStatus mozilla::detail::ConditionVariableImpl::wait_for(
+ MutexImpl& lock, const mozilla::TimeDuration& rel_time) {
+ if (rel_time == mozilla::TimeDuration::Forever()) {
+ wait(lock);
+ return CVStatus::NoTimeout;
+ }
+
+ SRWLOCK* srwlock = &lock.platformData()->lock;
+
+ // Note that DWORD is unsigned, so we have to be careful to clamp at 0. If
+ // rel_time is Forever, then ToMilliseconds is +inf, which evaluates as
+ // greater than UINT32_MAX, resulting in the correct INFINITE wait. We also
+ // don't want to round sub-millisecond waits to 0, as that wastes energy (see
+ // bug 1437167 comment 6), so we instead round submillisecond waits to 1ms.
+ double msecd = rel_time.ToMilliseconds();
+ DWORD msec;
+ if (msecd < 0.0) {
+ msec = 0;
+ } else if (msecd > UINT32_MAX) {
+ msec = INFINITE;
+ } else {
+ msec = static_cast<DWORD>(msecd);
+ // Round submillisecond waits to 1ms.
+ if (msec == 0 && !rel_time.IsZero()) {
+ msec = 1;
+ }
+ }
+
+ BOOL r = SleepConditionVariableSRW(&platformData()->cv_, srwlock, msec, 0);
+ if (r) return CVStatus::NoTimeout;
+ MOZ_RELEASE_ASSERT(GetLastError() == ERROR_TIMEOUT);
+ return CVStatus::Timeout;
+}
+
+mozilla::detail::ConditionVariableImpl::~ConditionVariableImpl() {
+ // Native condition variables don't require cleanup.
+}
+
+inline mozilla::detail::ConditionVariableImpl::PlatformData*
+mozilla::detail::ConditionVariableImpl::platformData() {
+ static_assert(sizeof platformData_ >= sizeof(PlatformData),
+ "platformData_ is too small");
+ return reinterpret_cast<PlatformData*>(platformData_);
+}
diff --git a/mozglue/misc/Debug.h b/mozglue/misc/Debug.h
new file mode 100644
index 0000000000..f8f05c6299
--- /dev/null
+++ b/mozglue/misc/Debug.h
@@ -0,0 +1,69 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_glue_Debug_h
+#define mozilla_glue_Debug_h
+
+/* This header file intends to supply debugging utilities for use in code
+ * that cannot use XPCOM debugging facilities like nsDebug.h.
+ * e.g. mozglue, browser/app
+ *
+ * NB: printf_stderr() is in the global namespace, so include this file with
+ * care; avoid including from header files.
+ */
+
+#include <io.h>
+#if defined(XP_WIN)
+# include <windows.h>
+#endif // defined(XP_WIN)
+#include "mozilla/Attributes.h"
+#include "mozilla/Sprintf.h"
+
+#if defined(MOZILLA_INTERNAL_API)
+# error Do not include this file from XUL sources.
+#endif
+
+// Though this is a separate implementation than nsDebug's, we want to make the
+// declarations compatible to avoid confusing the linker if both headers are
+// included.
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void printf_stderr(const char* fmt, ...) MOZ_FORMAT_PRINTF(1, 2);
+inline void printf_stderr(const char* fmt, ...) {
+#if defined(XP_WIN)
+ if (IsDebuggerPresent()) {
+ char buf[2048];
+ va_list args;
+ va_start(args, fmt);
+ VsprintfLiteral(buf, fmt, args);
+ va_end(args);
+ OutputDebugStringA(buf);
+ }
+#endif // defined(XP_WIN)
+
+ // stderr is unbuffered by default so we open a new FILE (which is buffered)
+ // so that calls to printf_stderr are not as likely to get mixed together.
+ int fd = _fileno(stderr);
+ if (fd == -2) return;
+
+ FILE* fp = _fdopen(_dup(fd), "a");
+ if (!fp) return;
+
+ va_list args;
+ va_start(args, fmt);
+ vfprintf(fp, fmt, args);
+ va_end(args);
+
+ fclose(fp);
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // mozilla_glue_Debug_h
diff --git a/mozglue/misc/DynamicallyLinkedFunctionPtr.h b/mozglue/misc/DynamicallyLinkedFunctionPtr.h
new file mode 100644
index 0000000000..4313974ec5
--- /dev/null
+++ b/mozglue/misc/DynamicallyLinkedFunctionPtr.h
@@ -0,0 +1,137 @@
+/* -*- 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/. */
+
+#ifndef mozilla_DynamicallyLinkedFunctionPtr_h
+#define mozilla_DynamicallyLinkedFunctionPtr_h
+
+#include <windows.h>
+
+#include <utility>
+
+#include "mozilla/Attributes.h"
+
+namespace mozilla {
+namespace detail {
+
+template <typename T>
+struct FunctionPtrCracker;
+
+template <typename R, typename... Args>
+struct FunctionPtrCracker<R (*)(Args...)> {
+ using ReturnT = R;
+ using FunctionPtrT = R (*)(Args...);
+};
+
+#if defined(_M_IX86)
+template <typename R, typename... Args>
+struct FunctionPtrCracker<R(__stdcall*)(Args...)> {
+ using ReturnT = R;
+ using FunctionPtrT = R(__stdcall*)(Args...);
+};
+
+template <typename R, typename... Args>
+struct FunctionPtrCracker<R(__fastcall*)(Args...)> {
+ using ReturnT = R;
+ using FunctionPtrT = R(__fastcall*)(Args...);
+};
+#endif // defined(_M_IX86)
+
+template <typename T>
+class DynamicallyLinkedFunctionPtrBase {
+ public:
+ using ReturnT = typename FunctionPtrCracker<T>::ReturnT;
+ using FunctionPtrT = typename FunctionPtrCracker<T>::FunctionPtrT;
+
+ DynamicallyLinkedFunctionPtrBase(const wchar_t* aLibName,
+ const char* aFuncName)
+ : mModule(::LoadLibraryW(aLibName)), mFunction(nullptr) {
+ if (!mModule) {
+ return;
+ }
+
+ mFunction =
+ reinterpret_cast<FunctionPtrT>(::GetProcAddress(mModule, aFuncName));
+
+ if (!mFunction) {
+ // Since the function doesn't exist, there is no point in holding a
+ // reference to mModule anymore.
+ ::FreeLibrary(mModule);
+ mModule = nullptr;
+ }
+ }
+
+ DynamicallyLinkedFunctionPtrBase(const DynamicallyLinkedFunctionPtrBase&) =
+ delete;
+ DynamicallyLinkedFunctionPtrBase& operator=(
+ const DynamicallyLinkedFunctionPtrBase&) = delete;
+
+ DynamicallyLinkedFunctionPtrBase(DynamicallyLinkedFunctionPtrBase&&) = delete;
+ DynamicallyLinkedFunctionPtrBase& operator=(
+ DynamicallyLinkedFunctionPtrBase&&) = delete;
+
+ template <typename... Args>
+ ReturnT operator()(Args&&... args) const {
+ return mFunction(std::forward<Args>(args)...);
+ }
+
+ explicit operator bool() const { return !!mFunction; }
+
+ protected:
+ HMODULE mModule;
+ FunctionPtrT mFunction;
+};
+
+} // namespace detail
+
+/**
+ * In most cases, this class is the one that you want to use for resolving a
+ * dynamically-linked function pointer. It should be instantiated as a static
+ * local variable.
+ *
+ * NB: It has a trivial destructor, so the DLL that is loaded is never freed.
+ * Assuming that this function is called fairly often, this is the most
+ * sensible option. OTOH, if the function you are calling is a one-off, or the
+ * static local requirement is too restrictive, use DynamicallyLinkedFunctionPtr
+ * instead.
+ */
+template <typename T>
+class MOZ_STATIC_LOCAL_CLASS StaticDynamicallyLinkedFunctionPtr final
+ : public detail::DynamicallyLinkedFunctionPtrBase<T> {
+ public:
+ StaticDynamicallyLinkedFunctionPtr(const wchar_t* aLibName,
+ const char* aFuncName)
+ : detail::DynamicallyLinkedFunctionPtrBase<T>(aLibName, aFuncName) {}
+
+ /**
+ * We only offer this operator for the static local case, as it is not
+ * possible for this object to be destroyed while the returned pointer is
+ * being held.
+ */
+ operator typename detail::DynamicallyLinkedFunctionPtrBase<T>::FunctionPtrT()
+ const {
+ return this->mFunction;
+ }
+};
+
+template <typename T>
+class MOZ_NON_PARAM MOZ_NON_TEMPORARY_CLASS DynamicallyLinkedFunctionPtr final
+ : public detail::DynamicallyLinkedFunctionPtrBase<T> {
+ public:
+ DynamicallyLinkedFunctionPtr(const wchar_t* aLibName, const char* aFuncName)
+ : detail::DynamicallyLinkedFunctionPtrBase<T>(aLibName, aFuncName) {}
+
+ ~DynamicallyLinkedFunctionPtr() {
+ if (!this->mModule) {
+ return;
+ }
+
+ ::FreeLibrary(this->mModule);
+ }
+};
+
+} // namespace mozilla
+
+#endif // mozilla_DynamicallyLinkedFunctionPtr_h
diff --git a/mozglue/misc/GetKnownFolderPath.cpp b/mozglue/misc/GetKnownFolderPath.cpp
new file mode 100644
index 0000000000..676a1c8056
--- /dev/null
+++ b/mozglue/misc/GetKnownFolderPath.cpp
@@ -0,0 +1,33 @@
+/* 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 "GetKnownFolderPath.h"
+
+namespace mozilla {
+
+UniquePtr<wchar_t, LoadedCoTaskMemFreeDeleter> GetKnownFolderPath(
+ REFKNOWNFOLDERID folderId) {
+ static decltype(SHGetKnownFolderPath)* shGetKnownFolderPath = nullptr;
+ if (!shGetKnownFolderPath) {
+ // We could go out of our way to `FreeLibrary` on this, decrementing its
+ // ref count and potentially unloading it. However doing so would be either
+ // effectively a no-op, or counterproductive. Just let it get cleaned up
+ // when the process is terminated, because we're going to load it anyway
+ // elsewhere.
+ HMODULE shell32Dll = ::LoadLibraryW(L"shell32");
+ if (!shell32Dll) {
+ return nullptr;
+ }
+ shGetKnownFolderPath = reinterpret_cast<decltype(shGetKnownFolderPath)>(
+ ::GetProcAddress(shell32Dll, "SHGetKnownFolderPath"));
+ if (!shGetKnownFolderPath) {
+ return nullptr;
+ }
+ }
+ PWSTR path = nullptr;
+ shGetKnownFolderPath(folderId, 0, nullptr, &path);
+ return UniquePtr<wchar_t, LoadedCoTaskMemFreeDeleter>(path);
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/GetKnownFolderPath.h b/mozglue/misc/GetKnownFolderPath.h
new file mode 100644
index 0000000000..3fd80440ab
--- /dev/null
+++ b/mozglue/misc/GetKnownFolderPath.h
@@ -0,0 +1,45 @@
+/* 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 mozilla_GetKnownFolderPath_h
+#define mozilla_GetKnownFolderPath_h
+
+#include <windows.h>
+#include <objbase.h>
+#include <shlobj.h>
+
+#include "mozilla/glue/Debug.h"
+#include "mozilla/UniquePtr.h"
+
+namespace mozilla {
+
+struct LoadedCoTaskMemFreeDeleter {
+ void operator()(void* ptr) {
+ static decltype(CoTaskMemFree)* coTaskMemFree = nullptr;
+ if (!coTaskMemFree) {
+ // Just let this get cleaned up when the process is terminated, because
+ // we're going to load it anyway elsewhere.
+ HMODULE ole32Dll = ::LoadLibraryW(L"ole32");
+ if (!ole32Dll) {
+ printf_stderr(
+ "Could not load ole32 - will not free with CoTaskMemFree");
+ return;
+ }
+ coTaskMemFree = reinterpret_cast<decltype(coTaskMemFree)>(
+ ::GetProcAddress(ole32Dll, "CoTaskMemFree"));
+ if (!coTaskMemFree) {
+ printf_stderr("Could not find CoTaskMemFree");
+ return;
+ }
+ }
+ coTaskMemFree(ptr);
+ }
+};
+
+UniquePtr<wchar_t, LoadedCoTaskMemFreeDeleter> GetKnownFolderPath(
+ REFKNOWNFOLDERID folderId);
+
+} // namespace mozilla
+
+#endif
diff --git a/mozglue/misc/ImportDir.h b/mozglue/misc/ImportDir.h
new file mode 100644
index 0000000000..6f7721d966
--- /dev/null
+++ b/mozglue/misc/ImportDir.h
@@ -0,0 +1,94 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/NativeNt.h"
+#include "mozilla/WinHeaderOnlyUtils.h"
+
+namespace mozilla {
+namespace detail {
+
+inline LauncherResult<nt::DataDirectoryEntry> GetImageDirectoryViaFileIo(
+ const nsAutoHandle& aImageFile, const uint32_t aOurImportDirectoryRva) {
+ OVERLAPPED ov = {};
+ ov.Offset = aOurImportDirectoryRva;
+
+ DWORD bytesRead;
+ nt::DataDirectoryEntry result;
+ if (!::ReadFile(aImageFile, &result, sizeof(result), &bytesRead, &ov) ||
+ bytesRead != sizeof(result)) {
+ return LAUNCHER_ERROR_FROM_LAST();
+ }
+
+ return result;
+}
+
+} // namespace detail
+
+/**
+ * This function ensures that the import directory of a loaded binary image
+ * matches the version that is found in the original file on disk. We do this
+ * to prevent tampering by third-party code.
+ *
+ * Yes, this function may perform file I/O on the critical path during
+ * startup. A mitigating factor here is that this function must be called
+ * immediately after creating a process using the image specified by
+ * |aFullImagePath|; by this point, the system has already paid the price of
+ * pulling the image file's contents into the page cache.
+ *
+ * @param aFullImagePath Wide-character string containing the absolute path
+ * to the binary whose import directory we are touching.
+ * @param aTransferMgr Encapsulating the transfer from the current process to
+ * the child process whose import table we are touching.
+ */
+inline LauncherVoidResult RestoreImportDirectory(
+ const wchar_t* aFullImagePath, nt::CrossExecTransferManager& aTransferMgr) {
+ uint32_t importDirEntryRva;
+ PIMAGE_DATA_DIRECTORY importDirEntry =
+ aTransferMgr.LocalPEHeaders().GetImageDirectoryEntryPtr(
+ IMAGE_DIRECTORY_ENTRY_IMPORT, &importDirEntryRva);
+ if (!importDirEntry) {
+ return LAUNCHER_ERROR_FROM_WIN32(ERROR_BAD_EXE_FORMAT);
+ }
+
+ nsAutoHandle file(::CreateFileW(aFullImagePath, GENERIC_READ, FILE_SHARE_READ,
+ nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
+ nullptr));
+ if (file.get() == INVALID_HANDLE_VALUE) {
+ return LAUNCHER_ERROR_FROM_LAST();
+ }
+
+ // Why do we use file I/O here instead of a memory mapping? The simple reason
+ // is that we do not want any kernel-mode drivers to start tampering with file
+ // contents under the belief that the file is being mapped for execution.
+ // Windows 8 supports creation of file mappings using the SEC_IMAGE_NO_EXECUTE
+ // flag, which may help to mitigate this, but we might as well just support
+ // a single implementation that works everywhere.
+ LauncherResult<nt::DataDirectoryEntry> realImportDirectory =
+ detail::GetImageDirectoryViaFileIo(file, importDirEntryRva);
+ if (realImportDirectory.isErr()) {
+ return realImportDirectory.propagateErr();
+ }
+
+ nt::DataDirectoryEntry toWrite = realImportDirectory.unwrap();
+
+ { // Scope for prot
+ AutoVirtualProtect prot = aTransferMgr.Protect(
+ importDirEntry, sizeof(IMAGE_DATA_DIRECTORY), PAGE_READWRITE);
+ if (!prot) {
+ return LAUNCHER_ERROR_FROM_MOZ_WINDOWS_ERROR(prot.GetError());
+ }
+
+ LauncherVoidResult writeResult = aTransferMgr.Transfer(
+ importDirEntry, &toWrite, sizeof(IMAGE_DATA_DIRECTORY));
+ if (writeResult.isErr()) {
+ return writeResult.propagateErr();
+ }
+ }
+
+ return Ok();
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/IntegerPrintfMacros.h b/mozglue/misc/IntegerPrintfMacros.h
new file mode 100644
index 0000000000..acf33eb85c
--- /dev/null
+++ b/mozglue/misc/IntegerPrintfMacros.h
@@ -0,0 +1,84 @@
+/* -*- 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/. */
+
+/* Implements the C99 <inttypes.h> interface. */
+
+#ifndef mozilla_IntegerPrintfMacros_h_
+#define mozilla_IntegerPrintfMacros_h_
+
+/*
+ * These macros should not be used with the NSPR printf-like functions or their
+ * users. If you need to use NSPR's facilities, see the comment on
+ * supported formats at the top of nsprpub/pr/include/prprf.h.
+ */
+
+/*
+ * scanf is a footgun: if the input number exceeds the bounds of the target
+ * type, behavior is undefined (in the compiler sense: that is, this code
+ * could overwrite your hard drive with zeroes):
+ *
+ * uint8_t u;
+ * sscanf("256", "%" SCNu8, &u); // BAD
+ *
+ * For this reason, *never* use the SCN* macros provided by this header!
+ */
+
+#include <inttypes.h>
+
+/*
+ * Fix up Android's broken [u]intptr_t inttype macros. Android's PRI*PTR
+ * macros are defined as "ld", but sizeof(long) is 8 and sizeof(intptr_t)
+ * is 4 on 32-bit Android. TestTypeTraits.cpp asserts that these new macro
+ * definitions match the actual type sizes seen at compile time.
+ */
+#if defined(ANDROID) && !defined(__LP64__)
+# undef PRIdPTR /* intptr_t */
+# define PRIdPTR "d" /* intptr_t */
+# undef PRIiPTR /* intptr_t */
+# define PRIiPTR "i" /* intptr_t */
+# undef PRIoPTR /* uintptr_t */
+# define PRIoPTR "o" /* uintptr_t */
+# undef PRIuPTR /* uintptr_t */
+# define PRIuPTR "u" /* uintptr_t */
+# undef PRIxPTR /* uintptr_t */
+# define PRIxPTR "x" /* uintptr_t */
+# undef PRIXPTR /* uintptr_t */
+# define PRIXPTR "X" /* uintptr_t */
+#endif
+
+/*
+ * Fix up Android's broken macros for [u]int_fastN_t. On ARM64, Android's
+ * PRI*FAST16/32 macros are defined as "d", but the types themselves are defined
+ * as long and unsigned long.
+ */
+#if defined(ANDROID) && defined(__LP64__)
+# undef PRIdFAST16 /* int_fast16_t */
+# define PRIdFAST16 PRId64 /* int_fast16_t */
+# undef PRIiFAST16 /* int_fast16_t */
+# define PRIiFAST16 PRIi64 /* int_fast16_t */
+# undef PRIoFAST16 /* uint_fast16_t */
+# define PRIoFAST16 PRIo64 /* uint_fast16_t */
+# undef PRIuFAST16 /* uint_fast16_t */
+# define PRIuFAST16 PRIu64 /* uint_fast16_t */
+# undef PRIxFAST16 /* uint_fast16_t */
+# define PRIxFAST16 PRIx64 /* uint_fast16_t */
+# undef PRIXFAST16 /* uint_fast16_t */
+# define PRIXFAST16 PRIX64 /* uint_fast16_t */
+# undef PRIdFAST32 /* int_fast32_t */
+# define PRIdFAST32 PRId64 /* int_fast32_t */
+# undef PRIiFAST32 /* int_fast32_t */
+# define PRIiFAST32 PRIi64 /* int_fast32_t */
+# undef PRIoFAST32 /* uint_fast32_t */
+# define PRIoFAST32 PRIo64 /* uint_fast32_t */
+# undef PRIuFAST32 /* uint_fast32_t */
+# define PRIuFAST32 PRIu64 /* uint_fast32_t */
+# undef PRIxFAST32 /* uint_fast32_t */
+# define PRIxFAST32 PRIx64 /* uint_fast32_t */
+# undef PRIXFAST32 /* uint_fast32_t */
+# define PRIXFAST32 PRIX64 /* uint_fast32_t */
+#endif
+
+#endif /* mozilla_IntegerPrintfMacros_h_ */
diff --git a/mozglue/misc/MmapFaultHandler.cpp b/mozglue/misc/MmapFaultHandler.cpp
new file mode 100644
index 0000000000..a73b9bd24b
--- /dev/null
+++ b/mozglue/misc/MmapFaultHandler.cpp
@@ -0,0 +1,130 @@
+/* -*- 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/. */
+
+#include "MmapFaultHandler.h"
+
+#if defined(XP_UNIX) && !defined(XP_DARWIN) && !defined(__wasi__)
+
+# include "mozilla/Assertions.h"
+# include "mozilla/Atomics.h"
+# include "mozilla/ThreadLocal.h"
+# include <signal.h>
+# include <cstring>
+
+static MOZ_THREAD_LOCAL(MmapAccessScope*) sMmapAccessScope;
+
+static struct sigaction sPrevSIGBUSHandler;
+
+static void MmapSIGBUSHandler(int signum, siginfo_t* info, void* context) {
+ MOZ_RELEASE_ASSERT(signum == SIGBUS);
+
+ MmapAccessScope* mas = sMmapAccessScope.get();
+
+ if (mas && mas->IsInsideBuffer(info->si_addr)) {
+ // Temporarily instead of handling the signal, we crash intentionally and
+ // send some diagnostic information to find out why the signal is received.
+ mas->CrashWithInfo(info->si_addr);
+
+ // The address is inside the buffer, handle the failure.
+ siglongjmp(mas->mJmpBuf, signum);
+ }
+
+ // This signal is not caused by accessing region protected by MmapAccessScope.
+ // Forward the signal to the next handler.
+ if (sPrevSIGBUSHandler.sa_flags & SA_SIGINFO) {
+ sPrevSIGBUSHandler.sa_sigaction(signum, info, context);
+ } else if (sPrevSIGBUSHandler.sa_handler == SIG_DFL ||
+ sPrevSIGBUSHandler.sa_handler == SIG_IGN) {
+ // There is no next handler. Uninstalling our handler and returning will
+ // cause a crash.
+ sigaction(signum, &sPrevSIGBUSHandler, nullptr);
+ } else {
+ sPrevSIGBUSHandler.sa_handler(signum);
+ }
+}
+
+mozilla::Atomic<bool> gSIGBUSHandlerInstalled(false);
+mozilla::Atomic<bool> gSIGBUSHandlerInstalling(false);
+
+void InstallMmapFaultHandler() {
+ // This function is called from MmapAccessScope's constructor because there is
+ // no single point where we could install the handler during startup. This
+ // means that it's called quite often, so to minimize using of the mutex we
+ // first check the atomic variable outside the lock.
+ if (gSIGBUSHandlerInstalled) {
+ return;
+ }
+
+ if (gSIGBUSHandlerInstalling.compareExchange(false, true)) {
+ sMmapAccessScope.infallibleInit();
+
+ struct sigaction busHandler;
+ busHandler.sa_flags = SA_SIGINFO | SA_NODEFER | SA_ONSTACK;
+ busHandler.sa_sigaction = MmapSIGBUSHandler;
+ sigemptyset(&busHandler.sa_mask);
+ if (sigaction(SIGBUS, &busHandler, &sPrevSIGBUSHandler)) {
+ MOZ_CRASH("Unable to install SIGBUS handler");
+ }
+
+ MOZ_ASSERT(!gSIGBUSHandlerInstalled);
+ gSIGBUSHandlerInstalled = true;
+ } else {
+ // Just spin lock here. It should not take a substantial amount
+ // of time, so a mutex would likely be a spin lock anyway, and
+ // this avoids the need to new up a static mutex from within
+ // mozglue/misc, which complicates things with
+ // check_vanilla_allocations.py
+ while (!gSIGBUSHandlerInstalled) {
+ }
+ }
+}
+
+MmapAccessScope::MmapAccessScope(void* aBuf, uint32_t aBufLen,
+ const char* aFilename) {
+ // Install signal handler if it wasn't installed yet.
+ InstallMmapFaultHandler();
+
+ // We'll handle the signal only if the crashing address is inside this buffer.
+ mBuf = aBuf;
+ mBufLen = aBufLen;
+ mFilename = aFilename;
+
+ SetThreadLocalScope();
+}
+
+MmapAccessScope::~MmapAccessScope() {
+ MOZ_RELEASE_ASSERT(sMmapAccessScope.get() == this);
+ sMmapAccessScope.set(mPreviousScope);
+}
+
+void MmapAccessScope::SetThreadLocalScope() {
+ // mJmpBuf is set outside of this classs for reasons mentioned in the header
+ // file, but we need to initialize the member here too to make Coverity happy.
+ memset(mJmpBuf, 0, sizeof(sigjmp_buf));
+
+ // If MmapAccessScopes are nested, save the previous one and restore it in
+ // the destructor.
+ mPreviousScope = sMmapAccessScope.get();
+
+ // MmapAccessScope is now set up (except mJmpBuf for reasons mentioned in the
+ // header file). Store the pointer in a thread-local variable sMmapAccessScope
+ // so we can use it in the handler if the signal is triggered.
+ sMmapAccessScope.set(this);
+}
+
+bool MmapAccessScope::IsInsideBuffer(void* aPtr) {
+ return aPtr >= mBuf && aPtr < (void*)((char*)mBuf + mBufLen);
+}
+
+void MmapAccessScope::CrashWithInfo(void* aPtr) {
+ // All we have is the buffer and the crashing address.
+ MOZ_CRASH_UNSAFE_PRINTF(
+ "SIGBUS received when accessing mmaped file [buffer=%p, "
+ "buflen=%u, address=%p, filename=%s]",
+ mBuf, mBufLen, aPtr, mFilename);
+}
+
+#endif
diff --git a/mozglue/misc/MmapFaultHandler.h b/mozglue/misc/MmapFaultHandler.h
new file mode 100644
index 0000000000..fca356921c
--- /dev/null
+++ b/mozglue/misc/MmapFaultHandler.h
@@ -0,0 +1,113 @@
+/* -*- 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 MmapFaultHandler_h_
+#define MmapFaultHandler_h_
+
+#if defined(XP_WIN)
+// Windows
+
+# ifdef HAVE_SEH_EXCEPTIONS
+# define MMAP_FAULT_HANDLER_BEGIN_HANDLE(fd) __try {
+# define MMAP_FAULT_HANDLER_BEGIN_BUFFER(buf, bufLen) __try {
+# define MMAP_FAULT_HANDLER_CATCH(retval) \
+ } \
+ __except (GetExceptionCode() == EXCEPTION_IN_PAGE_ERROR \
+ ? EXCEPTION_EXECUTE_HANDLER \
+ : EXCEPTION_CONTINUE_SEARCH) { \
+ NS_WARNING("unexpected EXCEPTION_IN_PAGE_ERROR"); \
+ return retval; \
+ }
+# else
+# define MMAP_FAULT_HANDLER_BEGIN_HANDLE(fd) {
+# define MMAP_FAULT_HANDLER_BEGIN_BUFFER(buf, bufLen) {
+# define MMAP_FAULT_HANDLER_CATCH(retval) }
+# endif
+
+#elif defined(XP_DARWIN)
+// MacOS
+
+# define MMAP_FAULT_HANDLER_BEGIN_HANDLE(fd) {
+# define MMAP_FAULT_HANDLER_BEGIN_BUFFER(buf, bufLen) {
+# define MMAP_FAULT_HANDLER_CATCH(retval) }
+
+#elif defined(__wasi__)
+
+# define MMAP_FAULT_HANDLER_BEGIN_HANDLE(fd) {
+# define MMAP_FAULT_HANDLER_BEGIN_BUFFER(buf, bufLen) {
+# define MMAP_FAULT_HANDLER_CATCH(retval) }
+
+#else
+// Linux
+
+# include "mozilla/Attributes.h"
+# include "mozilla/Types.h"
+# include <stdint.h>
+# include <setjmp.h>
+
+class MOZ_RAII MmapAccessScope {
+ public:
+ MFBT_API MmapAccessScope(void* aBuf, uint32_t aBufLen,
+ const char* aFilename = nullptr);
+ MFBT_API ~MmapAccessScope();
+
+ MmapAccessScope(const MmapAccessScope&) = delete;
+ MmapAccessScope& operator=(const MmapAccessScope&) = delete;
+
+ void SetThreadLocalScope();
+ bool IsInsideBuffer(void* aPtr);
+ void CrashWithInfo(void* aPtr);
+
+ // sigsetjmp cannot be called from a method that returns before calling
+ // siglongjmp, so the macro must call sigsetjmp directly and mJmpBuf must be
+ // public.
+ sigjmp_buf mJmpBuf;
+
+ private:
+ void* mBuf;
+ const char* mFilename;
+ uint32_t mBufLen;
+ MmapAccessScope* mPreviousScope;
+};
+
+// Gets around warnings for null-checking in a macro.
+template <typename T>
+inline bool ValidFD(T fd) {
+ return !!fd;
+}
+
+# define MMAP_FAULT_HANDLER_BEGIN_HANDLE(fd) \
+ { \
+ void* mmapScopeBuf = nullptr; \
+ nsCString mmapScopeFilename; \
+ uint32_t mmapScopeBufLen = 0; \
+ if (ValidFD(fd) && fd->mMap) { \
+ mmapScopeBuf = (void*)fd->mFileStart; \
+ mmapScopeBufLen = fd->mTotalLen; \
+ } \
+ if (ValidFD(fd) && fd->mFile) { \
+ nsCOMPtr<nsIFile> file = fd->mFile.GetBaseFile(); \
+ if (file) { \
+ file->GetNativeLeafName(mmapScopeFilename); \
+ } \
+ } \
+ MmapAccessScope mmapScope(mmapScopeBuf, mmapScopeBufLen, \
+ mmapScopeFilename.get()); \
+ if (sigsetjmp(mmapScope.mJmpBuf, 0) == 0) {
+# define MMAP_FAULT_HANDLER_BEGIN_BUFFER(buf, bufLen) \
+ { \
+ MmapAccessScope mmapScope((void*)(buf), (bufLen)); \
+ if (sigsetjmp(mmapScope.mJmpBuf, 0) == 0) {
+# define MMAP_FAULT_HANDLER_CATCH(retval) \
+ } \
+ else { \
+ NS_WARNING("SIGBUS received when accessing mmapped file"); \
+ return retval; \
+ } \
+ }
+
+#endif
+
+#endif
diff --git a/mozglue/misc/MutexPlatformData_noop.h b/mozglue/misc/MutexPlatformData_noop.h
new file mode 100644
index 0000000000..a2c8d060be
--- /dev/null
+++ b/mozglue/misc/MutexPlatformData_noop.h
@@ -0,0 +1,18 @@
+/* -*- 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/. */
+
+#ifndef MutexPlatformData_noop_h
+#define MutexPlatformData_noop_h
+
+#if !defined(__wasi__)
+# error This code is for WASI only.
+#endif
+
+#include "mozilla/PlatformMutex.h"
+
+struct mozilla::detail::MutexImpl::PlatformData {};
+
+#endif // MutexPlatformData_noop_h
diff --git a/mozglue/misc/MutexPlatformData_posix.h b/mozglue/misc/MutexPlatformData_posix.h
new file mode 100644
index 0000000000..d1659d8d7b
--- /dev/null
+++ b/mozglue/misc/MutexPlatformData_posix.h
@@ -0,0 +1,18 @@
+/* -*- 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/. */
+
+#ifndef MutexPlatformData_posix_h
+#define MutexPlatformData_posix_h
+
+#include <pthread.h>
+
+#include "mozilla/PlatformMutex.h"
+
+struct mozilla::detail::MutexImpl::PlatformData {
+ pthread_mutex_t ptMutex;
+};
+
+#endif // MutexPlatformData_posix_h
diff --git a/mozglue/misc/MutexPlatformData_windows.h b/mozglue/misc/MutexPlatformData_windows.h
new file mode 100644
index 0000000000..489f921115
--- /dev/null
+++ b/mozglue/misc/MutexPlatformData_windows.h
@@ -0,0 +1,18 @@
+/* -*- 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/. */
+
+#ifndef MutexPlatformData_windows_h
+#define MutexPlatformData_windows_h
+
+#include <windows.h>
+
+#include "mozilla/PlatformMutex.h"
+
+struct mozilla::detail::MutexImpl::PlatformData {
+ SRWLOCK lock;
+};
+
+#endif // MutexPlatformData_windows_h
diff --git a/mozglue/misc/Mutex_noop.cpp b/mozglue/misc/Mutex_noop.cpp
new file mode 100644
index 0000000000..eaa7959cc0
--- /dev/null
+++ b/mozglue/misc/Mutex_noop.cpp
@@ -0,0 +1,34 @@
+/* -*- 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/. */
+
+#include "mozilla/Assertions.h"
+
+#include <errno.h>
+#include <stdio.h>
+
+#include "mozilla/PlatformMutex.h"
+#include "MutexPlatformData_noop.h"
+
+mozilla::detail::MutexImpl::MutexImpl() {}
+
+mozilla::detail::MutexImpl::~MutexImpl() {}
+
+inline void mozilla::detail::MutexImpl::mutexLock() {}
+
+bool mozilla::detail::MutexImpl::tryLock() { return mutexTryLock(); }
+
+bool mozilla::detail::MutexImpl::mutexTryLock() { return true; }
+
+void mozilla::detail::MutexImpl::lock() { mutexLock(); }
+
+void mozilla::detail::MutexImpl::unlock() {}
+
+mozilla::detail::MutexImpl::PlatformData*
+mozilla::detail::MutexImpl::platformData() {
+ static_assert(sizeof(platformData_) >= sizeof(PlatformData),
+ "platformData_ is too small");
+ return reinterpret_cast<PlatformData*>(platformData_);
+}
diff --git a/mozglue/misc/Mutex_posix.cpp b/mozglue/misc/Mutex_posix.cpp
new file mode 100644
index 0000000000..7378a544f2
--- /dev/null
+++ b/mozglue/misc/Mutex_posix.cpp
@@ -0,0 +1,133 @@
+/* -*- 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/. */
+
+#include "mozilla/Assertions.h"
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+
+#if defined(XP_DARWIN)
+# include <pthread_spis.h>
+#endif
+
+#include "mozilla/PlatformMutex.h"
+#include "MutexPlatformData_posix.h"
+
+#define REPORT_PTHREADS_ERROR(result, msg) \
+ { \
+ errno = result; \
+ perror(msg); \
+ MOZ_CRASH(msg); \
+ }
+
+#define TRY_CALL_PTHREADS(call, msg) \
+ { \
+ int result = (call); \
+ if (result != 0) { \
+ REPORT_PTHREADS_ERROR(result, msg); \
+ } \
+ }
+
+mozilla::detail::MutexImpl::MutexImpl() {
+ pthread_mutexattr_t* attrp = nullptr;
+
+#if defined(DEBUG)
+# define MUTEX_KIND PTHREAD_MUTEX_ERRORCHECK
+// Linux with glibc, FreeBSD and macOS 10.14+ support adaptive mutexes that
+// spin for a short number of tries before sleeping. NSPR's locks did this,
+// too, and it seems like a reasonable thing to do.
+#elif (defined(__linux__) && defined(__GLIBC__)) || defined(__FreeBSD__)
+# define MUTEX_KIND PTHREAD_MUTEX_ADAPTIVE_NP
+#elif defined(XP_DARWIN)
+# if defined(PTHREAD_MUTEX_POLICY_FIRSTFIT_NP)
+# define POLICY_KIND PTHREAD_MUTEX_POLICY_FIRSTFIT_NP
+# else
+# define POLICY_KIND (3) // The definition is missing in old SDKs
+# endif
+#endif
+
+#if defined(MUTEX_KIND) || defined(POLICY_KIND)
+# define ATTR_REQUIRED
+#endif
+
+#if defined(ATTR_REQUIRED)
+ pthread_mutexattr_t attr;
+
+ TRY_CALL_PTHREADS(
+ pthread_mutexattr_init(&attr),
+ "mozilla::detail::MutexImpl::MutexImpl: pthread_mutexattr_init failed");
+
+# if defined(MUTEX_KIND)
+ TRY_CALL_PTHREADS(pthread_mutexattr_settype(&attr, MUTEX_KIND),
+ "mozilla::detail::MutexImpl::MutexImpl: "
+ "pthread_mutexattr_settype failed");
+# elif defined(POLICY_KIND)
+ if (__builtin_available(macOS 10.14, *)) {
+ TRY_CALL_PTHREADS(pthread_mutexattr_setpolicy_np(&attr, POLICY_KIND),
+ "mozilla::detail::MutexImpl::MutexImpl: "
+ "pthread_mutexattr_setpolicy_np failed");
+ }
+# endif
+ attrp = &attr;
+#endif
+
+ TRY_CALL_PTHREADS(
+ pthread_mutex_init(&platformData()->ptMutex, attrp),
+ "mozilla::detail::MutexImpl::MutexImpl: pthread_mutex_init failed");
+
+#if defined(ATTR_REQUIRED)
+ TRY_CALL_PTHREADS(pthread_mutexattr_destroy(&attr),
+ "mozilla::detail::MutexImpl::MutexImpl: "
+ "pthread_mutexattr_destroy failed");
+#endif
+}
+
+mozilla::detail::MutexImpl::~MutexImpl() {
+ TRY_CALL_PTHREADS(
+ pthread_mutex_destroy(&platformData()->ptMutex),
+ "mozilla::detail::MutexImpl::~MutexImpl: pthread_mutex_destroy failed");
+}
+
+inline void mozilla::detail::MutexImpl::mutexLock() {
+ TRY_CALL_PTHREADS(
+ pthread_mutex_lock(&platformData()->ptMutex),
+ "mozilla::detail::MutexImpl::mutexLock: pthread_mutex_lock failed");
+}
+
+bool mozilla::detail::MutexImpl::tryLock() { return mutexTryLock(); }
+
+bool mozilla::detail::MutexImpl::mutexTryLock() {
+ int result = pthread_mutex_trylock(&platformData()->ptMutex);
+ if (result == 0) {
+ return true;
+ }
+
+ if (result == EBUSY) {
+ return false;
+ }
+
+ REPORT_PTHREADS_ERROR(
+ result,
+ "mozilla::detail::MutexImpl::mutexTryLock: pthread_mutex_trylock failed");
+}
+
+void mozilla::detail::MutexImpl::lock() { mutexLock(); }
+
+void mozilla::detail::MutexImpl::unlock() {
+ TRY_CALL_PTHREADS(
+ pthread_mutex_unlock(&platformData()->ptMutex),
+ "mozilla::detail::MutexImpl::unlock: pthread_mutex_unlock failed");
+}
+
+#undef TRY_CALL_PTHREADS
+
+mozilla::detail::MutexImpl::PlatformData*
+mozilla::detail::MutexImpl::platformData() {
+ static_assert(sizeof(platformData_) >= sizeof(PlatformData),
+ "platformData_ is too small");
+ return reinterpret_cast<PlatformData*>(platformData_);
+}
diff --git a/mozglue/misc/Mutex_windows.cpp b/mozglue/misc/Mutex_windows.cpp
new file mode 100644
index 0000000000..c4c78fd4f6
--- /dev/null
+++ b/mozglue/misc/Mutex_windows.cpp
@@ -0,0 +1,40 @@
+/* -*- 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/. */
+
+#include "mozilla/Assertions.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/PlatformMutex.h"
+
+#include <windows.h>
+
+#include "MutexPlatformData_windows.h"
+
+mozilla::detail::MutexImpl::MutexImpl() {
+ InitializeSRWLock(&platformData()->lock);
+}
+
+mozilla::detail::MutexImpl::~MutexImpl() {}
+
+void mozilla::detail::MutexImpl::lock() {
+ AcquireSRWLockExclusive(&platformData()->lock);
+}
+
+bool mozilla::detail::MutexImpl::tryLock() { return mutexTryLock(); }
+
+bool mozilla::detail::MutexImpl::mutexTryLock() {
+ return !!TryAcquireSRWLockExclusive(&platformData()->lock);
+}
+
+void mozilla::detail::MutexImpl::unlock() {
+ ReleaseSRWLockExclusive(&platformData()->lock);
+}
+
+mozilla::detail::MutexImpl::PlatformData*
+mozilla::detail::MutexImpl::platformData() {
+ static_assert(sizeof(platformData_) >= sizeof(PlatformData),
+ "platformData_ is too small");
+ return reinterpret_cast<PlatformData*>(platformData_);
+}
diff --git a/mozglue/misc/NativeNt.h b/mozglue/misc/NativeNt.h
new file mode 100644
index 0000000000..439ef3d12a
--- /dev/null
+++ b/mozglue/misc/NativeNt.h
@@ -0,0 +1,1729 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_NativeNt_h
+#define mozilla_NativeNt_h
+
+#include <stdint.h>
+#include <windows.h>
+#include <winnt.h>
+#include <winternl.h>
+
+#include <algorithm>
+#include <utility>
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Range.h"
+#include "mozilla/Span.h"
+#include "mozilla/WinHeaderOnlyUtils.h"
+#include "mozilla/interceptor/MMPolicies.h"
+#include "mozilla/interceptor/TargetFunction.h"
+
+#if defined(MOZILLA_INTERNAL_API)
+# include "nsString.h"
+#endif // defined(MOZILLA_INTERNAL_API)
+
+// The declarations within this #if block are intended to be used for initial
+// process initialization ONLY. You probably don't want to be using these in
+// normal Gecko code!
+#if !defined(MOZILLA_INTERNAL_API)
+
+extern "C" {
+
+# if !defined(STATUS_ACCESS_DENIED)
+# define STATUS_ACCESS_DENIED ((NTSTATUS)0xC0000022L)
+# endif // !defined(STATUS_ACCESS_DENIED)
+
+# if !defined(STATUS_DLL_NOT_FOUND)
+# define STATUS_DLL_NOT_FOUND ((NTSTATUS)0xC0000135L)
+# endif // !defined(STATUS_DLL_NOT_FOUND)
+
+# if !defined(STATUS_UNSUCCESSFUL)
+# define STATUS_UNSUCCESSFUL ((NTSTATUS)0xC0000001L)
+# endif // !defined(STATUS_UNSUCCESSFUL)
+
+# if !defined(STATUS_INFO_LENGTH_MISMATCH)
+# define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004L)
+# endif
+
+enum SECTION_INHERIT { ViewShare = 1, ViewUnmap = 2 };
+
+NTSTATUS NTAPI NtMapViewOfSection(
+ HANDLE aSection, HANDLE aProcess, PVOID* aBaseAddress, ULONG_PTR aZeroBits,
+ SIZE_T aCommitSize, PLARGE_INTEGER aSectionOffset, PSIZE_T aViewSize,
+ SECTION_INHERIT aInheritDisposition, ULONG aAllocationType,
+ ULONG aProtectionFlags);
+
+NTSTATUS NTAPI NtUnmapViewOfSection(HANDLE aProcess, PVOID aBaseAddress);
+
+enum MEMORY_INFORMATION_CLASS {
+ MemoryBasicInformation = 0,
+ MemorySectionName = 2
+};
+
+// NB: When allocating, space for the buffer must also be included
+typedef struct _MEMORY_SECTION_NAME {
+ UNICODE_STRING mSectionFileName;
+} MEMORY_SECTION_NAME, *PMEMORY_SECTION_NAME;
+
+NTSTATUS NTAPI NtQueryVirtualMemory(HANDLE aProcess, PVOID aBaseAddress,
+ MEMORY_INFORMATION_CLASS aMemInfoClass,
+ PVOID aMemInfo, SIZE_T aMemInfoLen,
+ PSIZE_T aReturnLen);
+
+LONG NTAPI RtlCompareUnicodeString(PCUNICODE_STRING aStr1,
+ PCUNICODE_STRING aStr2,
+ BOOLEAN aCaseInsensitive);
+
+BOOLEAN NTAPI RtlEqualUnicodeString(PCUNICODE_STRING aStr1,
+ PCUNICODE_STRING aStr2,
+ BOOLEAN aCaseInsensitive);
+
+NTSTATUS NTAPI RtlGetVersion(PRTL_OSVERSIONINFOW aOutVersionInformation);
+
+VOID NTAPI RtlAcquireSRWLockExclusive(PSRWLOCK aLock);
+VOID NTAPI RtlAcquireSRWLockShared(PSRWLOCK aLock);
+
+VOID NTAPI RtlReleaseSRWLockExclusive(PSRWLOCK aLock);
+VOID NTAPI RtlReleaseSRWLockShared(PSRWLOCK aLock);
+
+ULONG NTAPI RtlNtStatusToDosError(NTSTATUS aStatus);
+VOID NTAPI RtlSetLastWin32Error(DWORD aError);
+DWORD NTAPI RtlGetLastWin32Error();
+
+VOID NTAPI RtlRunOnceInitialize(PRTL_RUN_ONCE aRunOnce);
+
+NTSTATUS NTAPI NtReadVirtualMemory(HANDLE aProcessHandle, PVOID aBaseAddress,
+ PVOID aBuffer, SIZE_T aNumBytesToRead,
+ PSIZE_T aNumBytesRead);
+
+NTSTATUS NTAPI LdrLoadDll(PWCHAR aDllPath, PULONG aFlags,
+ PUNICODE_STRING aDllName, PHANDLE aOutHandle);
+
+typedef ULONG(NTAPI* PRTL_RUN_ONCE_INIT_FN)(PRTL_RUN_ONCE, PVOID, PVOID*);
+NTSTATUS NTAPI RtlRunOnceExecuteOnce(PRTL_RUN_ONCE aRunOnce,
+ PRTL_RUN_ONCE_INIT_FN aInitFn,
+ PVOID aContext, PVOID* aParameter);
+
+} // extern "C"
+
+#endif // !defined(MOZILLA_INTERNAL_API)
+
+extern "C" {
+PVOID NTAPI RtlAllocateHeap(PVOID aHeapHandle, ULONG aFlags, SIZE_T aSize);
+
+PVOID NTAPI RtlReAllocateHeap(PVOID aHeapHandle, ULONG aFlags, LPVOID aMem,
+ SIZE_T aNewSize);
+
+BOOLEAN NTAPI RtlFreeHeap(PVOID aHeapHandle, ULONG aFlags, PVOID aHeapBase);
+
+BOOLEAN NTAPI RtlQueryPerformanceCounter(LARGE_INTEGER* aPerfCount);
+
+#define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE 1
+#define RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING 2
+NTSTATUS NTAPI RtlDuplicateUnicodeString(ULONG aFlags, PCUNICODE_STRING aSrc,
+ PUNICODE_STRING aDest);
+
+VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING aUnicodeString);
+} // extern "C"
+
+namespace mozilla {
+namespace nt {
+
+/**
+ * This class encapsulates a UNICODE_STRING that owns its own buffer. The
+ * buffer is always NULL terminated, thus allowing us to cast to a wide C-string
+ * without requiring any mutation.
+ *
+ * We only allow creation of this owned buffer from outside XUL.
+ */
+class AllocatedUnicodeString final {
+ public:
+ AllocatedUnicodeString() : mUnicodeString() {}
+
+#if defined(MOZILLA_INTERNAL_API)
+ AllocatedUnicodeString(const AllocatedUnicodeString& aOther) = delete;
+
+ AllocatedUnicodeString& operator=(const AllocatedUnicodeString& aOther) =
+ delete;
+#else
+ explicit AllocatedUnicodeString(PCUNICODE_STRING aSrc) {
+ if (!aSrc) {
+ mUnicodeString = {};
+ return;
+ }
+
+ Duplicate(aSrc);
+ }
+
+ explicit AllocatedUnicodeString(const char* aSrc) {
+ if (!aSrc) {
+ mUnicodeString = {};
+ return;
+ }
+
+ Duplicate(aSrc);
+ }
+
+ AllocatedUnicodeString(const AllocatedUnicodeString& aOther) {
+ Duplicate(&aOther.mUnicodeString);
+ }
+
+ AllocatedUnicodeString& operator=(const AllocatedUnicodeString& aOther) {
+ Clear();
+ Duplicate(&aOther.mUnicodeString);
+ return *this;
+ }
+
+ AllocatedUnicodeString& operator=(PCUNICODE_STRING aSrc) {
+ Clear();
+ Duplicate(aSrc);
+ return *this;
+ }
+#endif // defined(MOZILLA_INTERNAL_API)
+
+ AllocatedUnicodeString(AllocatedUnicodeString&& aOther)
+ : mUnicodeString(aOther.mUnicodeString) {
+ aOther.mUnicodeString = {};
+ }
+
+ AllocatedUnicodeString& operator=(AllocatedUnicodeString&& aOther) {
+ Clear();
+ mUnicodeString = aOther.mUnicodeString;
+ aOther.mUnicodeString = {};
+ return *this;
+ }
+
+ ~AllocatedUnicodeString() { Clear(); }
+
+ bool IsEmpty() const {
+ return !mUnicodeString.Buffer || !mUnicodeString.Length;
+ }
+
+ operator PCUNICODE_STRING() const { return &mUnicodeString; }
+
+ operator const WCHAR*() const { return mUnicodeString.Buffer; }
+
+ USHORT CharLen() const { return mUnicodeString.Length / sizeof(WCHAR); }
+
+#if defined(MOZILLA_INTERNAL_API)
+ nsDependentString AsString() const {
+ if (!mUnicodeString.Buffer) {
+ return nsDependentString();
+ }
+
+ // We can use nsDependentString here as we guaranteed null termination
+ // when we allocated the string.
+ return nsDependentString(mUnicodeString.Buffer, CharLen());
+ }
+#endif // defined(MOZILLA_INTERNAL_API)
+
+ private:
+#if !defined(MOZILLA_INTERNAL_API)
+ void Duplicate(PCUNICODE_STRING aSrc) {
+ MOZ_ASSERT(aSrc);
+
+ // We duplicate with null termination so that this string may be used
+ // as a wide C-string without any further manipulation.
+ NTSTATUS ntStatus = ::RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, aSrc, &mUnicodeString);
+ MOZ_ASSERT(NT_SUCCESS(ntStatus));
+ if (!NT_SUCCESS(ntStatus)) {
+ // Make sure that mUnicodeString does not contain bogus data
+ // (since not all callers zero it out before invoking)
+ mUnicodeString = {};
+ }
+ }
+
+ void Duplicate(const char* aSrc) {
+ MOZ_ASSERT(aSrc);
+
+ ANSI_STRING ansiStr;
+ RtlInitAnsiString(&ansiStr, aSrc);
+ NTSTATUS ntStatus =
+ ::RtlAnsiStringToUnicodeString(&mUnicodeString, &ansiStr, TRUE);
+ MOZ_ASSERT(NT_SUCCESS(ntStatus));
+ if (!NT_SUCCESS(ntStatus)) {
+ mUnicodeString = {};
+ }
+ }
+#endif // !defined(MOZILLA_INTERNAL_API)
+
+ void Clear() {
+ if (!mUnicodeString.Buffer) {
+ return;
+ }
+
+ ::RtlFreeUnicodeString(&mUnicodeString);
+ mUnicodeString = {};
+ }
+
+ UNICODE_STRING mUnicodeString;
+};
+
+#if !defined(MOZILLA_INTERNAL_API)
+
+struct MemorySectionNameBuf : public _MEMORY_SECTION_NAME {
+ MemorySectionNameBuf() {
+ mSectionFileName.Length = 0;
+ mSectionFileName.MaximumLength = sizeof(mBuf);
+ mSectionFileName.Buffer = mBuf;
+ }
+
+ MemorySectionNameBuf(const MemorySectionNameBuf& aOther) { *this = aOther; }
+
+ MemorySectionNameBuf(MemorySectionNameBuf&& aOther) {
+ *this = std::move(aOther);
+ }
+
+ // We cannot use default copy here because mSectionFileName.Buffer needs to
+ // be updated to point to |this->mBuf|, not |aOther.mBuf|.
+ MemorySectionNameBuf& operator=(const MemorySectionNameBuf& aOther) {
+ mSectionFileName.Length = aOther.mSectionFileName.Length;
+ mSectionFileName.MaximumLength = sizeof(mBuf);
+ MOZ_ASSERT(mSectionFileName.Length <= mSectionFileName.MaximumLength);
+ mSectionFileName.Buffer = mBuf;
+ memcpy(mBuf, aOther.mBuf, aOther.mSectionFileName.Length);
+ return *this;
+ }
+
+ MemorySectionNameBuf& operator=(MemorySectionNameBuf&& aOther) {
+ mSectionFileName.Length = aOther.mSectionFileName.Length;
+ aOther.mSectionFileName.Length = 0;
+ mSectionFileName.MaximumLength = sizeof(mBuf);
+ MOZ_ASSERT(mSectionFileName.Length <= mSectionFileName.MaximumLength);
+ aOther.mSectionFileName.MaximumLength = sizeof(aOther.mBuf);
+ mSectionFileName.Buffer = mBuf;
+ memmove(mBuf, aOther.mBuf, mSectionFileName.Length);
+ return *this;
+ }
+
+ // Native NT paths, so we can't assume MAX_PATH. Use a larger buffer.
+ WCHAR mBuf[2 * MAX_PATH];
+
+ bool IsEmpty() const {
+ return !mSectionFileName.Buffer || !mSectionFileName.Length;
+ }
+
+ operator PCUNICODE_STRING() const { return &mSectionFileName; }
+};
+
+class MemorySectionNameOnHeap {
+ UniquePtr<uint8_t[]> mBuffer;
+
+ MemorySectionNameOnHeap() = default;
+ explicit MemorySectionNameOnHeap(size_t aBufferLen)
+ : mBuffer(MakeUnique<uint8_t[]>(aBufferLen)) {}
+
+ public:
+ static MemorySectionNameOnHeap GetBackingFilePath(HANDLE aProcess,
+ void* aSectionAddr) {
+ SIZE_T bufferLen = MAX_PATH * 2;
+ do {
+ MemorySectionNameOnHeap sectionName(bufferLen);
+
+ SIZE_T requiredBytes;
+ NTSTATUS ntStatus = ::NtQueryVirtualMemory(
+ aProcess, aSectionAddr, MemorySectionName, sectionName.mBuffer.get(),
+ bufferLen, &requiredBytes);
+ if (NT_SUCCESS(ntStatus)) {
+ return sectionName;
+ }
+
+ if (ntStatus != STATUS_INFO_LENGTH_MISMATCH ||
+ bufferLen >= requiredBytes) {
+ break;
+ }
+
+ bufferLen = requiredBytes;
+ } while (1);
+
+ return MemorySectionNameOnHeap();
+ }
+
+ // Allow move & Disallow copy
+ MemorySectionNameOnHeap(MemorySectionNameOnHeap&&) = default;
+ MemorySectionNameOnHeap& operator=(MemorySectionNameOnHeap&&) = default;
+ MemorySectionNameOnHeap(const MemorySectionNameOnHeap&) = delete;
+ MemorySectionNameOnHeap& operator=(const MemorySectionNameOnHeap&) = delete;
+
+ PCUNICODE_STRING AsUnicodeString() const {
+ return reinterpret_cast<PCUNICODE_STRING>(mBuffer.get());
+ }
+};
+
+inline bool FindCharInUnicodeString(const UNICODE_STRING& aStr, WCHAR aChar,
+ uint16_t& aPos, uint16_t aStartIndex = 0) {
+ const uint16_t aMaxIndex = aStr.Length / sizeof(WCHAR);
+
+ for (uint16_t curIndex = aStartIndex; curIndex < aMaxIndex; ++curIndex) {
+ if (aStr.Buffer[curIndex] == aChar) {
+ aPos = curIndex;
+ return true;
+ }
+ }
+
+ return false;
+}
+
+inline bool IsHexDigit(WCHAR aChar) {
+ return (aChar >= L'0' && aChar <= L'9') || (aChar >= L'A' && aChar <= L'F') ||
+ (aChar >= L'a' && aChar <= L'f');
+}
+
+inline bool MatchUnicodeString(const UNICODE_STRING& aStr,
+ bool (*aPredicate)(WCHAR)) {
+ WCHAR* cur = aStr.Buffer;
+ WCHAR* end = &aStr.Buffer[aStr.Length / sizeof(WCHAR)];
+ while (cur < end) {
+ if (!aPredicate(*cur)) {
+ return false;
+ }
+
+ ++cur;
+ }
+
+ return true;
+}
+
+inline bool Contains12DigitHexString(const UNICODE_STRING& aLeafName) {
+ // Quick check: If the string is too short, don't bother
+ // (We need at least 12 hex digits, one char for '.', and 3 for extension)
+ const USHORT kMinLen = (12 + 1 + 3) * sizeof(wchar_t);
+ if (aLeafName.Length < kMinLen) {
+ return false;
+ }
+
+ uint16_t start, end;
+ if (!FindCharInUnicodeString(aLeafName, L'.', start)) {
+ return false;
+ }
+
+ ++start;
+ if (!FindCharInUnicodeString(aLeafName, L'.', end, start)) {
+ return false;
+ }
+
+ if (end - start != 12) {
+ return false;
+ }
+
+ UNICODE_STRING test;
+ test.Buffer = &aLeafName.Buffer[start];
+ test.Length = (end - start) * sizeof(WCHAR);
+ test.MaximumLength = test.Length;
+
+ return MatchUnicodeString(test, &IsHexDigit);
+}
+
+inline bool IsFileNameAtLeast16HexDigits(const UNICODE_STRING& aLeafName) {
+ // Quick check: If the string is too short, don't bother
+ // (We need 16 hex digits, one char for '.', and 3 for extension)
+ const USHORT kMinLen = (16 + 1 + 3) * sizeof(wchar_t);
+ if (aLeafName.Length < kMinLen) {
+ return false;
+ }
+
+ uint16_t dotIndex;
+ if (!FindCharInUnicodeString(aLeafName, L'.', dotIndex)) {
+ return false;
+ }
+
+ if (dotIndex < 16) {
+ return false;
+ }
+
+ UNICODE_STRING test;
+ test.Buffer = aLeafName.Buffer;
+ test.Length = dotIndex * sizeof(WCHAR);
+ test.MaximumLength = aLeafName.MaximumLength;
+
+ return MatchUnicodeString(test, &IsHexDigit);
+}
+
+inline void GetLeafName(PUNICODE_STRING aDestString,
+ PCUNICODE_STRING aSrcString) {
+ WCHAR* buf = aSrcString->Buffer;
+ WCHAR* end = &aSrcString->Buffer[(aSrcString->Length / sizeof(WCHAR)) - 1];
+ WCHAR* cur = end;
+ while (cur >= buf) {
+ if (*cur == L'\\') {
+ break;
+ }
+
+ --cur;
+ }
+
+ // At this point, either cur points to the final backslash, or it points to
+ // buf - 1. Either way, we're interested in cur + 1 as the desired buffer.
+ aDestString->Buffer = cur + 1;
+ aDestString->Length = (end - aDestString->Buffer + 1) * sizeof(WCHAR);
+ aDestString->MaximumLength = aDestString->Length;
+}
+
+#endif // !defined(MOZILLA_INTERNAL_API)
+
+#if defined(MOZILLA_INTERNAL_API)
+
+inline const nsDependentSubstring GetLeafName(const nsAString& aString) {
+ auto it = aString.EndReading();
+ size_t pos = aString.Length();
+ while (it > aString.BeginReading()) {
+ if (*(it - 1) == u'\\') {
+ return Substring(aString, pos);
+ }
+
+ MOZ_ASSERT(pos > 0);
+ --pos;
+ --it;
+ }
+
+ return Substring(aString, 0); // No backslash in the string
+}
+
+#endif // defined(MOZILLA_INTERNAL_API)
+
+inline char EnsureLowerCaseASCII(char aChar) {
+ if (aChar >= 'A' && aChar <= 'Z') {
+ aChar -= 'A' - 'a';
+ }
+
+ return aChar;
+}
+
+inline int StricmpASCII(const char* aLeft, const char* aRight) {
+ char curLeft, curRight;
+
+ do {
+ curLeft = EnsureLowerCaseASCII(*(aLeft++));
+ curRight = EnsureLowerCaseASCII(*(aRight++));
+ } while (curLeft && curLeft == curRight);
+
+ return curLeft - curRight;
+}
+
+inline int StrcmpASCII(const char* aLeft, const char* aRight) {
+ char curLeft, curRight;
+
+ do {
+ curLeft = *(aLeft++);
+ curRight = *(aRight++);
+ } while (curLeft && curLeft == curRight);
+
+ return curLeft - curRight;
+}
+
+inline size_t StrlenASCII(const char* aStr) {
+ size_t len = 0;
+
+ while (*(aStr++)) {
+ ++len;
+ }
+
+ return len;
+}
+
+struct CodeViewRecord70 {
+ uint32_t signature;
+ GUID pdbSignature;
+ uint32_t pdbAge;
+ // A UTF-8 string, according to
+ // https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/dbi/locator.cpp#L785
+ char pdbFileName[1];
+};
+
+class MOZ_RAII PEHeaders final {
+ /**
+ * This structure is documented on MSDN as VS_VERSIONINFO, but is not present
+ * in SDK headers because it cannot be specified as a C struct. The following
+ * structure contains the fixed-length fields at the beginning of
+ * VS_VERSIONINFO.
+ */
+ struct VS_VERSIONINFO_HEADER {
+ WORD wLength;
+ WORD wValueLength;
+ WORD wType;
+ WCHAR szKey[16]; // ArrayLength(L"VS_VERSION_INFO")
+ // Additional data goes here, aligned on a 4-byte boundary
+ };
+
+ public:
+ // The lowest two bits of an HMODULE are used as flags. Stripping those bits
+ // from the HMODULE yields the base address of the binary's memory mapping.
+ // (See LoadLibraryEx docs on MSDN)
+ template <typename T>
+ static T HModuleToBaseAddr(HMODULE aModule) {
+ return reinterpret_cast<T>(reinterpret_cast<uintptr_t>(aModule) &
+ ~uintptr_t(3));
+ }
+
+ explicit PEHeaders(void* aBaseAddress)
+ : PEHeaders(reinterpret_cast<PIMAGE_DOS_HEADER>(aBaseAddress)) {}
+
+ explicit PEHeaders(HMODULE aModule)
+ : PEHeaders(HModuleToBaseAddr<PIMAGE_DOS_HEADER>(aModule)) {}
+
+ explicit PEHeaders(PIMAGE_DOS_HEADER aMzHeader)
+ : mMzHeader(aMzHeader),
+ mPeHeader(nullptr),
+ mImageLimit(nullptr),
+ mIsImportDirectoryTampered(false) {
+ if (!mMzHeader || mMzHeader->e_magic != IMAGE_DOS_SIGNATURE) {
+ return;
+ }
+
+ mPeHeader = RVAToPtrUnchecked<PIMAGE_NT_HEADERS>(mMzHeader->e_lfanew);
+ if (!mPeHeader || mPeHeader->Signature != IMAGE_NT_SIGNATURE) {
+ return;
+ }
+
+ if (mPeHeader->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC) {
+ return;
+ }
+
+ DWORD imageSize = mPeHeader->OptionalHeader.SizeOfImage;
+ // This is a coarse-grained check to ensure that the image size is
+ // reasonable. It we aren't big enough to contain headers, we have a
+ // problem!
+ if (imageSize < sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS)) {
+ return;
+ }
+
+ mImageLimit = RVAToPtrUnchecked<void*>(imageSize - 1UL);
+
+ PIMAGE_DATA_DIRECTORY importDirEntry =
+ GetImageDirectoryEntryPtr(IMAGE_DIRECTORY_ENTRY_IMPORT);
+ if (!importDirEntry) {
+ return;
+ }
+
+ mIsImportDirectoryTampered = (importDirEntry->VirtualAddress >= imageSize);
+ }
+
+ explicit operator bool() const { return !!mImageLimit; }
+
+ /**
+ * This overload computes absolute virtual addresses relative to the base
+ * address of the binary.
+ */
+ template <typename T, typename R>
+ T RVAToPtr(R aRva) const {
+ return RVAToPtr<T>(mMzHeader, aRva);
+ }
+
+ /**
+ * This overload computes a result by adding aRva to aBase, but also ensures
+ * that the resulting pointer falls within the bounds of this binary's memory
+ * mapping.
+ */
+ template <typename T, typename R>
+ T RVAToPtr(void* aBase, R aRva) const {
+ if (!mImageLimit) {
+ return nullptr;
+ }
+
+ char* absAddress = reinterpret_cast<char*>(aBase) + aRva;
+ if (absAddress < reinterpret_cast<char*>(mMzHeader) ||
+ absAddress > reinterpret_cast<char*>(mImageLimit)) {
+ return nullptr;
+ }
+
+ return reinterpret_cast<T>(absAddress);
+ }
+
+ Maybe<Range<const uint8_t>> GetBounds() const {
+ if (!mImageLimit) {
+ return Nothing();
+ }
+
+ auto base = reinterpret_cast<const uint8_t*>(mMzHeader);
+ DWORD imageSize = mPeHeader->OptionalHeader.SizeOfImage;
+ return Some(Range(base, imageSize));
+ }
+
+ DWORD GetFileCharacteristics() const {
+ return mPeHeader ? mPeHeader->FileHeader.Characteristics : 0;
+ }
+
+ bool IsWithinImage(const void* aAddress) const {
+ uintptr_t addr = reinterpret_cast<uintptr_t>(aAddress);
+ uintptr_t imageBase = reinterpret_cast<uintptr_t>(mMzHeader);
+ uintptr_t imageLimit = reinterpret_cast<uintptr_t>(mImageLimit);
+ return addr >= imageBase && addr <= imageLimit;
+ }
+
+ PIMAGE_IMPORT_DESCRIPTOR GetImportDirectory() const {
+ // If the import directory is already tampered, we skip bounds check
+ // because it could be located outside the mapped image.
+ return mIsImportDirectoryTampered
+ ? GetImageDirectoryEntry<PIMAGE_IMPORT_DESCRIPTOR,
+ BoundsCheckPolicy::Skip>(
+ IMAGE_DIRECTORY_ENTRY_IMPORT)
+ : GetImageDirectoryEntry<PIMAGE_IMPORT_DESCRIPTOR>(
+ IMAGE_DIRECTORY_ENTRY_IMPORT);
+ }
+
+ PIMAGE_RESOURCE_DIRECTORY GetResourceTable() const {
+ return GetImageDirectoryEntry<PIMAGE_RESOURCE_DIRECTORY>(
+ IMAGE_DIRECTORY_ENTRY_RESOURCE);
+ }
+
+ PIMAGE_DATA_DIRECTORY GetImageDirectoryEntryPtr(
+ const uint32_t aDirectoryIndex, uint32_t* aOutRva = nullptr) const {
+ if (aOutRva) {
+ *aOutRva = 0;
+ }
+
+ IMAGE_OPTIONAL_HEADER& optionalHeader = mPeHeader->OptionalHeader;
+
+ const uint32_t maxIndex = std::min(optionalHeader.NumberOfRvaAndSizes,
+ DWORD(IMAGE_NUMBEROF_DIRECTORY_ENTRIES));
+ if (aDirectoryIndex >= maxIndex) {
+ return nullptr;
+ }
+
+ PIMAGE_DATA_DIRECTORY dirEntry =
+ &optionalHeader.DataDirectory[aDirectoryIndex];
+ if (aOutRva) {
+ *aOutRva = reinterpret_cast<char*>(dirEntry) -
+ reinterpret_cast<char*>(mMzHeader);
+ MOZ_ASSERT(*aOutRva);
+ }
+
+ return dirEntry;
+ }
+
+ bool GetVersionInfo(uint64_t& aOutVersion) const {
+ // RT_VERSION == 16
+ // Version resources require an id of 1
+ auto root = FindResourceLeaf<VS_VERSIONINFO_HEADER*>(16, 1);
+ if (!root) {
+ return false;
+ }
+
+ VS_FIXEDFILEINFO* fixedInfo = GetFixedFileInfo(root);
+ if (!fixedInfo) {
+ return false;
+ }
+
+ aOutVersion = ((static_cast<uint64_t>(fixedInfo->dwFileVersionMS) << 32) |
+ static_cast<uint64_t>(fixedInfo->dwFileVersionLS));
+ return true;
+ }
+
+ bool GetTimeStamp(DWORD& aResult) const {
+ if (!(*this)) {
+ return false;
+ }
+
+ aResult = mPeHeader->FileHeader.TimeDateStamp;
+ return true;
+ }
+
+ bool GetImageSize(DWORD& aResult) const {
+ if (!(*this)) {
+ return false;
+ }
+
+ aResult = mPeHeader->OptionalHeader.SizeOfImage;
+ return true;
+ }
+
+ bool GetCheckSum(DWORD& aResult) const {
+ if (!(*this)) {
+ return false;
+ }
+
+ aResult = mPeHeader->OptionalHeader.CheckSum;
+ return true;
+ }
+
+ PIMAGE_IMPORT_DESCRIPTOR
+ GetImportDescriptor(const char* aModuleNameASCII) const {
+ for (PIMAGE_IMPORT_DESCRIPTOR curImpDesc = GetImportDirectory();
+ IsValid(curImpDesc); ++curImpDesc) {
+ auto curName = mIsImportDirectoryTampered
+ ? RVAToPtrUnchecked<const char*>(curImpDesc->Name)
+ : RVAToPtr<const char*>(curImpDesc->Name);
+ if (!curName) {
+ return nullptr;
+ }
+
+ if (StricmpASCII(aModuleNameASCII, curName)) {
+ continue;
+ }
+
+ // curImpDesc now points to the IAT for the module we're interested in
+ return curImpDesc;
+ }
+
+ return nullptr;
+ }
+
+ template <typename CallbackT>
+ void EnumImportChunks(const CallbackT& aCallback) const {
+ for (PIMAGE_IMPORT_DESCRIPTOR curImpDesc = GetImportDirectory();
+ IsValid(curImpDesc); ++curImpDesc) {
+ auto curName = mIsImportDirectoryTampered
+ ? RVAToPtrUnchecked<const char*>(curImpDesc->Name)
+ : RVAToPtr<const char*>(curImpDesc->Name);
+ if (!curName) {
+ continue;
+ }
+
+ aCallback(curName);
+ }
+ }
+
+ /**
+ * If |aBoundaries| is given, this method checks whether each IAT entry is
+ * within the given range, and if any entry is out of the range, we return
+ * Nothing().
+ */
+ Maybe<Span<IMAGE_THUNK_DATA>> GetIATThunksForModule(
+ const char* aModuleNameASCII,
+ const Range<const uint8_t>* aBoundaries = nullptr) const {
+ PIMAGE_IMPORT_DESCRIPTOR impDesc = GetImportDescriptor(aModuleNameASCII);
+ if (!impDesc) {
+ return Nothing();
+ }
+
+ auto firstIatThunk =
+ this->template RVAToPtr<PIMAGE_THUNK_DATA>(impDesc->FirstThunk);
+ if (!firstIatThunk) {
+ return Nothing();
+ }
+
+ // Find the length by iterating through the table until we find a null entry
+ PIMAGE_THUNK_DATA curIatThunk = firstIatThunk;
+ while (IsValid(curIatThunk)) {
+ if (aBoundaries) {
+ auto iatEntry =
+ reinterpret_cast<const uint8_t*>(curIatThunk->u1.Function);
+ if (iatEntry < aBoundaries->begin().get() ||
+ iatEntry >= aBoundaries->end().get()) {
+ return Nothing();
+ }
+ }
+
+ ++curIatThunk;
+ }
+
+ return Some(Span(firstIatThunk, curIatThunk));
+ }
+
+ /**
+ * Resources are stored in a three-level tree. To locate a particular entry,
+ * you must supply a resource type, the resource id, and then the language id.
+ * If aLangId == 0, we just resolve the first entry regardless of language.
+ */
+ template <typename T>
+ T FindResourceLeaf(WORD aType, WORD aResId, WORD aLangId = 0) const {
+ PIMAGE_RESOURCE_DIRECTORY topLevel = GetResourceTable();
+ if (!topLevel) {
+ return nullptr;
+ }
+
+ PIMAGE_RESOURCE_DIRECTORY_ENTRY typeEntry =
+ FindResourceEntry(topLevel, aType);
+ if (!typeEntry || !typeEntry->DataIsDirectory) {
+ return nullptr;
+ }
+
+ auto idDir = RVAToPtr<PIMAGE_RESOURCE_DIRECTORY>(
+ topLevel, typeEntry->OffsetToDirectory);
+ PIMAGE_RESOURCE_DIRECTORY_ENTRY idEntry = FindResourceEntry(idDir, aResId);
+ if (!idEntry || !idEntry->DataIsDirectory) {
+ return nullptr;
+ }
+
+ auto langDir = RVAToPtr<PIMAGE_RESOURCE_DIRECTORY>(
+ topLevel, idEntry->OffsetToDirectory);
+ PIMAGE_RESOURCE_DIRECTORY_ENTRY langEntry;
+ if (aLangId) {
+ langEntry = FindResourceEntry(langDir, aLangId);
+ } else {
+ langEntry = FindFirstResourceEntry(langDir);
+ }
+
+ if (!langEntry || langEntry->DataIsDirectory) {
+ return nullptr;
+ }
+
+ auto dataEntry =
+ RVAToPtr<PIMAGE_RESOURCE_DATA_ENTRY>(topLevel, langEntry->OffsetToData);
+ return dataEntry ? RVAToPtr<T>(dataEntry->OffsetToData) : nullptr;
+ }
+
+ template <size_t N>
+ Maybe<Span<const uint8_t>> FindSection(const char (&aSecName)[N],
+ DWORD aCharacteristicsMask) const {
+ static_assert((N - 1) <= IMAGE_SIZEOF_SHORT_NAME,
+ "Section names must be at most 8 characters excluding null "
+ "terminator");
+
+ if (!(*this)) {
+ return Nothing();
+ }
+
+ Span<IMAGE_SECTION_HEADER> sectionTable = GetSectionTable();
+ for (auto&& sectionHeader : sectionTable) {
+ if (strncmp(reinterpret_cast<const char*>(sectionHeader.Name), aSecName,
+ IMAGE_SIZEOF_SHORT_NAME)) {
+ continue;
+ }
+
+ if (!(sectionHeader.Characteristics & aCharacteristicsMask)) {
+ // We found the section but it does not have the expected
+ // characteristics
+ return Nothing();
+ }
+
+ DWORD rva = sectionHeader.VirtualAddress;
+ if (!rva) {
+ return Nothing();
+ }
+
+ DWORD size = sectionHeader.Misc.VirtualSize;
+ if (!size) {
+ return Nothing();
+ }
+
+ auto base = RVAToPtr<const uint8_t*>(rva);
+ return Some(Span(base, size));
+ }
+
+ return Nothing();
+ }
+
+ // There may be other code sections in the binary besides .text
+ Maybe<Span<const uint8_t>> GetTextSectionInfo() const {
+ return FindSection(".text", IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE |
+ IMAGE_SCN_MEM_READ);
+ }
+
+ static bool IsValid(PIMAGE_IMPORT_DESCRIPTOR aImpDesc) {
+ return aImpDesc && aImpDesc->OriginalFirstThunk != 0;
+ }
+
+ static bool IsValid(PIMAGE_THUNK_DATA aImgThunk) {
+ return aImgThunk && aImgThunk->u1.Ordinal != 0;
+ }
+
+ bool IsImportDirectoryTampered() const { return mIsImportDirectoryTampered; }
+
+ FARPROC GetEntryPoint() const {
+ // Use the unchecked version because the entrypoint may be tampered.
+ return RVAToPtrUnchecked<FARPROC>(
+ mPeHeader->OptionalHeader.AddressOfEntryPoint);
+ }
+
+ const CodeViewRecord70* GetPdbInfo() const {
+ PIMAGE_DEBUG_DIRECTORY debugDirectory =
+ GetImageDirectoryEntry<PIMAGE_DEBUG_DIRECTORY>(
+ IMAGE_DIRECTORY_ENTRY_DEBUG);
+ if (!debugDirectory) {
+ return nullptr;
+ }
+
+ const CodeViewRecord70* debugInfo =
+ RVAToPtr<CodeViewRecord70*>(debugDirectory->AddressOfRawData);
+ return (debugInfo && debugInfo->signature == 'SDSR') ? debugInfo : nullptr;
+ }
+
+ private:
+ enum class BoundsCheckPolicy { Default, Skip };
+
+ template <typename T, BoundsCheckPolicy Policy = BoundsCheckPolicy::Default>
+ T GetImageDirectoryEntry(const uint32_t aDirectoryIndex) const {
+ PIMAGE_DATA_DIRECTORY dirEntry = GetImageDirectoryEntryPtr(aDirectoryIndex);
+ if (!dirEntry) {
+ return nullptr;
+ }
+
+ return Policy == BoundsCheckPolicy::Skip
+ ? RVAToPtrUnchecked<T>(dirEntry->VirtualAddress)
+ : RVAToPtr<T>(dirEntry->VirtualAddress);
+ }
+
+ // This private variant does not have bounds checks, because we need to be
+ // able to resolve the bounds themselves.
+ template <typename T, typename R>
+ T RVAToPtrUnchecked(R aRva) const {
+ return reinterpret_cast<T>(reinterpret_cast<char*>(mMzHeader) + aRva);
+ }
+
+ Span<IMAGE_SECTION_HEADER> GetSectionTable() const {
+ MOZ_ASSERT(*this);
+ auto base = RVAToPtr<PIMAGE_SECTION_HEADER>(
+ &mPeHeader->OptionalHeader, mPeHeader->FileHeader.SizeOfOptionalHeader);
+ // The Windows loader has an internal limit of 96 sections (per PE spec)
+ auto numSections =
+ std::min(mPeHeader->FileHeader.NumberOfSections, WORD(96));
+ return Span{base, numSections};
+ }
+
+ PIMAGE_RESOURCE_DIRECTORY_ENTRY
+ FindResourceEntry(PIMAGE_RESOURCE_DIRECTORY aCurLevel, WORD aId) const {
+ if (!aCurLevel) {
+ return nullptr;
+ }
+
+ // Immediately after the IMAGE_RESOURCE_DIRECTORY structure is an array
+ // of IMAGE_RESOURCE_DIRECTORY_ENTRY structures. Since this function
+ // searches by ID, we need to skip past any named entries before iterating.
+ auto dirEnt =
+ reinterpret_cast<PIMAGE_RESOURCE_DIRECTORY_ENTRY>(aCurLevel + 1) +
+ aCurLevel->NumberOfNamedEntries;
+ if (!(IsWithinImage(dirEnt) &&
+ IsWithinImage(&dirEnt[aCurLevel->NumberOfIdEntries - 1].Id))) {
+ return nullptr;
+ }
+
+ for (WORD i = 0; i < aCurLevel->NumberOfIdEntries; ++i) {
+ if (dirEnt[i].Id == aId) {
+ return &dirEnt[i];
+ }
+ }
+
+ return nullptr;
+ }
+
+ PIMAGE_RESOURCE_DIRECTORY_ENTRY
+ FindFirstResourceEntry(PIMAGE_RESOURCE_DIRECTORY aCurLevel) const {
+ // Immediately after the IMAGE_RESOURCE_DIRECTORY structure is an array
+ // of IMAGE_RESOURCE_DIRECTORY_ENTRY structures. We just return the first
+ // entry, regardless of whether it is indexed by name or by id.
+ auto dirEnt =
+ reinterpret_cast<PIMAGE_RESOURCE_DIRECTORY_ENTRY>(aCurLevel + 1);
+ WORD numEntries =
+ aCurLevel->NumberOfNamedEntries + aCurLevel->NumberOfIdEntries;
+ if (!numEntries) {
+ return nullptr;
+ }
+
+ return dirEnt;
+ }
+
+ VS_FIXEDFILEINFO* GetFixedFileInfo(VS_VERSIONINFO_HEADER* aVerInfo) const {
+ WORD length = aVerInfo->wLength;
+ if (length < sizeof(VS_VERSIONINFO_HEADER)) {
+ return nullptr;
+ }
+
+ const wchar_t kVersionInfoKey[] = L"VS_VERSION_INFO";
+ if (::RtlCompareMemory(aVerInfo->szKey, kVersionInfoKey,
+ ArrayLength(kVersionInfoKey)) !=
+ ArrayLength(kVersionInfoKey)) {
+ return nullptr;
+ }
+
+ if (aVerInfo->wValueLength != sizeof(VS_FIXEDFILEINFO)) {
+ // Fixed file info does not exist
+ return nullptr;
+ }
+
+ WORD offset = sizeof(VS_VERSIONINFO_HEADER);
+
+ uintptr_t base = reinterpret_cast<uintptr_t>(aVerInfo);
+ // Align up to 4-byte boundary
+#pragma warning(suppress : 4146)
+ offset += (-(base + offset) & 3);
+
+ if (offset >= length) {
+ return nullptr;
+ }
+
+ auto result = reinterpret_cast<VS_FIXEDFILEINFO*>(base + offset);
+ if (result->dwSignature != 0xFEEF04BD) {
+ return nullptr;
+ }
+
+ return result;
+ }
+
+ private:
+ PIMAGE_DOS_HEADER mMzHeader;
+ PIMAGE_NT_HEADERS mPeHeader;
+ void* mImageLimit;
+ bool mIsImportDirectoryTampered;
+};
+
+// This class represents an export section of a local/remote process.
+template <typename MMPolicy>
+class MOZ_RAII PEExportSection {
+ const MMPolicy& mMMPolicy;
+ uintptr_t mImageBase;
+ DWORD mOrdinalBase;
+ DWORD mRvaDirStart;
+ DWORD mRvaDirEnd;
+ mozilla::interceptor::TargetObjectArray<MMPolicy, DWORD> mExportAddressTable;
+ mozilla::interceptor::TargetObjectArray<MMPolicy, DWORD> mExportNameTable;
+ mozilla::interceptor::TargetObjectArray<MMPolicy, WORD> mExportOrdinalTable;
+
+ explicit PEExportSection(const MMPolicy& aMMPolicy)
+ : mMMPolicy(aMMPolicy),
+ mImageBase(0),
+ mOrdinalBase(0),
+ mRvaDirStart(0),
+ mRvaDirEnd(0),
+ mExportAddressTable(mMMPolicy),
+ mExportNameTable(mMMPolicy),
+ mExportOrdinalTable(mMMPolicy) {}
+
+ PEExportSection(const MMPolicy& aMMPolicy, uintptr_t aImageBase,
+ DWORD aRvaDirStart, DWORD aRvaDirEnd,
+ const IMAGE_EXPORT_DIRECTORY& exportDir)
+ : mMMPolicy(aMMPolicy),
+ mImageBase(aImageBase),
+ mOrdinalBase(exportDir.Base),
+ mRvaDirStart(aRvaDirStart),
+ mRvaDirEnd(aRvaDirEnd),
+ mExportAddressTable(mMMPolicy,
+ mImageBase + exportDir.AddressOfFunctions,
+ exportDir.NumberOfFunctions),
+ mExportNameTable(mMMPolicy, mImageBase + exportDir.AddressOfNames,
+ exportDir.NumberOfNames),
+ mExportOrdinalTable(mMMPolicy,
+ mImageBase + exportDir.AddressOfNameOrdinals,
+ exportDir.NumberOfNames) {}
+
+ static const PEExportSection Get(uintptr_t aImageBase,
+ const MMPolicy& aMMPolicy) {
+ mozilla::interceptor::TargetObject<MMPolicy, IMAGE_DOS_HEADER> mzHeader(
+ aMMPolicy, aImageBase);
+ if (!mzHeader || mzHeader->e_magic != IMAGE_DOS_SIGNATURE) {
+ return PEExportSection(aMMPolicy);
+ }
+
+ mozilla::interceptor::TargetObject<MMPolicy, IMAGE_NT_HEADERS> peHeader(
+ aMMPolicy, aImageBase + mzHeader->e_lfanew);
+ if (!peHeader || peHeader->Signature != IMAGE_NT_SIGNATURE) {
+ return PEExportSection(aMMPolicy);
+ }
+
+ if (peHeader->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC) {
+ return PEExportSection(aMMPolicy);
+ }
+
+ const IMAGE_OPTIONAL_HEADER& optionalHeader = peHeader->OptionalHeader;
+
+ DWORD imageSize = optionalHeader.SizeOfImage;
+ // This is a coarse-grained check to ensure that the image size is
+ // reasonable. It we aren't big enough to contain headers, we have a
+ // problem!
+ if (imageSize < sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS)) {
+ return PEExportSection(aMMPolicy);
+ }
+
+ if (optionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_EXPORT) {
+ return PEExportSection(aMMPolicy);
+ }
+
+ const IMAGE_DATA_DIRECTORY& exportDirectoryEntry =
+ optionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
+ if (!exportDirectoryEntry.VirtualAddress || !exportDirectoryEntry.Size) {
+ return PEExportSection(aMMPolicy);
+ }
+
+ mozilla::interceptor::TargetObject<MMPolicy, IMAGE_EXPORT_DIRECTORY>
+ exportDirectory(aMMPolicy,
+ aImageBase + exportDirectoryEntry.VirtualAddress);
+ if (!exportDirectory || !exportDirectory->NumberOfFunctions) {
+ return PEExportSection(aMMPolicy);
+ }
+
+ return PEExportSection(
+ aMMPolicy, aImageBase, exportDirectoryEntry.VirtualAddress,
+ exportDirectoryEntry.VirtualAddress + exportDirectoryEntry.Size,
+ *exportDirectory.GetLocalBase());
+ }
+
+ FARPROC GetProcAddressByOrdinal(WORD aOrdinal) const {
+ if (aOrdinal < mOrdinalBase) {
+ return nullptr;
+ }
+
+ auto rvaToFunction = mExportAddressTable[aOrdinal - mOrdinalBase];
+ if (!rvaToFunction) {
+ return nullptr;
+ }
+ return reinterpret_cast<FARPROC>(mImageBase + *rvaToFunction);
+ }
+
+ public:
+ static const PEExportSection Get(HMODULE aModule, const MMPolicy& aMMPolicy) {
+ return Get(PEHeaders::HModuleToBaseAddr<uintptr_t>(aModule), aMMPolicy);
+ }
+
+ explicit operator bool() const {
+ // Because PEExportSection doesn't use MMPolicy::Reserve(), a boolified
+ // mMMPolicy is expected to be false. We don't check mMMPolicy here.
+ return mImageBase && mRvaDirStart && mRvaDirEnd && mExportAddressTable &&
+ mExportNameTable && mExportOrdinalTable;
+ }
+
+ template <typename T>
+ T RVAToPtr(uint32_t aRva) const {
+ return reinterpret_cast<T>(mImageBase + aRva);
+ }
+
+ PIMAGE_EXPORT_DIRECTORY GetExportDirectory() const {
+ if (!*this) {
+ return nullptr;
+ }
+
+ return RVAToPtr<PIMAGE_EXPORT_DIRECTORY>(mRvaDirStart);
+ }
+
+ /**
+ * This functions searches the export table for a given string as
+ * GetProcAddress does, but this returns a matched entry of the Export
+ * Address Table i.e. a pointer to an RVA of a matched function instead
+ * of a function address. If the entry is forwarded, this function
+ * returns nullptr.
+ */
+ const DWORD* FindExportAddressTableEntry(
+ const char* aFunctionNameASCII) const {
+ if (!*this || !aFunctionNameASCII) {
+ return nullptr;
+ }
+
+ struct NameTableComparator {
+ NameTableComparator(const PEExportSection<MMPolicy>& aExportSection,
+ const char* aTarget)
+ : mExportSection(aExportSection),
+ mTargetName(aTarget),
+ mTargetNamelength(StrlenASCII(aTarget)) {}
+
+ int operator()(DWORD aRVAToString) const {
+ mozilla::interceptor::TargetObjectArray<MMPolicy, char> itemString(
+ mExportSection.mMMPolicy, mExportSection.mImageBase + aRVAToString,
+ mTargetNamelength + 1);
+ return StrcmpASCII(mTargetName, itemString[0]);
+ }
+
+ const PEExportSection<MMPolicy>& mExportSection;
+ const char* mTargetName;
+ size_t mTargetNamelength;
+ };
+
+ const NameTableComparator comp(*this, aFunctionNameASCII);
+
+ size_t match;
+ if (!mExportNameTable.BinarySearchIf(comp, &match)) {
+ return nullptr;
+ }
+
+ const WORD* index = mExportOrdinalTable[match];
+ if (!index) {
+ return nullptr;
+ }
+
+ const DWORD* rvaToFunction = mExportAddressTable[*index];
+ if (!rvaToFunction) {
+ return nullptr;
+ }
+
+ if (*rvaToFunction >= mRvaDirStart && *rvaToFunction < mRvaDirEnd) {
+ // If an entry points to an address within the export section, the
+ // field is a forwarder RVA. We return nullptr because the entry is
+ // not a function address but a null-terminated string used for export
+ // forwarding.
+ return nullptr;
+ }
+
+ return rvaToFunction;
+ }
+
+ /**
+ * This functions behaves the same as the native ::GetProcAddress except
+ * the following cases:
+ * - Returns nullptr if a target entry is forwarded to another dll.
+ */
+ FARPROC GetProcAddress(const char* aFunctionNameASCII) const {
+ uintptr_t maybeOdrinal = reinterpret_cast<uintptr_t>(aFunctionNameASCII);
+ // When the high-order word of |aFunctionNameASCII| is zero, it's not
+ // a string but an ordinal value.
+ if (maybeOdrinal < 0x10000) {
+ return GetProcAddressByOrdinal(static_cast<WORD>(maybeOdrinal));
+ }
+
+ auto rvaToFunction = FindExportAddressTableEntry(aFunctionNameASCII);
+ if (!rvaToFunction) {
+ return nullptr;
+ }
+ return reinterpret_cast<FARPROC>(mImageBase + *rvaToFunction);
+ }
+};
+
+inline HANDLE RtlGetProcessHeap() {
+ PTEB teb = ::NtCurrentTeb();
+ PPEB peb = teb->ProcessEnvironmentBlock;
+ return peb->Reserved4[1];
+}
+
+inline PVOID RtlGetThreadLocalStoragePointer() {
+ return ::NtCurrentTeb()->Reserved1[11];
+}
+
+inline void RtlSetThreadLocalStoragePointerForTestingOnly(PVOID aNewValue) {
+ ::NtCurrentTeb()->Reserved1[11] = aNewValue;
+}
+
+inline DWORD RtlGetCurrentThreadId() {
+ PTEB teb = ::NtCurrentTeb();
+ CLIENT_ID* cid = reinterpret_cast<CLIENT_ID*>(&teb->Reserved1[8]);
+ return static_cast<DWORD>(reinterpret_cast<uintptr_t>(cid->UniqueThread) &
+ 0xFFFFFFFFUL);
+}
+
+const HANDLE kCurrentProcess = reinterpret_cast<HANDLE>(-1);
+
+inline LauncherResult<DWORD> GetParentProcessId() {
+ struct PROCESS_BASIC_INFORMATION {
+ NTSTATUS ExitStatus;
+ PPEB PebBaseAddress;
+ ULONG_PTR AffinityMask;
+ LONG BasePriority;
+ ULONG_PTR UniqueProcessId;
+ ULONG_PTR InheritedFromUniqueProcessId;
+ };
+
+ ULONG returnLength;
+ PROCESS_BASIC_INFORMATION pbi = {};
+ NTSTATUS status =
+ ::NtQueryInformationProcess(kCurrentProcess, ProcessBasicInformation,
+ &pbi, sizeof(pbi), &returnLength);
+ if (!NT_SUCCESS(status)) {
+ return LAUNCHER_ERROR_FROM_NTSTATUS(status);
+ }
+
+ return static_cast<DWORD>(pbi.InheritedFromUniqueProcessId & 0xFFFFFFFF);
+}
+
+inline SIZE_T WINAPI VirtualQueryEx(HANDLE aProcess, LPCVOID aAddress,
+ PMEMORY_BASIC_INFORMATION aMemInfo,
+ SIZE_T aMemInfoLen) {
+#if defined(MOZILLA_INTERNAL_API)
+ return ::VirtualQueryEx(aProcess, aAddress, aMemInfo, aMemInfoLen);
+#else
+ SIZE_T returnedLength;
+ NTSTATUS status = ::NtQueryVirtualMemory(
+ aProcess, const_cast<PVOID>(aAddress), MemoryBasicInformation, aMemInfo,
+ aMemInfoLen, &returnedLength);
+ if (!NT_SUCCESS(status)) {
+ ::RtlSetLastWin32Error(::RtlNtStatusToDosError(status));
+ returnedLength = 0;
+ }
+ return returnedLength;
+#endif // defined(MOZILLA_INTERNAL_API)
+}
+
+inline SIZE_T WINAPI VirtualQuery(LPCVOID aAddress,
+ PMEMORY_BASIC_INFORMATION aMemInfo,
+ SIZE_T aMemInfoLen) {
+ return nt::VirtualQueryEx(kCurrentProcess, aAddress, aMemInfo, aMemInfoLen);
+}
+
+struct DataDirectoryEntry : public _IMAGE_DATA_DIRECTORY {
+ DataDirectoryEntry() : _IMAGE_DATA_DIRECTORY() {}
+
+ MOZ_IMPLICIT DataDirectoryEntry(const _IMAGE_DATA_DIRECTORY& aOther)
+ : _IMAGE_DATA_DIRECTORY(aOther) {}
+
+ DataDirectoryEntry(const DataDirectoryEntry& aOther) = default;
+
+ bool operator==(const DataDirectoryEntry& aOther) const {
+ return VirtualAddress == aOther.VirtualAddress && Size == aOther.Size;
+ }
+
+ bool operator!=(const DataDirectoryEntry& aOther) const {
+ return !(*this == aOther);
+ }
+};
+
+inline LauncherResult<void*> GetProcessPebPtr(HANDLE aProcess) {
+ ULONG returnLength;
+ PROCESS_BASIC_INFORMATION pbi;
+ NTSTATUS status = ::NtQueryInformationProcess(
+ aProcess, ProcessBasicInformation, &pbi, sizeof(pbi), &returnLength);
+ if (!NT_SUCCESS(status)) {
+ return LAUNCHER_ERROR_FROM_NTSTATUS(status);
+ }
+
+ return pbi.PebBaseAddress;
+}
+
+/**
+ * This function relies on a specific offset into the mostly-undocumented PEB
+ * structure. The risk is reduced thanks to the fact that the Chromium sandbox
+ * relies on the location of this field. It is unlikely to change at this point.
+ * To further reduce the risk, we also check for the magic 'MZ' signature that
+ * should indicate the beginning of a PE image.
+ */
+inline LauncherResult<HMODULE> GetProcessExeModule(HANDLE aProcess) {
+ LauncherResult<void*> ppeb = GetProcessPebPtr(aProcess);
+ if (ppeb.isErr()) {
+ return ppeb.propagateErr();
+ }
+
+ PEB peb;
+ SIZE_T bytesRead;
+
+#if defined(MOZILLA_INTERNAL_API)
+ if (!::ReadProcessMemory(aProcess, ppeb.unwrap(), &peb, sizeof(peb),
+ &bytesRead) ||
+ bytesRead != sizeof(peb)) {
+ return LAUNCHER_ERROR_FROM_LAST();
+ }
+#else
+ NTSTATUS ntStatus = ::NtReadVirtualMemory(aProcess, ppeb.unwrap(), &peb,
+ sizeof(peb), &bytesRead);
+ if (!NT_SUCCESS(ntStatus) || bytesRead != sizeof(peb)) {
+ return LAUNCHER_ERROR_FROM_NTSTATUS(ntStatus);
+ }
+#endif
+
+ // peb.ImageBaseAddress
+ void* baseAddress = peb.Reserved3[1];
+
+ char mzMagic[2];
+#if defined(MOZILLA_INTERNAL_API)
+ if (!::ReadProcessMemory(aProcess, baseAddress, mzMagic, sizeof(mzMagic),
+ &bytesRead) ||
+ bytesRead != sizeof(mzMagic)) {
+ return LAUNCHER_ERROR_FROM_LAST();
+ }
+#else
+ ntStatus = ::NtReadVirtualMemory(aProcess, baseAddress, mzMagic,
+ sizeof(mzMagic), &bytesRead);
+ if (!NT_SUCCESS(ntStatus) || bytesRead != sizeof(mzMagic)) {
+ return LAUNCHER_ERROR_FROM_NTSTATUS(ntStatus);
+ }
+#endif
+
+ MOZ_ASSERT(mzMagic[0] == 'M' && mzMagic[1] == 'Z');
+ if (mzMagic[0] != 'M' || mzMagic[1] != 'Z') {
+ return LAUNCHER_ERROR_FROM_WIN32(ERROR_BAD_EXE_FORMAT);
+ }
+
+ return static_cast<HMODULE>(baseAddress);
+}
+
+#if defined(_MSC_VER)
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+#endif
+
+// This class manages data transfer from the local process's executable
+// to another process's executable via WriteProcessMemory.
+// Bug 1662560 told us the same executable may be mapped onto a different
+// address in a different process. This means when we transfer data within
+// the mapped executable such as a global variable or IAT from the current
+// process to another process, we need to shift its address by the difference
+// between two executable's mapped imagebase.
+class CrossExecTransferManager final {
+ HANDLE mRemoteProcess;
+ uint8_t* mLocalImagebase;
+ PEHeaders mLocalExec;
+ uint8_t* mRemoteImagebase;
+
+ static HMODULE GetLocalExecModule() {
+#if defined(_MSC_VER)
+ return reinterpret_cast<HMODULE>(&__ImageBase);
+#else
+ return ::GetModuleHandleW(nullptr);
+#endif
+ }
+
+ LauncherVoidResult EnsureRemoteImagebase() {
+ if (!mRemoteImagebase) {
+ LauncherResult<HMODULE> remoteImageBaseResult =
+ GetProcessExeModule(mRemoteProcess);
+ if (remoteImageBaseResult.isErr()) {
+ return remoteImageBaseResult.propagateErr();
+ }
+
+ mRemoteImagebase =
+ reinterpret_cast<uint8_t*>(remoteImageBaseResult.unwrap());
+ }
+ return Ok();
+ }
+
+ template <typename T>
+ T* LocalExecToRemoteExec(T* aLocalAddress) const {
+ MOZ_ASSERT(mRemoteImagebase);
+ MOZ_ASSERT(mLocalExec.IsWithinImage(aLocalAddress));
+
+ if (!mRemoteImagebase || !mLocalExec.IsWithinImage(aLocalAddress)) {
+ return aLocalAddress;
+ }
+
+ uintptr_t offset = reinterpret_cast<uintptr_t>(aLocalAddress) -
+ reinterpret_cast<uintptr_t>(mLocalImagebase);
+ return reinterpret_cast<T*>(mRemoteImagebase + offset);
+ }
+
+ public:
+ explicit CrossExecTransferManager(HANDLE aRemoteProcess)
+ : mRemoteProcess(aRemoteProcess),
+ mLocalImagebase(
+ PEHeaders::HModuleToBaseAddr<uint8_t*>(GetLocalExecModule())),
+ mLocalExec(mLocalImagebase),
+ mRemoteImagebase(nullptr) {}
+
+ CrossExecTransferManager(HANDLE aRemoteProcess, HMODULE aLocalImagebase)
+ : mRemoteProcess(aRemoteProcess),
+ mLocalImagebase(
+ PEHeaders::HModuleToBaseAddr<uint8_t*>(aLocalImagebase)),
+ mLocalExec(mLocalImagebase),
+ mRemoteImagebase(nullptr) {}
+
+ explicit operator bool() const { return !!mLocalExec; }
+ HANDLE RemoteProcess() const { return mRemoteProcess; }
+ const PEHeaders& LocalPEHeaders() const { return mLocalExec; }
+
+ AutoVirtualProtect Protect(void* aLocalAddress, size_t aLength,
+ DWORD aProtFlags) {
+ // If EnsureRemoteImagebase() fails, a subsequent operaion will fail.
+ Unused << EnsureRemoteImagebase();
+ return AutoVirtualProtect(LocalExecToRemoteExec(aLocalAddress), aLength,
+ aProtFlags, mRemoteProcess);
+ }
+
+ LauncherVoidResult Transfer(LPVOID aDestinationAddress,
+ LPCVOID aBufferToWrite, SIZE_T aBufferSize) {
+ LauncherVoidResult result = EnsureRemoteImagebase();
+ if (result.isErr()) {
+ return result.propagateErr();
+ }
+
+ if (!::WriteProcessMemory(mRemoteProcess,
+ LocalExecToRemoteExec(aDestinationAddress),
+ aBufferToWrite, aBufferSize, nullptr)) {
+ return LAUNCHER_ERROR_FROM_LAST();
+ }
+
+ return Ok();
+ }
+};
+
+#if !defined(MOZILLA_INTERNAL_API)
+
+inline LauncherResult<HMODULE> GetModuleHandleFromLeafName(
+ const UNICODE_STRING& aTarget) {
+ auto maybePeb = nt::GetProcessPebPtr(kCurrentProcess);
+ if (maybePeb.isErr()) {
+ return maybePeb.propagateErr();
+ }
+
+ const PPEB peb = reinterpret_cast<PPEB>(maybePeb.unwrap());
+ if (!peb->Ldr) {
+ return LAUNCHER_ERROR_FROM_WIN32(ERROR_BAD_EXE_FORMAT);
+ }
+
+ auto firstItem = &peb->Ldr->InMemoryOrderModuleList;
+ for (auto p = firstItem->Flink; p != firstItem; p = p->Flink) {
+ const auto currentTableEntry =
+ CONTAINING_RECORD(p, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks);
+
+ UNICODE_STRING leafName;
+ nt::GetLeafName(&leafName, &currentTableEntry->FullDllName);
+
+ if (::RtlCompareUnicodeString(&leafName, &aTarget, TRUE) == 0) {
+ return reinterpret_cast<HMODULE>(currentTableEntry->DllBase);
+ }
+ }
+
+ return LAUNCHER_ERROR_FROM_WIN32(ERROR_MOD_NOT_FOUND);
+}
+
+class MOZ_ONLY_USED_TO_AVOID_STATIC_CONSTRUCTORS SRWLock final {
+ public:
+ constexpr SRWLock() : mLock(SRWLOCK_INIT) {}
+
+ void LockShared() { ::RtlAcquireSRWLockShared(&mLock); }
+
+ void LockExclusive() { ::RtlAcquireSRWLockExclusive(&mLock); }
+
+ void UnlockShared() { ::RtlReleaseSRWLockShared(&mLock); }
+
+ void UnlockExclusive() { ::RtlReleaseSRWLockExclusive(&mLock); }
+
+ SRWLock(const SRWLock&) = delete;
+ SRWLock(SRWLock&&) = delete;
+ SRWLock& operator=(const SRWLock&) = delete;
+ SRWLock& operator=(SRWLock&&) = delete;
+
+ SRWLOCK* operator&() { return &mLock; }
+
+ private:
+ SRWLOCK mLock;
+};
+
+class MOZ_RAII AutoExclusiveLock final {
+ public:
+ explicit AutoExclusiveLock(SRWLock& aLock) : mLock(aLock) {
+ aLock.LockExclusive();
+ }
+
+ ~AutoExclusiveLock() { mLock.UnlockExclusive(); }
+
+ AutoExclusiveLock(const AutoExclusiveLock&) = delete;
+ AutoExclusiveLock(AutoExclusiveLock&&) = delete;
+ AutoExclusiveLock& operator=(const AutoExclusiveLock&) = delete;
+ AutoExclusiveLock& operator=(AutoExclusiveLock&&) = delete;
+
+ private:
+ SRWLock& mLock;
+};
+
+class MOZ_RAII AutoSharedLock final {
+ public:
+ explicit AutoSharedLock(SRWLock& aLock) : mLock(aLock) { aLock.LockShared(); }
+
+ ~AutoSharedLock() { mLock.UnlockShared(); }
+
+ AutoSharedLock(const AutoSharedLock&) = delete;
+ AutoSharedLock(AutoSharedLock&&) = delete;
+ AutoSharedLock& operator=(const AutoSharedLock&) = delete;
+ AutoSharedLock& operator=(AutoSharedLock&&) = delete;
+
+ private:
+ SRWLock& mLock;
+};
+
+#endif // !defined(MOZILLA_INTERNAL_API)
+
+class RtlAllocPolicy {
+ public:
+ template <typename T>
+ T* maybe_pod_malloc(size_t aNumElems) {
+ if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
+ return nullptr;
+ }
+
+ return static_cast<T*>(
+ ::RtlAllocateHeap(RtlGetProcessHeap(), 0, aNumElems * sizeof(T)));
+ }
+
+ template <typename T>
+ T* maybe_pod_calloc(size_t aNumElems) {
+ if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
+ return nullptr;
+ }
+
+ return static_cast<T*>(::RtlAllocateHeap(
+ RtlGetProcessHeap(), HEAP_ZERO_MEMORY, aNumElems * sizeof(T)));
+ }
+
+ template <typename T>
+ T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize) {
+ if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
+ return nullptr;
+ }
+
+ return static_cast<T*>(::RtlReAllocateHeap(RtlGetProcessHeap(), 0, aPtr,
+ aNewSize * sizeof(T)));
+ }
+
+ template <typename T>
+ T* pod_malloc(size_t aNumElems) {
+ return maybe_pod_malloc<T>(aNumElems);
+ }
+
+ template <typename T>
+ T* pod_calloc(size_t aNumElems) {
+ return maybe_pod_calloc<T>(aNumElems);
+ }
+
+ template <typename T>
+ T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize) {
+ return maybe_pod_realloc<T>(aPtr, aOldSize, aNewSize);
+ }
+
+ template <typename T>
+ void free_(T* aPtr, size_t aNumElems = 0) {
+ ::RtlFreeHeap(RtlGetProcessHeap(), 0, aPtr);
+ }
+
+ void reportAllocOverflow() const {}
+
+ [[nodiscard]] bool checkSimulatedOOM() const { return true; }
+};
+
+class AutoMappedView final {
+ void* mView;
+
+ void Unmap() {
+ if (!mView) {
+ return;
+ }
+
+#if defined(MOZILLA_INTERNAL_API)
+ ::UnmapViewOfFile(mView);
+#else
+ NTSTATUS status = ::NtUnmapViewOfSection(nt::kCurrentProcess, mView);
+ if (!NT_SUCCESS(status)) {
+ ::RtlSetLastWin32Error(::RtlNtStatusToDosError(status));
+ }
+#endif
+ mView = nullptr;
+ }
+
+ public:
+ explicit AutoMappedView(void* aView) : mView(aView) {}
+
+ AutoMappedView(HANDLE aSection, ULONG aProtectionFlags) : mView(nullptr) {
+#if defined(MOZILLA_INTERNAL_API)
+ mView = ::MapViewOfFile(aSection, aProtectionFlags, 0, 0, 0);
+#else
+ SIZE_T viewSize = 0;
+ NTSTATUS status = ::NtMapViewOfSection(aSection, nt::kCurrentProcess,
+ &mView, 0, 0, nullptr, &viewSize,
+ ViewUnmap, 0, aProtectionFlags);
+ if (!NT_SUCCESS(status)) {
+ ::RtlSetLastWin32Error(::RtlNtStatusToDosError(status));
+ }
+#endif
+ }
+ ~AutoMappedView() { Unmap(); }
+
+ // Allow move & Disallow copy
+ AutoMappedView(AutoMappedView&& aOther) : mView(aOther.mView) {
+ aOther.mView = nullptr;
+ }
+ AutoMappedView& operator=(AutoMappedView&& aOther) {
+ if (this != &aOther) {
+ Unmap();
+ mView = aOther.mView;
+ aOther.mView = nullptr;
+ }
+ return *this;
+ }
+ AutoMappedView(const AutoMappedView&) = delete;
+ AutoMappedView& operator=(const AutoMappedView&) = delete;
+
+ explicit operator bool() const { return !!mView; }
+ template <typename T>
+ T* as() {
+ return reinterpret_cast<T*>(mView);
+ }
+
+ void* release() {
+ void* p = mView;
+ mView = nullptr;
+ return p;
+ }
+};
+
+} // namespace nt
+} // namespace mozilla
+
+#endif // mozilla_NativeNt_h
diff --git a/mozglue/misc/PlatformConditionVariable.h b/mozglue/misc/PlatformConditionVariable.h
new file mode 100644
index 0000000000..61fb06ade1
--- /dev/null
+++ b/mozglue/misc/PlatformConditionVariable.h
@@ -0,0 +1,71 @@
+/* -*- 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/. */
+
+#ifndef mozilla_ConditionVariable_h
+#define mozilla_ConditionVariable_h
+
+#include <stdint.h>
+
+#include <utility>
+
+#include "mozilla/Attributes.h"
+#include "mozilla/PlatformMutex.h"
+#include "mozilla/TimeStamp.h"
+#if !defined(XP_WIN) && !defined(__wasi__)
+# include <pthread.h>
+#endif
+
+namespace mozilla {
+
+enum class CVStatus { NoTimeout, Timeout };
+
+namespace detail {
+
+class ConditionVariableImpl {
+ public:
+ struct PlatformData;
+
+ MFBT_API ConditionVariableImpl();
+ MFBT_API ~ConditionVariableImpl();
+
+ // Wake one thread that is waiting on this condition.
+ MFBT_API void notify_one();
+
+ // Wake all threads that are waiting on this condition.
+ MFBT_API void notify_all();
+
+ // Atomically release |lock| and sleep the current thread of execution on
+ // this condition variable.
+ // |lock| will be re-acquired before this function returns.
+ // The thread may be woken from sleep from another thread via notify_one()
+ // or notify_all(), but may also wake spuriously. The caller should recheck
+ // its predicate after this function returns, typically in a while loop.
+ MFBT_API void wait(MutexImpl& lock);
+
+ MFBT_API CVStatus wait_for(MutexImpl& lock,
+ const mozilla::TimeDuration& rel_time);
+
+ private:
+ ConditionVariableImpl(const ConditionVariableImpl&) = delete;
+ ConditionVariableImpl& operator=(const ConditionVariableImpl&) = delete;
+
+ PlatformData* platformData();
+
+#if !defined(XP_WIN) && !defined(__wasi__)
+ void* platformData_[sizeof(pthread_cond_t) / sizeof(void*)];
+ static_assert(sizeof(pthread_cond_t) / sizeof(void*) != 0 &&
+ sizeof(pthread_cond_t) % sizeof(void*) == 0,
+ "pthread_cond_t must have pointer alignment");
+#else
+ void* platformData_[4];
+#endif
+};
+
+} // namespace detail
+
+} // namespace mozilla
+
+#endif // mozilla_ConditionVariable_h
diff --git a/mozglue/misc/PlatformMutex.h b/mozglue/misc/PlatformMutex.h
new file mode 100644
index 0000000000..ac5459cf10
--- /dev/null
+++ b/mozglue/misc/PlatformMutex.h
@@ -0,0 +1,66 @@
+/* -*- 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/. */
+
+#ifndef mozilla_PlatformMutex_h
+#define mozilla_PlatformMutex_h
+
+#include <utility>
+
+#include "mozilla/Attributes.h"
+#include "mozilla/Types.h"
+
+#if !defined(XP_WIN) && !defined(__wasi__)
+# include <pthread.h>
+#endif
+
+namespace mozilla {
+
+namespace detail {
+
+class ConditionVariableImpl;
+
+class MutexImpl {
+ public:
+ struct PlatformData;
+
+ explicit MFBT_API MutexImpl();
+ MFBT_API ~MutexImpl();
+
+ protected:
+ MFBT_API void lock();
+ MFBT_API void unlock();
+ // We have a separate, forwarding API so internal uses don't have to go
+ // through the PLT.
+ MFBT_API bool tryLock();
+
+ private:
+ MutexImpl(const MutexImpl&) = delete;
+ void operator=(const MutexImpl&) = delete;
+ MutexImpl(MutexImpl&&) = delete;
+ void operator=(MutexImpl&&) = delete;
+ bool operator==(const MutexImpl& rhs) = delete;
+
+ void mutexLock();
+ bool mutexTryLock();
+
+ PlatformData* platformData();
+
+#if !defined(XP_WIN) && !defined(__wasi__)
+ void* platformData_[sizeof(pthread_mutex_t) / sizeof(void*)];
+ static_assert(sizeof(pthread_mutex_t) / sizeof(void*) != 0 &&
+ sizeof(pthread_mutex_t) % sizeof(void*) == 0,
+ "pthread_mutex_t must have pointer alignment");
+#else
+ void* platformData_[6];
+#endif
+
+ friend class mozilla::detail::ConditionVariableImpl;
+};
+
+} // namespace detail
+
+} // namespace mozilla
+#endif // mozilla_PlatformMutex_h
diff --git a/mozglue/misc/PlatformRWLock.h b/mozglue/misc/PlatformRWLock.h
new file mode 100644
index 0000000000..0acd09b25b
--- /dev/null
+++ b/mozglue/misc/PlatformRWLock.h
@@ -0,0 +1,50 @@
+/* -*- 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/. */
+
+#ifndef mozilla_PlatformRWLock_h
+#define mozilla_PlatformRWLock_h
+
+#include "mozilla/Types.h"
+
+#ifndef XP_WIN
+# include <pthread.h>
+#endif
+
+namespace mozilla::detail {
+
+class RWLockImpl {
+ public:
+ explicit MFBT_API RWLockImpl();
+ MFBT_API ~RWLockImpl();
+
+ protected:
+ [[nodiscard]] MFBT_API bool tryReadLock();
+ MFBT_API void readLock();
+ MFBT_API void readUnlock();
+
+ [[nodiscard]] MFBT_API bool tryWriteLock();
+ MFBT_API void writeLock();
+ MFBT_API void writeUnlock();
+
+ private:
+ RWLockImpl(const RWLockImpl&) = delete;
+ void operator=(const RWLockImpl&) = delete;
+ RWLockImpl(RWLockImpl&&) = delete;
+ void operator=(RWLockImpl&&) = delete;
+ bool operator==(const RWLockImpl& rhs) = delete;
+
+#ifndef XP_WIN
+ pthread_rwlock_t mRWLock;
+#else
+ // SRWLock is pointer-sized. We declare it in such a fashion here to avoid
+ // pulling in windows.h wherever this header is used.
+ void* mRWLock;
+#endif
+};
+
+} // namespace mozilla::detail
+
+#endif // mozilla_PlatformRWLock_h
diff --git a/mozglue/misc/PreXULSkeletonUI.cpp b/mozglue/misc/PreXULSkeletonUI.cpp
new file mode 100644
index 0000000000..145a525f85
--- /dev/null
+++ b/mozglue/misc/PreXULSkeletonUI.cpp
@@ -0,0 +1,2238 @@
+/* -*- 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/. */
+
+#include "PreXULSkeletonUI.h"
+
+#include <algorithm>
+#include <math.h>
+#include <limits.h>
+#include <cmath>
+#include <locale>
+#include <string>
+#include <objbase.h>
+#include <shlobj.h>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/BaseProfilerMarkers.h"
+#include "mozilla/CacheNtDllThunk.h"
+#include "mozilla/FStream.h"
+#include "mozilla/GetKnownFolderPath.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/HelperMacros.h"
+#include "mozilla/glue/Debug.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/mscom/ProcessRuntime.h"
+#include "mozilla/ResultVariant.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/Unused.h"
+#include "mozilla/WindowsDpiAwareness.h"
+#include "mozilla/WindowsVersion.h"
+#include "mozilla/WindowsProcessMitigations.h"
+
+namespace mozilla {
+
+// ColorRect defines an optionally-rounded, optionally-bordered rectangle of a
+// particular color that we will draw.
+struct ColorRect {
+ uint32_t color;
+ uint32_t borderColor;
+ int x;
+ int y;
+ int width;
+ int height;
+ int borderWidth;
+ int borderRadius;
+ bool flipIfRTL;
+};
+
+// DrawRect is mostly the same as ColorRect, but exists as an implementation
+// detail to simplify drawing borders. We draw borders as a strokeOnly rect
+// underneath an inner rect of a particular color. We also need to keep
+// track of the backgroundColor for rounding rects, in order to correctly
+// anti-alias.
+struct DrawRect {
+ uint32_t color;
+ uint32_t backgroundColor;
+ int x;
+ int y;
+ int width;
+ int height;
+ int borderRadius;
+ int borderWidth;
+ bool strokeOnly;
+};
+
+struct NormalizedRGB {
+ double r;
+ double g;
+ double b;
+};
+
+NormalizedRGB UintToRGB(uint32_t color) {
+ double r = static_cast<double>(color >> 16 & 0xff) / 255.0;
+ double g = static_cast<double>(color >> 8 & 0xff) / 255.0;
+ double b = static_cast<double>(color >> 0 & 0xff) / 255.0;
+ return NormalizedRGB{r, g, b};
+}
+
+uint32_t RGBToUint(const NormalizedRGB& rgb) {
+ return (static_cast<uint32_t>(rgb.r * 255.0) << 16) |
+ (static_cast<uint32_t>(rgb.g * 255.0) << 8) |
+ (static_cast<uint32_t>(rgb.b * 255.0) << 0);
+}
+
+double Lerp(double a, double b, double x) { return a + x * (b - a); }
+
+NormalizedRGB Lerp(const NormalizedRGB& a, const NormalizedRGB& b, double x) {
+ return NormalizedRGB{Lerp(a.r, b.r, x), Lerp(a.g, b.g, x), Lerp(a.b, b.b, x)};
+}
+
+// Produces a smooth curve in [0,1] based on a linear input in [0,1]
+double SmoothStep3(double x) { return x * x * (3.0 - 2.0 * x); }
+
+static const wchar_t kPreXULSkeletonUIKeyPath[] =
+ L"SOFTWARE"
+ L"\\" MOZ_APP_VENDOR L"\\" MOZ_APP_BASENAME L"\\PreXULSkeletonUISettings";
+
+static bool sPreXULSkeletonUIShown = false;
+static bool sPreXULSkeletonUIEnabled = false;
+static HWND sPreXULSkeletonUIWindow;
+static LPWSTR const gStockApplicationIcon = MAKEINTRESOURCEW(32512);
+static LPWSTR const gIDCWait = MAKEINTRESOURCEW(32514);
+static HANDLE sPreXULSKeletonUIAnimationThread;
+static HANDLE sPreXULSKeletonUILockFile = INVALID_HANDLE_VALUE;
+
+static mozilla::mscom::ProcessRuntime* sProcessRuntime;
+static uint32_t* sPixelBuffer = nullptr;
+static Vector<ColorRect>* sAnimatedRects = nullptr;
+static int sTotalChromeHeight = 0;
+static volatile LONG sAnimationControlFlag = 0;
+static bool sMaximized = false;
+static int sNonClientVerticalMargins = 0;
+static int sNonClientHorizontalMargins = 0;
+static uint32_t sDpi = 0;
+
+// Color values needed by the animation loop
+static uint32_t sAnimationColor;
+static uint32_t sToolbarForegroundColor;
+
+static ThemeMode sTheme = ThemeMode::Invalid;
+
+typedef BOOL(WINAPI* EnableNonClientDpiScalingProc)(HWND);
+static EnableNonClientDpiScalingProc sEnableNonClientDpiScaling = NULL;
+typedef int(WINAPI* GetSystemMetricsForDpiProc)(int, UINT);
+GetSystemMetricsForDpiProc sGetSystemMetricsForDpi = NULL;
+typedef UINT(WINAPI* GetDpiForWindowProc)(HWND);
+GetDpiForWindowProc sGetDpiForWindow = NULL;
+typedef ATOM(WINAPI* RegisterClassWProc)(const WNDCLASSW*);
+RegisterClassWProc sRegisterClassW = NULL;
+typedef HICON(WINAPI* LoadIconWProc)(HINSTANCE, LPCWSTR);
+LoadIconWProc sLoadIconW = NULL;
+typedef HICON(WINAPI* LoadCursorWProc)(HINSTANCE, LPCWSTR);
+LoadCursorWProc sLoadCursorW = NULL;
+typedef HWND(WINAPI* CreateWindowExWProc)(DWORD, LPCWSTR, LPCWSTR, DWORD, int,
+ int, int, int, HWND, HMENU, HINSTANCE,
+ LPVOID);
+CreateWindowExWProc sCreateWindowExW = NULL;
+typedef BOOL(WINAPI* ShowWindowProc)(HWND, int);
+ShowWindowProc sShowWindow = NULL;
+typedef BOOL(WINAPI* SetWindowPosProc)(HWND, HWND, int, int, int, int, UINT);
+SetWindowPosProc sSetWindowPos = NULL;
+typedef HDC(WINAPI* GetWindowDCProc)(HWND);
+GetWindowDCProc sGetWindowDC = NULL;
+typedef int(WINAPI* FillRectProc)(HDC, const RECT*, HBRUSH);
+FillRectProc sFillRect = NULL;
+typedef BOOL(WINAPI* DeleteObjectProc)(HGDIOBJ);
+DeleteObjectProc sDeleteObject = NULL;
+typedef int(WINAPI* ReleaseDCProc)(HWND, HDC);
+ReleaseDCProc sReleaseDC = NULL;
+typedef HMONITOR(WINAPI* MonitorFromWindowProc)(HWND, DWORD);
+MonitorFromWindowProc sMonitorFromWindow = NULL;
+typedef BOOL(WINAPI* GetMonitorInfoWProc)(HMONITOR, LPMONITORINFO);
+GetMonitorInfoWProc sGetMonitorInfoW = NULL;
+typedef LONG_PTR(WINAPI* SetWindowLongPtrWProc)(HWND, int, LONG_PTR);
+SetWindowLongPtrWProc sSetWindowLongPtrW = NULL;
+typedef int(WINAPI* StretchDIBitsProc)(HDC, int, int, int, int, int, int, int,
+ int, const VOID*, const BITMAPINFO*,
+ UINT, DWORD);
+StretchDIBitsProc sStretchDIBits = NULL;
+typedef HBRUSH(WINAPI* CreateSolidBrushProc)(COLORREF);
+CreateSolidBrushProc sCreateSolidBrush = NULL;
+
+static int sWindowWidth;
+static int sWindowHeight;
+static double sCSSToDevPixelScaling;
+
+static Maybe<PreXULSkeletonUIError> sErrorReason;
+
+static const int kAnimationCSSPixelsPerFrame = 11;
+static const int kAnimationCSSExtraWindowSize = 300;
+
+// NOTE: these values were pulled out of thin air as round numbers that are
+// likely to be too big to be seen in practice. If we legitimately see windows
+// this big, we probably don't want to be drawing them on the CPU anyway.
+static const uint32_t kMaxWindowWidth = 1 << 16;
+static const uint32_t kMaxWindowHeight = 1 << 16;
+
+static const wchar_t* sEnabledRegSuffix = L"|Enabled";
+static const wchar_t* sScreenXRegSuffix = L"|ScreenX";
+static const wchar_t* sScreenYRegSuffix = L"|ScreenY";
+static const wchar_t* sWidthRegSuffix = L"|Width";
+static const wchar_t* sHeightRegSuffix = L"|Height";
+static const wchar_t* sMaximizedRegSuffix = L"|Maximized";
+static const wchar_t* sUrlbarCSSRegSuffix = L"|UrlbarCSSSpan";
+static const wchar_t* sCssToDevPixelScalingRegSuffix = L"|CssToDevPixelScaling";
+static const wchar_t* sSearchbarRegSuffix = L"|SearchbarCSSSpan";
+static const wchar_t* sSpringsCSSRegSuffix = L"|SpringsCSSSpan";
+static const wchar_t* sThemeRegSuffix = L"|Theme";
+static const wchar_t* sFlagsRegSuffix = L"|Flags";
+static const wchar_t* sProgressSuffix = L"|Progress";
+
+std::wstring GetRegValueName(const wchar_t* prefix, const wchar_t* suffix) {
+ std::wstring result(prefix);
+ result.append(suffix);
+ return result;
+}
+
+// This is paraphrased from WinHeaderOnlyUtils.h. The fact that this file is
+// included in standalone SpiderMonkey builds prohibits us from including that
+// file directly, and it hardly warrants its own header. Bug 1674920 tracks
+// only including this file for gecko-related builds.
+Result<UniquePtr<wchar_t[]>, PreXULSkeletonUIError> GetBinaryPath() {
+ DWORD bufLen = MAX_PATH;
+ UniquePtr<wchar_t[]> buf;
+ while (true) {
+ buf = MakeUnique<wchar_t[]>(bufLen);
+ DWORD retLen = ::GetModuleFileNameW(nullptr, buf.get(), bufLen);
+ if (!retLen) {
+ return Err(PreXULSkeletonUIError::FilesystemFailure);
+ }
+
+ if (retLen == bufLen && ::GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+ bufLen *= 2;
+ continue;
+ }
+
+ break;
+ }
+
+ return buf;
+}
+
+// PreXULSkeletonUIDisallowed means that we don't even have the capacity to
+// enable the skeleton UI, whether because we're on a platform that doesn't
+// support it or because we launched with command line arguments that we don't
+// support. Some of these situations are transient, so we want to make sure we
+// don't mess with registry values in these scenarios that we may use in
+// other scenarios in which the skeleton UI is actually enabled.
+static bool PreXULSkeletonUIDisallowed() {
+ return sErrorReason.isSome() &&
+ (*sErrorReason == PreXULSkeletonUIError::Cmdline ||
+ *sErrorReason == PreXULSkeletonUIError::EnvVars);
+}
+
+// Note: this is specifically *not* a robust, multi-locale lowercasing
+// operation. It is not intended to be such. It is simply intended to match the
+// way in which we look for other instances of firefox to remote into.
+// See
+// https://searchfox.org/mozilla-central/rev/71621bfa47a371f2b1ccfd33c704913124afb933/toolkit/components/remote/nsRemoteService.cpp#56
+static void MutateStringToLowercase(wchar_t* ptr) {
+ while (*ptr) {
+ wchar_t ch = *ptr;
+ if (ch >= L'A' && ch <= L'Z') {
+ *ptr = ch + (L'a' - L'A');
+ }
+ ++ptr;
+ }
+}
+
+static Result<Ok, PreXULSkeletonUIError> GetSkeletonUILock() {
+ auto localAppDataPath = GetKnownFolderPath(FOLDERID_LocalAppData);
+ if (!localAppDataPath) {
+ return Err(PreXULSkeletonUIError::FilesystemFailure);
+ }
+
+ if (sPreXULSKeletonUILockFile != INVALID_HANDLE_VALUE) {
+ return Ok();
+ }
+
+ // Note: because we're in mozglue, we cannot easily access things from
+ // toolkit, like `GetInstallHash`. We could move `GetInstallHash` into
+ // mozglue, and rip out all of its usage of types defined in toolkit headers.
+ // However, it seems cleaner to just hash the bin path ourselves. We don't
+ // get quite the same robustness that `GetInstallHash` might provide, but
+ // we already don't have that with how we key our registry values, so it
+ // probably makes sense to just match those.
+ UniquePtr<wchar_t[]> binPath;
+ MOZ_TRY_VAR(binPath, GetBinaryPath());
+
+ // Lowercase the binpath to match how we look for remote instances.
+ MutateStringToLowercase(binPath.get());
+
+ // The number of bytes * 2 characters per byte + 1 for the null terminator
+ uint32_t hexHashSize = sizeof(uint32_t) * 2 + 1;
+ UniquePtr<wchar_t[]> installHash = MakeUnique<wchar_t[]>(hexHashSize);
+ // This isn't perfect - it's a 32-bit hash of the path to our executable. It
+ // could reasonably collide, or casing could potentially affect things, but
+ // the theory is that that should be uncommon enough and the failure case
+ // mild enough that this is fine.
+ uint32_t binPathHash = HashString(binPath.get());
+ swprintf(installHash.get(), hexHashSize, L"%08x", binPathHash);
+
+ std::wstring lockFilePath;
+ lockFilePath.append(localAppDataPath.get());
+ lockFilePath.append(
+ L"\\" MOZ_APP_VENDOR L"\\" MOZ_APP_BASENAME L"\\SkeletonUILock-");
+ lockFilePath.append(installHash.get());
+
+ // We intentionally leak this file - that is okay, and (kind of) the point.
+ // We want to hold onto this handle until the application exits, and hold
+ // onto it with exclusive rights. If this check fails, then we assume that
+ // another instance of the executable is holding it, and thus return false.
+ sPreXULSKeletonUILockFile =
+ ::CreateFileW(lockFilePath.c_str(), GENERIC_READ | GENERIC_WRITE,
+ 0, // No sharing - this is how the lock works
+ nullptr, CREATE_ALWAYS,
+ FILE_FLAG_DELETE_ON_CLOSE, // Don't leave this lying around
+ nullptr);
+ if (sPreXULSKeletonUILockFile == INVALID_HANDLE_VALUE) {
+ return Err(PreXULSkeletonUIError::FailedGettingLock);
+ }
+
+ return Ok();
+}
+
+const char kGeneralSection[] = "[General]";
+const char kStartWithLastProfile[] = "StartWithLastProfile=";
+
+static bool ProfileDbHasStartWithLastProfile(IFStream& iniContents) {
+ bool inGeneral = false;
+ std::string line;
+ while (std::getline(iniContents, line)) {
+ size_t whitespace = 0;
+ while (line.length() > whitespace &&
+ (line[whitespace] == ' ' || line[whitespace] == '\t')) {
+ whitespace++;
+ }
+ line.erase(0, whitespace);
+
+ if (line.compare(kGeneralSection) == 0) {
+ inGeneral = true;
+ } else if (inGeneral) {
+ if (line[0] == '[') {
+ inGeneral = false;
+ } else {
+ if (line.find(kStartWithLastProfile) == 0) {
+ char val = line.c_str()[sizeof(kStartWithLastProfile) - 1];
+ if (val == '0') {
+ return false;
+ } else if (val == '1') {
+ return true;
+ }
+ }
+ }
+ }
+ }
+
+ // If we don't find it in the .ini file, we interpret that as true
+ return true;
+}
+
+static Result<Ok, PreXULSkeletonUIError> CheckForStartWithLastProfile() {
+ auto roamingAppData = GetKnownFolderPath(FOLDERID_RoamingAppData);
+ if (!roamingAppData) {
+ return Err(PreXULSkeletonUIError::FilesystemFailure);
+ }
+ std::wstring profileDbPath(roamingAppData.get());
+ profileDbPath.append(
+ L"\\" MOZ_APP_VENDOR L"\\" MOZ_APP_BASENAME L"\\profiles.ini");
+ IFStream profileDb(profileDbPath.c_str());
+ if (profileDb.fail()) {
+ return Err(PreXULSkeletonUIError::FilesystemFailure);
+ }
+
+ if (!ProfileDbHasStartWithLastProfile(profileDb)) {
+ return Err(PreXULSkeletonUIError::NoStartWithLastProfile);
+ }
+
+ return Ok();
+}
+
+// We could use nsAutoRegKey, but including nsWindowsHelpers.h causes build
+// failures in random places because we're in mozglue. Overall it should be
+// simpler and cleaner to just step around that issue with this class:
+class MOZ_RAII AutoCloseRegKey {
+ public:
+ explicit AutoCloseRegKey(HKEY key) : mKey(key) {}
+ ~AutoCloseRegKey() { ::RegCloseKey(mKey); }
+
+ private:
+ HKEY mKey;
+};
+
+int CSSToDevPixels(double cssPixels, double scaling) {
+ return floor(cssPixels * scaling + 0.5);
+}
+
+int CSSToDevPixels(int cssPixels, double scaling) {
+ return CSSToDevPixels((double)cssPixels, scaling);
+}
+
+int CSSToDevPixelsFloor(double cssPixels, double scaling) {
+ return floor(cssPixels * scaling);
+}
+
+// Some things appear to floor to device pixels rather than rounding. A good
+// example of this is border widths.
+int CSSToDevPixelsFloor(int cssPixels, double scaling) {
+ return CSSToDevPixelsFloor((double)cssPixels, scaling);
+}
+
+double SignedDistanceToCircle(double x, double y, double radius) {
+ return sqrt(x * x + y * y) - radius;
+}
+
+// For more details, see
+// https://searchfox.org/mozilla-central/rev/a5d9abfda1e26b1207db9549549ab0bdd73f735d/gfx/wr/webrender/res/shared.glsl#141-187
+// which was a reference for this function.
+double DistanceAntiAlias(double signedDistance) {
+ // Distance assumed to be in device pixels. We use an aa range of 0.5 for
+ // reasons detailed in the linked code above.
+ const double aaRange = 0.5;
+ double dist = 0.5 * signedDistance / aaRange;
+ if (dist <= -0.5 + std::numeric_limits<double>::epsilon()) return 1.0;
+ if (dist >= 0.5 - std::numeric_limits<double>::epsilon()) return 0.0;
+ return 0.5 + dist * (0.8431027 * dist * dist - 1.14453603);
+}
+
+void RasterizeRoundedRectTopAndBottom(const DrawRect& rect) {
+ if (rect.height <= 2 * rect.borderRadius) {
+ MOZ_ASSERT(false, "Skeleton UI rect height too small for border radius.");
+ return;
+ }
+ if (rect.width <= 2 * rect.borderRadius) {
+ MOZ_ASSERT(false, "Skeleton UI rect width too small for border radius.");
+ return;
+ }
+
+ NormalizedRGB rgbBase = UintToRGB(rect.backgroundColor);
+ NormalizedRGB rgbBlend = UintToRGB(rect.color);
+
+ for (int rowIndex = 0; rowIndex < rect.borderRadius; ++rowIndex) {
+ int yTop = rect.y + rect.borderRadius - 1 - rowIndex;
+ int yBottom = rect.y + rect.height - rect.borderRadius + rowIndex;
+
+ uint32_t* lineStartTop = &sPixelBuffer[yTop * sWindowWidth];
+ uint32_t* innermostPixelTopLeft =
+ lineStartTop + rect.x + rect.borderRadius - 1;
+ uint32_t* innermostPixelTopRight =
+ lineStartTop + rect.x + rect.width - rect.borderRadius;
+ uint32_t* lineStartBottom = &sPixelBuffer[yBottom * sWindowWidth];
+ uint32_t* innermostPixelBottomLeft =
+ lineStartBottom + rect.x + rect.borderRadius - 1;
+ uint32_t* innermostPixelBottomRight =
+ lineStartBottom + rect.x + rect.width - rect.borderRadius;
+
+ // Add 0.5 to x and y to get the pixel center.
+ double pixelY = (double)rowIndex + 0.5;
+ for (int columnIndex = 0; columnIndex < rect.borderRadius; ++columnIndex) {
+ double pixelX = (double)columnIndex + 0.5;
+ double distance =
+ SignedDistanceToCircle(pixelX, pixelY, (double)rect.borderRadius);
+ double alpha = DistanceAntiAlias(distance);
+ NormalizedRGB rgb = Lerp(rgbBase, rgbBlend, alpha);
+ uint32_t color = RGBToUint(rgb);
+
+ innermostPixelTopLeft[-columnIndex] = color;
+ innermostPixelTopRight[columnIndex] = color;
+ innermostPixelBottomLeft[-columnIndex] = color;
+ innermostPixelBottomRight[columnIndex] = color;
+ }
+
+ std::fill(innermostPixelTopLeft + 1, innermostPixelTopRight, rect.color);
+ std::fill(innermostPixelBottomLeft + 1, innermostPixelBottomRight,
+ rect.color);
+ }
+}
+
+void RasterizeAnimatedRoundedRectTopAndBottom(
+ const ColorRect& colorRect, const uint32_t* animationLookup,
+ int priorUpdateAreaMin, int priorUpdateAreaMax, int currentUpdateAreaMin,
+ int currentUpdateAreaMax, int animationMin) {
+ // We iterate through logical pixel rows here, from inside to outside, which
+ // for the top of the rounded rect means from bottom to top, and for the
+ // bottom of the rect means top to bottom. We paint pixels from left to
+ // right on the top and bottom rows at the same time for the entire animation
+ // window. (If the animation window does not overlap any rounded corners,
+ // however, we won't be called at all)
+ for (int rowIndex = 0; rowIndex < colorRect.borderRadius; ++rowIndex) {
+ int yTop = colorRect.y + colorRect.borderRadius - 1 - rowIndex;
+ int yBottom =
+ colorRect.y + colorRect.height - colorRect.borderRadius + rowIndex;
+
+ uint32_t* lineStartTop = &sPixelBuffer[yTop * sWindowWidth];
+ uint32_t* lineStartBottom = &sPixelBuffer[yBottom * sWindowWidth];
+
+ // Add 0.5 to x and y to get the pixel center.
+ double pixelY = (double)rowIndex + 0.5;
+ for (int x = priorUpdateAreaMin; x < currentUpdateAreaMax; ++x) {
+ // The column index is the distance from the innermost pixel, which
+ // is different depending on whether we're on the left or right
+ // side of the rect. It will always be the max here, and if it's
+ // negative that just means we're outside the rounded area.
+ int columnIndex =
+ std::max((int)colorRect.x + (int)colorRect.borderRadius - x - 1,
+ x - ((int)colorRect.x + (int)colorRect.width -
+ (int)colorRect.borderRadius));
+
+ double alpha = 1.0;
+ if (columnIndex >= 0) {
+ double pixelX = (double)columnIndex + 0.5;
+ double distance = SignedDistanceToCircle(
+ pixelX, pixelY, (double)colorRect.borderRadius);
+ alpha = DistanceAntiAlias(distance);
+ }
+ // We don't do alpha blending for the antialiased pixels at the
+ // shape's border. It is not noticeable in the animation.
+ if (alpha > 1.0 - std::numeric_limits<double>::epsilon()) {
+ // Overwrite the tail end of last frame's animation with the
+ // rect's normal, unanimated color.
+ uint32_t color = x < priorUpdateAreaMax
+ ? colorRect.color
+ : animationLookup[x - animationMin];
+ lineStartTop[x] = color;
+ lineStartBottom[x] = color;
+ }
+ }
+ }
+}
+
+void RasterizeColorRect(const ColorRect& colorRect) {
+ // We sometimes split our rect into two, to simplify drawing borders. If we
+ // have a border, we draw a stroke-only rect first, and then draw the smaller
+ // inner rect on top of it.
+ Vector<DrawRect, 2> drawRects;
+ Unused << drawRects.reserve(2);
+ if (colorRect.borderWidth == 0) {
+ DrawRect rect = {};
+ rect.color = colorRect.color;
+ rect.backgroundColor =
+ sPixelBuffer[colorRect.y * sWindowWidth + colorRect.x];
+ rect.x = colorRect.x;
+ rect.y = colorRect.y;
+ rect.width = colorRect.width;
+ rect.height = colorRect.height;
+ rect.borderRadius = colorRect.borderRadius;
+ rect.strokeOnly = false;
+ drawRects.infallibleAppend(rect);
+ } else {
+ DrawRect borderRect = {};
+ borderRect.color = colorRect.borderColor;
+ borderRect.backgroundColor =
+ sPixelBuffer[colorRect.y * sWindowWidth + colorRect.x];
+ borderRect.x = colorRect.x;
+ borderRect.y = colorRect.y;
+ borderRect.width = colorRect.width;
+ borderRect.height = colorRect.height;
+ borderRect.borderRadius = colorRect.borderRadius;
+ borderRect.borderWidth = colorRect.borderWidth;
+ borderRect.strokeOnly = true;
+ drawRects.infallibleAppend(borderRect);
+
+ DrawRect baseRect = {};
+ baseRect.color = colorRect.color;
+ baseRect.backgroundColor = borderRect.color;
+ baseRect.x = colorRect.x + colorRect.borderWidth;
+ baseRect.y = colorRect.y + colorRect.borderWidth;
+ baseRect.width = colorRect.width - 2 * colorRect.borderWidth;
+ baseRect.height = colorRect.height - 2 * colorRect.borderWidth;
+ baseRect.borderRadius =
+ std::max(0, (int)colorRect.borderRadius - (int)colorRect.borderWidth);
+ baseRect.borderWidth = 0;
+ baseRect.strokeOnly = false;
+ drawRects.infallibleAppend(baseRect);
+ }
+
+ for (const DrawRect& rect : drawRects) {
+ if (rect.height <= 0 || rect.width <= 0) {
+ continue;
+ }
+
+ // For rounded rectangles, the first thing we do is draw the top and
+ // bottom of the rectangle, with the more complicated logic below. After
+ // that we can just draw the vertically centered part of the rect like
+ // normal.
+ RasterizeRoundedRectTopAndBottom(rect);
+
+ // We then draw the flat, central portion of the rect (which in the case of
+ // non-rounded rects, is just the entire thing.)
+ int solidRectStartY =
+ std::clamp(rect.y + rect.borderRadius, 0, sTotalChromeHeight);
+ int solidRectEndY = std::clamp(rect.y + rect.height - rect.borderRadius, 0,
+ sTotalChromeHeight);
+ for (int y = solidRectStartY; y < solidRectEndY; ++y) {
+ // For strokeOnly rects (used to draw borders), we just draw the left
+ // and right side here. Looping down a column of pixels is not the most
+ // cache-friendly thing, but it shouldn't be a big deal given the height
+ // of the urlbar.
+ // Also, if borderRadius is less than borderWidth, we need to ensure
+ // that we fully draw the top and bottom lines, so we make sure to check
+ // that we're inside the middle range range before excluding pixels.
+ if (rect.strokeOnly && y - rect.y > rect.borderWidth &&
+ rect.y + rect.height - y > rect.borderWidth) {
+ int startXLeft = std::clamp(rect.x, 0, sWindowWidth);
+ int endXLeft = std::clamp(rect.x + rect.borderWidth, 0, sWindowWidth);
+ int startXRight =
+ std::clamp(rect.x + rect.width - rect.borderWidth, 0, sWindowWidth);
+ int endXRight = std::clamp(rect.x + rect.width, 0, sWindowWidth);
+
+ uint32_t* lineStart = &sPixelBuffer[y * sWindowWidth];
+ uint32_t* dataStartLeft = lineStart + startXLeft;
+ uint32_t* dataEndLeft = lineStart + endXLeft;
+ uint32_t* dataStartRight = lineStart + startXRight;
+ uint32_t* dataEndRight = lineStart + endXRight;
+ std::fill(dataStartLeft, dataEndLeft, rect.color);
+ std::fill(dataStartRight, dataEndRight, rect.color);
+ } else {
+ int startX = std::clamp(rect.x, 0, sWindowWidth);
+ int endX = std::clamp(rect.x + rect.width, 0, sWindowWidth);
+ uint32_t* lineStart = &sPixelBuffer[y * sWindowWidth];
+ uint32_t* dataStart = lineStart + startX;
+ uint32_t* dataEnd = lineStart + endX;
+ std::fill(dataStart, dataEnd, rect.color);
+ }
+ }
+ }
+}
+
+// Paints the pixels to sPixelBuffer for the skeleton UI animation (a light
+// gradient which moves from left to right across the grey placeholder rects).
+// Takes in the rect to draw, together with a lookup table for the gradient,
+// and the bounds of the previous and current frame of the animation.
+bool RasterizeAnimatedRect(const ColorRect& colorRect,
+ const uint32_t* animationLookup,
+ int priorAnimationMin, int animationMin,
+ int animationMax) {
+ int rectMin = colorRect.x;
+ int rectMax = colorRect.x + colorRect.width;
+ bool animationWindowOverlaps =
+ rectMax >= priorAnimationMin && rectMin < animationMax;
+
+ int priorUpdateAreaMin = std::max(rectMin, priorAnimationMin);
+ int priorUpdateAreaMax = std::min(rectMax, animationMin);
+ int currentUpdateAreaMin = std::max(rectMin, animationMin);
+ int currentUpdateAreaMax = std::min(rectMax, animationMax);
+
+ if (!animationWindowOverlaps) {
+ return false;
+ }
+
+ bool animationWindowOverlapsBorderRadius =
+ rectMin + colorRect.borderRadius > priorAnimationMin ||
+ rectMax - colorRect.borderRadius <= animationMax;
+
+ // If we don't overlap the left or right side of the rounded rectangle,
+ // just pretend it's not rounded. This is a small optimization but
+ // there's no point in doing all of this rounded rectangle checking if
+ // we aren't even overlapping
+ int borderRadius =
+ animationWindowOverlapsBorderRadius ? colorRect.borderRadius : 0;
+
+ if (borderRadius > 0) {
+ // Similarly to how we draw the rounded rects in DrawSkeletonUI, we
+ // first draw the rounded top and bottom, and then we draw the center
+ // rect.
+ RasterizeAnimatedRoundedRectTopAndBottom(
+ colorRect, animationLookup, priorUpdateAreaMin, priorUpdateAreaMax,
+ currentUpdateAreaMin, currentUpdateAreaMax, animationMin);
+ }
+
+ for (int y = colorRect.y + borderRadius;
+ y < colorRect.y + colorRect.height - borderRadius; ++y) {
+ uint32_t* lineStart = &sPixelBuffer[y * sWindowWidth];
+ // Overwrite the tail end of last frame's animation with the rect's
+ // normal, unanimated color.
+ for (int x = priorUpdateAreaMin; x < priorUpdateAreaMax; ++x) {
+ lineStart[x] = colorRect.color;
+ }
+ // Then apply the animated color
+ for (int x = currentUpdateAreaMin; x < currentUpdateAreaMax; ++x) {
+ lineStart[x] = animationLookup[x - animationMin];
+ }
+ }
+
+ return true;
+}
+
+Result<Ok, PreXULSkeletonUIError> DrawSkeletonUI(
+ HWND hWnd, CSSPixelSpan urlbarCSSSpan, CSSPixelSpan searchbarCSSSpan,
+ Vector<CSSPixelSpan>& springs, const ThemeColors& currentTheme,
+ const EnumSet<SkeletonUIFlag, uint32_t>& flags) {
+ // NOTE: we opt here to paint a pixel buffer for the application chrome by
+ // hand, without using native UI library methods. Why do we do this?
+ //
+ // 1) It gives us a little bit more control, especially if we want to animate
+ // any of this.
+ // 2) It's actually more portable. We can do this on any platform where we
+ // can blit a pixel buffer to the screen, and it only has to change
+ // insofar as the UI is different on those platforms (and thus would have
+ // to change anyway.)
+ //
+ // The performance impact of this ought to be negligible. As far as has been
+ // observed, on slow reference hardware this might take up to a millisecond,
+ // for a startup which otherwise takes 30 seconds.
+ //
+ // The readability and maintainability are a greater concern. When the
+ // silhouette of Firefox's core UI changes, this code will likely need to
+ // change. However, for the foreseeable future, our skeleton UI will be mostly
+ // axis-aligned geometric shapes, and the thought is that any code which is
+ // manipulating raw pixels should not be *too* hard to maintain and
+ // understand so long as it is only painting such simple shapes.
+
+ sAnimationColor = currentTheme.animationColor;
+ sToolbarForegroundColor = currentTheme.toolbarForegroundColor;
+
+ bool menubarShown = flags.contains(SkeletonUIFlag::MenubarShown);
+ bool bookmarksToolbarShown =
+ flags.contains(SkeletonUIFlag::BookmarksToolbarShown);
+ bool rtlEnabled = flags.contains(SkeletonUIFlag::RtlEnabled);
+
+ int chromeHorMargin = CSSToDevPixels(2, sCSSToDevPixelScaling);
+ int verticalOffset = sMaximized ? sNonClientVerticalMargins : 0;
+ int horizontalOffset =
+ sNonClientHorizontalMargins - (sMaximized ? 0 : chromeHorMargin);
+
+ // found in tabs.inc.css, "--tab-min-height" + 2 * "--tab-block-margin"
+ int tabBarHeight = CSSToDevPixels(44, sCSSToDevPixelScaling);
+ int selectedTabBorderWidth = CSSToDevPixels(2, sCSSToDevPixelScaling);
+ // found in tabs.inc.css, "--tab-block-margin"
+ int titlebarSpacerWidth = horizontalOffset +
+ CSSToDevPixels(2, sCSSToDevPixelScaling) -
+ selectedTabBorderWidth;
+ if (!sMaximized && !menubarShown) {
+ // found in tabs.inc.css, ".titlebar-spacer"
+ titlebarSpacerWidth += CSSToDevPixels(40, sCSSToDevPixelScaling);
+ }
+ // found in tabs.inc.css, "--tab-block-margin"
+ int selectedTabMarginTop =
+ CSSToDevPixels(4, sCSSToDevPixelScaling) - selectedTabBorderWidth;
+ int selectedTabMarginBottom =
+ CSSToDevPixels(4, sCSSToDevPixelScaling) - selectedTabBorderWidth;
+ int selectedTabBorderRadius = CSSToDevPixels(4, sCSSToDevPixelScaling);
+ int selectedTabWidth =
+ CSSToDevPixels(221, sCSSToDevPixelScaling) + 2 * selectedTabBorderWidth;
+ int toolbarHeight = CSSToDevPixels(40, sCSSToDevPixelScaling);
+ // found in browser.css, "#PersonalToolbar"
+ int bookmarkToolbarHeight = CSSToDevPixels(28, sCSSToDevPixelScaling);
+ if (bookmarksToolbarShown) {
+ toolbarHeight += bookmarkToolbarHeight;
+ }
+ // found in urlbar-searchbar.inc.css, "#urlbar[breakout]"
+ int urlbarTopOffset = CSSToDevPixels(4, sCSSToDevPixelScaling);
+ int urlbarHeight = CSSToDevPixels(32, sCSSToDevPixelScaling);
+ // found in browser-aero.css, "#navigator-toolbox::after" border-bottom
+ int chromeContentDividerHeight = CSSToDevPixels(1, sCSSToDevPixelScaling);
+
+ int tabPlaceholderBarMarginTop = CSSToDevPixels(14, sCSSToDevPixelScaling);
+ int tabPlaceholderBarMarginLeft = CSSToDevPixels(10, sCSSToDevPixelScaling);
+ int tabPlaceholderBarHeight = CSSToDevPixels(10, sCSSToDevPixelScaling);
+ int tabPlaceholderBarWidth = CSSToDevPixels(120, sCSSToDevPixelScaling);
+
+ int toolbarPlaceholderHeight = CSSToDevPixels(10, sCSSToDevPixelScaling);
+ int toolbarPlaceholderMarginRight =
+ rtlEnabled ? CSSToDevPixels(11, sCSSToDevPixelScaling)
+ : CSSToDevPixels(9, sCSSToDevPixelScaling);
+ int toolbarPlaceholderMarginLeft =
+ rtlEnabled ? CSSToDevPixels(9, sCSSToDevPixelScaling)
+ : CSSToDevPixels(11, sCSSToDevPixelScaling);
+ int placeholderMargin = CSSToDevPixels(8, sCSSToDevPixelScaling);
+
+ int menubarHeightDevPixels =
+ menubarShown ? CSSToDevPixels(28, sCSSToDevPixelScaling) : 0;
+
+ // defined in urlbar-searchbar.inc.css as --urlbar-margin-inline: 5px
+ int urlbarMargin =
+ CSSToDevPixels(5, sCSSToDevPixelScaling) + horizontalOffset;
+
+ int urlbarTextPlaceholderMarginTop =
+ CSSToDevPixels(12, sCSSToDevPixelScaling);
+ int urlbarTextPlaceholderMarginLeft =
+ CSSToDevPixels(12, sCSSToDevPixelScaling);
+ int urlbarTextPlaceHolderWidth = CSSToDevPixels(
+ std::clamp(urlbarCSSSpan.end - urlbarCSSSpan.start - 10.0, 0.0, 260.0),
+ sCSSToDevPixelScaling);
+ int urlbarTextPlaceholderHeight = CSSToDevPixels(10, sCSSToDevPixelScaling);
+
+ int searchbarTextPlaceholderWidth = CSSToDevPixels(62, sCSSToDevPixelScaling);
+
+ auto scopeExit = MakeScopeExit([&] {
+ delete sAnimatedRects;
+ sAnimatedRects = nullptr;
+ });
+
+ Vector<ColorRect> rects;
+
+ ColorRect menubar = {};
+ menubar.color = currentTheme.tabBarColor;
+ menubar.x = 0;
+ menubar.y = verticalOffset;
+ menubar.width = sWindowWidth;
+ menubar.height = menubarHeightDevPixels;
+ menubar.flipIfRTL = false;
+ if (!rects.append(menubar)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ int placeholderBorderRadius = CSSToDevPixels(4, sCSSToDevPixelScaling);
+ // found in browser.css "--toolbarbutton-border-radius"
+ int urlbarBorderRadius = CSSToDevPixels(4, sCSSToDevPixelScaling);
+
+ // The (traditionally dark blue on Windows) background of the tab bar.
+ ColorRect tabBar = {};
+ tabBar.color = currentTheme.tabBarColor;
+ tabBar.x = 0;
+ tabBar.y = menubar.y + menubar.height;
+ tabBar.width = sWindowWidth;
+ tabBar.height = tabBarHeight;
+ tabBar.flipIfRTL = false;
+ if (!rects.append(tabBar)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ // The initial selected tab
+ ColorRect selectedTab = {};
+ selectedTab.color = currentTheme.tabColor;
+ selectedTab.x = titlebarSpacerWidth;
+ selectedTab.y = menubar.y + menubar.height + selectedTabMarginTop;
+ selectedTab.width = selectedTabWidth;
+ selectedTab.height =
+ tabBar.y + tabBar.height - selectedTab.y - selectedTabMarginBottom;
+ selectedTab.borderColor = currentTheme.tabOutlineColor;
+ selectedTab.borderWidth = selectedTabBorderWidth;
+ selectedTab.borderRadius = selectedTabBorderRadius;
+ selectedTab.flipIfRTL = true;
+ if (!rects.append(selectedTab)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ // A placeholder rect representing text that will fill the selected tab title
+ ColorRect tabTextPlaceholder = {};
+ tabTextPlaceholder.color = currentTheme.toolbarForegroundColor;
+ tabTextPlaceholder.x = selectedTab.x + tabPlaceholderBarMarginLeft;
+ tabTextPlaceholder.y = selectedTab.y + tabPlaceholderBarMarginTop;
+ tabTextPlaceholder.width = tabPlaceholderBarWidth;
+ tabTextPlaceholder.height = tabPlaceholderBarHeight;
+ tabTextPlaceholder.borderRadius = placeholderBorderRadius;
+ tabTextPlaceholder.flipIfRTL = true;
+ if (!rects.append(tabTextPlaceholder)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ // The toolbar background
+ ColorRect toolbar = {};
+ toolbar.color = currentTheme.backgroundColor;
+ toolbar.x = 0;
+ toolbar.y = tabBar.y + tabBarHeight;
+ toolbar.width = sWindowWidth;
+ toolbar.height = toolbarHeight;
+ toolbar.flipIfRTL = false;
+ if (!rects.append(toolbar)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ // The single-pixel divider line below the toolbar
+ ColorRect chromeContentDivider = {};
+ chromeContentDivider.color = currentTheme.chromeContentDividerColor;
+ chromeContentDivider.x = 0;
+ chromeContentDivider.y = toolbar.y + toolbar.height;
+ chromeContentDivider.width = sWindowWidth;
+ chromeContentDivider.height = chromeContentDividerHeight;
+ chromeContentDivider.flipIfRTL = false;
+ if (!rects.append(chromeContentDivider)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ // The urlbar
+ ColorRect urlbar = {};
+ urlbar.color = currentTheme.urlbarColor;
+ urlbar.x = CSSToDevPixels(urlbarCSSSpan.start, sCSSToDevPixelScaling) +
+ horizontalOffset;
+ urlbar.y = tabBar.y + tabBarHeight + urlbarTopOffset;
+ urlbar.width = CSSToDevPixels((urlbarCSSSpan.end - urlbarCSSSpan.start),
+ sCSSToDevPixelScaling);
+ urlbar.height = urlbarHeight;
+ urlbar.borderColor = currentTheme.urlbarBorderColor;
+ urlbar.borderWidth = CSSToDevPixels(1, sCSSToDevPixelScaling);
+ urlbar.borderRadius = urlbarBorderRadius;
+ urlbar.flipIfRTL = false;
+ if (!rects.append(urlbar)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ // The urlbar placeholder rect representating text that will fill the urlbar
+ // If rtl is enabled, it is flipped relative to the the urlbar rectangle, not
+ // sWindowWidth.
+ ColorRect urlbarTextPlaceholder = {};
+ urlbarTextPlaceholder.color = currentTheme.toolbarForegroundColor;
+ urlbarTextPlaceholder.x =
+ rtlEnabled
+ ? ((urlbar.x + urlbar.width) - urlbarTextPlaceholderMarginLeft -
+ urlbarTextPlaceHolderWidth)
+ : (urlbar.x + urlbarTextPlaceholderMarginLeft);
+ urlbarTextPlaceholder.y = urlbar.y + urlbarTextPlaceholderMarginTop;
+ urlbarTextPlaceholder.width = urlbarTextPlaceHolderWidth;
+ urlbarTextPlaceholder.height = urlbarTextPlaceholderHeight;
+ urlbarTextPlaceholder.borderRadius = placeholderBorderRadius;
+ urlbarTextPlaceholder.flipIfRTL = false;
+ if (!rects.append(urlbarTextPlaceholder)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ // The searchbar and placeholder text, if present
+ // This is y-aligned with the urlbar
+ bool hasSearchbar = searchbarCSSSpan.start != 0 && searchbarCSSSpan.end != 0;
+ ColorRect searchbarRect = {};
+ if (hasSearchbar == true) {
+ searchbarRect.color = currentTheme.urlbarColor;
+ searchbarRect.x =
+ CSSToDevPixels(searchbarCSSSpan.start, sCSSToDevPixelScaling) +
+ horizontalOffset;
+ searchbarRect.y = urlbar.y;
+ searchbarRect.width = CSSToDevPixels(
+ searchbarCSSSpan.end - searchbarCSSSpan.start, sCSSToDevPixelScaling);
+ searchbarRect.height = urlbarHeight;
+ searchbarRect.borderRadius = urlbarBorderRadius;
+ searchbarRect.borderColor = currentTheme.urlbarBorderColor;
+ searchbarRect.borderWidth = CSSToDevPixels(1, sCSSToDevPixelScaling);
+ searchbarRect.flipIfRTL = false;
+ if (!rects.append(searchbarRect)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ // The placeholder rect representating text that will fill the searchbar
+ // This uses the same margins as the urlbarTextPlaceholder
+ // If rtl is enabled, it is flipped relative to the the searchbar rectangle,
+ // not sWindowWidth.
+ ColorRect searchbarTextPlaceholder = {};
+ searchbarTextPlaceholder.color = currentTheme.toolbarForegroundColor;
+ searchbarTextPlaceholder.x =
+ rtlEnabled
+ ? ((searchbarRect.x + searchbarRect.width) -
+ urlbarTextPlaceholderMarginLeft - searchbarTextPlaceholderWidth)
+ : (searchbarRect.x + urlbarTextPlaceholderMarginLeft);
+ searchbarTextPlaceholder.y =
+ searchbarRect.y + urlbarTextPlaceholderMarginTop;
+ searchbarTextPlaceholder.width = searchbarTextPlaceholderWidth;
+ searchbarTextPlaceholder.height = urlbarTextPlaceholderHeight;
+ searchbarTextPlaceholder.flipIfRTL = false;
+ if (!rects.append(searchbarTextPlaceholder) ||
+ !sAnimatedRects->append(searchbarTextPlaceholder)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+ }
+
+ // Determine where the placeholder rectangles should not go. This is
+ // anywhere occupied by a spring, urlbar, or searchbar
+ Vector<DevPixelSpan> noPlaceholderSpans;
+
+ DevPixelSpan urlbarSpan;
+ urlbarSpan.start = urlbar.x - urlbarMargin;
+ urlbarSpan.end = urlbar.width + urlbar.x + urlbarMargin;
+
+ DevPixelSpan searchbarSpan;
+ if (hasSearchbar) {
+ searchbarSpan.start = searchbarRect.x - urlbarMargin;
+ searchbarSpan.end = searchbarRect.width + searchbarRect.x + urlbarMargin;
+ }
+
+ DevPixelSpan marginLeftPlaceholder;
+ marginLeftPlaceholder.start = toolbarPlaceholderMarginLeft;
+ marginLeftPlaceholder.end = toolbarPlaceholderMarginLeft;
+ if (!noPlaceholderSpans.append(marginLeftPlaceholder)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ if (rtlEnabled) {
+ // If we're RTL, then the springs as ordered in the DOM will be from right
+ // to left, which will break our comparison logic below
+ springs.reverse();
+ }
+
+ for (auto spring : springs) {
+ DevPixelSpan springDevPixels;
+ springDevPixels.start =
+ CSSToDevPixels(spring.start, sCSSToDevPixelScaling) + horizontalOffset;
+ springDevPixels.end =
+ CSSToDevPixels(spring.end, sCSSToDevPixelScaling) + horizontalOffset;
+ if (!noPlaceholderSpans.append(springDevPixels)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+ }
+
+ DevPixelSpan marginRightPlaceholder;
+ marginRightPlaceholder.start = sWindowWidth - toolbarPlaceholderMarginRight;
+ marginRightPlaceholder.end = sWindowWidth - toolbarPlaceholderMarginRight;
+ if (!noPlaceholderSpans.append(marginRightPlaceholder)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ Vector<DevPixelSpan, 2> spansToAdd;
+ Unused << spansToAdd.reserve(2);
+ spansToAdd.infallibleAppend(urlbarSpan);
+ if (hasSearchbar) {
+ spansToAdd.infallibleAppend(searchbarSpan);
+ }
+
+ for (auto& toAdd : spansToAdd) {
+ for (auto& span : noPlaceholderSpans) {
+ if (span.start > toAdd.start) {
+ if (!noPlaceholderSpans.insert(&span, toAdd)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+ break;
+ }
+ }
+ }
+
+ for (size_t i = 1; i < noPlaceholderSpans.length(); i++) {
+ int start = noPlaceholderSpans[i - 1].end + placeholderMargin;
+ int end = noPlaceholderSpans[i].start - placeholderMargin;
+ if (start + 2 * placeholderBorderRadius >= end) {
+ continue;
+ }
+
+ // The placeholder rects should all be y-aligned.
+ ColorRect placeholderRect = {};
+ placeholderRect.color = currentTheme.toolbarForegroundColor;
+ placeholderRect.x = start;
+ placeholderRect.y = urlbarTextPlaceholder.y;
+ placeholderRect.width = end - start;
+ placeholderRect.height = toolbarPlaceholderHeight;
+ placeholderRect.borderRadius = placeholderBorderRadius;
+ placeholderRect.flipIfRTL = false;
+ if (!rects.append(placeholderRect) ||
+ !sAnimatedRects->append(placeholderRect)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+ }
+
+ sTotalChromeHeight = chromeContentDivider.y + chromeContentDivider.height;
+ if (sTotalChromeHeight > sWindowHeight) {
+ return Err(PreXULSkeletonUIError::BadWindowDimensions);
+ }
+
+ if (!sAnimatedRects->append(tabTextPlaceholder) ||
+ !sAnimatedRects->append(urlbarTextPlaceholder)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ sPixelBuffer =
+ (uint32_t*)calloc(sWindowWidth * sTotalChromeHeight, sizeof(uint32_t));
+
+ for (auto& rect : *sAnimatedRects) {
+ if (rtlEnabled && rect.flipIfRTL) {
+ rect.x = sWindowWidth - rect.x - rect.width;
+ }
+ rect.x = std::clamp(rect.x, 0, sWindowWidth);
+ rect.width = std::clamp(rect.width, 0, sWindowWidth - rect.x);
+ rect.y = std::clamp(rect.y, 0, sTotalChromeHeight);
+ rect.height = std::clamp(rect.height, 0, sTotalChromeHeight - rect.y);
+ }
+
+ for (auto& rect : rects) {
+ if (rtlEnabled && rect.flipIfRTL) {
+ rect.x = sWindowWidth - rect.x - rect.width;
+ }
+ rect.x = std::clamp(rect.x, 0, sWindowWidth);
+ rect.width = std::clamp(rect.width, 0, sWindowWidth - rect.x);
+ rect.y = std::clamp(rect.y, 0, sTotalChromeHeight);
+ rect.height = std::clamp(rect.height, 0, sTotalChromeHeight - rect.y);
+ RasterizeColorRect(rect);
+ }
+
+ HDC hdc = sGetWindowDC(hWnd);
+ if (!hdc) {
+ return Err(PreXULSkeletonUIError::FailedGettingDC);
+ }
+ auto cleanupDC = MakeScopeExit([=] { sReleaseDC(hWnd, hdc); });
+
+ BITMAPINFO chromeBMI = {};
+ chromeBMI.bmiHeader.biSize = sizeof(chromeBMI.bmiHeader);
+ chromeBMI.bmiHeader.biWidth = sWindowWidth;
+ chromeBMI.bmiHeader.biHeight = -sTotalChromeHeight;
+ chromeBMI.bmiHeader.biPlanes = 1;
+ chromeBMI.bmiHeader.biBitCount = 32;
+ chromeBMI.bmiHeader.biCompression = BI_RGB;
+
+ // First, we just paint the chrome area with our pixel buffer
+ int scanLinesCopied = sStretchDIBits(
+ hdc, 0, 0, sWindowWidth, sTotalChromeHeight, 0, 0, sWindowWidth,
+ sTotalChromeHeight, sPixelBuffer, &chromeBMI, DIB_RGB_COLORS, SRCCOPY);
+ if (scanLinesCopied == 0) {
+ return Err(PreXULSkeletonUIError::FailedBlitting);
+ }
+
+ // Then, we just fill the rest with FillRect
+ RECT rect = {0, sTotalChromeHeight, sWindowWidth, sWindowHeight};
+ HBRUSH brush =
+ sCreateSolidBrush(RGB((currentTheme.backgroundColor & 0xff0000) >> 16,
+ (currentTheme.backgroundColor & 0x00ff00) >> 8,
+ (currentTheme.backgroundColor & 0x0000ff) >> 0));
+ int fillRectResult = sFillRect(hdc, &rect, brush);
+
+ sDeleteObject(brush);
+
+ if (fillRectResult == 0) {
+ return Err(PreXULSkeletonUIError::FailedFillingBottomRect);
+ }
+
+ scopeExit.release();
+ return Ok();
+}
+
+DWORD WINAPI AnimateSkeletonUI(void* aUnused) {
+ if (!sPixelBuffer || sAnimatedRects->empty()) {
+ return 0;
+ }
+
+ // See the comments above the InterlockedIncrement calls below here - we
+ // atomically flip this up and down around sleep so the main thread doesn't
+ // have to wait for us if we're just sleeping.
+ if (InterlockedIncrement(&sAnimationControlFlag) != 1) {
+ return 0;
+ }
+ // Sleep for two seconds - startups faster than this don't really benefit
+ // from an animation, and we don't want to take away cycles from them.
+ // Startups longer than this, however, are more likely to be blocked on IO,
+ // and thus animating does not substantially impact startup times for them.
+ ::Sleep(2000);
+ if (InterlockedDecrement(&sAnimationControlFlag) != 0) {
+ return 0;
+ }
+
+ // On each of the animated rects (which happen to all be placeholder UI
+ // rects sharing the same color), we want to animate a gradient moving across
+ // the screen from left to right. The gradient starts as the rect's color on,
+ // the left side, changes to the background color of the window by the middle
+ // of the gradient, and then goes back down to the rect's color. To make this
+ // faster than interpolating between the two colors for each pixel for each
+ // frame, we simply create a lookup buffer in which we can look up the color
+ // for a particular offset into the gradient.
+ //
+ // To do this we just interpolate between the two values, and to give the
+ // gradient a smoother transition between colors, we transform the linear
+ // blend amount via the cubic smooth step function (SmoothStep3) to produce
+ // a smooth start and stop for the gradient. We do this for the first half
+ // of the gradient, and then simply copy that backwards for the second half.
+ //
+ // The CSS width of 80 chosen here is effectively is just to match the size
+ // of the animation provided in the design mockup. We define it in CSS pixels
+ // simply because the rest of our UI is based off of CSS scalings.
+ int animationWidth = CSSToDevPixels(80, sCSSToDevPixelScaling);
+ UniquePtr<uint32_t[]> animationLookup =
+ MakeUnique<uint32_t[]>(animationWidth);
+ uint32_t animationColor = sAnimationColor;
+ NormalizedRGB rgbBlend = UintToRGB(animationColor);
+
+ // Build the first half of the lookup table
+ for (int i = 0; i < animationWidth / 2; ++i) {
+ uint32_t baseColor = sToolbarForegroundColor;
+ double blendAmountLinear =
+ static_cast<double>(i) / (static_cast<double>(animationWidth / 2));
+ double blendAmount = SmoothStep3(blendAmountLinear);
+
+ NormalizedRGB rgbBase = UintToRGB(baseColor);
+ NormalizedRGB rgb = Lerp(rgbBase, rgbBlend, blendAmount);
+ animationLookup[i] = RGBToUint(rgb);
+ }
+
+ // Copy the first half of the lookup table into the second half backwards
+ for (int i = animationWidth / 2; i < animationWidth; ++i) {
+ int j = animationWidth - 1 - i;
+ if (j == animationWidth / 2) {
+ // If animationWidth is odd, we'll be left with one pixel at the center.
+ // Just color that as the animation color.
+ animationLookup[i] = animationColor;
+ } else {
+ animationLookup[i] = animationLookup[j];
+ }
+ }
+
+ // The bitmap info remains unchanged throughout the animation - this just
+ // effectively describes the contents of sPixelBuffer
+ BITMAPINFO chromeBMI = {};
+ chromeBMI.bmiHeader.biSize = sizeof(chromeBMI.bmiHeader);
+ chromeBMI.bmiHeader.biWidth = sWindowWidth;
+ chromeBMI.bmiHeader.biHeight = -sTotalChromeHeight;
+ chromeBMI.bmiHeader.biPlanes = 1;
+ chromeBMI.bmiHeader.biBitCount = 32;
+ chromeBMI.bmiHeader.biCompression = BI_RGB;
+
+ uint32_t animationIteration = 0;
+
+ int devPixelsPerFrame =
+ CSSToDevPixels(kAnimationCSSPixelsPerFrame, sCSSToDevPixelScaling);
+ int devPixelsExtraWindowSize =
+ CSSToDevPixels(kAnimationCSSExtraWindowSize, sCSSToDevPixelScaling);
+
+ if (::InterlockedCompareExchange(&sAnimationControlFlag, 0, 0)) {
+ // The window got consumed before we were able to draw anything.
+ return 0;
+ }
+
+ while (true) {
+ // The gradient will move across the screen at devPixelsPerFrame at
+ // 60fps, and then loop back to the beginning. However, we add a buffer of
+ // devPixelsExtraWindowSize around the edges so it doesn't immediately
+ // jump back, giving it a more pulsing feel.
+ int animationMin = ((animationIteration * devPixelsPerFrame) %
+ (sWindowWidth + devPixelsExtraWindowSize)) -
+ devPixelsExtraWindowSize / 2;
+ int animationMax = animationMin + animationWidth;
+ // The priorAnimationMin is the beginning of the previous frame's animation.
+ // Since we only want to draw the bits of the image that we updated, we need
+ // to overwrite the left bit of the animation we drew last frame with the
+ // default color.
+ int priorAnimationMin = animationMin - devPixelsPerFrame;
+ animationMin = std::max(0, animationMin);
+ priorAnimationMin = std::max(0, priorAnimationMin);
+ animationMax = std::min((int)sWindowWidth, animationMax);
+
+ // The gradient only affects the specific rects that we put into
+ // sAnimatedRects. So we simply update those rects, and maintain a flag
+ // to avoid drawing when we don't need to.
+ bool updatedAnything = false;
+ for (ColorRect rect : *sAnimatedRects) {
+ bool hadUpdates =
+ RasterizeAnimatedRect(rect, animationLookup.get(), priorAnimationMin,
+ animationMin, animationMax);
+ updatedAnything = updatedAnything || hadUpdates;
+ }
+
+ if (updatedAnything) {
+ HDC hdc = sGetWindowDC(sPreXULSkeletonUIWindow);
+ if (!hdc) {
+ return 0;
+ }
+
+ sStretchDIBits(hdc, priorAnimationMin, 0,
+ animationMax - priorAnimationMin, sTotalChromeHeight,
+ priorAnimationMin, 0, animationMax - priorAnimationMin,
+ sTotalChromeHeight, sPixelBuffer, &chromeBMI,
+ DIB_RGB_COLORS, SRCCOPY);
+
+ sReleaseDC(sPreXULSkeletonUIWindow, hdc);
+ }
+
+ animationIteration++;
+
+ // We coordinate around our sleep here to ensure that the main thread does
+ // not wait on us if we're sleeping. If we don't get 1 here, it means the
+ // window has been consumed and we don't need to sleep. If in
+ // ConsumePreXULSkeletonUIHandle we get a value other than 1 after
+ // incrementing, it means we're sleeping, and that function can assume that
+ // we will safely exit after the sleep because of the observed value of
+ // sAnimationControlFlag.
+ if (InterlockedIncrement(&sAnimationControlFlag) != 1) {
+ return 0;
+ }
+
+ // Note: Sleep does not guarantee an exact time interval. If the system is
+ // busy, for instance, we could easily end up taking several frames longer,
+ // and really we could be left unscheduled for an arbitrarily long time.
+ // This is fine, and we don't really care. We could track how much time this
+ // actually took and jump the animation forward the appropriate amount, but
+ // its not even clear that that's a better user experience. So we leave this
+ // as simple as we can.
+ ::Sleep(16);
+
+ // Here we bring sAnimationControlFlag back down - again, if we don't get a
+ // 0 here it means we consumed the skeleton UI window in the mean time, so
+ // we can simply exit.
+ if (InterlockedDecrement(&sAnimationControlFlag) != 0) {
+ return 0;
+ }
+ }
+}
+
+LRESULT WINAPI PreXULSkeletonUIProc(HWND hWnd, UINT msg, WPARAM wParam,
+ LPARAM lParam) {
+ // Exposing a generic oleacc proxy for the skeleton isn't useful and may cause
+ // screen readers to report spurious information when the skeleton appears.
+ if (msg == WM_GETOBJECT && sPreXULSkeletonUIWindow) {
+ return E_FAIL;
+ }
+
+ // NOTE: this block was copied from WinUtils.cpp, and needs to be kept in
+ // sync.
+ if (msg == WM_NCCREATE && sEnableNonClientDpiScaling) {
+ sEnableNonClientDpiScaling(hWnd);
+ }
+
+ // NOTE: this block was paraphrased from the WM_NCCALCSIZE handler in
+ // nsWindow.cpp, and will need to be kept in sync.
+ if (msg == WM_NCCALCSIZE) {
+ RECT* clientRect =
+ wParam ? &(reinterpret_cast<NCCALCSIZE_PARAMS*>(lParam))->rgrc[0]
+ : (reinterpret_cast<RECT*>(lParam));
+
+ // These match the margins set in browser-tabsintitlebar.js with
+ // default prefs on Windows. Bug 1673092 tracks lining this up with
+ // that more correctly instead of hard-coding it.
+ int horizontalOffset =
+ sNonClientHorizontalMargins -
+ (sMaximized ? 0 : CSSToDevPixels(2, sCSSToDevPixelScaling));
+ int verticalOffset =
+ sNonClientHorizontalMargins -
+ (sMaximized ? 0 : CSSToDevPixels(2, sCSSToDevPixelScaling));
+ clientRect->top = clientRect->top;
+ clientRect->left += horizontalOffset;
+ clientRect->right -= horizontalOffset;
+ clientRect->bottom -= verticalOffset;
+ return 0;
+ }
+
+ return ::DefWindowProcW(hWnd, msg, wParam, lParam);
+}
+
+bool IsSystemDarkThemeEnabled() {
+ DWORD result;
+ HKEY themeKey;
+ DWORD dataLen = sizeof(uint32_t);
+ LPCWSTR keyName =
+ L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize";
+
+ result = ::RegOpenKeyExW(HKEY_CURRENT_USER, keyName, 0, KEY_READ, &themeKey);
+ if (result != ERROR_SUCCESS) {
+ return false;
+ }
+ AutoCloseRegKey closeKey(themeKey);
+
+ uint32_t lightThemeEnabled;
+ result = ::RegGetValueW(
+ themeKey, nullptr, L"AppsUseLightTheme", RRF_RT_REG_DWORD, nullptr,
+ reinterpret_cast<PBYTE>(&lightThemeEnabled), &dataLen);
+ if (result != ERROR_SUCCESS) {
+ return false;
+ }
+ return !lightThemeEnabled;
+}
+
+ThemeColors GetTheme(ThemeMode themeId) {
+ ThemeColors theme = {};
+ switch (themeId) {
+ case ThemeMode::Dark:
+ // Dark theme or default theme when in dark mode
+
+ // controlled by css variable --toolbar-bgcolor
+ theme.backgroundColor = 0x2b2a33;
+ theme.tabColor = 0x42414d;
+ theme.toolbarForegroundColor = 0x6a6a6d;
+ theme.tabOutlineColor = 0x1c1b22;
+ // controlled by css variable --lwt-accent-color
+ theme.tabBarColor = 0x1c1b22;
+ // controlled by --toolbar-non-lwt-textcolor in browser.css
+ theme.chromeContentDividerColor = 0x0c0c0d;
+ // controlled by css variable --toolbar-field-background-color
+ theme.urlbarColor = 0x42414d;
+ theme.urlbarBorderColor = 0x42414d;
+ theme.animationColor = theme.urlbarColor;
+ return theme;
+ case ThemeMode::Light:
+ case ThemeMode::Default:
+ default:
+ // --toolbar-non-lwt-bgcolor in browser.css
+ theme.backgroundColor = 0xf9f9fb;
+ theme.tabColor = 0xf9f9fb;
+ theme.toolbarForegroundColor = 0xdddde1;
+ theme.tabOutlineColor = 0xdddde1;
+ // found in browser-aero.css ":root[tabsintitlebar]:not(:-moz-lwtheme)"
+ // (set to "hsl(235,33%,19%)")
+ theme.tabBarColor = 0xf0f0f4;
+ // --chrome-content-separator-color in browser.css
+ theme.chromeContentDividerColor = 0xe1e1e2;
+ // controlled by css variable --toolbar-color
+ theme.urlbarColor = 0xffffff;
+ theme.urlbarBorderColor = 0xdddde1;
+ theme.animationColor = theme.backgroundColor;
+ return theme;
+ }
+}
+
+Result<HKEY, PreXULSkeletonUIError> OpenPreXULSkeletonUIRegKey() {
+ HKEY key;
+ DWORD disposition;
+ LSTATUS result =
+ ::RegCreateKeyExW(HKEY_CURRENT_USER, kPreXULSkeletonUIKeyPath, 0, nullptr,
+ 0, KEY_ALL_ACCESS, nullptr, &key, &disposition);
+
+ if (result != ERROR_SUCCESS) {
+ return Err(PreXULSkeletonUIError::FailedToOpenRegistryKey);
+ }
+
+ if (disposition == REG_CREATED_NEW_KEY ||
+ disposition == REG_OPENED_EXISTING_KEY) {
+ return key;
+ }
+
+ ::RegCloseKey(key);
+ return Err(PreXULSkeletonUIError::FailedToOpenRegistryKey);
+}
+
+Result<Ok, PreXULSkeletonUIError> LoadGdi32AndUser32Procedures() {
+ HMODULE user32Dll = ::LoadLibraryW(L"user32");
+ HMODULE gdi32Dll = ::LoadLibraryW(L"gdi32");
+
+ if (!user32Dll || !gdi32Dll) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+
+ auto getThreadDpiAwarenessContext =
+ (decltype(GetThreadDpiAwarenessContext)*)::GetProcAddress(
+ user32Dll, "GetThreadDpiAwarenessContext");
+ auto areDpiAwarenessContextsEqual =
+ (decltype(AreDpiAwarenessContextsEqual)*)::GetProcAddress(
+ user32Dll, "AreDpiAwarenessContextsEqual");
+ if (getThreadDpiAwarenessContext && areDpiAwarenessContextsEqual &&
+ areDpiAwarenessContextsEqual(getThreadDpiAwarenessContext(),
+ DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE)) {
+ // EnableNonClientDpiScaling is optional - we can handle not having it.
+ sEnableNonClientDpiScaling =
+ (EnableNonClientDpiScalingProc)::GetProcAddress(
+ user32Dll, "EnableNonClientDpiScaling");
+ }
+
+ sGetSystemMetricsForDpi = (GetSystemMetricsForDpiProc)::GetProcAddress(
+ user32Dll, "GetSystemMetricsForDpi");
+ if (!sGetSystemMetricsForDpi) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sGetDpiForWindow =
+ (GetDpiForWindowProc)::GetProcAddress(user32Dll, "GetDpiForWindow");
+ if (!sGetDpiForWindow) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sRegisterClassW =
+ (RegisterClassWProc)::GetProcAddress(user32Dll, "RegisterClassW");
+ if (!sRegisterClassW) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sCreateWindowExW =
+ (CreateWindowExWProc)::GetProcAddress(user32Dll, "CreateWindowExW");
+ if (!sCreateWindowExW) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sShowWindow = (ShowWindowProc)::GetProcAddress(user32Dll, "ShowWindow");
+ if (!sShowWindow) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sSetWindowPos = (SetWindowPosProc)::GetProcAddress(user32Dll, "SetWindowPos");
+ if (!sSetWindowPos) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sGetWindowDC = (GetWindowDCProc)::GetProcAddress(user32Dll, "GetWindowDC");
+ if (!sGetWindowDC) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sFillRect = (FillRectProc)::GetProcAddress(user32Dll, "FillRect");
+ if (!sFillRect) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sReleaseDC = (ReleaseDCProc)::GetProcAddress(user32Dll, "ReleaseDC");
+ if (!sReleaseDC) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sLoadIconW = (LoadIconWProc)::GetProcAddress(user32Dll, "LoadIconW");
+ if (!sLoadIconW) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sLoadCursorW = (LoadCursorWProc)::GetProcAddress(user32Dll, "LoadCursorW");
+ if (!sLoadCursorW) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sMonitorFromWindow =
+ (MonitorFromWindowProc)::GetProcAddress(user32Dll, "MonitorFromWindow");
+ if (!sMonitorFromWindow) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sGetMonitorInfoW =
+ (GetMonitorInfoWProc)::GetProcAddress(user32Dll, "GetMonitorInfoW");
+ if (!sGetMonitorInfoW) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sSetWindowLongPtrW =
+ (SetWindowLongPtrWProc)::GetProcAddress(user32Dll, "SetWindowLongPtrW");
+ if (!sSetWindowLongPtrW) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sStretchDIBits =
+ (StretchDIBitsProc)::GetProcAddress(gdi32Dll, "StretchDIBits");
+ if (!sStretchDIBits) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sCreateSolidBrush =
+ (CreateSolidBrushProc)::GetProcAddress(gdi32Dll, "CreateSolidBrush");
+ if (!sCreateSolidBrush) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+ sDeleteObject = (DeleteObjectProc)::GetProcAddress(gdi32Dll, "DeleteObject");
+ if (!sDeleteObject) {
+ return Err(PreXULSkeletonUIError::FailedLoadingDynamicProcs);
+ }
+
+ return Ok();
+}
+
+// Strips "--", "-", and "/" from the front of the arg if one of those exists,
+// returning `arg + 2`, `arg + 1`, and `arg + 1` respectively. If none of these
+// prefixes are found, the argument is not a flag, and nullptr is returned.
+const char* NormalizeFlag(const char* arg) {
+ if (strstr(arg, "--") == arg) {
+ return arg + 2;
+ }
+
+ if (arg[0] == '-') {
+ return arg + 1;
+ }
+
+ if (arg[0] == '/') {
+ return arg + 1;
+ }
+
+ return nullptr;
+}
+
+static bool EnvHasValue(const char* name) {
+ const char* val = getenv(name);
+ return (val && *val);
+}
+
+// Ensures that we only see arguments in the command line which are acceptable.
+// This is based on manual inspection of the list of arguments listed in the MDN
+// page for Gecko/Firefox commandline options:
+// https://developer.mozilla.org/en-US/docs/Mozilla/Command_Line_Options
+// Broadly speaking, we want to reject any argument which causes us to show
+// something other than the default window at its normal size. Here is a non-
+// exhaustive list of command line options we want to *exclude*:
+//
+// -ProfileManager : This will display the profile manager window, which does
+// not match the skeleton UI at all.
+//
+// -CreateProfile : This will display a firefox window with the default
+// screen position and size, and not the position and size
+// which we have recorded in the registry.
+//
+// -P <profile> : This could cause us to display firefox with a position
+// and size of a different profile than that in which we
+// were previously running.
+//
+// -width, -height : This will cause the width and height values in the
+// registry to be incorrect.
+//
+// -kiosk : See above.
+//
+// -headless : This one should be rather obvious.
+//
+// -migration : This will start with the import wizard, which of course
+// does not match the skeleton UI.
+//
+// -private-window : This is tricky, but the colors of the main content area
+// make this not feel great with the white content of the
+// default skeleton UI.
+//
+// NOTE: we generally want to skew towards erroneous rejections of the command
+// line rather than erroneous approvals. The consequence of a bad rejection
+// is that we don't show the skeleton UI, which is business as usual. The
+// consequence of a bad approval is that we show it when we're not supposed to,
+// which is visually jarring and can also be unpredictable - there's no
+// guarantee that the code which handles the non-default window is set up to
+// properly handle the transition from the skeleton UI window.
+static Result<Ok, PreXULSkeletonUIError> ValidateCmdlineArguments(
+ int argc, char** argv, bool* explicitProfile) {
+ const char* approvedArgumentsArray[] = {
+ // These won't cause the browser to be visualy different in any way
+ "new-instance", "no-remote", "browser", "foreground", "setDefaultBrowser",
+ "attach-console", "wait-for-browser", "osint",
+
+ // These will cause the chrome to be a bit different or extra windows to
+ // be created, but overall the skeleton UI should still be broadly
+ // correct enough.
+ "new-tab", "new-window",
+
+ // To the extent possible, we want to ensure that existing tests cover
+ // the skeleton UI, so we need to allow marionette
+ "marionette",
+
+ // These will cause the content area to appear different, but won't
+ // meaningfully affect the chrome
+ "preferences", "search", "url",
+
+#ifndef MOZILLA_OFFICIAL
+ // On local builds, we want to allow -profile, because it's how `mach run`
+ // operates, and excluding that would create an unnecessary blind spot for
+ // Firefox devs.
+ "profile"
+#endif
+
+ // There are other arguments which are likely okay. However, they are
+ // not included here because this list is not intended to be
+ // exhaustive - it only intends to green-light some somewhat commonly
+ // used arguments. We want to err on the side of an unnecessary
+ // rejection of the command line.
+ };
+
+ int approvedArgumentsArraySize =
+ sizeof(approvedArgumentsArray) / sizeof(approvedArgumentsArray[0]);
+ Vector<const char*> approvedArguments;
+ if (!approvedArguments.reserve(approvedArgumentsArraySize)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+
+ for (int i = 0; i < approvedArgumentsArraySize; ++i) {
+ approvedArguments.infallibleAppend(approvedArgumentsArray[i]);
+ }
+
+#ifdef MOZILLA_OFFICIAL
+ int profileArgIndex = -1;
+ // If we're running mochitests or direct marionette tests, those specify a
+ // temporary profile, and we want to ensure that we get the added coverage
+ // from those.
+ for (int i = 1; i < argc; ++i) {
+ const char* flag = NormalizeFlag(argv[i]);
+ if (flag && !strcmp(flag, "marionette")) {
+ if (!approvedArguments.append("profile")) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+ profileArgIndex = approvedArguments.length() - 1;
+
+ break;
+ }
+ }
+#else
+ int profileArgIndex = approvedArguments.length() - 1;
+#endif
+
+ for (int i = 1; i < argc; ++i) {
+ const char* flag = NormalizeFlag(argv[i]);
+ if (!flag) {
+ // If this is not a flag, then we interpret it as a URL, similar to
+ // BrowserContentHandler.sys.mjs. Some command line options take
+ // additional arguments, which may or may not be URLs. We don't need to
+ // know this, because we don't need to parse them out; we just rely on the
+ // assumption that if arg X is actually a parameter for the preceding
+ // arg Y, then X must not look like a flag (starting with "--", "-",
+ // or "/").
+ //
+ // The most important thing here is the assumption that if something is
+ // going to meaningfully alter the appearance of the window itself, it
+ // must be a flag.
+ continue;
+ }
+
+ bool approved = false;
+ for (const char* approvedArg : approvedArguments) {
+ // We do a case-insensitive compare here with _stricmp. Even though some
+ // of these arguments are *not* read as case-insensitive, others *are*.
+ // Similar to the flag logic above, we don't really care about this
+ // distinction, because we don't need to parse the arguments - we just
+ // rely on the assumption that none of the listed flags in our
+ // approvedArguments are overloaded in such a way that a different
+ // casing would visually alter the firefox window.
+ if (!_stricmp(flag, approvedArg)) {
+ approved = true;
+
+ if (i == profileArgIndex) {
+ *explicitProfile = true;
+ }
+ break;
+ }
+ }
+
+ if (!approved) {
+ return Err(PreXULSkeletonUIError::Cmdline);
+ }
+ }
+
+ return Ok();
+}
+
+static Result<Ok, PreXULSkeletonUIError> ValidateEnvVars() {
+ if (EnvHasValue("MOZ_SAFE_MODE_RESTART") ||
+ EnvHasValue("MOZ_APP_SILENT_START") ||
+ EnvHasValue("MOZ_RESET_PROFILE_RESTART") || EnvHasValue("MOZ_HEADLESS") ||
+ (EnvHasValue("XRE_PROFILE_PATH") &&
+ !EnvHasValue("MOZ_SKELETON_UI_RESTARTING"))) {
+ return Err(PreXULSkeletonUIError::EnvVars);
+ }
+
+ return Ok();
+}
+
+static bool VerifyWindowDimensions(uint32_t windowWidth,
+ uint32_t windowHeight) {
+ return windowWidth <= kMaxWindowWidth && windowHeight <= kMaxWindowHeight;
+}
+
+static Result<Vector<CSSPixelSpan>, PreXULSkeletonUIError> ReadRegCSSPixelSpans(
+ HKEY regKey, const std::wstring& valueName) {
+ DWORD dataLen = 0;
+ LSTATUS result = ::RegQueryValueExW(regKey, valueName.c_str(), nullptr,
+ nullptr, nullptr, &dataLen);
+ if (result != ERROR_SUCCESS) {
+ return Err(PreXULSkeletonUIError::RegistryError);
+ }
+
+ if (dataLen % (2 * sizeof(double)) != 0) {
+ return Err(PreXULSkeletonUIError::CorruptData);
+ }
+
+ auto buffer = MakeUniqueFallible<wchar_t[]>(dataLen);
+ if (!buffer) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+ result =
+ ::RegGetValueW(regKey, nullptr, valueName.c_str(), RRF_RT_REG_BINARY,
+ nullptr, reinterpret_cast<PBYTE>(buffer.get()), &dataLen);
+ if (result != ERROR_SUCCESS) {
+ return Err(PreXULSkeletonUIError::RegistryError);
+ }
+
+ Vector<CSSPixelSpan> resultVector;
+ double* asDoubles = reinterpret_cast<double*>(buffer.get());
+ for (size_t i = 0; i < dataLen / (2 * sizeof(double)); i++) {
+ CSSPixelSpan span = {};
+ span.start = *(asDoubles++);
+ span.end = *(asDoubles++);
+ if (!resultVector.append(span)) {
+ return Err(PreXULSkeletonUIError::OOM);
+ }
+ }
+
+ return resultVector;
+}
+
+static Result<double, PreXULSkeletonUIError> ReadRegDouble(
+ HKEY regKey, const std::wstring& valueName) {
+ double value = 0;
+ DWORD dataLen = sizeof(double);
+ LSTATUS result =
+ ::RegGetValueW(regKey, nullptr, valueName.c_str(), RRF_RT_REG_BINARY,
+ nullptr, reinterpret_cast<PBYTE>(&value), &dataLen);
+ if (result != ERROR_SUCCESS || dataLen != sizeof(double)) {
+ return Err(PreXULSkeletonUIError::RegistryError);
+ }
+
+ return value;
+}
+
+static Result<uint32_t, PreXULSkeletonUIError> ReadRegUint(
+ HKEY regKey, const std::wstring& valueName) {
+ DWORD value = 0;
+ DWORD dataLen = sizeof(uint32_t);
+ LSTATUS result =
+ ::RegGetValueW(regKey, nullptr, valueName.c_str(), RRF_RT_REG_DWORD,
+ nullptr, reinterpret_cast<PBYTE>(&value), &dataLen);
+ if (result != ERROR_SUCCESS) {
+ return Err(PreXULSkeletonUIError::RegistryError);
+ }
+
+ return value;
+}
+
+static Result<bool, PreXULSkeletonUIError> ReadRegBool(
+ HKEY regKey, const std::wstring& valueName) {
+ uint32_t value;
+ MOZ_TRY_VAR(value, ReadRegUint(regKey, valueName));
+ return !!value;
+}
+
+static Result<Ok, PreXULSkeletonUIError> WriteRegCSSPixelSpans(
+ HKEY regKey, const std::wstring& valueName, const CSSPixelSpan* spans,
+ int spansLength) {
+ // No guarantee on the packing of CSSPixelSpan. We could #pragma it, but it's
+ // also trivial to just copy them into a buffer of doubles.
+ auto doubles = MakeUnique<double[]>(spansLength * 2);
+ for (int i = 0; i < spansLength; ++i) {
+ doubles[i * 2] = spans[i].start;
+ doubles[i * 2 + 1] = spans[i].end;
+ }
+
+ LSTATUS result =
+ ::RegSetValueExW(regKey, valueName.c_str(), 0, REG_BINARY,
+ reinterpret_cast<const BYTE*>(doubles.get()),
+ spansLength * sizeof(double) * 2);
+ if (result != ERROR_SUCCESS) {
+ return Err(PreXULSkeletonUIError::RegistryError);
+ }
+ return Ok();
+}
+
+static Result<Ok, PreXULSkeletonUIError> WriteRegDouble(
+ HKEY regKey, const std::wstring& valueName, double value) {
+ LSTATUS result =
+ ::RegSetValueExW(regKey, valueName.c_str(), 0, REG_BINARY,
+ reinterpret_cast<const BYTE*>(&value), sizeof(value));
+ if (result != ERROR_SUCCESS) {
+ return Err(PreXULSkeletonUIError::RegistryError);
+ }
+
+ return Ok();
+}
+
+static Result<Ok, PreXULSkeletonUIError> WriteRegUint(
+ HKEY regKey, const std::wstring& valueName, uint32_t value) {
+ LSTATUS result =
+ ::RegSetValueExW(regKey, valueName.c_str(), 0, REG_DWORD,
+ reinterpret_cast<PBYTE>(&value), sizeof(value));
+ if (result != ERROR_SUCCESS) {
+ return Err(PreXULSkeletonUIError::RegistryError);
+ }
+
+ return Ok();
+}
+
+static Result<Ok, PreXULSkeletonUIError> WriteRegBool(
+ HKEY regKey, const std::wstring& valueName, bool value) {
+ return WriteRegUint(regKey, valueName, value ? 1 : 0);
+}
+
+static Result<Ok, PreXULSkeletonUIError> CreateAndStorePreXULSkeletonUIImpl(
+ HINSTANCE hInstance, int argc, char** argv) {
+ // Initializing COM below may load modules via SetWindowHookEx, some of
+ // which may modify the executable's IAT for ntdll.dll. If that happens,
+ // this browser process fails to launch sandbox processes because we cannot
+ // copy a modified IAT into a remote process (See SandboxBroker::LaunchApp).
+ // To prevent that, we cache the intact IAT before COM initialization.
+ // If EAF+ is enabled, CacheNtDllThunk() causes a crash, but EAF+ will
+ // also prevent an injected module from parsing the PE headers and modifying
+ // the IAT. Therefore, we can skip CacheNtDllThunk().
+ if (!mozilla::IsEafPlusEnabled()) {
+ CacheNtDllThunk();
+ }
+
+ // NOTE: it's important that we initialize sProcessRuntime before showing a
+ // window. Historically we ran into issues where showing the window would
+ // cause an accessibility win event to fire, which could cause in-process
+ // system or third party components to initialize COM and prevent us from
+ // initializing it with important settings we need.
+
+ // Some COM settings are global to the process and must be set before any non-
+ // trivial COM is run in the application. Since these settings may affect
+ // stability, we should instantiate COM ASAP so that we can ensure that these
+ // global settings are configured before anything can interfere.
+ sProcessRuntime = new mscom::ProcessRuntime(
+ mscom::ProcessRuntime::ProcessCategory::GeckoBrowserParent);
+
+ const TimeStamp skeletonStart = TimeStamp::Now();
+
+ if (!IsWin10OrLater()) {
+ return Err(PreXULSkeletonUIError::Ineligible);
+ }
+
+ HKEY regKey;
+ MOZ_TRY_VAR(regKey, OpenPreXULSkeletonUIRegKey());
+ AutoCloseRegKey closeKey(regKey);
+
+ UniquePtr<wchar_t[]> binPath;
+ MOZ_TRY_VAR(binPath, GetBinaryPath());
+
+ std::wstring regProgressName =
+ GetRegValueName(binPath.get(), sProgressSuffix);
+ auto progressResult = ReadRegUint(regKey, regProgressName);
+ if (!progressResult.isErr() &&
+ progressResult.unwrap() !=
+ static_cast<uint32_t>(PreXULSkeletonUIProgress::Completed)) {
+ return Err(PreXULSkeletonUIError::CrashedOnce);
+ }
+
+ MOZ_TRY(
+ WriteRegUint(regKey, regProgressName,
+ static_cast<uint32_t>(PreXULSkeletonUIProgress::Started)));
+ auto writeCompletion = MakeScopeExit([&] {
+ Unused << WriteRegUint(
+ regKey, regProgressName,
+ static_cast<uint32_t>(PreXULSkeletonUIProgress::Completed));
+ });
+
+ MOZ_TRY(GetSkeletonUILock());
+
+ bool explicitProfile = false;
+ MOZ_TRY(ValidateCmdlineArguments(argc, argv, &explicitProfile));
+ MOZ_TRY(ValidateEnvVars());
+
+ auto enabledResult =
+ ReadRegBool(regKey, GetRegValueName(binPath.get(), sEnabledRegSuffix));
+ if (enabledResult.isErr()) {
+ return Err(PreXULSkeletonUIError::EnabledKeyDoesNotExist);
+ }
+ if (!enabledResult.unwrap()) {
+ return Err(PreXULSkeletonUIError::Disabled);
+ }
+ sPreXULSkeletonUIEnabled = true;
+
+ MOZ_ASSERT(!sAnimatedRects);
+ sAnimatedRects = new Vector<ColorRect>();
+
+ MOZ_TRY(LoadGdi32AndUser32Procedures());
+
+ if (!explicitProfile) {
+ MOZ_TRY(CheckForStartWithLastProfile());
+ }
+
+ WNDCLASSW wc;
+ wc.style = CS_DBLCLKS;
+ wc.lpfnWndProc = PreXULSkeletonUIProc;
+ wc.cbClsExtra = 0;
+ wc.cbWndExtra = 0;
+ wc.hInstance = hInstance;
+ wc.hIcon = sLoadIconW(::GetModuleHandleW(nullptr), gStockApplicationIcon);
+ wc.hCursor = sLoadCursorW(hInstance, gIDCWait);
+ wc.hbrBackground = nullptr;
+ wc.lpszMenuName = nullptr;
+
+ // TODO: just ensure we disable this if we've overridden the window class
+ wc.lpszClassName = L"MozillaWindowClass";
+
+ if (!sRegisterClassW(&wc)) {
+ return Err(PreXULSkeletonUIError::FailedRegisteringWindowClass);
+ }
+
+ uint32_t screenX;
+ MOZ_TRY_VAR(screenX, ReadRegUint(regKey, GetRegValueName(binPath.get(),
+ sScreenXRegSuffix)));
+ uint32_t screenY;
+ MOZ_TRY_VAR(screenY, ReadRegUint(regKey, GetRegValueName(binPath.get(),
+ sScreenYRegSuffix)));
+ uint32_t windowWidth;
+ MOZ_TRY_VAR(
+ windowWidth,
+ ReadRegUint(regKey, GetRegValueName(binPath.get(), sWidthRegSuffix)));
+ uint32_t windowHeight;
+ MOZ_TRY_VAR(
+ windowHeight,
+ ReadRegUint(regKey, GetRegValueName(binPath.get(), sHeightRegSuffix)));
+ MOZ_TRY_VAR(
+ sMaximized,
+ ReadRegBool(regKey, GetRegValueName(binPath.get(), sMaximizedRegSuffix)));
+ MOZ_TRY_VAR(
+ sCSSToDevPixelScaling,
+ ReadRegDouble(regKey, GetRegValueName(binPath.get(),
+ sCssToDevPixelScalingRegSuffix)));
+ Vector<CSSPixelSpan> urlbar;
+ MOZ_TRY_VAR(urlbar,
+ ReadRegCSSPixelSpans(
+ regKey, GetRegValueName(binPath.get(), sUrlbarCSSRegSuffix)));
+ Vector<CSSPixelSpan> searchbar;
+ MOZ_TRY_VAR(searchbar,
+ ReadRegCSSPixelSpans(
+ regKey, GetRegValueName(binPath.get(), sSearchbarRegSuffix)));
+ Vector<CSSPixelSpan> springs;
+ MOZ_TRY_VAR(springs, ReadRegCSSPixelSpans(
+ regKey, GetRegValueName(binPath.get(),
+ sSpringsCSSRegSuffix)));
+
+ if (urlbar.empty() || searchbar.empty()) {
+ return Err(PreXULSkeletonUIError::CorruptData);
+ }
+
+ EnumSet<SkeletonUIFlag, uint32_t> flags;
+ uint32_t flagsUint;
+ MOZ_TRY_VAR(flagsUint, ReadRegUint(regKey, GetRegValueName(binPath.get(),
+ sFlagsRegSuffix)));
+ flags.deserialize(flagsUint);
+
+ if (flags.contains(SkeletonUIFlag::TouchDensity) ||
+ flags.contains(SkeletonUIFlag::CompactDensity)) {
+ return Err(PreXULSkeletonUIError::BadUIDensity);
+ }
+
+ uint32_t theme;
+ MOZ_TRY_VAR(theme, ReadRegUint(regKey, GetRegValueName(binPath.get(),
+ sThemeRegSuffix)));
+ ThemeMode themeMode = static_cast<ThemeMode>(theme);
+ if (themeMode == ThemeMode::Default) {
+ if (IsSystemDarkThemeEnabled() == true) {
+ themeMode = ThemeMode::Dark;
+ }
+ }
+ ThemeColors currentTheme = GetTheme(themeMode);
+
+ if (!VerifyWindowDimensions(windowWidth, windowHeight)) {
+ return Err(PreXULSkeletonUIError::BadWindowDimensions);
+ }
+
+ int showCmd = SW_SHOWNORMAL;
+ DWORD windowStyle = kPreXULSkeletonUIWindowStyle;
+ if (sMaximized) {
+ showCmd = SW_SHOWMAXIMIZED;
+ windowStyle |= WS_MAXIMIZE;
+ }
+
+ sPreXULSkeletonUIWindow =
+ sCreateWindowExW(kPreXULSkeletonUIWindowStyleEx, L"MozillaWindowClass",
+ L"", windowStyle, screenX, screenY, windowWidth,
+ windowHeight, nullptr, nullptr, hInstance, nullptr);
+ if (!sPreXULSkeletonUIWindow) {
+ return Err(PreXULSkeletonUIError::CreateWindowFailed);
+ }
+
+ sShowWindow(sPreXULSkeletonUIWindow, showCmd);
+
+ sDpi = sGetDpiForWindow(sPreXULSkeletonUIWindow);
+ sNonClientHorizontalMargins =
+ sGetSystemMetricsForDpi(SM_CXFRAME, sDpi) +
+ sGetSystemMetricsForDpi(SM_CXPADDEDBORDER, sDpi);
+ sNonClientVerticalMargins = sGetSystemMetricsForDpi(SM_CYFRAME, sDpi) +
+ sGetSystemMetricsForDpi(SM_CXPADDEDBORDER, sDpi);
+
+ if (sMaximized) {
+ HMONITOR monitor =
+ sMonitorFromWindow(sPreXULSkeletonUIWindow, MONITOR_DEFAULTTONULL);
+ if (!monitor) {
+ // NOTE: we specifically don't clean up the window here. If we're unable
+ // to finish setting up the window how we want it, we still need to keep
+ // it around and consume it with the first real toplevel window we
+ // create, to avoid flickering.
+ return Err(PreXULSkeletonUIError::FailedGettingMonitorInfo);
+ }
+ MONITORINFO mi = {sizeof(MONITORINFO)};
+ if (!sGetMonitorInfoW(monitor, &mi)) {
+ return Err(PreXULSkeletonUIError::FailedGettingMonitorInfo);
+ }
+
+ sWindowWidth =
+ mi.rcWork.right - mi.rcWork.left + sNonClientHorizontalMargins * 2;
+ sWindowHeight =
+ mi.rcWork.bottom - mi.rcWork.top + sNonClientVerticalMargins * 2;
+ } else {
+ sWindowWidth = static_cast<int>(windowWidth);
+ sWindowHeight = static_cast<int>(windowHeight);
+ }
+
+ sSetWindowPos(sPreXULSkeletonUIWindow, 0, 0, 0, 0, 0,
+ SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE |
+ SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);
+ MOZ_TRY(DrawSkeletonUI(sPreXULSkeletonUIWindow, urlbar[0], searchbar[0],
+ springs, currentTheme, flags));
+ if (sAnimatedRects) {
+ sPreXULSKeletonUIAnimationThread = ::CreateThread(
+ nullptr, 256 * 1024, AnimateSkeletonUI, nullptr, 0, nullptr);
+ }
+
+ BASE_PROFILER_MARKER_UNTYPED(
+ "CreatePreXULSkeletonUI", OTHER,
+ MarkerTiming::IntervalUntilNowFrom(skeletonStart));
+
+ return Ok();
+}
+
+void CreateAndStorePreXULSkeletonUI(HINSTANCE hInstance, int argc,
+ char** argv) {
+ auto result = CreateAndStorePreXULSkeletonUIImpl(hInstance, argc, argv);
+
+ if (result.isErr()) {
+ sErrorReason.emplace(result.unwrapErr());
+ }
+}
+
+void CleanupProcessRuntime() {
+ delete sProcessRuntime;
+ sProcessRuntime = nullptr;
+}
+
+bool WasPreXULSkeletonUIMaximized() { return sMaximized; }
+
+bool GetPreXULSkeletonUIWasShown() {
+ return sPreXULSkeletonUIShown || !!sPreXULSkeletonUIWindow;
+}
+
+HWND ConsumePreXULSkeletonUIHandle() {
+ // NOTE: we need to make sure that everything that runs here is a no-op if
+ // it failed to be set, which is a possibility. If anything fails to be set
+ // we don't want to clean everything up right away, because if we have a
+ // blank window up, we want that to stick around and get consumed by nsWindow
+ // as normal, otherwise the window will flicker in and out, which we imagine
+ // is unpleasant.
+
+ // If we don't get 1 here, it means the thread is actually just sleeping, so
+ // we don't need to worry about giving out ownership of the window, because
+ // the thread will simply exit after its sleep. However, if it is 1, we need
+ // to wait for the thread to exit to be safe, as it could be doing anything.
+ if (InterlockedIncrement(&sAnimationControlFlag) == 1) {
+ ::WaitForSingleObject(sPreXULSKeletonUIAnimationThread, INFINITE);
+ }
+ ::CloseHandle(sPreXULSKeletonUIAnimationThread);
+ sPreXULSKeletonUIAnimationThread = nullptr;
+ HWND result = sPreXULSkeletonUIWindow;
+ sPreXULSkeletonUIWindow = nullptr;
+ free(sPixelBuffer);
+ sPixelBuffer = nullptr;
+ delete sAnimatedRects;
+ sAnimatedRects = nullptr;
+
+ return result;
+}
+
+Maybe<PreXULSkeletonUIError> GetPreXULSkeletonUIErrorReason() {
+ return sErrorReason;
+}
+
+Result<Ok, PreXULSkeletonUIError> PersistPreXULSkeletonUIValues(
+ const SkeletonUISettings& settings) {
+ if (!sPreXULSkeletonUIEnabled) {
+ return Err(PreXULSkeletonUIError::Disabled);
+ }
+
+ HKEY regKey;
+ MOZ_TRY_VAR(regKey, OpenPreXULSkeletonUIRegKey());
+ AutoCloseRegKey closeKey(regKey);
+
+ UniquePtr<wchar_t[]> binPath;
+ MOZ_TRY_VAR(binPath, GetBinaryPath());
+
+ MOZ_TRY(WriteRegUint(regKey,
+ GetRegValueName(binPath.get(), sScreenXRegSuffix),
+ settings.screenX));
+ MOZ_TRY(WriteRegUint(regKey,
+ GetRegValueName(binPath.get(), sScreenYRegSuffix),
+ settings.screenY));
+ MOZ_TRY(WriteRegUint(regKey, GetRegValueName(binPath.get(), sWidthRegSuffix),
+ settings.width));
+ MOZ_TRY(WriteRegUint(regKey, GetRegValueName(binPath.get(), sHeightRegSuffix),
+ settings.height));
+
+ MOZ_TRY(WriteRegBool(regKey,
+ GetRegValueName(binPath.get(), sMaximizedRegSuffix),
+ settings.maximized));
+
+ EnumSet<SkeletonUIFlag, uint32_t> flags;
+ if (settings.menubarShown) {
+ flags += SkeletonUIFlag::MenubarShown;
+ }
+ if (settings.bookmarksToolbarShown) {
+ flags += SkeletonUIFlag::BookmarksToolbarShown;
+ }
+ if (settings.rtlEnabled) {
+ flags += SkeletonUIFlag::RtlEnabled;
+ }
+ if (settings.uiDensity == SkeletonUIDensity::Touch) {
+ flags += SkeletonUIFlag::TouchDensity;
+ }
+ if (settings.uiDensity == SkeletonUIDensity::Compact) {
+ flags += SkeletonUIFlag::CompactDensity;
+ }
+
+ uint32_t flagsUint = flags.serialize();
+ MOZ_TRY(WriteRegUint(regKey, GetRegValueName(binPath.get(), sFlagsRegSuffix),
+ flagsUint));
+
+ MOZ_TRY(WriteRegDouble(
+ regKey, GetRegValueName(binPath.get(), sCssToDevPixelScalingRegSuffix),
+ settings.cssToDevPixelScaling));
+ MOZ_TRY(WriteRegCSSPixelSpans(
+ regKey, GetRegValueName(binPath.get(), sUrlbarCSSRegSuffix),
+ &settings.urlbarSpan, 1));
+ MOZ_TRY(WriteRegCSSPixelSpans(
+ regKey, GetRegValueName(binPath.get(), sSearchbarRegSuffix),
+ &settings.searchbarSpan, 1));
+ MOZ_TRY(WriteRegCSSPixelSpans(
+ regKey, GetRegValueName(binPath.get(), sSpringsCSSRegSuffix),
+ settings.springs.begin(), settings.springs.length()));
+
+ return Ok();
+}
+
+MFBT_API bool GetPreXULSkeletonUIEnabled() { return sPreXULSkeletonUIEnabled; }
+
+MFBT_API Result<Ok, PreXULSkeletonUIError> SetPreXULSkeletonUIEnabledIfAllowed(
+ bool value) {
+ // If the pre-XUL skeleton UI was disallowed for some reason, we just want to
+ // ignore changes to the registry. An example of how things could be bad if
+ // we didn't: someone running firefox with the -profile argument could
+ // turn the skeleton UI on or off for the default profile. Turning it off
+ // maybe isn't so bad (though it's likely still incorrect), but turning it
+ // on could be bad if the user had specifically disabled it for a profile for
+ // some reason. Ultimately there's no correct decision here, and the
+ // messiness of this is just a consequence of sharing the registry values
+ // across profiles. However, whatever ill effects we observe should be
+ // correct themselves after one session.
+ if (PreXULSkeletonUIDisallowed()) {
+ return Err(PreXULSkeletonUIError::Disabled);
+ }
+
+ HKEY regKey;
+ MOZ_TRY_VAR(regKey, OpenPreXULSkeletonUIRegKey());
+ AutoCloseRegKey closeKey(regKey);
+
+ UniquePtr<wchar_t[]> binPath;
+ MOZ_TRY_VAR(binPath, GetBinaryPath());
+ MOZ_TRY(WriteRegBool(
+ regKey, GetRegValueName(binPath.get(), sEnabledRegSuffix), value));
+
+ if (!sPreXULSkeletonUIEnabled && value) {
+ // We specifically don't care if we fail to get this lock. We just want to
+ // do our best effort to lock it so that future instances don't create
+ // skeleton UIs while we're still running, since they will immediately exit
+ // and tell us to open a new window.
+ Unused << GetSkeletonUILock();
+ }
+
+ sPreXULSkeletonUIEnabled = value;
+
+ return Ok();
+}
+
+MFBT_API Result<Ok, PreXULSkeletonUIError> SetPreXULSkeletonUIThemeId(
+ ThemeMode theme) {
+ if (theme == sTheme) {
+ return Ok();
+ }
+ sTheme = theme;
+
+ // If we fail below, invalidate sTheme
+ auto invalidateTheme = MakeScopeExit([] { sTheme = ThemeMode::Invalid; });
+
+ HKEY regKey;
+ MOZ_TRY_VAR(regKey, OpenPreXULSkeletonUIRegKey());
+ AutoCloseRegKey closeKey(regKey);
+
+ UniquePtr<wchar_t[]> binPath;
+ MOZ_TRY_VAR(binPath, GetBinaryPath());
+ MOZ_TRY(WriteRegUint(regKey, GetRegValueName(binPath.get(), sThemeRegSuffix),
+ static_cast<uint32_t>(theme)));
+
+ invalidateTheme.release();
+ return Ok();
+}
+
+MFBT_API void PollPreXULSkeletonUIEvents() {
+ if (sPreXULSkeletonUIEnabled && sPreXULSkeletonUIWindow) {
+ MSG outMsg = {};
+ PeekMessageW(&outMsg, sPreXULSkeletonUIWindow, 0, 0, 0);
+ }
+}
+
+Result<Ok, PreXULSkeletonUIError> NotePreXULSkeletonUIRestarting() {
+ if (!sPreXULSkeletonUIEnabled) {
+ return Err(PreXULSkeletonUIError::Disabled);
+ }
+
+ ::SetEnvironmentVariableW(L"MOZ_SKELETON_UI_RESTARTING", L"1");
+
+ // We assume that we are going to exit the application very shortly after
+ // this. It should thus be fine to release this lock, and we'll need to,
+ // since during a restart we launch the new instance before closing this
+ // one.
+ if (sPreXULSKeletonUILockFile != INVALID_HANDLE_VALUE) {
+ ::CloseHandle(sPreXULSKeletonUILockFile);
+ }
+ return Ok();
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/PreXULSkeletonUI.h b/mozglue/misc/PreXULSkeletonUI.h
new file mode 100644
index 0000000000..ee193b1dc8
--- /dev/null
+++ b/mozglue/misc/PreXULSkeletonUI.h
@@ -0,0 +1,186 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef PreXULSkeletonUI_h_
+#define PreXULSkeletonUI_h_
+
+#include <windows.h>
+#include "mozilla/EnumSet.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Result.h"
+#include "mozilla/Types.h"
+#include "mozilla/Vector.h"
+
+namespace mozilla {
+
+// These unfortunately need to be kept in sync with the window style and
+// extended window style computations in nsWindow. Luckily those styles seem
+// to not vary based off of any user settings for the initial toplevel window,
+// so we're safe here for now.
+static const DWORD kPreXULSkeletonUIWindowStyle =
+ WS_CLIPCHILDREN | WS_DLGFRAME | WS_BORDER | WS_MAXIMIZEBOX |
+ WS_MINIMIZEBOX | WS_SIZEBOX | WS_SYSMENU;
+static const DWORD kPreXULSkeletonUIWindowStyleEx = WS_EX_WINDOWEDGE;
+
+struct CSSPixelSpan {
+ double start;
+ double end;
+};
+
+struct DevPixelSpan {
+ int start;
+ int end;
+};
+
+enum class SkeletonUIDensity { Default, Touch, Compact };
+
+struct SkeletonUISettings {
+ uint32_t screenX;
+ uint32_t screenY;
+ uint32_t width;
+ uint32_t height;
+ CSSPixelSpan urlbarSpan;
+ CSSPixelSpan searchbarSpan;
+ double cssToDevPixelScaling;
+ Vector<CSSPixelSpan> springs;
+ bool maximized;
+ bool menubarShown;
+ bool bookmarksToolbarShown;
+ bool rtlEnabled;
+ SkeletonUIDensity uiDensity;
+};
+
+enum class ThemeMode : uint32_t { Invalid, Default, Dark, Light };
+
+enum class SkeletonUIFlag : uint8_t {
+ MenubarShown,
+ BookmarksToolbarShown,
+ RtlEnabled,
+ TouchDensity,
+ CompactDensity,
+};
+
+struct ThemeColors {
+ uint32_t backgroundColor;
+ uint32_t toolbarForegroundColor;
+ uint32_t tabBarColor;
+ uint32_t tabColor;
+ uint32_t tabOutlineColor;
+ uint32_t chromeContentDividerColor;
+ uint32_t urlbarColor;
+ uint32_t urlbarBorderColor;
+ uint32_t animationColor;
+};
+
+enum class PreXULSkeletonUIError : uint32_t {
+ None,
+ Ineligible,
+ Disabled,
+ EnabledKeyDoesNotExist,
+ OOM,
+ Cmdline,
+ EnvVars,
+ FailedToOpenRegistryKey,
+ RegistryError,
+ FailedLoadingDynamicProcs,
+ FailedGettingLock,
+ FilesystemFailure,
+ NoStartWithLastProfile,
+ FailedRegisteringWindowClass,
+ CorruptData,
+ BadWindowDimensions,
+ FailedGettingMonitorInfo,
+ CreateWindowFailed,
+ FailedGettingDC,
+ FailedBlitting,
+ FailedFillingBottomRect,
+ CrashedOnce,
+ BadUIDensity,
+ Unknown,
+};
+
+inline const wchar_t* GetPreXULSkeletonUIErrorString(
+ PreXULSkeletonUIError error) {
+ switch (error) {
+ case PreXULSkeletonUIError::None:
+ return L"None";
+ case PreXULSkeletonUIError::Ineligible:
+ return L"Ineligible";
+ case PreXULSkeletonUIError::Disabled:
+ return L"Disabled";
+ case PreXULSkeletonUIError::OOM:
+ return L"OOM";
+ case PreXULSkeletonUIError::Cmdline:
+ return L"Cmdline";
+ case PreXULSkeletonUIError::EnvVars:
+ return L"EnvVars";
+ case PreXULSkeletonUIError::FailedToOpenRegistryKey:
+ return L"FailedToOpenRegistryKey";
+ case PreXULSkeletonUIError::RegistryError:
+ return L"RegistryError";
+ case PreXULSkeletonUIError::FailedLoadingDynamicProcs:
+ return L"FailedLoadingDynamicProcs";
+ case PreXULSkeletonUIError::FailedGettingLock:
+ return L"FailedGettingLock";
+ case PreXULSkeletonUIError::FilesystemFailure:
+ return L"FilesystemFailure";
+ case PreXULSkeletonUIError::NoStartWithLastProfile:
+ return L"NoStartWithLastProfile";
+ case PreXULSkeletonUIError::FailedRegisteringWindowClass:
+ return L"FailedRegisteringWindowClass";
+ case PreXULSkeletonUIError::CorruptData:
+ return L"CorruptData";
+ case PreXULSkeletonUIError::BadWindowDimensions:
+ return L"BadWindowDimensions";
+ case PreXULSkeletonUIError::FailedGettingMonitorInfo:
+ return L"FailedGettingMonitorInfo";
+ case PreXULSkeletonUIError::EnabledKeyDoesNotExist:
+ return L"EnabledKeyDoesNotExist";
+ case PreXULSkeletonUIError::CreateWindowFailed:
+ return L"CreateWindowFailed";
+ case PreXULSkeletonUIError::FailedGettingDC:
+ return L"FailedGettingDC";
+ case PreXULSkeletonUIError::FailedBlitting:
+ return L"FailedBlitting";
+ case PreXULSkeletonUIError::FailedFillingBottomRect:
+ return L"FailedFillingBottomRect";
+ case PreXULSkeletonUIError::CrashedOnce:
+ return L"CrashedOnce";
+ case PreXULSkeletonUIError::BadUIDensity:
+ return L"BadUIDensity";
+ case PreXULSkeletonUIError::Unknown:
+ return L"Unknown";
+ }
+
+ MOZ_ASSERT_UNREACHABLE();
+ return L"Unknown";
+}
+
+enum class PreXULSkeletonUIProgress : uint32_t {
+ Started,
+ Completed,
+};
+
+MFBT_API void CreateAndStorePreXULSkeletonUI(HINSTANCE hInstance, int argc,
+ char** argv);
+MFBT_API void CleanupProcessRuntime();
+MFBT_API bool GetPreXULSkeletonUIWasShown();
+MFBT_API HWND ConsumePreXULSkeletonUIHandle();
+MFBT_API Maybe<PreXULSkeletonUIError> GetPreXULSkeletonUIErrorReason();
+MFBT_API bool WasPreXULSkeletonUIMaximized();
+MFBT_API Result<Ok, PreXULSkeletonUIError> PersistPreXULSkeletonUIValues(
+ const SkeletonUISettings& settings);
+MFBT_API bool GetPreXULSkeletonUIEnabled();
+MFBT_API Result<Ok, PreXULSkeletonUIError> SetPreXULSkeletonUIEnabledIfAllowed(
+ bool value);
+MFBT_API void PollPreXULSkeletonUIEvents();
+MFBT_API Result<Ok, PreXULSkeletonUIError> SetPreXULSkeletonUIThemeId(
+ ThemeMode theme);
+MFBT_API Result<Ok, PreXULSkeletonUIError> NotePreXULSkeletonUIRestarting();
+
+} // namespace mozilla
+
+#endif
diff --git a/mozglue/misc/Printf.cpp b/mozglue/misc/Printf.cpp
new file mode 100644
index 0000000000..10e06ff51c
--- /dev/null
+++ b/mozglue/misc/Printf.cpp
@@ -0,0 +1,1105 @@
+/* -*- 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/. */
+
+/*
+ * Portable safe sprintf code.
+ *
+ * Author: Kipp E.B. Hickman
+ */
+
+#include "double-conversion/double-to-string.h"
+#include "mozilla/AllocPolicy.h"
+#include "mozilla/Printf.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/Vector.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(XP_WIN)
+# include <windows.h>
+#endif
+
+using double_conversion::DoubleToStringConverter;
+using DTSC = DoubleToStringConverter;
+
+/*
+ * Numbered Argument State
+ */
+struct NumArgState {
+ int type; // type of the current ap
+ va_list ap; // point to the corresponding position on ap
+};
+
+using NumArgStateVector =
+ mozilla::Vector<NumArgState, 20, mozilla::MallocAllocPolicy>;
+
+// For values up to and including TYPE_DOUBLE, the lowest bit indicates
+// whether the type is signed (0) or unsigned (1).
+#define TYPE_SHORT 0
+#define TYPE_USHORT 1
+#define TYPE_INTN 2
+#define TYPE_UINTN 3
+#define TYPE_LONG 4
+#define TYPE_ULONG 5
+#define TYPE_LONGLONG 6
+#define TYPE_ULONGLONG 7
+#define TYPE_DOUBLE 8
+#define TYPE_STRING 9
+#define TYPE_INTSTR 10
+#define TYPE_POINTER 11
+#if defined(XP_WIN)
+# define TYPE_WSTRING 12
+#endif
+#define TYPE_SCHAR 14
+#define TYPE_UCHAR 15
+#define TYPE_UNKNOWN 20
+
+#define FLAG_LEFT 0x1
+#define FLAG_SIGNED 0x2
+#define FLAG_SPACED 0x4
+#define FLAG_ZEROS 0x8
+#define FLAG_NEG 0x10
+
+static const char hex[] = "0123456789abcdef";
+static const char HEX[] = "0123456789ABCDEF";
+
+// Fill into the buffer using the data in src
+bool mozilla::PrintfTarget::fill2(const char* src, int srclen, int width,
+ int flags) {
+ char space = ' ';
+
+ width -= srclen;
+ if (width > 0 && (flags & FLAG_LEFT) == 0) { // Right adjusting
+ if (flags & FLAG_ZEROS) {
+ space = '0';
+ }
+ while (--width >= 0) {
+ if (!emit(&space, 1)) {
+ return false;
+ }
+ }
+ }
+
+ // Copy out the source data
+ if (!emit(src, srclen)) {
+ return false;
+ }
+
+ if (width > 0 && (flags & FLAG_LEFT) != 0) { // Left adjusting
+ while (--width >= 0) {
+ if (!emit(&space, 1)) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+/*
+ * Fill a number. The order is: optional-sign zero-filling conversion-digits
+ */
+bool mozilla::PrintfTarget::fill_n(const char* src, int srclen, int width,
+ int prec, int type, int flags) {
+ int zerowidth = 0;
+ int precwidth = 0;
+ int signwidth = 0;
+ int leftspaces = 0;
+ int rightspaces = 0;
+ int cvtwidth;
+ char sign;
+
+ if ((type & 1) == 0) {
+ if (flags & FLAG_NEG) {
+ sign = '-';
+ signwidth = 1;
+ } else if (flags & FLAG_SIGNED) {
+ sign = '+';
+ signwidth = 1;
+ } else if (flags & FLAG_SPACED) {
+ sign = ' ';
+ signwidth = 1;
+ }
+ }
+ cvtwidth = signwidth + srclen;
+
+ if (prec > 0 && (type != TYPE_DOUBLE)) {
+ if (prec > srclen) {
+ precwidth = prec - srclen; // Need zero filling
+ cvtwidth += precwidth;
+ }
+ }
+
+ if ((flags & FLAG_ZEROS) && ((type == TYPE_DOUBLE) || (prec < 0))) {
+ if (width > cvtwidth) {
+ zerowidth = width - cvtwidth; // Zero filling
+ cvtwidth += zerowidth;
+ }
+ }
+
+ if (flags & FLAG_LEFT) {
+ if (width > cvtwidth) {
+ // Space filling on the right (i.e. left adjusting)
+ rightspaces = width - cvtwidth;
+ }
+ } else {
+ if (width > cvtwidth) {
+ // Space filling on the left (i.e. right adjusting)
+ leftspaces = width - cvtwidth;
+ }
+ }
+ while (--leftspaces >= 0) {
+ if (!emit(" ", 1)) {
+ return false;
+ }
+ }
+ if (signwidth) {
+ if (!emit(&sign, 1)) {
+ return false;
+ }
+ }
+ while (--precwidth >= 0) {
+ if (!emit("0", 1)) {
+ return false;
+ }
+ }
+ while (--zerowidth >= 0) {
+ if (!emit("0", 1)) {
+ return false;
+ }
+ }
+ if (!emit(src, uint32_t(srclen))) {
+ return false;
+ }
+ while (--rightspaces >= 0) {
+ if (!emit(" ", 1)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+// All that the cvt_* functions care about as far as the TYPE_* constants is
+// that the low bit is set to indicate unsigned, or unset to indicate signed.
+// So we don't try to hard to ensure that the passed TYPE_* constant lines
+// up with the actual size of the number being printed here. The main printf
+// code, below, does have to care so that the correct bits are extracted from
+// the varargs list.
+bool mozilla::PrintfTarget::appendIntDec(int32_t num) {
+ int flags = 0;
+ long n = num;
+ if (n < 0) {
+ n = -n;
+ flags |= FLAG_NEG;
+ }
+ return cvt_l(n, -1, -1, 10, TYPE_INTN, flags, hex);
+}
+
+bool mozilla::PrintfTarget::appendIntDec(uint32_t num) {
+ return cvt_l(num, -1, -1, 10, TYPE_UINTN, 0, hex);
+}
+
+bool mozilla::PrintfTarget::appendIntOct(uint32_t num) {
+ return cvt_l(num, -1, -1, 8, TYPE_UINTN, 0, hex);
+}
+
+bool mozilla::PrintfTarget::appendIntHex(uint32_t num) {
+ return cvt_l(num, -1, -1, 16, TYPE_UINTN, 0, hex);
+}
+
+bool mozilla::PrintfTarget::appendIntDec(int64_t num) {
+ int flags = 0;
+ if (num < 0) {
+ num = -num;
+ flags |= FLAG_NEG;
+ }
+ return cvt_ll(num, -1, -1, 10, TYPE_INTN, flags, hex);
+}
+
+bool mozilla::PrintfTarget::appendIntDec(uint64_t num) {
+ return cvt_ll(num, -1, -1, 10, TYPE_UINTN, 0, hex);
+}
+
+bool mozilla::PrintfTarget::appendIntOct(uint64_t num) {
+ return cvt_ll(num, -1, -1, 8, TYPE_UINTN, 0, hex);
+}
+
+bool mozilla::PrintfTarget::appendIntHex(uint64_t num) {
+ return cvt_ll(num, -1, -1, 16, TYPE_UINTN, 0, hex);
+}
+
+/* Convert a long into its printable form. */
+bool mozilla::PrintfTarget::cvt_l(long num, int width, int prec, int radix,
+ int type, int flags, const char* hexp) {
+ char cvtbuf[100];
+ char* cvt;
+ int digits;
+
+ // according to the man page this needs to happen
+ if ((prec == 0) && (num == 0)) {
+ return fill_n("", 0, width, prec, type, flags);
+ }
+
+ // Converting decimal is a little tricky. In the unsigned case we
+ // need to stop when we hit 10 digits. In the signed case, we can
+ // stop when the number is zero.
+ cvt = cvtbuf + sizeof(cvtbuf);
+ digits = 0;
+ while (num) {
+ int digit = (((unsigned long)num) % radix) & 0xF;
+ *--cvt = hexp[digit];
+ digits++;
+ num = (long)(((unsigned long)num) / radix);
+ }
+ if (digits == 0) {
+ *--cvt = '0';
+ digits++;
+ }
+
+ // Now that we have the number converted without its sign, deal with
+ // the sign and zero padding.
+ return fill_n(cvt, digits, width, prec, type, flags);
+}
+
+/* Convert a 64-bit integer into its printable form. */
+bool mozilla::PrintfTarget::cvt_ll(int64_t num, int width, int prec, int radix,
+ int type, int flags, const char* hexp) {
+ // According to the man page, this needs to happen.
+ if (prec == 0 && num == 0) {
+ return fill_n("", 0, width, prec, type, flags);
+ }
+
+ // Converting decimal is a little tricky. In the unsigned case we
+ // need to stop when we hit 10 digits. In the signed case, we can
+ // stop when the number is zero.
+ int64_t rad = int64_t(radix);
+ char cvtbuf[100];
+ char* cvt = cvtbuf + sizeof(cvtbuf);
+ int digits = 0;
+ while (num != 0) {
+ int64_t quot = uint64_t(num) / rad;
+ int64_t rem = uint64_t(num) % rad;
+ int32_t digit = int32_t(rem);
+ *--cvt = hexp[digit & 0xf];
+ digits++;
+ num = quot;
+ }
+ if (digits == 0) {
+ *--cvt = '0';
+ digits++;
+ }
+
+ // Now that we have the number converted without its sign, deal with
+ // the sign and zero padding.
+ return fill_n(cvt, digits, width, prec, type, flags);
+}
+
+template <size_t N>
+constexpr static size_t lengthof(const char (&)[N]) {
+ return N - 1;
+}
+
+// Longest possible output from ToFixed for positive numbers:
+// [0-9]{kMaxFixedDigitsBeforePoint}\.[0-9]{kMaxFixedDigitsAfterPoint}?
+constexpr int FIXED_MAX_CHARS =
+ DTSC::kMaxFixedDigitsBeforePoint + 1 + DTSC::kMaxFixedDigitsAfterPoint;
+
+// Longest possible output from ToExponential:
+// [1-9]\.[0-9]{kMaxExponentialDigits}e[+-][0-9]{1,3}
+// (std::numeric_limits<double>::max() has exponent 308).
+constexpr int EXPONENTIAL_MAX_CHARS =
+ lengthof("1.") + DTSC::kMaxExponentialDigits + lengthof("e+999");
+
+// Longest possible output from ToPrecise:
+// [0-9\.]{kMaxPrecisionDigits+1} or
+// [1-9]\.[0-9]{kMaxPrecisionDigits-1}e[+-][0-9]{1,3}
+constexpr int PRECISE_MAX_CHARS =
+ lengthof("1.") + DTSC::kMaxPrecisionDigits - 1 + lengthof("e+999");
+
+constexpr int DTSC_MAX_CHARS =
+ std::max({FIXED_MAX_CHARS, EXPONENTIAL_MAX_CHARS, PRECISE_MAX_CHARS});
+
+/*
+ * Convert a double precision floating point number into its printable
+ * form.
+ */
+bool mozilla::PrintfTarget::cvt_f(double d, char c, int width, int prec,
+ int flags) {
+ bool lower = islower(c);
+ const char* inf = lower ? "inf" : "INF";
+ const char* nan = lower ? "nan" : "NAN";
+ char e = lower ? 'e' : 'E';
+ DoubleToStringConverter converter(DTSC::UNIQUE_ZERO | DTSC::NO_TRAILING_ZERO |
+ DTSC::EMIT_POSITIVE_EXPONENT_SIGN,
+ inf, nan, e, 0, 0, 4, 0, 2);
+ // Longest of the above cases, plus space for a terminal nul character.
+ char buf[DTSC_MAX_CHARS + 1];
+ double_conversion::StringBuilder builder(buf, sizeof(buf));
+ bool success = false;
+ if (std::signbit(d)) {
+ d = std::abs(d);
+ flags |= FLAG_NEG;
+ }
+ if (!std::isfinite(d)) {
+ flags &= ~FLAG_ZEROS;
+ }
+ // "If the precision is missing, it shall be taken as 6."
+ if (prec < 0) {
+ prec = 6;
+ }
+ switch (c) {
+ case 'e':
+ case 'E':
+ success = converter.ToExponential(d, prec, &builder);
+ break;
+ case 'f':
+ case 'F':
+ success = converter.ToFixed(d, prec, &builder);
+ break;
+ case 'g':
+ case 'G':
+ // "If an explicit precision is zero, it shall be taken as 1."
+ success = converter.ToPrecision(d, prec ? prec : 1, &builder);
+ break;
+ }
+ if (!success) {
+ return false;
+ }
+ int len = builder.position();
+ char* cvt = builder.Finalize();
+ return fill_n(cvt, len, width, prec, TYPE_DOUBLE, flags);
+}
+
+/*
+ * Convert a string into its printable form. "width" is the output
+ * width. "prec" is the maximum number of characters of "s" to output,
+ * where -1 means until NUL.
+ */
+bool mozilla::PrintfTarget::cvt_s(const char* s, int width, int prec,
+ int flags) {
+ if (prec == 0) {
+ return true;
+ }
+ if (!s) {
+ s = "(null)";
+ }
+
+ // Limit string length by precision value
+ int slen = int(strlen(s));
+ if (0 < prec && prec < slen) {
+ slen = prec;
+ }
+
+ // and away we go
+ return fill2(s, slen, width, flags);
+}
+
+/*
+ * BuildArgArray stands for Numbered Argument list Sprintf
+ * for example,
+ * fmp = "%4$i, %2$d, %3s, %1d";
+ * the number must start from 1, and no gap among them
+ */
+static bool BuildArgArray(const char* fmt, va_list ap, NumArgStateVector& nas) {
+ size_t number = 0, cn = 0, i;
+ const char* p;
+ char c;
+
+ // First pass:
+ // Detemine how many legal % I have got, then allocate space.
+
+ p = fmt;
+ i = 0;
+ while ((c = *p++) != 0) {
+ if (c != '%') {
+ continue;
+ }
+ if ((c = *p++) == '%') { // skip %% case
+ continue;
+ }
+
+ while (c != 0) {
+ if (c > '9' || c < '0') {
+ if (c == '$') { // numbered argument case
+ if (i > 0) {
+ MOZ_CRASH("Bad format string");
+ }
+ number++;
+ } else { // non-numbered argument case
+ if (number > 0) {
+ MOZ_CRASH("Bad format string");
+ }
+ i = 1;
+ }
+ break;
+ }
+
+ c = *p++;
+ }
+ }
+
+ if (number == 0) {
+ return true;
+ }
+
+ // Only allow a limited number of arguments.
+ MOZ_RELEASE_ASSERT(number <= 20);
+
+ if (!nas.growByUninitialized(number)) {
+ return false;
+ }
+
+ for (i = 0; i < number; i++) {
+ nas[i].type = TYPE_UNKNOWN;
+ }
+
+ // Second pass:
+ // Set nas[].type.
+
+ p = fmt;
+ while ((c = *p++) != 0) {
+ if (c != '%') {
+ continue;
+ }
+ c = *p++;
+ if (c == '%') {
+ continue;
+ }
+
+ cn = 0;
+ while (c && c != '$') { // should improve error check later
+ cn = cn * 10 + c - '0';
+ c = *p++;
+ }
+
+ if (!c || cn < 1 || cn > number) {
+ MOZ_CRASH("Bad format string");
+ }
+
+ // nas[cn] starts from 0, and make sure nas[cn].type is not assigned.
+ cn--;
+ if (nas[cn].type != TYPE_UNKNOWN) {
+ continue;
+ }
+
+ c = *p++;
+
+ // flags
+ while ((c == '-') || (c == '+') || (c == ' ') || (c == '0')) {
+ c = *p++;
+ }
+
+ // width
+ if (c == '*') {
+ // not supported feature, for the argument is not numbered
+ MOZ_CRASH("Bad format string");
+ }
+
+ while ((c >= '0') && (c <= '9')) {
+ c = *p++;
+ }
+
+ // precision
+ if (c == '.') {
+ c = *p++;
+ if (c == '*') {
+ // not supported feature, for the argument is not numbered
+ MOZ_CRASH("Bad format string");
+ }
+
+ while ((c >= '0') && (c <= '9')) {
+ c = *p++;
+ }
+ }
+
+ // size
+ nas[cn].type = TYPE_INTN;
+ if (c == 'h') {
+ nas[cn].type = TYPE_SHORT;
+ c = *p++;
+ if (c == 'h') {
+ nas[cn].type = TYPE_SCHAR;
+ c = *p++;
+ }
+ } else if (c == 'L') {
+ nas[cn].type = TYPE_LONGLONG;
+ c = *p++;
+ } else if (c == 'l') {
+ nas[cn].type = TYPE_LONG;
+ c = *p++;
+ if (c == 'l') {
+ nas[cn].type = TYPE_LONGLONG;
+ c = *p++;
+ }
+ } else if (c == 'z' || c == 'I') {
+ static_assert(sizeof(size_t) == sizeof(int) ||
+ sizeof(size_t) == sizeof(long) ||
+ sizeof(size_t) == sizeof(long long),
+ "size_t is not one of the expected sizes");
+ nas[cn].type = sizeof(size_t) == sizeof(int) ? TYPE_INTN
+ : sizeof(size_t) == sizeof(long) ? TYPE_LONG
+ : TYPE_LONGLONG;
+ c = *p++;
+ } else if (c == 't') {
+ static_assert(sizeof(ptrdiff_t) == sizeof(int) ||
+ sizeof(ptrdiff_t) == sizeof(long) ||
+ sizeof(ptrdiff_t) == sizeof(long long),
+ "ptrdiff_t is not one of the expected sizes");
+ nas[cn].type = sizeof(ptrdiff_t) == sizeof(int) ? TYPE_INTN
+ : sizeof(ptrdiff_t) == sizeof(long) ? TYPE_LONG
+ : TYPE_LONGLONG;
+ c = *p++;
+ } else if (c == 'j') {
+ static_assert(sizeof(intmax_t) == sizeof(int) ||
+ sizeof(intmax_t) == sizeof(long) ||
+ sizeof(intmax_t) == sizeof(long long),
+ "intmax_t is not one of the expected sizes");
+ nas[cn].type = sizeof(intmax_t) == sizeof(int) ? TYPE_INTN
+ : sizeof(intmax_t) == sizeof(long) ? TYPE_LONG
+ : TYPE_LONGLONG;
+ c = *p++;
+ }
+
+ // format
+ switch (c) {
+ case 'd':
+ case 'c':
+ case 'i':
+ break;
+
+ case 'o':
+ case 'u':
+ case 'x':
+ case 'X':
+ // Mark as unsigned type.
+ nas[cn].type |= 1;
+ break;
+
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'F':
+ case 'g':
+ case 'G':
+ nas[cn].type = TYPE_DOUBLE;
+ break;
+
+ case 'p':
+ nas[cn].type = TYPE_POINTER;
+ break;
+
+ case 'S':
+#if defined(XP_WIN)
+ nas[cn].type = TYPE_WSTRING;
+#else
+ MOZ_ASSERT(0);
+ nas[cn].type = TYPE_UNKNOWN;
+#endif
+ break;
+
+ case 's':
+#if defined(XP_WIN)
+ if (nas[cn].type == TYPE_LONG) {
+ nas[cn].type = TYPE_WSTRING;
+ break;
+ }
+#endif
+ // Other type sizes are not supported here.
+ MOZ_ASSERT(nas[cn].type == TYPE_INTN);
+ nas[cn].type = TYPE_STRING;
+ break;
+
+ case 'n':
+ nas[cn].type = TYPE_INTSTR;
+ break;
+
+ default:
+ MOZ_ASSERT(0);
+ nas[cn].type = TYPE_UNKNOWN;
+ break;
+ }
+
+ // get a legal para.
+ if (nas[cn].type == TYPE_UNKNOWN) {
+ MOZ_CRASH("Bad format string");
+ }
+ }
+
+ // Third pass:
+ // Fill nas[].ap.
+
+ cn = 0;
+ while (cn < number) {
+ // A TYPE_UNKNOWN here means that the format asked for a
+ // positional argument without specifying the meaning of some
+ // earlier argument.
+ MOZ_ASSERT(nas[cn].type != TYPE_UNKNOWN);
+
+ va_copy(nas[cn].ap, ap);
+
+ switch (nas[cn].type) {
+ case TYPE_SCHAR:
+ case TYPE_UCHAR:
+ case TYPE_SHORT:
+ case TYPE_USHORT:
+ case TYPE_INTN:
+ case TYPE_UINTN:
+ (void)va_arg(ap, int);
+ break;
+ case TYPE_LONG:
+ (void)va_arg(ap, long);
+ break;
+ case TYPE_ULONG:
+ (void)va_arg(ap, unsigned long);
+ break;
+ case TYPE_LONGLONG:
+ (void)va_arg(ap, long long);
+ break;
+ case TYPE_ULONGLONG:
+ (void)va_arg(ap, unsigned long long);
+ break;
+ case TYPE_STRING:
+ (void)va_arg(ap, char*);
+ break;
+ case TYPE_INTSTR:
+ (void)va_arg(ap, int*);
+ break;
+ case TYPE_DOUBLE:
+ (void)va_arg(ap, double);
+ break;
+ case TYPE_POINTER:
+ (void)va_arg(ap, void*);
+ break;
+#if defined(XP_WIN)
+ case TYPE_WSTRING:
+ (void)va_arg(ap, wchar_t*);
+ break;
+#endif
+
+ default:
+ MOZ_CRASH();
+ }
+
+ cn++;
+ }
+
+ return true;
+}
+
+mozilla::PrintfTarget::PrintfTarget() : mEmitted(0) {}
+
+bool mozilla::PrintfTarget::vprint(const char* fmt, va_list ap) {
+ char c;
+ int flags, width, prec, radix, type;
+ union {
+ char ch;
+ int i;
+ long l;
+ long long ll;
+ double d;
+ const char* s;
+ int* ip;
+ void* p;
+#if defined(XP_WIN)
+ const wchar_t* ws;
+#endif
+ } u{};
+ const char* hexp;
+ int i;
+
+ // Build an argument array, IF the fmt is numbered argument
+ // list style, to contain the Numbered Argument list pointers.
+
+ NumArgStateVector nas;
+ if (!BuildArgArray(fmt, ap, nas)) {
+ // the fmt contains error Numbered Argument format, jliu@netscape.com
+ MOZ_CRASH("Bad format string");
+ }
+
+ while ((c = *fmt++) != 0) {
+ if (c != '%') {
+ if (!emit(fmt - 1, 1)) {
+ return false;
+ }
+
+ continue;
+ }
+
+ // Gobble up the % format string. Hopefully we have handled all
+ // of the strange cases!
+ flags = 0;
+ c = *fmt++;
+ if (c == '%') {
+ // quoting a % with %%
+ if (!emit(fmt - 1, 1)) {
+ return false;
+ }
+
+ continue;
+ }
+
+ if (!nas.empty()) {
+ // the fmt contains the Numbered Arguments feature
+ i = 0;
+ while (c && c != '$') { // should improve error check later
+ i = (i * 10) + (c - '0');
+ c = *fmt++;
+ }
+
+ if (nas[i - 1].type == TYPE_UNKNOWN) {
+ MOZ_CRASH("Bad format string");
+ }
+
+ ap = nas[i - 1].ap;
+ c = *fmt++;
+ }
+
+ // Examine optional flags. Note that we do not implement the
+ // '#' flag of sprintf(). The ANSI C spec. of the '#' flag is
+ // somewhat ambiguous and not ideal, which is perhaps why
+ // the various sprintf() implementations are inconsistent
+ // on this feature.
+ while ((c == '-') || (c == '+') || (c == ' ') || (c == '0')) {
+ if (c == '-') {
+ flags |= FLAG_LEFT;
+ }
+ if (c == '+') {
+ flags |= FLAG_SIGNED;
+ }
+ if (c == ' ') {
+ flags |= FLAG_SPACED;
+ }
+ if (c == '0') {
+ flags |= FLAG_ZEROS;
+ }
+ c = *fmt++;
+ }
+ if (flags & FLAG_SIGNED) {
+ flags &= ~FLAG_SPACED;
+ }
+ if (flags & FLAG_LEFT) {
+ flags &= ~FLAG_ZEROS;
+ }
+
+ // width
+ if (c == '*') {
+ c = *fmt++;
+ width = va_arg(ap, int);
+ if (width < 0) {
+ width = -width;
+ flags |= FLAG_LEFT;
+ flags &= ~FLAG_ZEROS;
+ }
+ } else {
+ width = 0;
+ while ((c >= '0') && (c <= '9')) {
+ width = (width * 10) + (c - '0');
+ c = *fmt++;
+ }
+ }
+
+ // precision
+ prec = -1;
+ if (c == '.') {
+ c = *fmt++;
+ if (c == '*') {
+ c = *fmt++;
+ prec = va_arg(ap, int);
+ } else {
+ prec = 0;
+ while ((c >= '0') && (c <= '9')) {
+ prec = (prec * 10) + (c - '0');
+ c = *fmt++;
+ }
+ }
+ }
+
+ // size
+ type = TYPE_INTN;
+ if (c == 'h') {
+ type = TYPE_SHORT;
+ c = *fmt++;
+ if (c == 'h') {
+ type = TYPE_SCHAR;
+ c = *fmt++;
+ }
+ } else if (c == 'L') {
+ type = TYPE_LONGLONG;
+ c = *fmt++;
+ } else if (c == 'l') {
+ type = TYPE_LONG;
+ c = *fmt++;
+ if (c == 'l') {
+ type = TYPE_LONGLONG;
+ c = *fmt++;
+ }
+ } else if (c == 'z' || c == 'I') {
+ static_assert(sizeof(size_t) == sizeof(int) ||
+ sizeof(size_t) == sizeof(long) ||
+ sizeof(size_t) == sizeof(long long),
+ "size_t is not one of the expected sizes");
+ type = sizeof(size_t) == sizeof(int) ? TYPE_INTN
+ : sizeof(size_t) == sizeof(long) ? TYPE_LONG
+ : TYPE_LONGLONG;
+ c = *fmt++;
+ } else if (c == 't') {
+ static_assert(sizeof(ptrdiff_t) == sizeof(int) ||
+ sizeof(ptrdiff_t) == sizeof(long) ||
+ sizeof(ptrdiff_t) == sizeof(long long),
+ "ptrdiff_t is not one of the expected sizes");
+ type = sizeof(ptrdiff_t) == sizeof(int) ? TYPE_INTN
+ : sizeof(ptrdiff_t) == sizeof(long) ? TYPE_LONG
+ : TYPE_LONGLONG;
+ c = *fmt++;
+ } else if (c == 'j') {
+ static_assert(sizeof(intmax_t) == sizeof(int) ||
+ sizeof(intmax_t) == sizeof(long) ||
+ sizeof(intmax_t) == sizeof(long long),
+ "intmax_t is not one of the expected sizes");
+ type = sizeof(intmax_t) == sizeof(int) ? TYPE_INTN
+ : sizeof(intmax_t) == sizeof(long) ? TYPE_LONG
+ : TYPE_LONGLONG;
+ c = *fmt++;
+ }
+
+ // format
+ hexp = hex;
+ switch (c) {
+ case 'd':
+ case 'i': // decimal/integer
+ radix = 10;
+ goto fetch_and_convert;
+
+ case 'o': // octal
+ radix = 8;
+ type |= 1;
+ goto fetch_and_convert;
+
+ case 'u': // unsigned decimal
+ radix = 10;
+ type |= 1;
+ goto fetch_and_convert;
+
+ case 'x': // unsigned hex
+ radix = 16;
+ type |= 1;
+ goto fetch_and_convert;
+
+ case 'X': // unsigned HEX
+ radix = 16;
+ hexp = HEX;
+ type |= 1;
+ goto fetch_and_convert;
+
+ fetch_and_convert:
+ switch (type) {
+ case TYPE_SCHAR:
+ u.l = (signed char)va_arg(ap, int);
+ if (u.l < 0) {
+ u.l = -u.l;
+ flags |= FLAG_NEG;
+ }
+ goto do_long;
+ case TYPE_UCHAR:
+ u.l = (unsigned char)va_arg(ap, unsigned int);
+ goto do_long;
+ case TYPE_SHORT:
+ u.l = (short)va_arg(ap, int);
+ if (u.l < 0) {
+ u.l = -u.l;
+ flags |= FLAG_NEG;
+ }
+ goto do_long;
+ case TYPE_USHORT:
+ u.l = (unsigned short)va_arg(ap, unsigned int);
+ goto do_long;
+ case TYPE_INTN:
+ u.l = va_arg(ap, int);
+ if (u.l < 0) {
+ u.l = -u.l;
+ flags |= FLAG_NEG;
+ }
+ goto do_long;
+ case TYPE_UINTN:
+ u.l = (long)va_arg(ap, unsigned int);
+ goto do_long;
+
+ case TYPE_LONG:
+ u.l = va_arg(ap, long);
+ if (u.l < 0) {
+ u.l = -u.l;
+ flags |= FLAG_NEG;
+ }
+ goto do_long;
+ case TYPE_ULONG:
+ u.l = (long)va_arg(ap, unsigned long);
+ do_long:
+ if (!cvt_l(u.l, width, prec, radix, type, flags, hexp)) {
+ return false;
+ }
+
+ break;
+
+ case TYPE_LONGLONG:
+ u.ll = va_arg(ap, long long);
+ if (u.ll < 0) {
+ u.ll = -u.ll;
+ flags |= FLAG_NEG;
+ }
+ goto do_longlong;
+ case TYPE_POINTER:
+ u.ll = (uintptr_t)va_arg(ap, void*);
+ goto do_longlong;
+ case TYPE_ULONGLONG:
+ u.ll = va_arg(ap, unsigned long long);
+ do_longlong:
+ if (!cvt_ll(u.ll, width, prec, radix, type, flags, hexp)) {
+ return false;
+ }
+
+ break;
+ }
+ break;
+
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'F':
+ case 'g':
+ case 'G':
+ u.d = va_arg(ap, double);
+ if (!cvt_f(u.d, c, width, prec, flags)) {
+ return false;
+ }
+
+ break;
+
+ case 'c':
+ if ((flags & FLAG_LEFT) == 0) {
+ while (width-- > 1) {
+ if (!emit(" ", 1)) {
+ return false;
+ }
+ }
+ }
+ switch (type) {
+ case TYPE_SHORT:
+ case TYPE_INTN:
+ u.ch = va_arg(ap, int);
+ if (!emit(&u.ch, 1)) {
+ return false;
+ }
+ break;
+ }
+ if (flags & FLAG_LEFT) {
+ while (width-- > 1) {
+ if (!emit(" ", 1)) {
+ return false;
+ }
+ }
+ }
+ break;
+
+ case 'p':
+ type = TYPE_POINTER;
+ radix = 16;
+ goto fetch_and_convert;
+
+ case 's':
+ if (type == TYPE_INTN) {
+ u.s = va_arg(ap, const char*);
+ if (!cvt_s(u.s, width, prec, flags)) {
+ return false;
+ }
+ break;
+ }
+ MOZ_ASSERT(type == TYPE_LONG);
+ [[fallthrough]];
+ case 'S':
+#if defined(XP_WIN)
+ {
+ u.ws = va_arg(ap, const wchar_t*);
+
+ int rv = WideCharToMultiByte(CP_ACP, 0, u.ws, -1, NULL, 0, NULL, NULL);
+ if (rv == 0 && GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
+ if (!cvt_s("<unicode errors in string>", width, prec, flags)) {
+ return false;
+ }
+ } else {
+ if (rv == 0) {
+ rv = 1;
+ }
+ UniqueFreePtr<char[]> buf((char*)malloc(rv));
+ WideCharToMultiByte(CP_ACP, 0, u.ws, -1, buf.get(), rv, NULL, NULL);
+ buf[rv - 1] = '\0';
+
+ if (!cvt_s(buf.get(), width, prec, flags)) {
+ return false;
+ }
+ }
+ }
+#else
+ // Not supported here.
+ MOZ_ASSERT(0);
+#endif
+ break;
+
+ case 'n':
+ u.ip = va_arg(ap, int*);
+ if (u.ip) {
+ *u.ip = mEmitted;
+ }
+ break;
+
+ default:
+ // Not a % token after all... skip it
+ if (!emit("%", 1)) {
+ return false;
+ }
+ if (!emit(fmt - 1, 1)) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+
+/************************************************************************/
+
+bool mozilla::PrintfTarget::print(const char* format, ...) {
+ va_list ap;
+
+ va_start(ap, format);
+ bool result = vprint(format, ap);
+ va_end(ap);
+ return result;
+}
+
+#undef TYPE_SHORT
+#undef TYPE_USHORT
+#undef TYPE_INTN
+#undef TYPE_UINTN
+#undef TYPE_LONG
+#undef TYPE_ULONG
+#undef TYPE_LONGLONG
+#undef TYPE_ULONGLONG
+#undef TYPE_STRING
+#undef TYPE_DOUBLE
+#undef TYPE_INTSTR
+#undef TYPE_POINTER
+#undef TYPE_WSTRING
+#undef TYPE_UNKNOWN
+#undef TYPE_SCHAR
+#undef TYPE_UCHAR
+
+#undef FLAG_LEFT
+#undef FLAG_SIGNED
+#undef FLAG_SPACED
+#undef FLAG_ZEROS
+#undef FLAG_NEG
diff --git a/mozglue/misc/Printf.h b/mozglue/misc/Printf.h
new file mode 100644
index 0000000000..3f4fa2c1bb
--- /dev/null
+++ b/mozglue/misc/Printf.h
@@ -0,0 +1,266 @@
+/* -*- 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/. */
+
+/* Printf-like functions, with canned variants that malloc their result. */
+
+#ifndef mozilla_Printf_h
+#define mozilla_Printf_h
+
+/*
+** API for PR printf like routines.
+**
+** These exist partly for historical reasons -- initially they were in
+** NSPR, then forked in tree and modified in js/ -- but now the prime
+** motivation is both closer control over the exact formatting (with
+** one exception, see below) and also the ability to control where
+** exactly the generated results are sent.
+**
+** It might seem that this could all be dispensed with in favor of a
+** wrapper around |vsnprintf| -- except that this implementation
+** guarantees that the %s format will accept a NULL pointer, whereas
+** with standard functions this is undefined.
+**
+** This supports the following formats. It implements a subset of the
+** standard formats; due to the use of MOZ_FORMAT_PRINTF, it is not
+** permissible to extend the standard, aside from relaxing undefined
+** behavior.
+**
+** %d - decimal
+** %u - unsigned decimal
+** %x - unsigned hex
+** %X - unsigned uppercase hex
+** %o - unsigned octal
+** %hd, %hu, %hx, %hX, %ho - "short" versions of above
+** %ld, %lu, %lx, %lX, %lo - "long" versions of above
+** %lld, %llu, %llx, %llX, %llo - "long long" versions of above
+** %zd, %zo, %zu, %zx, %zX - size_t versions of above
+** %Id, %Io, %Iu, %Ix, %IX - size_t versions of above (for Windows compat).
+** Note that MSVC 2015 and newer supports the z length modifier so
+** users should prefer using %z instead of %I. We are supporting %I in
+** addition to %z in case third-party code that uses %I gets routed to
+** use this printf implementation.
+** %s - string
+** %S, %ls - wide string, that is wchar_t*
+** %c - character
+** %p - pointer (deals with machine dependent pointer size)
+** %f - float; note that this is actually formatted using the
+** system's native printf, and so the results may vary
+** %g - float; note that this is actually formatted using the
+** system's native printf, and so the results may vary
+*/
+
+#include "mozilla/AllocPolicy.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/Types.h"
+#include "mozilla/UniquePtr.h"
+
+#include <stdarg.h>
+#include <string.h>
+
+namespace mozilla {
+
+/*
+ * This class may be subclassed to provide a way to get the output of
+ * a printf-like call, as the output is generated.
+ */
+class PrintfTarget {
+ public:
+ /* The Printf-like interface. */
+ bool MFBT_API print(const char* format, ...) MOZ_FORMAT_PRINTF(2, 3);
+
+ /* The Vprintf-like interface. */
+ bool MFBT_API vprint(const char* fmt, va_list) MOZ_FORMAT_PRINTF(2, 0);
+
+ /* Fast paths for formatting integers as though by %d, %o, %u, or %x.
+ Since octal and hex formatting always treat numbers as unsigned, there
+ are no signed overloads for AppendInt{Oct,Hex}. */
+ bool MFBT_API appendIntDec(int32_t);
+ bool MFBT_API appendIntDec(uint32_t);
+ bool MFBT_API appendIntOct(uint32_t);
+ bool MFBT_API appendIntHex(uint32_t);
+ bool MFBT_API appendIntDec(int64_t);
+ bool MFBT_API appendIntDec(uint64_t);
+ bool MFBT_API appendIntOct(uint64_t);
+ bool MFBT_API appendIntHex(uint64_t);
+
+ inline size_t emitted() { return mEmitted; }
+
+ protected:
+ MFBT_API PrintfTarget();
+ virtual ~PrintfTarget() = default;
+
+ /* Subclasses override this. It is called when more output is
+ available. It may be called with len==0. This should return
+ true on success, or false on failure. */
+ virtual bool append(const char* sp, size_t len) = 0;
+
+ private:
+ /* Number of bytes emitted so far. */
+ size_t mEmitted;
+
+ /* The implementation calls this to emit bytes and update
+ mEmitted. */
+ bool emit(const char* sp, size_t len) {
+ mEmitted += len;
+ return append(sp, len);
+ }
+
+ bool fill2(const char* src, int srclen, int width, int flags);
+ bool fill_n(const char* src, int srclen, int width, int prec, int type,
+ int flags);
+ bool cvt_l(long num, int width, int prec, int radix, int type, int flags,
+ const char* hexp);
+ bool cvt_ll(int64_t num, int width, int prec, int radix, int type, int flags,
+ const char* hexp);
+ bool cvt_f(double d, char c, int width, int prec, int flags);
+ bool cvt_s(const char* s, int width, int prec, int flags);
+};
+
+namespace detail {
+
+template <typename AllocPolicy = mozilla::MallocAllocPolicy>
+struct AllocPolicyBasedFreePolicy {
+ void operator()(const void* ptr) {
+ AllocPolicy policy;
+ policy.free_(const_cast<void*>(ptr));
+ }
+};
+
+} // namespace detail
+
+// The type returned by Smprintf and friends.
+template <typename AllocPolicy>
+using SmprintfPolicyPointer =
+ mozilla::UniquePtr<char, detail::AllocPolicyBasedFreePolicy<AllocPolicy>>;
+
+// The default type if no alloc policy is specified.
+typedef SmprintfPolicyPointer<mozilla::MallocAllocPolicy> SmprintfPointer;
+
+// Used in the implementation of Smprintf et al.
+template <typename AllocPolicy>
+class MOZ_STACK_CLASS SprintfState final : private mozilla::PrintfTarget,
+ private AllocPolicy {
+ public:
+ explicit SprintfState(char* base)
+ : mMaxlen(base ? strlen(base) : 0),
+ mBase(base),
+ mCur(base ? base + mMaxlen : 0) {}
+
+ ~SprintfState() { this->free_(mBase); }
+
+ bool vprint(const char* format, va_list ap_list) MOZ_FORMAT_PRINTF(2, 0) {
+ // The "" here has a single \0 character, which is what we're
+ // trying to append.
+ return mozilla::PrintfTarget::vprint(format, ap_list) && append("", 1);
+ }
+
+ SmprintfPolicyPointer<AllocPolicy> release() {
+ SmprintfPolicyPointer<AllocPolicy> result(mBase);
+ mBase = nullptr;
+ return result;
+ }
+
+ protected:
+ bool append(const char* sp, size_t len) override {
+ ptrdiff_t off;
+ char* newbase;
+ size_t newlen;
+
+ off = mCur - mBase;
+ if (off + len >= mMaxlen) {
+ /* Grow the buffer */
+ newlen = mMaxlen + ((len > 32) ? len : 32);
+ newbase = this->template maybe_pod_malloc<char>(newlen);
+ if (!newbase) {
+ /* Ran out of memory */
+ return false;
+ }
+ memcpy(newbase, mBase, mMaxlen);
+ this->free_(mBase);
+ mBase = newbase;
+ mMaxlen = newlen;
+ mCur = mBase + off;
+ }
+
+ /* Copy data */
+ memcpy(mCur, sp, len);
+ mCur += len;
+ MOZ_ASSERT(size_t(mCur - mBase) <= mMaxlen);
+ return true;
+ }
+
+ private:
+ size_t mMaxlen;
+ char* mBase;
+ char* mCur;
+};
+
+/*
+** sprintf into a malloc'd buffer. Return a pointer to the malloc'd
+** buffer on success, nullptr on failure. Call AllocPolicy::free_ to release
+** the memory returned.
+*/
+template <typename AllocPolicy = mozilla::MallocAllocPolicy>
+MOZ_FORMAT_PRINTF(1, 2)
+SmprintfPolicyPointer<AllocPolicy> Smprintf(const char* fmt, ...) {
+ SprintfState<AllocPolicy> ss(nullptr);
+ va_list ap;
+ va_start(ap, fmt);
+ bool r = ss.vprint(fmt, ap);
+ va_end(ap);
+ if (!r) {
+ return nullptr;
+ }
+ return ss.release();
+}
+
+/*
+** "append" sprintf into a malloc'd buffer. "last" is the last value of
+** the malloc'd buffer. sprintf will append data to the end of last,
+** growing it as necessary using realloc. If last is nullptr, SmprintfAppend
+** will allocate the initial string. The return value is the new value of
+** last for subsequent calls, or nullptr if there is a malloc failure.
+*/
+template <typename AllocPolicy = mozilla::MallocAllocPolicy>
+MOZ_FORMAT_PRINTF(2, 3)
+SmprintfPolicyPointer<AllocPolicy> SmprintfAppend(
+ SmprintfPolicyPointer<AllocPolicy>&& last, const char* fmt, ...) {
+ SprintfState<AllocPolicy> ss(last.release());
+ va_list ap;
+ va_start(ap, fmt);
+ bool r = ss.vprint(fmt, ap);
+ va_end(ap);
+ if (!r) {
+ return nullptr;
+ }
+ return ss.release();
+}
+
+/*
+** va_list forms of the above.
+*/
+template <typename AllocPolicy = mozilla::MallocAllocPolicy>
+MOZ_FORMAT_PRINTF(1, 0)
+SmprintfPolicyPointer<AllocPolicy> Vsmprintf(const char* fmt, va_list ap) {
+ SprintfState<AllocPolicy> ss(nullptr);
+ if (!ss.vprint(fmt, ap)) return nullptr;
+ return ss.release();
+}
+
+template <typename AllocPolicy = mozilla::MallocAllocPolicy>
+MOZ_FORMAT_PRINTF(2, 0)
+SmprintfPolicyPointer<AllocPolicy> VsmprintfAppend(
+ SmprintfPolicyPointer<AllocPolicy>&& last, const char* fmt, va_list ap) {
+ SprintfState<AllocPolicy> ss(last.release());
+ if (!ss.vprint(fmt, ap)) return nullptr;
+ return ss.release();
+}
+
+} // namespace mozilla
+
+#endif /* mozilla_Printf_h */
diff --git a/mozglue/misc/ProcessType.cpp b/mozglue/misc/ProcessType.cpp
new file mode 100644
index 0000000000..031d242328
--- /dev/null
+++ b/mozglue/misc/ProcessType.cpp
@@ -0,0 +1,58 @@
+/* -*- 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/. */
+
+#include "ProcessType.h"
+
+#include <cstring>
+
+#include "mozilla/Assertions.h"
+
+using namespace mozilla::startup;
+
+namespace mozilla {
+namespace startup {
+GeckoProcessType sChildProcessType = GeckoProcessType_Default;
+} // namespace startup
+
+void SetGeckoProcessType(const char* aProcessTypeString) {
+#if !defined(DEBUG)
+ // If not a DEBUG build then just return if sChildProcessType has already been
+ // set and is not fork server. In DEBUG builds we will check that process type
+ // matches the one already set if it is not fork server.
+ if (sChildProcessType != GeckoProcessType_Default &&
+ sChildProcessType != GeckoProcessType_ForkServer) {
+ return;
+ }
+#endif
+
+#define GECKO_PROCESS_TYPE(enum_value, enum_name, string_name, proc_typename, \
+ process_bin_type, procinfo_typename, \
+ webidl_typename, allcaps_name) \
+ if (std::strcmp(aProcessTypeString, string_name) == 0) { \
+ MOZ_ASSERT_IF( \
+ sChildProcessType != GeckoProcessType_Default && \
+ sChildProcessType != GeckoProcessType_ForkServer, \
+ sChildProcessType == GeckoProcessType::GeckoProcessType_##enum_name); \
+ sChildProcessType = GeckoProcessType::GeckoProcessType_##enum_name; \
+ return; \
+ }
+#define SKIP_PROCESS_TYPE_DEFAULT
+#if !defined(MOZ_ENABLE_FORKSERVER)
+# define SKIP_PROCESS_TYPE_FORKSERVER
+#endif
+#if !defined(ENABLE_TESTS)
+# define SKIP_PROCESS_TYPE_IPDLUNITTEST
+#endif
+#include "mozilla/GeckoProcessTypes.h"
+#undef SKIP_PROCESS_TYPE_IPDLUNITTEST
+#undef SKIP_PROCESS_TYPE_FORKSERVER
+#undef SKIP_PROCESS_TYPE_DEFAULT
+#undef GECKO_PROCESS_TYPE
+
+ MOZ_CRASH("aProcessTypeString is not valid.");
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/ProcessType.h b/mozglue/misc/ProcessType.h
new file mode 100644
index 0000000000..890ed4faac
--- /dev/null
+++ b/mozglue/misc/ProcessType.h
@@ -0,0 +1,44 @@
+/* -*- 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/. */
+
+#ifndef IPC_PROCESSTYPE_H_
+#define IPC_PROCESSTYPE_H_
+
+#include "mozilla/Attributes.h"
+#include "mozilla/Types.h"
+
+// This enum is not dense. See GeckoProcessTypes.h for details.
+enum GeckoProcessType {
+#define GECKO_PROCESS_TYPE(enum_value, enum_name, string_name, proc_typename, \
+ process_bin_type, procinfo_typename, \
+ webidl_typename, allcaps_name) \
+ GeckoProcessType_##enum_name = (enum_value),
+#include "mozilla/GeckoProcessTypes.h"
+#undef GECKO_PROCESS_TYPE
+ GeckoProcessType_End,
+ GeckoProcessType_Invalid = GeckoProcessType_End
+};
+
+namespace mozilla {
+namespace startup {
+extern MFBT_DATA GeckoProcessType sChildProcessType;
+} // namespace startup
+
+/**
+ * @return the GeckoProcessType of the current process.
+ */
+MOZ_ALWAYS_INLINE GeckoProcessType GetGeckoProcessType() {
+ return startup::sChildProcessType;
+}
+
+/**
+ * Set the gecko process type based on a null-terminated byte string.
+ */
+MFBT_API void SetGeckoProcessType(const char* aProcessTypeString);
+
+} // namespace mozilla
+
+#endif // IPC_PROCESSTYPE_H_
diff --git a/mozglue/misc/RWLock_posix.cpp b/mozglue/misc/RWLock_posix.cpp
new file mode 100644
index 0000000000..970bddd1aa
--- /dev/null
+++ b/mozglue/misc/RWLock_posix.cpp
@@ -0,0 +1,64 @@
+/* -*- 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/. */
+
+#ifdef XP_WIN
+# error This file should only be compiled on non-Windows platforms.
+#endif
+
+#include "mozilla/PlatformRWLock.h"
+
+#include "mozilla/Assertions.h"
+
+#include <errno.h>
+
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+mozilla::detail::RWLockImpl::RWLockImpl() {
+ MOZ_RELEASE_ASSERT(pthread_rwlock_init(&mRWLock, nullptr) == 0,
+ "pthread_rwlock_init failed");
+}
+
+mozilla::detail::RWLockImpl::~RWLockImpl() {
+ MOZ_RELEASE_ASSERT(pthread_rwlock_destroy(&mRWLock) == 0,
+ "pthread_rwlock_destroy failed");
+}
+
+bool mozilla::detail::RWLockImpl::tryReadLock() {
+ int rv = pthread_rwlock_tryrdlock(&mRWLock);
+ // We allow EDEADLK here because it has been observed returned on macos when
+ // the write lock is held by the current thread.
+ MOZ_RELEASE_ASSERT(rv == 0 || rv == EBUSY || rv == EDEADLK,
+ "pthread_rwlock_tryrdlock failed");
+ return rv == 0;
+}
+
+void mozilla::detail::RWLockImpl::readLock() {
+ MOZ_RELEASE_ASSERT(pthread_rwlock_rdlock(&mRWLock) == 0,
+ "pthread_rwlock_rdlock failed");
+}
+
+void mozilla::detail::RWLockImpl::readUnlock() {
+ MOZ_RELEASE_ASSERT(pthread_rwlock_unlock(&mRWLock) == 0,
+ "pthread_rwlock_unlock failed");
+}
+
+bool mozilla::detail::RWLockImpl::tryWriteLock() {
+ int rv = pthread_rwlock_trywrlock(&mRWLock);
+ // We allow EDEADLK here because it has been observed returned on macos when
+ // the write lock is held by the current thread.
+ MOZ_RELEASE_ASSERT(rv == 0 || rv == EBUSY || rv == EDEADLK,
+ "pthread_rwlock_trywrlock failed");
+ return rv == 0;
+}
+
+void mozilla::detail::RWLockImpl::writeLock() {
+ MOZ_RELEASE_ASSERT(pthread_rwlock_wrlock(&mRWLock) == 0,
+ "pthread_rwlock_wrlock failed");
+}
+
+void mozilla::detail::RWLockImpl::writeUnlock() {
+ MOZ_RELEASE_ASSERT(pthread_rwlock_unlock(&mRWLock) == 0,
+ "pthread_rwlock_unlock failed");
+}
diff --git a/mozglue/misc/RWLock_windows.cpp b/mozglue/misc/RWLock_windows.cpp
new file mode 100644
index 0000000000..2c347f218c
--- /dev/null
+++ b/mozglue/misc/RWLock_windows.cpp
@@ -0,0 +1,48 @@
+/* -*- 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/. */
+
+#ifndef XP_WIN
+# error This file should only be compiled on Windows.
+#endif
+
+#include "mozilla/PlatformRWLock.h"
+
+#include <windows.h>
+
+#define NativeHandle(m) (reinterpret_cast<SRWLOCK*>(&m))
+
+mozilla::detail::RWLockImpl::RWLockImpl() {
+ static_assert(sizeof(SRWLOCK) <= sizeof(mRWLock), "SRWLOCK is too big!");
+ InitializeSRWLock(NativeHandle(mRWLock));
+}
+
+mozilla::detail::RWLockImpl::~RWLockImpl() {}
+
+bool mozilla::detail::RWLockImpl::tryReadLock() {
+ return TryAcquireSRWLockShared(NativeHandle(mRWLock));
+}
+
+void mozilla::detail::RWLockImpl::readLock() {
+ AcquireSRWLockShared(NativeHandle(mRWLock));
+}
+
+void mozilla::detail::RWLockImpl::readUnlock() {
+ ReleaseSRWLockShared(NativeHandle(mRWLock));
+}
+
+bool mozilla::detail::RWLockImpl::tryWriteLock() {
+ return TryAcquireSRWLockExclusive(NativeHandle(mRWLock));
+}
+
+void mozilla::detail::RWLockImpl::writeLock() {
+ AcquireSRWLockExclusive(NativeHandle(mRWLock));
+}
+
+void mozilla::detail::RWLockImpl::writeUnlock() {
+ ReleaseSRWLockExclusive(NativeHandle(mRWLock));
+}
+
+#undef NativeHandle
diff --git a/mozglue/misc/RuntimeExceptionModule.cpp b/mozglue/misc/RuntimeExceptionModule.cpp
new file mode 100644
index 0000000000..6b7e55c5e9
--- /dev/null
+++ b/mozglue/misc/RuntimeExceptionModule.cpp
@@ -0,0 +1,111 @@
+/* -*- 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/. */
+
+#include "RuntimeExceptionModule.h"
+
+#include <cstdint>
+
+#include "mozilla/ProcessType.h"
+
+#if defined(XP_WIN)
+# include <windows.h>
+# if defined(__MINGW32__) || defined(__MINGW64__)
+// Add missing constants and types for mingw builds
+# define HREPORT HANDLE
+# define PWER_SUBMIT_RESULT WER_SUBMIT_RESULT*
+# define WER_MAX_PREFERRED_MODULES_BUFFER (256)
+# endif // defined(__MINGW32__) || defined(__MINGW64__)
+# include <werapi.h> // For WerRegisterRuntimeExceptionModule()
+# include <stdlib.h>
+
+# include "mozilla/mozalloc_oom.h"
+# include "mozilla/Unused.h"
+
+using mozilla::Unused;
+#endif
+
+namespace CrashReporter {
+
+#ifdef XP_WIN
+
+struct InProcessWindowsErrorReportingData {
+ uint32_t mProcessType;
+ size_t* mOOMAllocationSizePtr;
+};
+
+static InProcessWindowsErrorReportingData gInProcessWerData;
+const static size_t kModulePathLength = MAX_PATH + 1;
+static wchar_t sModulePath[kModulePathLength];
+
+bool GetRuntimeExceptionModulePath(wchar_t* aPath, const size_t aLength) {
+ const wchar_t* kModuleName = L"mozwer.dll";
+ DWORD res = ::GetModuleFileNameW(nullptr, aPath, aLength);
+ if ((res > 0) && (res != aLength)) {
+ wchar_t* last_backslash = wcsrchr(aPath, L'\\');
+ if (last_backslash) {
+ *(last_backslash + 1) = L'\0';
+ if (wcscat_s(aPath, aLength, kModuleName) == 0) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+#endif // XP_WIN
+
+void RegisterRuntimeExceptionModule() {
+#ifdef XP_WIN
+# if defined(DEBUG)
+ // In debug builds, disable the crash reporter by default, and allow to
+ // enable it with the MOZ_CRASHREPORTER environment variable.
+ const char* envvar = getenv("MOZ_CRASHREPORTER");
+ if (!envvar || !*envvar) {
+ return;
+ }
+# else
+ // In other builds, enable the crash reporter by default, and allow
+ // disabling it with the MOZ_CRASHREPORTER_DISABLE environment variable.
+ const char* envvar = getenv("MOZ_CRASHREPORTER_DISABLE");
+ if (envvar && *envvar) {
+ return;
+ }
+# endif
+
+ // If sModulePath is set we have already registerd the module.
+ if (*sModulePath) {
+ return;
+ }
+
+ // If we fail to get the path just return.
+ if (!GetRuntimeExceptionModulePath(sModulePath, kModulePathLength)) {
+ return;
+ }
+
+ gInProcessWerData.mProcessType = mozilla::GetGeckoProcessType();
+ gInProcessWerData.mOOMAllocationSizePtr = &gOOMAllocationSize;
+ if (FAILED(::WerRegisterRuntimeExceptionModule(sModulePath,
+ &gInProcessWerData))) {
+ // The registration failed null out sModulePath to record this.
+ *sModulePath = L'\0';
+ return;
+ }
+#endif // XP_WIN
+}
+
+void UnregisterRuntimeExceptionModule() {
+#ifdef XP_WIN
+ // If sModulePath is set then we have registered the module.
+ if (*sModulePath) {
+ Unused << ::WerUnregisterRuntimeExceptionModule(sModulePath,
+ &gInProcessWerData);
+ *sModulePath = L'\0';
+ }
+#endif // XP_WIN
+}
+
+} // namespace CrashReporter
diff --git a/mozglue/misc/RuntimeExceptionModule.h b/mozglue/misc/RuntimeExceptionModule.h
new file mode 100644
index 0000000000..47468e4f36
--- /dev/null
+++ b/mozglue/misc/RuntimeExceptionModule.h
@@ -0,0 +1,20 @@
+/* -*- 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/. */
+
+#ifndef RUNTIMEEXCEPTIONMODULE_H_
+#define RUNTIMEEXCEPTIONMODULE_H_
+
+#include "mozilla/Types.h"
+
+namespace CrashReporter {
+
+MFBT_API void RegisterRuntimeExceptionModule();
+
+MFBT_API void UnregisterRuntimeExceptionModule();
+
+} // namespace CrashReporter
+
+#endif // RUNTIMEEXCEPTIONMODULE_H_
diff --git a/mozglue/misc/SIMD.cpp b/mozglue/misc/SIMD.cpp
new file mode 100644
index 0000000000..3893de57b3
--- /dev/null
+++ b/mozglue/misc/SIMD.cpp
@@ -0,0 +1,565 @@
+/* -*- 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/. */
+
+#include "mozilla/SIMD.h"
+
+#include <cstring>
+#include <stdint.h>
+#include <type_traits>
+
+#include "mozilla/EndianUtils.h"
+#include "mozilla/SSE.h"
+
+#ifdef MOZILLA_PRESUME_SSE2
+
+# include <immintrin.h>
+
+#endif
+
+namespace mozilla {
+
+template <typename TValue>
+const TValue* FindInBufferNaive(const TValue* ptr, TValue value,
+ size_t length) {
+ const TValue* end = ptr + length;
+ while (ptr < end) {
+ if (*ptr == value) {
+ return ptr;
+ }
+ ptr++;
+ }
+ return nullptr;
+}
+
+#ifdef MOZILLA_PRESUME_SSE2
+
+const __m128i* Cast128(uintptr_t ptr) {
+ return reinterpret_cast<const __m128i*>(ptr);
+}
+
+template <typename T>
+T GetAs(uintptr_t ptr) {
+ return *reinterpret_cast<const T*>(ptr);
+}
+
+// Akin to ceil/floor, AlignDown/AlignUp will return the original pointer if it
+// is already aligned.
+uintptr_t AlignDown16(uintptr_t ptr) { return ptr & ~0xf; }
+
+uintptr_t AlignUp16(uintptr_t ptr) { return AlignDown16(ptr + 0xf); }
+
+template <typename TValue>
+__m128i CmpEq128(__m128i a, __m128i b) {
+ static_assert(sizeof(TValue) == 1 || sizeof(TValue) == 2);
+ if (sizeof(TValue) == 1) {
+ return _mm_cmpeq_epi8(a, b);
+ }
+ return _mm_cmpeq_epi16(a, b);
+}
+
+# ifdef __GNUC__
+
+// Earlier versions of GCC are missing the _mm_loadu_si32 instruction. This
+// workaround from Peter Cordes (https://stackoverflow.com/a/72837992) compiles
+// down to the same instructions. We could just replace _mm_loadu_si32
+__m128i Load32BitsIntoXMM(uintptr_t ptr) {
+ int tmp;
+ memcpy(&tmp, reinterpret_cast<const void*>(ptr),
+ sizeof(tmp)); // unaligned aliasing-safe load
+ return _mm_cvtsi32_si128(tmp); // efficient on GCC/clang/MSVC
+}
+
+# else
+
+__m128i Load32BitsIntoXMM(uintptr_t ptr) {
+ return _mm_loadu_si32(Cast128(ptr));
+}
+
+# endif
+
+const char* Check4x4Chars(__m128i needle, uintptr_t a, uintptr_t b, uintptr_t c,
+ uintptr_t d) {
+ __m128i haystackA = Load32BitsIntoXMM(a);
+ __m128i cmpA = CmpEq128<char>(needle, haystackA);
+ __m128i haystackB = Load32BitsIntoXMM(b);
+ __m128i cmpB = CmpEq128<char>(needle, haystackB);
+ __m128i haystackC = Load32BitsIntoXMM(c);
+ __m128i cmpC = CmpEq128<char>(needle, haystackC);
+ __m128i haystackD = Load32BitsIntoXMM(d);
+ __m128i cmpD = CmpEq128<char>(needle, haystackD);
+ __m128i or_ab = _mm_or_si128(cmpA, cmpB);
+ __m128i or_cd = _mm_or_si128(cmpC, cmpD);
+ __m128i or_abcd = _mm_or_si128(or_ab, or_cd);
+ int orMask = _mm_movemask_epi8(or_abcd);
+ if (orMask & 0xf) {
+ int cmpMask;
+ cmpMask = _mm_movemask_epi8(cmpA);
+ if (cmpMask & 0xf) {
+ return reinterpret_cast<const char*>(a + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpB);
+ if (cmpMask & 0xf) {
+ return reinterpret_cast<const char*>(b + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpC);
+ if (cmpMask & 0xf) {
+ return reinterpret_cast<const char*>(c + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpD);
+ if (cmpMask & 0xf) {
+ return reinterpret_cast<const char*>(d + __builtin_ctz(cmpMask));
+ }
+ }
+
+ return nullptr;
+}
+
+template <typename TValue>
+const TValue* Check4x16Bytes(__m128i needle, uintptr_t a, uintptr_t b,
+ uintptr_t c, uintptr_t d) {
+ __m128i haystackA = _mm_loadu_si128(Cast128(a));
+ __m128i cmpA = CmpEq128<TValue>(needle, haystackA);
+ __m128i haystackB = _mm_loadu_si128(Cast128(b));
+ __m128i cmpB = CmpEq128<TValue>(needle, haystackB);
+ __m128i haystackC = _mm_loadu_si128(Cast128(c));
+ __m128i cmpC = CmpEq128<TValue>(needle, haystackC);
+ __m128i haystackD = _mm_loadu_si128(Cast128(d));
+ __m128i cmpD = CmpEq128<TValue>(needle, haystackD);
+ __m128i or_ab = _mm_or_si128(cmpA, cmpB);
+ __m128i or_cd = _mm_or_si128(cmpC, cmpD);
+ __m128i or_abcd = _mm_or_si128(or_ab, or_cd);
+ int orMask = _mm_movemask_epi8(or_abcd);
+ if (orMask) {
+ int cmpMask;
+ cmpMask = _mm_movemask_epi8(cmpA);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(a + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpB);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(b + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpC);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(c + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpD);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(d + __builtin_ctz(cmpMask));
+ }
+ }
+
+ return nullptr;
+}
+
+enum class HaystackOverlap {
+ Overlapping,
+ Sequential,
+};
+
+// Check two 16-byte chunks for the two-byte sequence loaded into needle1
+// followed by needle1. `carryOut` is an optional pointer which we will
+// populate based on whether the last character of b matches needle1. This
+// should be provided on subsequent calls via `carryIn` so we can detect cases
+// where the last byte of b's 16-byte chunk is needle1 and the first byte of
+// the next a's 16-byte chunk is needle2. `overlap` and whether
+// `carryIn`/`carryOut` are NULL should be knowable at compile time to avoid
+// branching.
+template <typename TValue>
+const TValue* Check2x2x16Bytes(__m128i needle1, __m128i needle2, uintptr_t a,
+ uintptr_t b, __m128i* carryIn, __m128i* carryOut,
+ HaystackOverlap overlap) {
+ const int shiftRightAmount = 16 - sizeof(TValue);
+ const int shiftLeftAmount = sizeof(TValue);
+ __m128i haystackA = _mm_loadu_si128(Cast128(a));
+ __m128i cmpA1 = CmpEq128<TValue>(needle1, haystackA);
+ __m128i cmpA2 = CmpEq128<TValue>(needle2, haystackA);
+ __m128i cmpA;
+ if (carryIn) {
+ cmpA = _mm_and_si128(
+ _mm_or_si128(_mm_bslli_si128(cmpA1, shiftLeftAmount), *carryIn), cmpA2);
+ } else {
+ cmpA = _mm_and_si128(_mm_bslli_si128(cmpA1, shiftLeftAmount), cmpA2);
+ }
+ __m128i haystackB = _mm_loadu_si128(Cast128(b));
+ __m128i cmpB1 = CmpEq128<TValue>(needle1, haystackB);
+ __m128i cmpB2 = CmpEq128<TValue>(needle2, haystackB);
+ __m128i cmpB;
+ if (overlap == HaystackOverlap::Overlapping) {
+ cmpB = _mm_and_si128(_mm_bslli_si128(cmpB1, shiftLeftAmount), cmpB2);
+ } else {
+ MOZ_ASSERT(overlap == HaystackOverlap::Sequential);
+ __m128i carryAB = _mm_bsrli_si128(cmpA1, shiftRightAmount);
+ cmpB = _mm_and_si128(
+ _mm_or_si128(_mm_bslli_si128(cmpB1, shiftLeftAmount), carryAB), cmpB2);
+ }
+ __m128i or_ab = _mm_or_si128(cmpA, cmpB);
+ int orMask = _mm_movemask_epi8(or_ab);
+ if (orMask) {
+ int cmpMask;
+ cmpMask = _mm_movemask_epi8(cmpA);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(a + __builtin_ctz(cmpMask) -
+ shiftLeftAmount);
+ }
+ cmpMask = _mm_movemask_epi8(cmpB);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(b + __builtin_ctz(cmpMask) -
+ shiftLeftAmount);
+ }
+ }
+
+ if (carryOut) {
+ _mm_store_si128(carryOut, _mm_bsrli_si128(cmpB1, shiftRightAmount));
+ }
+
+ return nullptr;
+}
+
+template <typename TValue>
+const TValue* FindInBuffer(const TValue* ptr, TValue value, size_t length) {
+ static_assert(sizeof(TValue) == 1 || sizeof(TValue) == 2);
+ static_assert(std::is_unsigned<TValue>::value);
+ uint64_t splat64;
+ if (sizeof(TValue) == 1) {
+ splat64 = 0x0101010101010101llu;
+ } else {
+ splat64 = 0x0001000100010001llu;
+ }
+
+ // Load our needle into a 16-byte register
+ uint64_t u64_value = static_cast<uint64_t>(value) * splat64;
+ int64_t i64_value = *reinterpret_cast<int64_t*>(&u64_value);
+ __m128i needle = _mm_set_epi64x(i64_value, i64_value);
+
+ size_t numBytes = length * sizeof(TValue);
+ uintptr_t cur = reinterpret_cast<uintptr_t>(ptr);
+ uintptr_t end = cur + numBytes;
+
+ if ((sizeof(TValue) > 1 && numBytes < 16) || numBytes < 4) {
+ while (cur < end) {
+ if (GetAs<TValue>(cur) == value) {
+ return reinterpret_cast<const TValue*>(cur);
+ }
+ cur += sizeof(TValue);
+ }
+ return nullptr;
+ }
+
+ if (numBytes < 16) {
+ // NOTE: here and below, we have some bit fiddling which could look a
+ // little weird. The important thing to note though is it's just a trick
+ // for getting the number 4 if numBytes is greater than or equal to 8,
+ // and 0 otherwise. This lets us fully cover the range without any
+ // branching for the case where numBytes is in [4,8), and [8,16). We get
+ // four ranges from this - if numbytes > 8, we get:
+ // [0,4), [4,8], [end - 8), [end - 4)
+ // and if numbytes < 8, we get
+ // [0,4), [0,4), [end - 4), [end - 4)
+ uintptr_t a = cur;
+ uintptr_t b = cur + ((numBytes & 8) >> 1);
+ uintptr_t c = end - 4 - ((numBytes & 8) >> 1);
+ uintptr_t d = end - 4;
+ const char* charResult = Check4x4Chars(needle, a, b, c, d);
+ // Note: we ensure above that sizeof(TValue) == 1 here, so this is
+ // either char to char or char to something like a uint8_t.
+ return reinterpret_cast<const TValue*>(charResult);
+ }
+
+ if (numBytes < 64) {
+ // NOTE: see the above explanation of the similar chunk of code, but in
+ // this case, replace 8 with 32 and 4 with 16.
+ uintptr_t a = cur;
+ uintptr_t b = cur + ((numBytes & 32) >> 1);
+ uintptr_t c = end - 16 - ((numBytes & 32) >> 1);
+ uintptr_t d = end - 16;
+ return Check4x16Bytes<TValue>(needle, a, b, c, d);
+ }
+
+ // Get the initial unaligned load out of the way. This will overlap with the
+ // aligned stuff below, but the overlapped part should effectively be free
+ // (relative to a mispredict from doing a byte-by-byte loop).
+ __m128i haystack = _mm_loadu_si128(Cast128(cur));
+ __m128i cmp = CmpEq128<TValue>(needle, haystack);
+ int cmpMask = _mm_movemask_epi8(cmp);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(cur + __builtin_ctz(cmpMask));
+ }
+
+ // Now we're working with aligned memory. Hooray! \o/
+ cur = AlignUp16(cur);
+
+ // The address of the final 48-63 bytes. We overlap this with what we check in
+ // our hot loop below to avoid branching. Again, the overlap should be
+ // negligible compared with a branch mispredict.
+ uintptr_t tailStartPtr = AlignDown16(end - 48);
+ uintptr_t tailEndPtr = end - 16;
+
+ while (cur < tailStartPtr) {
+ uintptr_t a = cur;
+ uintptr_t b = cur + 16;
+ uintptr_t c = cur + 32;
+ uintptr_t d = cur + 48;
+ const TValue* result = Check4x16Bytes<TValue>(needle, a, b, c, d);
+ if (result) {
+ return result;
+ }
+ cur += 64;
+ }
+
+ uintptr_t a = tailStartPtr;
+ uintptr_t b = tailStartPtr + 16;
+ uintptr_t c = tailStartPtr + 32;
+ uintptr_t d = tailEndPtr;
+ return Check4x16Bytes<TValue>(needle, a, b, c, d);
+}
+
+template <typename TValue>
+const TValue* TwoElementLoop(uintptr_t start, uintptr_t end, TValue v1,
+ TValue v2) {
+ static_assert(sizeof(TValue) == 1 || sizeof(TValue) == 2);
+
+ const TValue* cur = reinterpret_cast<const TValue*>(start);
+ const TValue* preEnd = reinterpret_cast<const TValue*>(end - sizeof(TValue));
+
+ uint32_t expected = static_cast<uint32_t>(v1) |
+ (static_cast<uint32_t>(v2) << (sizeof(TValue) * 8));
+ while (cur < preEnd) {
+ // NOTE: this should only ever be called on little endian architectures.
+ static_assert(MOZ_LITTLE_ENDIAN());
+ // We or cur[0] and cur[1] together explicitly and compare to expected,
+ // in order to avoid UB from just loading them as a uint16_t/uint32_t.
+ // However, it will compile down the same code after optimizations on
+ // little endian systems which support unaligned loads. Comparing them
+ // value-by-value, however, will not, and seems to perform worse in local
+ // microbenchmarking. Even after bitwise or'ing the comparison values
+ // together to avoid the short circuit, the compiler doesn't seem to get
+ // the hint and creates two branches, the first of which might be
+ // frequently mispredicted.
+ uint32_t actual = static_cast<uint32_t>(cur[0]) |
+ (static_cast<uint32_t>(cur[1]) << (sizeof(TValue) * 8));
+ if (actual == expected) {
+ return cur;
+ }
+ cur++;
+ }
+ return nullptr;
+}
+
+template <typename TValue>
+const TValue* FindTwoInBuffer(const TValue* ptr, TValue v1, TValue v2,
+ size_t length) {
+ static_assert(sizeof(TValue) == 1 || sizeof(TValue) == 2);
+ static_assert(std::is_unsigned<TValue>::value);
+ uint64_t splat64;
+ if (sizeof(TValue) == 1) {
+ splat64 = 0x0101010101010101llu;
+ } else {
+ splat64 = 0x0001000100010001llu;
+ }
+
+ // Load our needle into a 16-byte register
+ uint64_t u64_v1 = static_cast<uint64_t>(v1) * splat64;
+ int64_t i64_v1 = *reinterpret_cast<int64_t*>(&u64_v1);
+ __m128i needle1 = _mm_set_epi64x(i64_v1, i64_v1);
+ uint64_t u64_v2 = static_cast<uint64_t>(v2) * splat64;
+ int64_t i64_v2 = *reinterpret_cast<int64_t*>(&u64_v2);
+ __m128i needle2 = _mm_set_epi64x(i64_v2, i64_v2);
+
+ size_t numBytes = length * sizeof(TValue);
+ uintptr_t cur = reinterpret_cast<uintptr_t>(ptr);
+ uintptr_t end = cur + numBytes;
+
+ if (numBytes < 16) {
+ return TwoElementLoop<TValue>(cur, end, v1, v2);
+ }
+
+ if (numBytes < 32) {
+ uintptr_t a = cur;
+ uintptr_t b = end - 16;
+ return Check2x2x16Bytes<TValue>(needle1, needle2, a, b, nullptr, nullptr,
+ HaystackOverlap::Overlapping);
+ }
+
+ // Get the initial unaligned load out of the way. This will likely overlap
+ // with the aligned stuff below, but the overlapped part should effectively
+ // be free.
+ __m128i haystack = _mm_loadu_si128(Cast128(cur));
+ __m128i cmp1 = CmpEq128<TValue>(needle1, haystack);
+ __m128i cmp2 = CmpEq128<TValue>(needle2, haystack);
+ int cmpMask1 = _mm_movemask_epi8(cmp1);
+ int cmpMask2 = _mm_movemask_epi8(cmp2);
+ int cmpMask = (cmpMask1 << sizeof(TValue)) & cmpMask2;
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(cur + __builtin_ctz(cmpMask) -
+ sizeof(TValue));
+ }
+
+ // Now we're working with aligned memory. Hooray! \o/
+ cur = AlignUp16(cur);
+
+ // The address of the final 48-63 bytes. We overlap this with what we check in
+ // our hot loop below to avoid branching. Again, the overlap should be
+ // negligible compared with a branch mispredict.
+ uintptr_t tailEndPtr = end - 16;
+ uintptr_t tailStartPtr = AlignDown16(tailEndPtr);
+
+ __m128i cmpMaskCarry = _mm_set1_epi32(0);
+ while (cur < tailStartPtr) {
+ uintptr_t a = cur;
+ uintptr_t b = cur + 16;
+ const TValue* result =
+ Check2x2x16Bytes<TValue>(needle1, needle2, a, b, &cmpMaskCarry,
+ &cmpMaskCarry, HaystackOverlap::Sequential);
+ if (result) {
+ return result;
+ }
+ cur += 32;
+ }
+
+ uint32_t carry = (cur == tailStartPtr) ? 0xffffffff : 0;
+ __m128i wideCarry = Load32BitsIntoXMM(reinterpret_cast<uintptr_t>(&carry));
+ cmpMaskCarry = _mm_and_si128(cmpMaskCarry, wideCarry);
+ uintptr_t a = tailStartPtr;
+ uintptr_t b = tailEndPtr;
+ return Check2x2x16Bytes<TValue>(needle1, needle2, a, b, &cmpMaskCarry,
+ nullptr, HaystackOverlap::Overlapping);
+}
+
+const char* SIMD::memchr8SSE2(const char* ptr, char value, size_t length) {
+ // Signed chars are just really annoying to do bit logic with. Convert to
+ // unsigned at the outermost scope so we don't have to worry about it.
+ const unsigned char* uptr = reinterpret_cast<const unsigned char*>(ptr);
+ unsigned char uvalue = static_cast<unsigned char>(value);
+ const unsigned char* uresult =
+ FindInBuffer<unsigned char>(uptr, uvalue, length);
+ return reinterpret_cast<const char*>(uresult);
+}
+
+// So, this is a bit awkward. It generally simplifies things if we can just
+// assume all the AVX2 code is 64-bit, so we have this preprocessor guard
+// in SIMD_avx2 over all of its actual code, and it also defines versions
+// of its endpoints that just assert false if the guard is not satisfied.
+// A 32 bit processor could implement the AVX2 instruction set though, which
+// would result in it passing the supports_avx2() check and landing in an
+// assertion failure. Accordingly, we just don't allow that to happen. We
+// are not particularly concerned about ensuring that newer 32 bit processors
+// get access to the AVX2 functions exposed here.
+# if defined(MOZILLA_MAY_SUPPORT_AVX2) && defined(__x86_64__)
+
+bool SupportsAVX2() { return supports_avx2(); }
+
+# else
+
+bool SupportsAVX2() { return false; }
+
+# endif
+
+const char* SIMD::memchr8(const char* ptr, char value, size_t length) {
+ if (SupportsAVX2()) {
+ return memchr8AVX2(ptr, value, length);
+ }
+ return memchr8SSE2(ptr, value, length);
+}
+
+const char16_t* SIMD::memchr16SSE2(const char16_t* ptr, char16_t value,
+ size_t length) {
+ return FindInBuffer<char16_t>(ptr, value, length);
+}
+
+const char16_t* SIMD::memchr16(const char16_t* ptr, char16_t value,
+ size_t length) {
+ if (SupportsAVX2()) {
+ return memchr16AVX2(ptr, value, length);
+ }
+ return memchr16SSE2(ptr, value, length);
+}
+
+const uint64_t* SIMD::memchr64(const uint64_t* ptr, uint64_t value,
+ size_t length) {
+ if (SupportsAVX2()) {
+ return memchr64AVX2(ptr, value, length);
+ }
+ return FindInBufferNaive<uint64_t>(ptr, value, length);
+}
+
+const char* SIMD::memchr2x8(const char* ptr, char v1, char v2, size_t length) {
+ // Signed chars are just really annoying to do bit logic with. Convert to
+ // unsigned at the outermost scope so we don't have to worry about it.
+ const unsigned char* uptr = reinterpret_cast<const unsigned char*>(ptr);
+ unsigned char uv1 = static_cast<unsigned char>(v1);
+ unsigned char uv2 = static_cast<unsigned char>(v2);
+ const unsigned char* uresult =
+ FindTwoInBuffer<unsigned char>(uptr, uv1, uv2, length);
+ return reinterpret_cast<const char*>(uresult);
+}
+
+const char16_t* SIMD::memchr2x16(const char16_t* ptr, char16_t v1, char16_t v2,
+ size_t length) {
+ return FindTwoInBuffer<char16_t>(ptr, v1, v2, length);
+}
+
+#else
+
+const char* SIMD::memchr8(const char* ptr, char value, size_t length) {
+ const void* result = ::memchr(reinterpret_cast<const void*>(ptr),
+ static_cast<int>(value), length);
+ return reinterpret_cast<const char*>(result);
+}
+
+const char* SIMD::memchr8SSE2(const char* ptr, char value, size_t length) {
+ return memchr8(ptr, value, length);
+}
+
+const char16_t* SIMD::memchr16(const char16_t* ptr, char16_t value,
+ size_t length) {
+ return FindInBufferNaive<char16_t>(ptr, value, length);
+}
+
+const char16_t* SIMD::memchr16SSE2(const char16_t* ptr, char16_t value,
+ size_t length) {
+ return memchr16(ptr, value, length);
+}
+
+const uint64_t* SIMD::memchr64(const uint64_t* ptr, uint64_t value,
+ size_t length) {
+ return FindInBufferNaive<uint64_t>(ptr, value, length);
+}
+
+const char* SIMD::memchr2x8(const char* ptr, char v1, char v2, size_t length) {
+ const char* end = ptr + length - 1;
+ while (ptr < end) {
+ ptr = memchr8(ptr, v1, end - ptr);
+ if (!ptr) {
+ return nullptr;
+ }
+ if (ptr[1] == v2) {
+ return ptr;
+ }
+ ptr++;
+ }
+ return nullptr;
+}
+
+const char16_t* SIMD::memchr2x16(const char16_t* ptr, char16_t v1, char16_t v2,
+ size_t length) {
+ const char16_t* end = ptr + length - 1;
+ while (ptr < end) {
+ ptr = memchr16(ptr, v1, end - ptr);
+ if (!ptr) {
+ return nullptr;
+ }
+ if (ptr[1] == v2) {
+ return ptr;
+ }
+ ptr++;
+ }
+ return nullptr;
+}
+
+#endif
+
+} // namespace mozilla
diff --git a/mozglue/misc/SIMD.h b/mozglue/misc/SIMD.h
new file mode 100644
index 0000000000..3d17185656
--- /dev/null
+++ b/mozglue/misc/SIMD.h
@@ -0,0 +1,81 @@
+/* -*- 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/. */
+
+#ifndef mozilla_SIMD_h
+#define mozilla_SIMD_h
+
+#include "mozilla/Types.h"
+
+namespace mozilla {
+// A collection of SIMD-implemented algorithms. Some of these exist in the CRT.
+// However, the quality of the C runtime implementation varies wildly across
+// platforms, so these should at least ensure consistency.
+//
+// NOTE: these are currently only implemented with hand-written SIMD for x86
+// and AMD64 platforms, and fallback to the the C runtime or naive loops on
+// other architectures. Please consider this before switching an already
+// optimized loop to these helpers.
+class SIMD {
+ public:
+ // NOTE: for memchr we have a goofy void* signature just to be an easy drop
+ // in replacement for the CRT version. We also give memchr8 which is just a
+ // typed version of memchr.
+ static const void* memchr(const void* ptr, int value, size_t num) {
+ return memchr8(reinterpret_cast<const char*>(ptr), static_cast<char>(value),
+ num);
+ }
+
+ // Search through `ptr[0..length]` for the first occurrence of `value` and
+ // return the pointer to it, or nullptr if it cannot be found.
+ static MFBT_API const char* memchr8(const char* ptr, char value,
+ size_t length);
+
+ // This function just restricts our execution to the SSE2 path
+ static MFBT_API const char* memchr8SSE2(const char* ptr, char value,
+ size_t length);
+
+ // This function just restricts our execution to the AVX2 path
+ static MFBT_API const char* memchr8AVX2(const char* ptr, char value,
+ size_t length);
+
+ // Search through `ptr[0..length]` for the first occurrence of `value` and
+ // return the pointer to it, or nullptr if it cannot be found.
+ static MFBT_API const char16_t* memchr16(const char16_t* ptr, char16_t value,
+ size_t length);
+
+ // This function just restricts our execution to the SSE2 path
+ static MFBT_API const char16_t* memchr16SSE2(const char16_t* ptr,
+ char16_t value, size_t length);
+
+ // This function just restricts our execution to the AVX2 path
+ static MFBT_API const char16_t* memchr16AVX2(const char16_t* ptr,
+ char16_t value, size_t length);
+
+ // Search through `ptr[0..length]` for the first occurrence of `value` and
+ // return the pointer to it, or nullptr if it cannot be found.
+ static MFBT_API const uint64_t* memchr64(const uint64_t* ptr, uint64_t value,
+ size_t length);
+
+ // This function just restricts our execution to the AVX2 path
+ static MFBT_API const uint64_t* memchr64AVX2(const uint64_t* ptr,
+ uint64_t value, size_t length);
+
+ // Search through `ptr[0..length]` for the first occurrence of `v1` which is
+ // immediately followed by `v2` and return the pointer to the occurrence of
+ // `v1`.
+ static MFBT_API const char* memchr2x8(const char* ptr, char v1, char v2,
+ size_t length);
+
+ // Search through `ptr[0..length]` for the first occurrence of `v1` which is
+ // immediately followed by `v2` and return the pointer to the occurrence of
+ // `v1`.
+ static MFBT_API const char16_t* memchr2x16(const char16_t* ptr, char16_t v1,
+ char16_t v2, size_t length);
+};
+
+} // namespace mozilla
+
+#endif // mozilla_SIMD_h
diff --git a/mozglue/misc/SIMD_avx2.cpp b/mozglue/misc/SIMD_avx2.cpp
new file mode 100644
index 0000000000..a1467c7a55
--- /dev/null
+++ b/mozglue/misc/SIMD_avx2.cpp
@@ -0,0 +1,294 @@
+/* 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/. */
+
+#include "mozilla/SIMD.h"
+
+#include "mozilla/SSE.h"
+#include "mozilla/Assertions.h"
+
+// Restricting to x86_64 simplifies things, and we're not particularly
+// worried about slightly degraded performance on 32 bit processors which
+// support AVX2, as this should be quite a minority.
+#if defined(MOZILLA_MAY_SUPPORT_AVX2) && defined(__x86_64__)
+
+# include <cstring>
+# include <immintrin.h>
+# include <stdint.h>
+# include <type_traits>
+
+# include "mozilla/EndianUtils.h"
+
+namespace mozilla {
+
+const __m256i* Cast256(uintptr_t ptr) {
+ return reinterpret_cast<const __m256i*>(ptr);
+}
+
+template <typename T>
+T GetAs(uintptr_t ptr) {
+ return *reinterpret_cast<const T*>(ptr);
+}
+
+uintptr_t AlignDown32(uintptr_t ptr) { return ptr & ~0x1f; }
+
+uintptr_t AlignUp32(uintptr_t ptr) { return AlignDown32(ptr + 0x1f); }
+
+template <typename TValue>
+__m128i CmpEq128(__m128i a, __m128i b) {
+ static_assert(sizeof(TValue) == 1 || sizeof(TValue) == 2);
+ if (sizeof(TValue) == 1) {
+ return _mm_cmpeq_epi8(a, b);
+ }
+ return _mm_cmpeq_epi16(a, b);
+}
+
+template <typename TValue>
+__m256i CmpEq256(__m256i a, __m256i b) {
+ static_assert(sizeof(TValue) == 1 || sizeof(TValue) == 2 ||
+ sizeof(TValue) == 8);
+ if (sizeof(TValue) == 1) {
+ return _mm256_cmpeq_epi8(a, b);
+ }
+ if (sizeof(TValue) == 2) {
+ return _mm256_cmpeq_epi16(a, b);
+ }
+
+ return _mm256_cmpeq_epi64(a, b);
+}
+
+# if defined(__GNUC__) && !defined(__clang__)
+
+// See the comment in SIMD.cpp over Load32BitsIntoXMM. This is just adapted
+// from that workaround. Testing this, it also yields the correct instructions
+// across all tested compilers.
+__m128i Load64BitsIntoXMM(uintptr_t ptr) {
+ int64_t tmp;
+ memcpy(&tmp, reinterpret_cast<const void*>(ptr), sizeof(tmp));
+ return _mm_cvtsi64_si128(tmp);
+}
+
+# else
+
+__m128i Load64BitsIntoXMM(uintptr_t ptr) {
+ return _mm_loadu_si64(reinterpret_cast<const __m128i*>(ptr));
+}
+
+# endif
+
+template <typename TValue>
+const TValue* Check4x8Bytes(__m128i needle, uintptr_t a, uintptr_t b,
+ uintptr_t c, uintptr_t d) {
+ __m128i haystackA = Load64BitsIntoXMM(a);
+ __m128i cmpA = CmpEq128<TValue>(needle, haystackA);
+ __m128i haystackB = Load64BitsIntoXMM(b);
+ __m128i cmpB = CmpEq128<TValue>(needle, haystackB);
+ __m128i haystackC = Load64BitsIntoXMM(c);
+ __m128i cmpC = CmpEq128<TValue>(needle, haystackC);
+ __m128i haystackD = Load64BitsIntoXMM(d);
+ __m128i cmpD = CmpEq128<TValue>(needle, haystackD);
+ __m128i or_ab = _mm_or_si128(cmpA, cmpB);
+ __m128i or_cd = _mm_or_si128(cmpC, cmpD);
+ __m128i or_abcd = _mm_or_si128(or_ab, or_cd);
+ int orMask = _mm_movemask_epi8(or_abcd);
+ if (orMask & 0xff) {
+ int cmpMask;
+ cmpMask = _mm_movemask_epi8(cmpA);
+ if (cmpMask & 0xff) {
+ return reinterpret_cast<const TValue*>(a + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpB);
+ if (cmpMask & 0xff) {
+ return reinterpret_cast<const TValue*>(b + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpC);
+ if (cmpMask & 0xff) {
+ return reinterpret_cast<const TValue*>(c + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm_movemask_epi8(cmpD);
+ if (cmpMask & 0xff) {
+ return reinterpret_cast<const TValue*>(d + __builtin_ctz(cmpMask));
+ }
+ }
+
+ return nullptr;
+}
+
+template <typename TValue>
+const TValue* Check4x32Bytes(__m256i needle, uintptr_t a, uintptr_t b,
+ uintptr_t c, uintptr_t d) {
+ __m256i haystackA = _mm256_loadu_si256(Cast256(a));
+ __m256i cmpA = CmpEq256<TValue>(needle, haystackA);
+ __m256i haystackB = _mm256_loadu_si256(Cast256(b));
+ __m256i cmpB = CmpEq256<TValue>(needle, haystackB);
+ __m256i haystackC = _mm256_loadu_si256(Cast256(c));
+ __m256i cmpC = CmpEq256<TValue>(needle, haystackC);
+ __m256i haystackD = _mm256_loadu_si256(Cast256(d));
+ __m256i cmpD = CmpEq256<TValue>(needle, haystackD);
+ __m256i or_ab = _mm256_or_si256(cmpA, cmpB);
+ __m256i or_cd = _mm256_or_si256(cmpC, cmpD);
+ __m256i or_abcd = _mm256_or_si256(or_ab, or_cd);
+ int orMask = _mm256_movemask_epi8(or_abcd);
+ if (orMask) {
+ int cmpMask;
+ cmpMask = _mm256_movemask_epi8(cmpA);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(a + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm256_movemask_epi8(cmpB);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(b + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm256_movemask_epi8(cmpC);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(c + __builtin_ctz(cmpMask));
+ }
+ cmpMask = _mm256_movemask_epi8(cmpD);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(d + __builtin_ctz(cmpMask));
+ }
+ }
+
+ return nullptr;
+}
+
+template <typename TValue>
+const TValue* FindInBufferAVX2(const TValue* ptr, TValue value, size_t length) {
+ static_assert(sizeof(TValue) == 1 || sizeof(TValue) == 2 ||
+ sizeof(TValue) == 8);
+ static_assert(std::is_unsigned<TValue>::value);
+
+ // Load our needle into a 32-byte register
+ __m256i needle;
+ if (sizeof(TValue) == 1) {
+ needle = _mm256_set1_epi8(value);
+ } else if (sizeof(TValue) == 2) {
+ needle = _mm256_set1_epi16(value);
+ } else {
+ needle = _mm256_set1_epi64x(value);
+ }
+
+ size_t numBytes = length * sizeof(TValue);
+ uintptr_t cur = reinterpret_cast<uintptr_t>(ptr);
+ uintptr_t end = cur + numBytes;
+
+ if (numBytes < 8 || (sizeof(TValue) == 8 && numBytes < 32)) {
+ while (cur < end) {
+ if (GetAs<TValue>(cur) == value) {
+ return reinterpret_cast<const TValue*>(cur);
+ }
+ cur += sizeof(TValue);
+ }
+ return nullptr;
+ }
+
+ if constexpr (sizeof(TValue) != 8) {
+ if (numBytes < 32) {
+ __m128i needle_narrow;
+ if (sizeof(TValue) == 1) {
+ needle_narrow = _mm_set1_epi8(value);
+ } else {
+ needle_narrow = _mm_set1_epi16(value);
+ }
+ uintptr_t a = cur;
+ uintptr_t b = cur + ((numBytes & 16) >> 1);
+ uintptr_t c = end - 8 - ((numBytes & 16) >> 1);
+ uintptr_t d = end - 8;
+ return Check4x8Bytes<TValue>(needle_narrow, a, b, c, d);
+ }
+ }
+
+ if (numBytes < 128) {
+ // NOTE: here and below, we have some bit fiddling which could look a
+ // little weird. The important thing to note though is it's just a trick
+ // for getting the number 32 if numBytes is greater than or equal to 64,
+ // and 0 otherwise. This lets us fully cover the range without any
+ // branching for the case where numBytes is in [32,64), and [64,128). We get
+ // four ranges from this - if numbytes > 64, we get:
+ // [0,32), [32,64], [end - 64), [end - 32)
+ // and if numbytes < 64, we get
+ // [0,32), [0,32), [end - 32), [end - 32)
+ uintptr_t a = cur;
+ uintptr_t b = cur + ((numBytes & 64) >> 1);
+ uintptr_t c = end - 32 - ((numBytes & 64) >> 1);
+ uintptr_t d = end - 32;
+ return Check4x32Bytes<TValue>(needle, a, b, c, d);
+ }
+
+ // Get the initial unaligned load out of the way. This will overlap with the
+ // aligned stuff below, but the overlapped part should effectively be free
+ // (relative to a mispredict from doing a byte-by-byte loop).
+ __m256i haystack = _mm256_loadu_si256(Cast256(cur));
+ __m256i cmp = CmpEq256<TValue>(needle, haystack);
+ int cmpMask = _mm256_movemask_epi8(cmp);
+ if (cmpMask) {
+ return reinterpret_cast<const TValue*>(cur + __builtin_ctz(cmpMask));
+ }
+
+ // Now we're working with aligned memory. Hooray! \o/
+ cur = AlignUp32(cur);
+
+ uintptr_t tailStartPtr = AlignDown32(end - 96);
+ uintptr_t tailEndPtr = end - 32;
+
+ while (cur < tailStartPtr) {
+ uintptr_t a = cur;
+ uintptr_t b = cur + 32;
+ uintptr_t c = cur + 64;
+ uintptr_t d = cur + 96;
+ const TValue* result = Check4x32Bytes<TValue>(needle, a, b, c, d);
+ if (result) {
+ return result;
+ }
+ cur += 128;
+ }
+
+ uintptr_t a = tailStartPtr;
+ uintptr_t b = tailStartPtr + 32;
+ uintptr_t c = tailStartPtr + 64;
+ uintptr_t d = tailEndPtr;
+ return Check4x32Bytes<TValue>(needle, a, b, c, d);
+}
+
+const char* SIMD::memchr8AVX2(const char* ptr, char value, size_t length) {
+ const unsigned char* uptr = reinterpret_cast<const unsigned char*>(ptr);
+ unsigned char uvalue = static_cast<unsigned char>(value);
+ const unsigned char* uresult =
+ FindInBufferAVX2<unsigned char>(uptr, uvalue, length);
+ return reinterpret_cast<const char*>(uresult);
+}
+
+const char16_t* SIMD::memchr16AVX2(const char16_t* ptr, char16_t value,
+ size_t length) {
+ return FindInBufferAVX2<char16_t>(ptr, value, length);
+}
+
+const uint64_t* SIMD::memchr64AVX2(const uint64_t* ptr, uint64_t value,
+ size_t length) {
+ return FindInBufferAVX2<uint64_t>(ptr, value, length);
+}
+
+} // namespace mozilla
+
+#else
+
+namespace mozilla {
+
+const char* SIMD::memchr8AVX2(const char* ptr, char value, size_t length) {
+ MOZ_RELEASE_ASSERT(false, "AVX2 not supported in this binary.");
+}
+
+const char16_t* SIMD::memchr16AVX2(const char16_t* ptr, char16_t value,
+ size_t length) {
+ MOZ_RELEASE_ASSERT(false, "AVX2 not supported in this binary.");
+}
+
+const uint64_t* SIMD::memchr64AVX2(const uint64_t* ptr, uint64_t value,
+ size_t length) {
+ MOZ_RELEASE_ASSERT(false, "AVX2 not supported in this binary.");
+}
+
+} // namespace mozilla
+
+#endif
diff --git a/mozglue/misc/SSE.cpp b/mozglue/misc/SSE.cpp
new file mode 100644
index 0000000000..ca0b4c3c86
--- /dev/null
+++ b/mozglue/misc/SSE.cpp
@@ -0,0 +1,202 @@
+/* vim: set shiftwidth=4 tabstop=8 autoindent cindent expandtab: */
+/* 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/. */
+
+/* compile-time and runtime tests for whether to use SSE instructions */
+
+#include "SSE.h"
+
+#ifdef HAVE_CPUID_H
+// cpuid.h is available on gcc 4.3 and higher on i386 and x86_64
+# include <cpuid.h>
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64))
+// MSVC 2005 or newer on x86-32 or x86-64
+# include <intrin.h>
+#endif
+
+namespace {
+
+// SSE.h has parallel #ifs which declare MOZILLA_SSE_HAVE_CPUID_DETECTION.
+// We can't declare these functions in the header file, however, because
+// <intrin.h> conflicts with <windows.h> on MSVC 2005, and some files want to
+// include both SSE.h and <windows.h>.
+
+#ifdef HAVE_CPUID_H
+
+enum CPUIDRegister { eax = 0, ebx = 1, ecx = 2, edx = 3 };
+
+static bool has_cpuid_bits(unsigned int level, CPUIDRegister reg,
+ unsigned int bits) {
+ unsigned int regs[4];
+ unsigned int eax, ebx, ecx, edx;
+ unsigned max = __get_cpuid_max(level & 0x80000000u, nullptr);
+ if (level > max) return false;
+ __cpuid_count(level, 0, eax, ebx, ecx, edx);
+ regs[0] = eax;
+ regs[1] = ebx;
+ regs[2] = ecx;
+ regs[3] = edx;
+ return (regs[reg] & bits) == bits;
+}
+
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64))
+
+enum CPUIDRegister { eax = 0, ebx = 1, ecx = 2, edx = 3 };
+
+static bool has_cpuid_bits(unsigned int level, CPUIDRegister reg,
+ unsigned int bits) {
+ // Check that the level in question is supported.
+ int regs[4];
+ __cpuid(regs, level & 0x80000000u);
+ if (unsigned(regs[0]) < level) return false;
+
+ // "The __cpuid intrinsic clears the ECX register before calling the cpuid
+ // instruction."
+ __cpuid(regs, level);
+ return (unsigned(regs[reg]) & bits) == bits;
+}
+
+#elif (defined(__GNUC__) || defined(__SUNPRO_CC)) && \
+ (defined(__i386) || defined(__x86_64__))
+
+enum CPUIDRegister { eax = 0, ebx = 1, ecx = 2, edx = 3 };
+
+# ifdef __i386
+static void moz_cpuid(int CPUInfo[4], int InfoType) {
+ asm("xchg %esi, %ebx\n"
+ "xor %ecx, %ecx\n" // ecx is the sub-leaf (we only ever need 0)
+ "cpuid\n"
+ "movl %eax, (%edi)\n"
+ "movl %ebx, 4(%edi)\n"
+ "movl %ecx, 8(%edi)\n"
+ "movl %edx, 12(%edi)\n"
+ "xchg %esi, %ebx\n"
+ :
+ : "a"(InfoType), // %eax
+ "D"(CPUInfo) // %edi
+ : "%ecx", "%edx", "%esi");
+}
+# else
+static void moz_cpuid(int CPUInfo[4], int InfoType) {
+ asm("xchg %rsi, %rbx\n"
+ "xor %ecx, %ecx\n" // ecx is the sub-leaf (we only ever need 0)
+ "cpuid\n"
+ "movl %eax, (%rdi)\n"
+ "movl %ebx, 4(%rdi)\n"
+ "movl %ecx, 8(%rdi)\n"
+ "movl %edx, 12(%rdi)\n"
+ "xchg %rsi, %rbx\n"
+ :
+ : "a"(InfoType), // %eax
+ "D"(CPUInfo) // %rdi
+ : "%ecx", "%edx", "%rsi");
+}
+# endif
+
+static bool has_cpuid_bits(unsigned int level, CPUIDRegister reg,
+ unsigned int bits) {
+ // Check that the level in question is supported.
+ volatile int regs[4];
+ moz_cpuid((int*)regs, level & 0x80000000u);
+ if (unsigned(regs[0]) < level) return false;
+
+ moz_cpuid((int*)regs, level);
+ return (unsigned(regs[reg]) & bits) == bits;
+}
+
+#endif // end CPUID declarations
+
+} // namespace
+
+namespace mozilla {
+
+namespace sse_private {
+
+#if defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+
+# if !defined(MOZILLA_PRESUME_MMX)
+bool mmx_enabled = has_cpuid_bits(1u, edx, (1u << 23));
+# endif
+
+# if !defined(MOZILLA_PRESUME_SSE)
+bool sse_enabled = has_cpuid_bits(1u, edx, (1u << 25));
+# endif
+
+# if !defined(MOZILLA_PRESUME_SSE2)
+bool sse2_enabled = has_cpuid_bits(1u, edx, (1u << 26));
+# endif
+
+# if !defined(MOZILLA_PRESUME_SSE3)
+bool sse3_enabled = has_cpuid_bits(1u, ecx, (1u << 0));
+# endif
+
+# if !defined(MOZILLA_PRESUME_SSSE3)
+bool ssse3_enabled = has_cpuid_bits(1u, ecx, (1u << 9));
+# endif
+
+# if !defined(MOZILLA_PRESUME_SSE4A)
+bool sse4a_enabled = has_cpuid_bits(0x80000001u, ecx, (1u << 6));
+# endif
+
+# if !defined(MOZILLA_PRESUME_SSE4_1)
+bool sse4_1_enabled = has_cpuid_bits(1u, ecx, (1u << 19));
+# endif
+
+# if !defined(MOZILLA_PRESUME_SSE4_2)
+bool sse4_2_enabled = has_cpuid_bits(1u, ecx, (1u << 20));
+# endif
+
+# if !defined(MOZILLA_PRESUME_FMA3)
+bool fma3_enabled = has_cpuid_bits(1u, ecx, (1u << 12));
+# endif
+
+# if !defined(MOZILLA_PRESUME_AVX) || !defined(MOZILLA_PRESUME_AVX2)
+static bool has_avx() {
+# if defined(MOZILLA_PRESUME_AVX)
+ return true;
+# else
+ const unsigned AVX = 1u << 28;
+ const unsigned OSXSAVE = 1u << 27;
+ const unsigned XSAVE = 1u << 26;
+
+ const unsigned XMM_STATE = 1u << 1;
+ const unsigned YMM_STATE = 1u << 2;
+ const unsigned AVX_STATE = XMM_STATE | YMM_STATE;
+
+ return has_cpuid_bits(1u, ecx, AVX | OSXSAVE | XSAVE) &&
+ // ensure the OS supports XSAVE of YMM registers
+ (xgetbv(0) & AVX_STATE) == AVX_STATE;
+# endif // MOZILLA_PRESUME_AVX
+}
+# endif // !MOZILLA_PRESUME_AVX || !MOZILLA_PRESUME_AVX2
+
+# if !defined(MOZILLA_PRESUME_AVX)
+bool avx_enabled = has_avx();
+# endif
+
+# if !defined(MOZILLA_PRESUME_AVX2)
+bool avx2_enabled = has_avx() && has_cpuid_bits(7u, ebx, (1u << 5));
+# endif
+
+# if !defined(MOZILLA_PRESUME_AES)
+bool aes_enabled = has_cpuid_bits(1u, ecx, (1u << 25));
+# endif
+
+bool has_constant_tsc = has_cpuid_bits(0x80000007u, edx, (1u << 8));
+
+#endif
+
+} // namespace sse_private
+
+#ifdef HAVE_CPUID_H
+
+uint64_t xgetbv(uint32_t xcr) {
+ uint32_t eax, edx;
+ __asm__(".byte 0x0f, 0x01, 0xd0" : "=a"(eax), "=d"(edx) : "c"(xcr));
+ return (uint64_t)(edx) << 32 | eax;
+}
+
+#endif
+
+} // namespace mozilla
diff --git a/mozglue/misc/SSE.h b/mozglue/misc/SSE.h
new file mode 100644
index 0000000000..0b87366a80
--- /dev/null
+++ b/mozglue/misc/SSE.h
@@ -0,0 +1,371 @@
+/* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
+/* 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/. */
+
+/* compile-time and runtime tests for whether to use SSE instructions */
+
+#ifndef mozilla_SSE_h_
+#define mozilla_SSE_h_
+
+// for definition of MFBT_DATA
+#include "mozilla/Types.h"
+
+/**
+ * The public interface of this header consists of a set of macros and
+ * functions for Intel CPU features.
+ *
+ * DETECTING ISA EXTENSIONS
+ * ========================
+ *
+ * This header provides the following functions for determining whether the
+ * current CPU supports a particular instruction set extension:
+ *
+ * mozilla::supports_mmx
+ * mozilla::supports_sse
+ * mozilla::supports_sse2
+ * mozilla::supports_sse3
+ * mozilla::supports_ssse3
+ * mozilla::supports_sse4a
+ * mozilla::supports_sse4_1
+ * mozilla::supports_sse4_2
+ * mozilla::supports_avx
+ * mozilla::supports_avx2
+ * mozilla::supports_aes
+ * mozilla::has_constant_tsc
+ *
+ * If you're writing code using inline assembly, you should guard it with a
+ * call to one of these functions. For instance:
+ *
+ * if (mozilla::supports_sse2()) {
+ * asm(" ... ");
+ * }
+ * else {
+ * ...
+ * }
+ *
+ * Note that these functions depend on cpuid intrinsics only available in gcc
+ * 4.3 or later and MSVC 8.0 (Visual C++ 2005) or later, so they return false
+ * in older compilers. (This could be fixed by replacing the code with inline
+ * assembly.)
+ *
+ *
+ * USING INTRINSICS
+ * ================
+ *
+ * This header also provides support for coding using CPU intrinsics.
+ *
+ * For each mozilla::supports_abc function, we define a MOZILLA_MAY_SUPPORT_ABC
+ * macro which indicates that the target/compiler combination we're using is
+ * compatible with the ABC extension. For instance, x86_64 with MSVC 2003 is
+ * compatible with SSE2 but not SSE3, since although there exist x86_64 CPUs
+ * with SSE3 support, MSVC 2003 only supports through SSE2.
+ *
+ * Until gcc fixes #pragma target [1] [2] or our x86 builds require SSE2,
+ * you'll need to separate code using intrinsics into a file separate from your
+ * regular code. Here's the recommended pattern:
+ *
+ * #ifdef MOZILLA_MAY_SUPPORT_ABC
+ * namespace mozilla {
+ * namespace ABC {
+ * void foo();
+ * }
+ * }
+ * #endif
+ *
+ * void foo() {
+ * #ifdef MOZILLA_MAY_SUPPORT_ABC
+ * if (mozilla::supports_abc()) {
+ * mozilla::ABC::foo(); // in a separate file
+ * return;
+ * }
+ * #endif
+ *
+ * foo_unvectorized();
+ * }
+ *
+ * You'll need to define mozilla::ABC::foo() in a separate file and add the
+ * -mabc flag when using gcc.
+ *
+ * [1] http://gcc.gnu.org/bugzilla/show_bug.cgi?id=39787 and
+ * [2] http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41201 being fixed.
+ *
+ */
+
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+
+# ifdef __MMX__
+// It's ok to use MMX instructions based on the -march option (or
+// the default for x86_64 or for Intel Mac).
+# define MOZILLA_PRESUME_MMX 1
+# endif
+# ifdef __SSE__
+// It's ok to use SSE instructions based on the -march option (or
+// the default for x86_64 or for Intel Mac).
+# define MOZILLA_PRESUME_SSE 1
+# endif
+# ifdef __SSE2__
+// It's ok to use SSE2 instructions based on the -march option (or
+// the default for x86_64 or for Intel Mac).
+# define MOZILLA_PRESUME_SSE2 1
+# endif
+# ifdef __SSE3__
+// It's ok to use SSE3 instructions based on the -march option (or the
+// default for Intel Mac).
+# define MOZILLA_PRESUME_SSE3 1
+# endif
+# ifdef __SSSE3__
+// It's ok to use SSSE3 instructions based on the -march option.
+# define MOZILLA_PRESUME_SSSE3 1
+# endif
+# ifdef __SSE4A__
+// It's ok to use SSE4A instructions based on the -march option.
+# define MOZILLA_PRESUME_SSE4A 1
+# endif
+# ifdef __SSE4_1__
+// It's ok to use SSE4.1 instructions based on the -march option.
+# define MOZILLA_PRESUME_SSE4_1 1
+# endif
+# ifdef __SSE4_2__
+// It's ok to use SSE4.2 instructions based on the -march option.
+# define MOZILLA_PRESUME_SSE4_2 1
+# endif
+# ifdef __AVX__
+// It's ok to use AVX instructions based on the -march option.
+# define MOZILLA_PRESUME_AVX 1
+# endif
+# ifdef __AVX2__
+// It's ok to use AVX instructions based on the -march option.
+# define MOZILLA_PRESUME_AVX2 1
+# endif
+# ifdef __AES__
+// It's ok to use AES instructions based on the -march option.
+# define MOZILLA_PRESUME_AES 1
+# endif
+
+# ifdef HAVE_CPUID_H
+# define MOZILLA_SSE_HAVE_CPUID_DETECTION
+# endif
+
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64))
+
+# define MOZILLA_SSE_HAVE_CPUID_DETECTION
+
+# if defined(_M_IX86_FP)
+
+# if _M_IX86_FP >= 1
+// It's ok to use SSE instructions based on the /arch option
+# define MOZILLA_PRESUME_SSE
+# endif
+# if _M_IX86_FP >= 2
+// It's ok to use SSE2 instructions based on the /arch option
+# define MOZILLA_PRESUME_SSE2
+# endif
+
+# elif defined(_M_AMD64)
+// MSVC for AMD64 doesn't support MMX, so don't presume it here.
+
+// SSE is always available on AMD64.
+# define MOZILLA_PRESUME_SSE
+// SSE2 is always available on AMD64.
+# define MOZILLA_PRESUME_SSE2
+# endif
+
+#elif defined(__SUNPRO_CC) && (defined(__i386) || defined(__x86_64__))
+// Sun Studio on x86 or amd64
+
+# define MOZILLA_SSE_HAVE_CPUID_DETECTION
+
+# if defined(__x86_64__)
+// MMX is always available on AMD64.
+# define MOZILLA_PRESUME_MMX
+// SSE is always available on AMD64.
+# define MOZILLA_PRESUME_SSE
+// SSE2 is always available on AMD64.
+# define MOZILLA_PRESUME_SSE2
+# endif
+
+#endif
+
+namespace mozilla {
+
+namespace sse_private {
+#if defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# if !defined(MOZILLA_PRESUME_MMX)
+extern bool MFBT_DATA mmx_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_SSE)
+extern bool MFBT_DATA sse_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_SSE2)
+extern bool MFBT_DATA sse2_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_SSE3)
+extern bool MFBT_DATA sse3_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_SSSE3)
+extern bool MFBT_DATA ssse3_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_SSE4A)
+extern bool MFBT_DATA sse4a_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_SSE4_1)
+extern bool MFBT_DATA sse4_1_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_SSE4_2)
+extern bool MFBT_DATA sse4_2_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_FMA3)
+extern bool MFBT_DATA fma3_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_AVX)
+extern bool MFBT_DATA avx_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_AVX2)
+extern bool MFBT_DATA avx2_enabled;
+# endif
+# if !defined(MOZILLA_PRESUME_AES)
+extern bool MFBT_DATA aes_enabled;
+# endif
+extern bool MFBT_DATA has_constant_tsc;
+
+#endif
+} // namespace sse_private
+
+#ifdef HAVE_CPUID_H
+MOZ_EXPORT uint64_t xgetbv(uint32_t xcr);
+#endif
+
+#if defined(MOZILLA_PRESUME_MMX)
+# define MOZILLA_MAY_SUPPORT_MMX 1
+inline bool supports_mmx() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# if !(defined(_MSC_VER) && defined(_M_AMD64))
+// Define MOZILLA_MAY_SUPPORT_MMX only if we're not on MSVC for
+// AMD64, since that compiler doesn't support MMX.
+# define MOZILLA_MAY_SUPPORT_MMX 1
+# endif
+inline bool supports_mmx() { return sse_private::mmx_enabled; }
+#else
+inline bool supports_mmx() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_SSE)
+# define MOZILLA_MAY_SUPPORT_SSE 1
+inline bool supports_sse() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_SSE 1
+inline bool supports_sse() { return sse_private::sse_enabled; }
+#else
+inline bool supports_sse() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_SSE2)
+# define MOZILLA_MAY_SUPPORT_SSE2 1
+inline bool supports_sse2() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_SSE2 1
+inline bool supports_sse2() { return sse_private::sse2_enabled; }
+#else
+inline bool supports_sse2() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_SSE3)
+# define MOZILLA_MAY_SUPPORT_SSE3 1
+inline bool supports_sse3() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_SSE3 1
+inline bool supports_sse3() { return sse_private::sse3_enabled; }
+#else
+inline bool supports_sse3() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_SSSE3)
+# define MOZILLA_MAY_SUPPORT_SSSE3 1
+inline bool supports_ssse3() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_SSSE3 1
+inline bool supports_ssse3() { return sse_private::ssse3_enabled; }
+#else
+inline bool supports_ssse3() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_SSE4A)
+# define MOZILLA_MAY_SUPPORT_SSE4A 1
+inline bool supports_sse4a() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_SSE4A 1
+inline bool supports_sse4a() { return sse_private::sse4a_enabled; }
+#else
+inline bool supports_sse4a() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_SSE4_1)
+# define MOZILLA_MAY_SUPPORT_SSE4_1 1
+inline bool supports_sse4_1() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_SSE4_1 1
+inline bool supports_sse4_1() { return sse_private::sse4_1_enabled; }
+#else
+inline bool supports_sse4_1() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_SSE4_2)
+# define MOZILLA_MAY_SUPPORT_SSE4_2 1
+inline bool supports_sse4_2() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_SSE4_2 1
+inline bool supports_sse4_2() { return sse_private::sse4_2_enabled; }
+#else
+inline bool supports_sse4_2() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_FMA3)
+# define MOZILLA_MAY_SUPPORT_FMA3 1
+inline bool supports_fma3() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_FMA3 1
+inline bool supports_fma3() { return sse_private::fma3_enabled; }
+#else
+inline bool supports_fma3() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_AVX)
+# define MOZILLA_MAY_SUPPORT_AVX 1
+inline bool supports_avx() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_AVX 1
+inline bool supports_avx() { return sse_private::avx_enabled; }
+#else
+inline bool supports_avx() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_AVX2)
+# define MOZILLA_MAY_SUPPORT_AVX2 1
+inline bool supports_avx2() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_AVX2 1
+inline bool supports_avx2() { return sse_private::avx2_enabled; }
+#else
+inline bool supports_avx2() { return false; }
+#endif
+
+#if defined(MOZILLA_PRESUME_AES)
+# define MOZILLA_MAY_SUPPORT_AES 1
+inline bool supports_aes() { return true; }
+#elif defined(MOZILLA_SSE_HAVE_CPUID_DETECTION)
+# define MOZILLA_MAY_SUPPORT_AES 1
+inline bool supports_aes() { return sse_private::aes_enabled; }
+#else
+inline bool supports_aes() { return false; }
+#endif
+
+#ifdef MOZILLA_SSE_HAVE_CPUID_DETECTION
+inline bool has_constant_tsc() { return sse_private::has_constant_tsc; }
+#else
+inline bool has_constant_tsc() { return false; }
+#endif
+
+} // namespace mozilla
+
+#endif /* !defined(mozilla_SSE_h_) */
diff --git a/mozglue/misc/Sprintf.h b/mozglue/misc/Sprintf.h
new file mode 100644
index 0000000000..4b459de82d
--- /dev/null
+++ b/mozglue/misc/Sprintf.h
@@ -0,0 +1,98 @@
+/* -*- 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/. */
+
+/* Provides a safer sprintf for printing to fixed-size character arrays. */
+
+#ifndef mozilla_Sprintf_h_
+#define mozilla_Sprintf_h_
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <algorithm>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Printf.h"
+
+#ifdef __cplusplus
+
+# ifndef SPRINTF_H_USES_VSNPRINTF
+namespace mozilla {
+namespace detail {
+
+struct MOZ_STACK_CLASS SprintfAppend final : public mozilla::PrintfTarget {
+ explicit SprintfAppend(char* aBuf, size_t aBufLen)
+ : mBuf(aBuf), mBufLen(aBufLen) {}
+
+ bool append(const char* aStr, size_t aLen) override {
+ if (aLen == 0) {
+ return true;
+ }
+ // Don't copy more than what's left to use.
+ size_t copy = std::min(mBufLen, aLen);
+ if (copy > 0) {
+ memcpy(mBuf, aStr, copy);
+ mBuf += copy;
+ mBufLen -= copy;
+ }
+ return true;
+ }
+
+ private:
+ char* mBuf;
+ size_t mBufLen;
+};
+
+} // namespace detail
+} // namespace mozilla
+# endif // SPRINTF_H_USES_VSNPRINTF
+
+MOZ_FORMAT_PRINTF(3, 0)
+MOZ_MAYBE_UNUSED
+static int VsprintfBuf(char* buffer, size_t bufsize, const char* format,
+ va_list args) {
+ MOZ_ASSERT(format != buffer);
+# ifdef SPRINTF_H_USES_VSNPRINTF
+ int result = vsnprintf(buffer, bufsize, format, args);
+ buffer[bufsize - 1] = '\0';
+ return result;
+# else
+ mozilla::detail::SprintfAppend ss(buffer, bufsize);
+ ss.vprint(format, args);
+ size_t len = ss.emitted();
+ buffer[std::min(len, bufsize - 1)] = '\0';
+ return len;
+# endif
+}
+
+MOZ_FORMAT_PRINTF(3, 4)
+MOZ_MAYBE_UNUSED
+static int SprintfBuf(char* buffer, size_t bufsize, const char* format, ...) {
+ va_list args;
+ va_start(args, format);
+ int result = VsprintfBuf(buffer, bufsize, format, args);
+ va_end(args);
+ return result;
+}
+
+template <size_t N>
+MOZ_FORMAT_PRINTF(2, 0)
+int VsprintfLiteral(char (&buffer)[N], const char* format, va_list args) {
+ return VsprintfBuf(buffer, N, format, args);
+}
+
+template <size_t N>
+MOZ_FORMAT_PRINTF(2, 3)
+int SprintfLiteral(char (&buffer)[N], const char* format, ...) {
+ va_list args;
+ va_start(args, format);
+ int result = VsprintfLiteral(buffer, format, args);
+ va_end(args);
+ return result;
+}
+
+#endif
+#endif /* mozilla_Sprintf_h_ */
diff --git a/mozglue/misc/StackWalk.cpp b/mozglue/misc/StackWalk.cpp
new file mode 100644
index 0000000000..307715b170
--- /dev/null
+++ b/mozglue/misc/StackWalk.cpp
@@ -0,0 +1,1063 @@
+/* -*- 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/. */
+
+/* API for getting a stack trace of the C/C++ stack on the current thread */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/StackWalk.h"
+#ifdef XP_WIN
+# include "mozilla/StackWalkThread.h"
+# include <io.h>
+#else
+# include <unistd.h>
+#endif
+#include "mozilla/Sprintf.h"
+
+#include <string.h>
+
+#if defined(ANDROID) && defined(MOZ_LINKER)
+# include "Linker.h"
+# include <android/log.h>
+#endif
+
+using namespace mozilla;
+
+// for _Unwind_Backtrace from libcxxrt or libunwind
+// cxxabi.h from libcxxrt implicitly includes unwind.h first
+#if defined(HAVE__UNWIND_BACKTRACE) && !defined(_GNU_SOURCE)
+# define _GNU_SOURCE
+#endif
+
+#if defined(HAVE_DLOPEN) || defined(XP_DARWIN)
+# include <dlfcn.h>
+#endif
+
+#if (defined(XP_DARWIN) && \
+ (defined(__i386) || defined(__ppc__) || defined(HAVE__UNWIND_BACKTRACE)))
+# define MOZ_STACKWALK_SUPPORTS_MACOSX 1
+#else
+# define MOZ_STACKWALK_SUPPORTS_MACOSX 0
+#endif
+
+#if (defined(linux) && \
+ ((defined(__GNUC__) && (defined(__i386) || defined(PPC))) || \
+ defined(HAVE__UNWIND_BACKTRACE)))
+# define MOZ_STACKWALK_SUPPORTS_LINUX 1
+#else
+# define MOZ_STACKWALK_SUPPORTS_LINUX 0
+#endif
+
+#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1)
+# define HAVE___LIBC_STACK_END 1
+#else
+# define HAVE___LIBC_STACK_END 0
+#endif
+
+#if HAVE___LIBC_STACK_END
+extern MOZ_EXPORT void* __libc_stack_end; // from ld-linux.so
+#endif
+
+#ifdef ANDROID
+# include <algorithm>
+# include <unistd.h>
+# include <pthread.h>
+#endif
+
+class FrameSkipper {
+ public:
+ constexpr FrameSkipper() : mPc(0) {}
+ bool ShouldSkipPC(void* aPC) {
+ // Skip frames until we encounter the one we were initialized with,
+ // and then never skip again.
+ if (mPc != 0) {
+ if (mPc != uintptr_t(aPC)) {
+ return true;
+ }
+ mPc = 0;
+ }
+ return false;
+ }
+ explicit FrameSkipper(const void* aPc) : mPc(uintptr_t(aPc)) {}
+
+ private:
+ uintptr_t mPc;
+};
+
+#ifdef XP_WIN
+
+# include <windows.h>
+# include <process.h>
+# include <stdio.h>
+# include <malloc.h>
+# include "mozilla/ArrayUtils.h"
+# include "mozilla/Atomics.h"
+# include "mozilla/StackWalk_windows.h"
+# include "mozilla/WindowsVersion.h"
+
+# include <imagehlp.h>
+// We need a way to know if we are building for WXP (or later), as if we are, we
+// need to use the newer 64-bit APIs. API_VERSION_NUMBER seems to fit the bill.
+// A value of 9 indicates we want to use the new APIs.
+# if API_VERSION_NUMBER < 9
+# error Too old imagehlp.h
+# endif
+
+CRITICAL_SECTION gDbgHelpCS;
+
+# if defined(_M_AMD64) || defined(_M_ARM64)
+// Because various Win64 APIs acquire function-table locks, we need a way of
+// preventing stack walking while those APIs are being called. Otherwise, the
+// stack walker may suspend a thread holding such a lock, and deadlock when the
+// stack unwind code attempts to wait for that lock.
+//
+// We're using an atomic counter rather than a critical section because we
+// don't require mutual exclusion with the stack walker. If the stack walker
+// determines that it's safe to start unwinding the suspended thread (i.e.
+// there are no suppressions when the unwind begins), then it's safe to
+// continue unwinding that thread even if other threads request suppressions
+// in the meantime, because we can't deadlock with those other threads.
+//
+// XXX: This global variable is a larger-than-necessary hammer. A more scoped
+// solution would be to maintain a counter per thread, but then it would be
+// more difficult for WalkStackMain64 to read the suspended thread's counter.
+static Atomic<size_t> sStackWalkSuppressions;
+
+void SuppressStackWalking() { ++sStackWalkSuppressions; }
+
+void DesuppressStackWalking() { --sStackWalkSuppressions; }
+
+MFBT_API
+AutoSuppressStackWalking::AutoSuppressStackWalking() { SuppressStackWalking(); }
+
+MFBT_API
+AutoSuppressStackWalking::~AutoSuppressStackWalking() {
+ DesuppressStackWalking();
+}
+
+static uint8_t* sJitCodeRegionStart;
+static size_t sJitCodeRegionSize;
+uint8_t* sMsMpegJitCodeRegionStart;
+size_t sMsMpegJitCodeRegionSize;
+
+MFBT_API void RegisterJitCodeRegion(uint8_t* aStart, size_t aSize) {
+ // Currently we can only handle one JIT code region at a time
+ MOZ_RELEASE_ASSERT(!sJitCodeRegionStart);
+
+ sJitCodeRegionStart = aStart;
+ sJitCodeRegionSize = aSize;
+}
+
+MFBT_API void UnregisterJitCodeRegion(uint8_t* aStart, size_t aSize) {
+ // Currently we can only handle one JIT code region at a time
+ MOZ_RELEASE_ASSERT(sJitCodeRegionStart && sJitCodeRegionStart == aStart &&
+ sJitCodeRegionSize == aSize);
+
+ sJitCodeRegionStart = nullptr;
+ sJitCodeRegionSize = 0;
+}
+
+# endif // _M_AMD64 || _M_ARM64
+
+// Routine to print an error message to standard error.
+static void PrintError(const char* aPrefix) {
+ LPSTR lpMsgBuf;
+ DWORD lastErr = GetLastError();
+ FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ nullptr, lastErr,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+ (LPSTR)&lpMsgBuf, 0, nullptr);
+ fprintf(stderr, "### ERROR: %s: %s", aPrefix,
+ lpMsgBuf ? lpMsgBuf : "(null)\n");
+ fflush(stderr);
+ LocalFree(lpMsgBuf);
+}
+
+static void InitializeDbgHelpCriticalSection() {
+ static bool initialized = false;
+ if (initialized) {
+ return;
+ }
+ ::InitializeCriticalSection(&gDbgHelpCS);
+ initialized = true;
+}
+
+// Wrapper around a reference to a CONTEXT, to simplify access to main
+// platform-specific execution registers.
+// It also avoids using CONTEXT* nullable pointers.
+class CONTEXTGenericAccessors {
+ public:
+ explicit CONTEXTGenericAccessors(CONTEXT& aCONTEXT) : mCONTEXT(aCONTEXT) {}
+
+ CONTEXT* CONTEXTPtr() { return &mCONTEXT; }
+
+ inline auto& PC() {
+# if defined(_M_AMD64)
+ return mCONTEXT.Rip;
+# elif defined(_M_ARM64)
+ return mCONTEXT.Pc;
+# elif defined(_M_IX86)
+ return mCONTEXT.Eip;
+# else
+# error "unknown platform"
+# endif
+ }
+
+ inline auto& SP() {
+# if defined(_M_AMD64)
+ return mCONTEXT.Rsp;
+# elif defined(_M_ARM64)
+ return mCONTEXT.Sp;
+# elif defined(_M_IX86)
+ return mCONTEXT.Esp;
+# else
+# error "unknown platform"
+# endif
+ }
+
+ inline auto& BP() {
+# if defined(_M_AMD64)
+ return mCONTEXT.Rbp;
+# elif defined(_M_ARM64)
+ return mCONTEXT.Fp;
+# elif defined(_M_IX86)
+ return mCONTEXT.Ebp;
+# else
+# error "unknown platform"
+# endif
+ }
+
+ private:
+ CONTEXT& mCONTEXT;
+};
+
+/**
+ * Walk the stack, translating PC's found into strings and recording the
+ * chain in aBuffer. For this to work properly, the DLLs must be rebased
+ * so that the address in the file agrees with the address in memory.
+ * Otherwise StackWalk will return FALSE when it hits a frame in a DLL
+ * whose in memory address doesn't match its in-file address.
+ */
+
+static void DoMozStackWalkThread(MozWalkStackCallback aCallback,
+ const void* aFirstFramePC, uint32_t aMaxFrames,
+ void* aClosure, HANDLE aThread,
+ CONTEXT* aContext) {
+ InitializeDbgHelpCriticalSection();
+
+ HANDLE targetThread = aThread;
+ bool walkCallingThread;
+ if (!targetThread) {
+ targetThread = ::GetCurrentThread();
+ walkCallingThread = true;
+ } else {
+ DWORD targetThreadId = ::GetThreadId(targetThread);
+ DWORD currentThreadId = ::GetCurrentThreadId();
+ walkCallingThread = (targetThreadId == currentThreadId);
+ }
+
+ // If not already provided, get a context for the specified thread.
+ CONTEXT context_buf;
+ if (!aContext) {
+ memset(&context_buf, 0, sizeof(CONTEXT));
+ context_buf.ContextFlags = CONTEXT_FULL;
+ if (walkCallingThread) {
+ ::RtlCaptureContext(&context_buf);
+ } else if (!GetThreadContext(targetThread, &context_buf)) {
+ return;
+ }
+ }
+ CONTEXTGenericAccessors context{aContext ? *aContext : context_buf};
+
+# if defined(_M_IX86)
+ // Setup initial stack frame to walk from.
+ STACKFRAME64 frame64;
+ memset(&frame64, 0, sizeof(frame64));
+ frame64.AddrPC.Offset = context.PC();
+ frame64.AddrStack.Offset = context.SP();
+ frame64.AddrFrame.Offset = context.BP();
+ frame64.AddrPC.Mode = AddrModeFlat;
+ frame64.AddrStack.Mode = AddrModeFlat;
+ frame64.AddrFrame.Mode = AddrModeFlat;
+ frame64.AddrReturn.Mode = AddrModeFlat;
+# endif
+
+# if defined(_M_AMD64) || defined(_M_ARM64)
+ // If there are any active suppressions, then at least one thread (we don't
+ // know which) is holding a lock that can deadlock RtlVirtualUnwind. Since
+ // that thread may be the one that we're trying to unwind, we can't proceed.
+ //
+ // But if there are no suppressions, then our target thread can't be holding
+ // a lock, and it's safe to proceed. By virtue of being suspended, the target
+ // thread can't acquire any new locks during the unwind process, so we only
+ // need to do this check once. After that, sStackWalkSuppressions can be
+ // changed by other threads while we're unwinding, and that's fine because
+ // we can't deadlock with those threads.
+ if (sStackWalkSuppressions) {
+ return;
+ }
+# endif
+
+# if defined(_M_AMD64) || defined(_M_ARM64)
+ bool firstFrame = true;
+# endif
+
+ FrameSkipper skipper(aFirstFramePC);
+
+ uint32_t frames = 0;
+
+ // Now walk the stack.
+ while (true) {
+ DWORD64 addr;
+ DWORD64 spaddr;
+
+# if defined(_M_IX86)
+ // 32-bit frame unwinding.
+ // Debug routines are not threadsafe, so grab the lock.
+ EnterCriticalSection(&gDbgHelpCS);
+ BOOL ok = StackWalk64(
+# if defined _M_IX86
+ IMAGE_FILE_MACHINE_I386,
+# endif
+ ::GetCurrentProcess(), targetThread, &frame64, context.CONTEXTPtr(),
+ nullptr,
+ SymFunctionTableAccess64, // function table access routine
+ SymGetModuleBase64, // module base routine
+ 0);
+ LeaveCriticalSection(&gDbgHelpCS);
+
+ if (ok) {
+ addr = frame64.AddrPC.Offset;
+ spaddr = frame64.AddrStack.Offset;
+ } else {
+ addr = 0;
+ spaddr = 0;
+ if (walkCallingThread) {
+ PrintError("WalkStack64");
+ }
+ }
+
+ if (!ok) {
+ break;
+ }
+
+# elif defined(_M_AMD64) || defined(_M_ARM64)
+
+ auto currentInstr = context.PC();
+
+ // If we reach a frame in JIT code, we don't have enough information to
+ // unwind, so we have to give up.
+ if (sJitCodeRegionStart && (uint8_t*)currentInstr >= sJitCodeRegionStart &&
+ (uint8_t*)currentInstr < sJitCodeRegionStart + sJitCodeRegionSize) {
+ break;
+ }
+
+ // We must also avoid msmpeg2vdec.dll's JIT region: they don't generate
+ // unwind data, so their JIT unwind callback just throws up its hands and
+ // terminates the process.
+ if (sMsMpegJitCodeRegionStart &&
+ (uint8_t*)currentInstr >= sMsMpegJitCodeRegionStart &&
+ (uint8_t*)currentInstr <
+ sMsMpegJitCodeRegionStart + sMsMpegJitCodeRegionSize) {
+ break;
+ }
+
+ // 64-bit frame unwinding.
+ // Try to look up unwind metadata for the current function.
+ ULONG64 imageBase;
+ PRUNTIME_FUNCTION runtimeFunction =
+ RtlLookupFunctionEntry(currentInstr, &imageBase, NULL);
+
+ if (runtimeFunction) {
+ PVOID dummyHandlerData;
+ ULONG64 dummyEstablisherFrame;
+ RtlVirtualUnwind(UNW_FLAG_NHANDLER, imageBase, currentInstr,
+ runtimeFunction, context.CONTEXTPtr(), &dummyHandlerData,
+ &dummyEstablisherFrame, nullptr);
+ } else if (firstFrame) {
+ // Leaf functions can be unwound by hand.
+ context.PC() = *reinterpret_cast<DWORD64*>(context.SP());
+ context.SP() += sizeof(void*);
+ } else {
+ // Something went wrong.
+ break;
+ }
+
+ addr = context.PC();
+ spaddr = context.SP();
+ firstFrame = false;
+# else
+# error "unknown platform"
+# endif
+
+ if (addr == 0) {
+ break;
+ }
+
+ if (skipper.ShouldSkipPC((void*)addr)) {
+ continue;
+ }
+
+ aCallback(++frames, (void*)addr, (void*)spaddr, aClosure);
+
+ if (aMaxFrames != 0 && frames == aMaxFrames) {
+ break;
+ }
+
+# if defined(_M_IX86)
+ if (frame64.AddrReturn.Offset == 0) {
+ break;
+ }
+# endif
+ }
+}
+
+MFBT_API void MozStackWalkThread(MozWalkStackCallback aCallback,
+ uint32_t aMaxFrames, void* aClosure,
+ HANDLE aThread, CONTEXT* aContext) {
+ // We don't pass a aFirstFramePC because we walk the stack for another
+ // thread.
+ DoMozStackWalkThread(aCallback, nullptr, aMaxFrames, aClosure, aThread,
+ aContext);
+}
+
+MFBT_API void MozStackWalk(MozWalkStackCallback aCallback,
+ const void* aFirstFramePC, uint32_t aMaxFrames,
+ void* aClosure) {
+ DoMozStackWalkThread(aCallback, aFirstFramePC ? aFirstFramePC : CallerPC(),
+ aMaxFrames, aClosure, nullptr, nullptr);
+}
+
+static BOOL CALLBACK callbackEspecial64(PCSTR aModuleName, DWORD64 aModuleBase,
+ ULONG aModuleSize, PVOID aUserContext) {
+ BOOL retval = TRUE;
+ DWORD64 addr = *(DWORD64*)aUserContext;
+
+ /*
+ * You'll want to control this if we are running on an
+ * architecture where the addresses go the other direction.
+ * Not sure this is even a realistic consideration.
+ */
+ const BOOL addressIncreases = TRUE;
+
+ /*
+ * If it falls in side the known range, load the symbols.
+ */
+ if (addressIncreases
+ ? (addr >= aModuleBase && addr <= (aModuleBase + aModuleSize))
+ : (addr <= aModuleBase && addr >= (aModuleBase - aModuleSize))) {
+ retval = !!SymLoadModule64(GetCurrentProcess(), nullptr, (PSTR)aModuleName,
+ nullptr, aModuleBase, aModuleSize);
+ if (!retval) {
+ PrintError("SymLoadModule64");
+ }
+ }
+
+ return retval;
+}
+
+/*
+ * SymGetModuleInfoEspecial
+ *
+ * Attempt to determine the module information.
+ * Bug 112196 says this DLL may not have been loaded at the time
+ * SymInitialize was called, and thus the module information
+ * and symbol information is not available.
+ * This code rectifies that problem.
+ */
+
+// New members were added to IMAGEHLP_MODULE64 (that show up in the
+// Platform SDK that ships with VC8, but not the Platform SDK that ships
+// with VC7.1, i.e., between DbgHelp 6.0 and 6.1), but we don't need to
+// use them, and it's useful to be able to function correctly with the
+// older library. (Stock Windows XP SP2 seems to ship with dbghelp.dll
+// version 5.1.) Since Platform SDK version need not correspond to
+// compiler version, and the version number in debughlp.h was NOT bumped
+// when these changes were made, ifdef based on a constant that was
+// added between these versions.
+# ifdef SSRVOPT_SETCONTEXT
+# define NS_IMAGEHLP_MODULE64_SIZE \
+ (((offsetof(IMAGEHLP_MODULE64, LoadedPdbName) + sizeof(DWORD64) - 1) / \
+ sizeof(DWORD64)) * \
+ sizeof(DWORD64))
+# else
+# define NS_IMAGEHLP_MODULE64_SIZE sizeof(IMAGEHLP_MODULE64)
+# endif
+
+BOOL SymGetModuleInfoEspecial64(HANDLE aProcess, DWORD64 aAddr,
+ PIMAGEHLP_MODULE64 aModuleInfo,
+ PIMAGEHLP_LINE64 aLineInfo) {
+ BOOL retval = FALSE;
+
+ /*
+ * Init the vars if we have em.
+ */
+ aModuleInfo->SizeOfStruct = NS_IMAGEHLP_MODULE64_SIZE;
+ if (aLineInfo) {
+ aLineInfo->SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+ }
+
+ /*
+ * Give it a go.
+ * It may already be loaded.
+ */
+ retval = SymGetModuleInfo64(aProcess, aAddr, aModuleInfo);
+ if (retval == FALSE) {
+ /*
+ * Not loaded, here's the magic.
+ * Go through all the modules.
+ */
+ // Need to cast to PENUMLOADED_MODULES_CALLBACK64 because the
+ // constness of the first parameter of
+ // PENUMLOADED_MODULES_CALLBACK64 varies over SDK versions (from
+ // non-const to const over time). See bug 391848 and bug
+ // 415426.
+ BOOL enumRes = EnumerateLoadedModules64(
+ aProcess, (PENUMLOADED_MODULES_CALLBACK64)callbackEspecial64,
+ (PVOID)&aAddr);
+ if (enumRes != FALSE) {
+ /*
+ * One final go.
+ * If it fails, then well, we have other problems.
+ */
+ retval = SymGetModuleInfo64(aProcess, aAddr, aModuleInfo);
+ }
+ }
+
+ /*
+ * If we got module info, we may attempt line info as well.
+ * We will not report failure if this does not work.
+ */
+ if (retval != FALSE && aLineInfo) {
+ DWORD displacement = 0;
+ BOOL lineRes = FALSE;
+ lineRes = SymGetLineFromAddr64(aProcess, aAddr, &displacement, aLineInfo);
+ if (!lineRes) {
+ // Clear out aLineInfo to indicate that it's not valid
+ memset(aLineInfo, 0, sizeof(*aLineInfo));
+ }
+ }
+
+ return retval;
+}
+
+static bool EnsureSymInitialized() {
+ static bool gInitialized = false;
+ bool retStat;
+
+ if (gInitialized) {
+ return gInitialized;
+ }
+
+ InitializeDbgHelpCriticalSection();
+
+ SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME);
+ retStat = SymInitialize(GetCurrentProcess(), nullptr, TRUE);
+ if (!retStat) {
+ PrintError("SymInitialize");
+ }
+
+ gInitialized = retStat;
+ /* XXX At some point we need to arrange to call SymCleanup */
+
+ return retStat;
+}
+
+MFBT_API bool MozDescribeCodeAddress(void* aPC,
+ MozCodeAddressDetails* aDetails) {
+ aDetails->library[0] = '\0';
+ aDetails->loffset = 0;
+ aDetails->filename[0] = '\0';
+ aDetails->lineno = 0;
+ aDetails->function[0] = '\0';
+ aDetails->foffset = 0;
+
+ if (!EnsureSymInitialized()) {
+ return false;
+ }
+
+ HANDLE myProcess = ::GetCurrentProcess();
+ BOOL ok;
+
+ // debug routines are not threadsafe, so grab the lock.
+ EnterCriticalSection(&gDbgHelpCS);
+
+ //
+ // Attempt to load module info before we attempt to resolve the symbol.
+ // This just makes sure we get good info if available.
+ //
+
+ DWORD64 addr = (DWORD64)aPC;
+ IMAGEHLP_MODULE64 modInfo;
+ IMAGEHLP_LINE64 lineInfo;
+ BOOL modInfoRes;
+ modInfoRes = SymGetModuleInfoEspecial64(myProcess, addr, &modInfo, &lineInfo);
+
+ if (modInfoRes) {
+ strncpy(aDetails->library, modInfo.LoadedImageName,
+ sizeof(aDetails->library));
+ aDetails->library[mozilla::ArrayLength(aDetails->library) - 1] = '\0';
+ aDetails->loffset = (char*)aPC - (char*)modInfo.BaseOfImage;
+
+ if (lineInfo.FileName) {
+ strncpy(aDetails->filename, lineInfo.FileName,
+ sizeof(aDetails->filename));
+ aDetails->filename[mozilla::ArrayLength(aDetails->filename) - 1] = '\0';
+ aDetails->lineno = lineInfo.LineNumber;
+ }
+ }
+
+ ULONG64 buffer[(sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR) +
+ sizeof(ULONG64) - 1) /
+ sizeof(ULONG64)];
+ PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
+ pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+ pSymbol->MaxNameLen = MAX_SYM_NAME;
+
+ DWORD64 displacement;
+ ok = SymFromAddr(myProcess, addr, &displacement, pSymbol);
+
+ if (ok) {
+ strncpy(aDetails->function, pSymbol->Name, sizeof(aDetails->function));
+ aDetails->function[mozilla::ArrayLength(aDetails->function) - 1] = '\0';
+ aDetails->foffset = static_cast<ptrdiff_t>(displacement);
+ }
+
+ LeaveCriticalSection(&gDbgHelpCS); // release our lock
+ return true;
+}
+
+// i386 or PPC Linux stackwalking code
+#elif HAVE_DLADDR && \
+ (HAVE__UNWIND_BACKTRACE || MOZ_STACKWALK_SUPPORTS_LINUX || \
+ MOZ_STACKWALK_SUPPORTS_MACOSX)
+
+# include <stdlib.h>
+# include <stdio.h>
+
+// On glibc 2.1, the Dl_info api defined in <dlfcn.h> is only exposed
+// if __USE_GNU is defined. I suppose its some kind of standards
+// adherence thing.
+//
+# if (__GLIBC_MINOR__ >= 1) && !defined(__USE_GNU)
+# define __USE_GNU
+# endif
+
+// This thing is exported by libstdc++
+// Yes, this is a gcc only hack
+# if defined(MOZ_DEMANGLE_SYMBOLS)
+# include <cxxabi.h>
+# endif // MOZ_DEMANGLE_SYMBOLS
+
+namespace mozilla {
+
+void DemangleSymbol(const char* aSymbol, char* aBuffer, int aBufLen) {
+ aBuffer[0] = '\0';
+
+# if defined(MOZ_DEMANGLE_SYMBOLS)
+ /* See demangle.h in the gcc source for the voodoo */
+ char* demangled = abi::__cxa_demangle(aSymbol, 0, 0, 0);
+
+ if (demangled) {
+ strncpy(aBuffer, demangled, aBufLen);
+ aBuffer[aBufLen - 1] = '\0';
+ free(demangled);
+ }
+# endif // MOZ_DEMANGLE_SYMBOLS
+}
+
+} // namespace mozilla
+
+// {x86, ppc} x {Linux, Mac} stackwalking code.
+# if ((defined(__i386) || defined(PPC) || defined(__ppc__)) && \
+ (MOZ_STACKWALK_SUPPORTS_MACOSX || MOZ_STACKWALK_SUPPORTS_LINUX))
+
+static void DoFramePointerStackWalk(MozWalkStackCallback aCallback,
+ const void* aFirstFramePC,
+ uint32_t aMaxFrames, void* aClosure,
+ void** aBp, void* aStackEnd);
+
+MFBT_API void MozStackWalk(MozWalkStackCallback aCallback,
+ const void* aFirstFramePC, uint32_t aMaxFrames,
+ void* aClosure) {
+ // Get the frame pointer
+ void** bp = (void**)__builtin_frame_address(0);
+
+ void* stackEnd;
+# if HAVE___LIBC_STACK_END
+ stackEnd = __libc_stack_end;
+# elif defined(XP_DARWIN)
+ stackEnd = pthread_get_stackaddr_np(pthread_self());
+# elif defined(ANDROID)
+ pthread_attr_t sattr;
+ pthread_attr_init(&sattr);
+ pthread_getattr_np(pthread_self(), &sattr);
+ void* stackBase = stackEnd = nullptr;
+ size_t stackSize = 0;
+ if (gettid() != getpid()) {
+ // bionic's pthread_attr_getstack doesn't tell the truth for the main
+ // thread (see bug 846670). So don't use it for the main thread.
+ if (!pthread_attr_getstack(&sattr, &stackBase, &stackSize)) {
+ stackEnd = static_cast<char*>(stackBase) + stackSize;
+ } else {
+ stackEnd = nullptr;
+ }
+ }
+ if (!stackEnd) {
+ // So consider the current frame pointer + an arbitrary size of 8MB
+ // (modulo overflow ; not really arbitrary as it's the default stack
+ // size for the main thread) if pthread_attr_getstack failed for
+ // some reason (or was skipped).
+ static const uintptr_t kMaxStackSize = 8 * 1024 * 1024;
+ uintptr_t maxStackStart = uintptr_t(-1) - kMaxStackSize;
+ uintptr_t stackStart = std::max(maxStackStart, uintptr_t(bp));
+ stackEnd = reinterpret_cast<void*>(stackStart + kMaxStackSize);
+ }
+# else
+# error Unsupported configuration
+# endif
+ DoFramePointerStackWalk(aCallback, aFirstFramePC, aMaxFrames, aClosure, bp,
+ stackEnd);
+}
+
+# elif defined(HAVE__UNWIND_BACKTRACE)
+
+// libgcc_s.so symbols _Unwind_Backtrace@@GCC_3.3 and _Unwind_GetIP@@GCC_3.0
+# include <unwind.h>
+
+struct unwind_info {
+ MozWalkStackCallback callback;
+ FrameSkipper skipper;
+ int maxFrames;
+ int numFrames;
+ void* closure;
+};
+
+static _Unwind_Reason_Code unwind_callback(struct _Unwind_Context* context,
+ void* closure) {
+ unwind_info* info = static_cast<unwind_info*>(closure);
+ void* pc = reinterpret_cast<void*>(_Unwind_GetIP(context));
+ // TODO Use something like '_Unwind_GetGR()' to get the stack pointer.
+ if (!info->skipper.ShouldSkipPC(pc)) {
+ info->numFrames++;
+ (*info->callback)(info->numFrames, pc, nullptr, info->closure);
+ if (info->maxFrames != 0 && info->numFrames == info->maxFrames) {
+ // Again, any error code that stops the walk will do.
+ return _URC_FOREIGN_EXCEPTION_CAUGHT;
+ }
+ }
+ return _URC_NO_REASON;
+}
+
+MFBT_API void MozStackWalk(MozWalkStackCallback aCallback,
+ const void* aFirstFramePC, uint32_t aMaxFrames,
+ void* aClosure) {
+ unwind_info info;
+ info.callback = aCallback;
+ info.skipper = FrameSkipper(aFirstFramePC ? aFirstFramePC : CallerPC());
+ info.maxFrames = aMaxFrames;
+ info.numFrames = 0;
+ info.closure = aClosure;
+
+ // We ignore the return value from _Unwind_Backtrace. There are three main
+ // reasons for this.
+ // - On ARM/Android bionic's _Unwind_Backtrace usually (always?) returns
+ // _URC_FAILURE. See
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=717853#c110.
+ // - If aMaxFrames != 0, we want to stop early, and the only way to do that
+ // is to make unwind_callback return something other than _URC_NO_REASON,
+ // which causes _Unwind_Backtrace to return a non-success code.
+ // - MozStackWalk doesn't have a return value anyway.
+ (void)_Unwind_Backtrace(unwind_callback, &info);
+}
+
+# endif
+
+bool MFBT_API MozDescribeCodeAddress(void* aPC,
+ MozCodeAddressDetails* aDetails) {
+ aDetails->library[0] = '\0';
+ aDetails->loffset = 0;
+ aDetails->filename[0] = '\0';
+ aDetails->lineno = 0;
+ aDetails->function[0] = '\0';
+ aDetails->foffset = 0;
+
+ Dl_info info;
+
+# if defined(ANDROID) && defined(MOZ_LINKER)
+ int ok = __wrap_dladdr(aPC, &info);
+# else
+ int ok = dladdr(aPC, &info);
+# endif
+
+ if (!ok) {
+ return true;
+ }
+
+ strncpy(aDetails->library, info.dli_fname, sizeof(aDetails->library));
+ aDetails->library[mozilla::ArrayLength(aDetails->library) - 1] = '\0';
+ aDetails->loffset = (char*)aPC - (char*)info.dli_fbase;
+
+# if !defined(XP_FREEBSD)
+ // On FreeBSD, dli_sname is unusably bad, it often returns things like
+ // 'gtk_xtbin_new' or 'XRE_GetBootstrap' instead of long C++ symbols. Just let
+ // GetFunction do the lookup directly in the ELF image.
+
+ const char* symbol = info.dli_sname;
+ if (!symbol || symbol[0] == '\0') {
+ return true;
+ }
+
+ DemangleSymbol(symbol, aDetails->function, sizeof(aDetails->function));
+
+ if (aDetails->function[0] == '\0') {
+ // Just use the mangled symbol if demangling failed.
+ strncpy(aDetails->function, symbol, sizeof(aDetails->function));
+ aDetails->function[mozilla::ArrayLength(aDetails->function) - 1] = '\0';
+ }
+
+ aDetails->foffset = (char*)aPC - (char*)info.dli_saddr;
+# endif
+
+ return true;
+}
+
+#else // unsupported platform.
+
+MFBT_API void MozStackWalk(MozWalkStackCallback aCallback,
+ const void* aFirstFramePC, uint32_t aMaxFrames,
+ void* aClosure) {}
+
+MFBT_API bool MozDescribeCodeAddress(void* aPC,
+ MozCodeAddressDetails* aDetails) {
+ aDetails->library[0] = '\0';
+ aDetails->loffset = 0;
+ aDetails->filename[0] = '\0';
+ aDetails->lineno = 0;
+ aDetails->function[0] = '\0';
+ aDetails->foffset = 0;
+ return false;
+}
+
+#endif
+
+#if defined(XP_WIN) || defined(XP_MACOSX) || defined(XP_LINUX)
+
+# if defined(XP_MACOSX) && defined(__aarch64__)
+// On macOS arm64, system libraries are arm64e binaries, and arm64e can do
+// pointer authentication: The low bits of the pointer are the actual pointer
+// value, and the high bits are an encrypted hash. During stackwalking, we need
+// to strip off this hash. In theory, ptrauth_strip would be the right function
+// to call for this. However, that function is a no-op unless it's called from
+// code which also builds as arm64e - which we do not. So we cannot use it. So
+// for now, we hardcode a mask that seems to work today: 40 bits for the pointer
+// and 24 bits for the hash seems to do the trick. We can worry about
+// dynamically computing the correct mask if this ever stops working.
+const uintptr_t kPointerMask =
+ (uintptr_t(1) << 40) - 1; // 40 bits pointer, 24 bit PAC
+# else
+const uintptr_t kPointerMask = ~uintptr_t(0);
+# endif
+
+MOZ_ASAN_IGNORE
+static void DoFramePointerStackWalk(MozWalkStackCallback aCallback,
+ const void* aFirstFramePC,
+ uint32_t aMaxFrames, void* aClosure,
+ void** aBp, void* aStackEnd) {
+ // Stack walking code courtesy Kipp's "leaky".
+
+ FrameSkipper skipper(aFirstFramePC);
+ uint32_t numFrames = 0;
+
+ // Sanitize the given aBp. Assume that something reasonably close to
+ // but before the stack end is going be a valid frame pointer. Also
+ // check that it is an aligned address. This increases the chances
+ // that if the pointer is not valid (which might happen if the caller
+ // called __builtin_frame_address(1) and its frame is busted for some
+ // reason), we won't read it, leading to a crash. Because the calling
+ // code is not using frame pointers when returning, it might actually
+ // recover just fine.
+ static const uintptr_t kMaxStackSize = 8 * 1024 * 1024;
+ if (uintptr_t(aBp) < uintptr_t(aStackEnd) -
+ std::min(kMaxStackSize, uintptr_t(aStackEnd)) ||
+ aBp >= aStackEnd || (uintptr_t(aBp) & 3)) {
+ return;
+ }
+
+ while (aBp) {
+ void** next = (void**)*aBp;
+ // aBp may not be a frame pointer on i386 if code was compiled with
+ // -fomit-frame-pointer, so do some sanity checks.
+ // (aBp should be a frame pointer on ppc(64) but checking anyway may help
+ // a little if the stack has been corrupted.)
+ // We don't need to check against the begining of the stack because
+ // we can assume that aBp > sp
+ if (next <= aBp || next >= aStackEnd || (uintptr_t(next) & 3)) {
+ break;
+ }
+# if (defined(__ppc__) && defined(XP_MACOSX)) || defined(__powerpc64__)
+ // ppc mac or powerpc64 linux
+ void* pc = *(aBp + 2);
+ aBp += 3;
+# else // i386 or powerpc32 linux
+ void* pc = *(aBp + 1);
+ aBp += 2;
+# endif
+
+ // Strip off pointer authentication hash, if present. For now, it looks
+ // like only return addresses require stripping, and stack pointers do
+ // not. This might change in the future.
+ pc = (void*)((uintptr_t)pc & kPointerMask);
+
+ if (!skipper.ShouldSkipPC(pc)) {
+ // Assume that the SP points to the BP of the function
+ // it called. We can't know the exact location of the SP
+ // but this should be sufficient for our use the SP
+ // to order elements on the stack.
+ numFrames++;
+ (*aCallback)(numFrames, pc, aBp, aClosure);
+ if (aMaxFrames != 0 && numFrames == aMaxFrames) {
+ break;
+ }
+ }
+ aBp = next;
+ }
+}
+
+namespace mozilla {
+
+MFBT_API void FramePointerStackWalk(MozWalkStackCallback aCallback,
+ uint32_t aMaxFrames, void* aClosure,
+ void** aBp, void* aStackEnd) {
+ // We don't pass a aFirstFramePC because we start walking the stack from the
+ // frame at aBp.
+ DoFramePointerStackWalk(aCallback, nullptr, aMaxFrames, aClosure, aBp,
+ aStackEnd);
+}
+
+} // namespace mozilla
+
+#else
+
+namespace mozilla {
+MFBT_API void FramePointerStackWalk(MozWalkStackCallback aCallback,
+ uint32_t aMaxFrames, void* aClosure,
+ void** aBp, void* aStackEnd) {}
+} // namespace mozilla
+
+#endif
+
+MFBT_API int MozFormatCodeAddressDetails(
+ char* aBuffer, uint32_t aBufferSize, uint32_t aFrameNumber, void* aPC,
+ const MozCodeAddressDetails* aDetails) {
+ return MozFormatCodeAddress(aBuffer, aBufferSize, aFrameNumber, aPC,
+ aDetails->function, aDetails->library,
+ aDetails->loffset, aDetails->filename,
+ aDetails->lineno);
+}
+
+MFBT_API int MozFormatCodeAddress(char* aBuffer, uint32_t aBufferSize,
+ uint32_t aFrameNumber, const void* aPC,
+ const char* aFunction, const char* aLibrary,
+ ptrdiff_t aLOffset, const char* aFileName,
+ uint32_t aLineNo) {
+ const char* function = aFunction && aFunction[0] ? aFunction : "???";
+ if (aFileName && aFileName[0]) {
+ // We have a filename and (presumably) a line number. Use them.
+ return SprintfBuf(aBuffer, aBufferSize, "#%02u: %s (%s:%u)", aFrameNumber,
+ function, aFileName, aLineNo);
+ } else if (aLibrary && aLibrary[0]) {
+ // We have no filename, but we do have a library name. Use it and the
+ // library offset, and print them in a way that `fix_stacks.py` can
+ // post-process.
+ return SprintfBuf(aBuffer, aBufferSize, "#%02u: %s[%s +0x%" PRIxPTR "]",
+ aFrameNumber, function, aLibrary,
+ static_cast<uintptr_t>(aLOffset));
+ } else {
+ // We have nothing useful to go on. (The format string is split because
+ // '??)' is a trigraph and causes a warning, sigh.)
+ return SprintfBuf(aBuffer, aBufferSize,
+ "#%02u: ??? (???:???"
+ ")",
+ aFrameNumber);
+ }
+}
+
+static void EnsureWrite(FILE* aStream, const char* aBuf, size_t aLen) {
+#ifdef XP_WIN
+ int fd = _fileno(aStream);
+#else
+ int fd = fileno(aStream);
+#endif
+ while (aLen > 0) {
+#ifdef XP_WIN
+ auto written = _write(fd, aBuf, aLen);
+#else
+ auto written = write(fd, aBuf, aLen);
+#endif
+ if (written <= 0 || size_t(written) > aLen) {
+ break;
+ }
+ aBuf += written;
+ aLen -= written;
+ }
+}
+
+template <int N>
+static int PrintStackFrameBuf(char (&aBuf)[N], uint32_t aFrameNumber, void* aPC,
+ void* aSP) {
+ MozCodeAddressDetails details;
+ MozDescribeCodeAddress(aPC, &details);
+ int len =
+ MozFormatCodeAddressDetails(aBuf, N - 1, aFrameNumber, aPC, &details);
+ len = std::min(len, N - 2);
+ aBuf[len++] = '\n';
+ aBuf[len] = '\0';
+ return len;
+}
+
+static void PrintStackFrame(uint32_t aFrameNumber, void* aPC, void* aSP,
+ void* aClosure) {
+ FILE* stream = (FILE*)aClosure;
+ char buf[1025]; // 1024 + 1 for trailing '\n'
+ int len = PrintStackFrameBuf(buf, aFrameNumber, aPC, aSP);
+ fflush(stream);
+ EnsureWrite(stream, buf, len);
+}
+
+static bool WalkTheStackEnabled() {
+ static bool result = [] {
+ char* value = getenv("MOZ_DISABLE_WALKTHESTACK");
+ return !(value && value[0]);
+ }();
+ return result;
+}
+
+MFBT_API void MozWalkTheStack(FILE* aStream, const void* aFirstFramePC,
+ uint32_t aMaxFrames) {
+ if (WalkTheStackEnabled()) {
+ MozStackWalk(PrintStackFrame, aFirstFramePC ? aFirstFramePC : CallerPC(),
+ aMaxFrames, aStream);
+ }
+}
+
+static void WriteStackFrame(uint32_t aFrameNumber, void* aPC, void* aSP,
+ void* aClosure) {
+ auto writer = (void (*)(const char*))aClosure;
+ char buf[1024];
+ PrintStackFrameBuf(buf, aFrameNumber, aPC, aSP);
+ writer(buf);
+}
+
+MFBT_API void MozWalkTheStackWithWriter(void (*aWriter)(const char*),
+ const void* aFirstFramePC,
+ uint32_t aMaxFrames) {
+ if (WalkTheStackEnabled()) {
+ MozStackWalk(WriteStackFrame, aFirstFramePC ? aFirstFramePC : CallerPC(),
+ aMaxFrames, (void*)aWriter);
+ }
+}
diff --git a/mozglue/misc/StackWalk.h b/mozglue/misc/StackWalk.h
new file mode 100644
index 0000000000..250160934f
--- /dev/null
+++ b/mozglue/misc/StackWalk.h
@@ -0,0 +1,215 @@
+/* -*- 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/. */
+
+/* APIs for getting a stack trace of the current thread */
+
+#ifndef mozilla_StackWalk_h
+#define mozilla_StackWalk_h
+
+#include "mozilla/Types.h"
+#include <stdint.h>
+#include <stdio.h>
+
+MOZ_BEGIN_EXTERN_C
+
+/**
+ * Returns the position of the Program Counter for the caller of the current
+ * function. This is meant to be used to feed the aFirstFramePC argument to
+ * MozStackWalk or MozWalkTheStack*, and should be used in the last function
+ * that should be skipped in the trace, and passed down to MozStackWalk or
+ * MozWalkTheStack*, through any intermediaries.
+ *
+ * THIS DOES NOT 100% RELIABLY GIVE THE CALLER PC, but marking functions
+ * calling this macro with MOZ_NEVER_INLINE gets us close. In cases it doesn't
+ * give the caller's PC, it may give the caller of the caller, or its caller,
+ * etc. depending on tail call optimization.
+ *
+ * Past versions of stackwalking relied on passing a constant number of frames
+ * to skip to MozStackWalk or MozWalkTheStack, which fell short in more cases
+ * (inlining of intermediaries, tail call optimization).
+ */
+#define CallerPC() __builtin_extract_return_addr(__builtin_return_address(0))
+
+/**
+ * The callback for MozStackWalk and MozStackWalkThread.
+ *
+ * @param aFrameNumber The frame number (starts at 1, not 0).
+ * @param aPC The program counter value.
+ * @param aSP The best approximation possible of what the stack
+ * pointer will be pointing to when the execution returns
+ * to executing that at aPC. If no approximation can
+ * be made it will be nullptr.
+ * @param aClosure Extra data passed in from MozStackWalk() or
+ * MozStackWalkThread().
+ */
+typedef void (*MozWalkStackCallback)(uint32_t aFrameNumber, void* aPC,
+ void* aSP, void* aClosure);
+
+/**
+ * Call aCallback for each stack frame on the current thread, from
+ * the caller of MozStackWalk to main (or above).
+ *
+ * @param aCallback Callback function, called once per frame.
+ * @param aFirstFramePC Position of the Program Counter where the trace
+ * starts from. All frames seen before reaching that
+ * address are skipped. Nullptr means that the first
+ * callback will be for the caller of MozStackWalk.
+ * @param aMaxFrames Maximum number of frames to trace. 0 means no limit.
+ * @param aClosure Caller-supplied data passed through to aCallback.
+ *
+ * May skip some stack frames due to compiler optimizations or code
+ * generation.
+ */
+MFBT_API void MozStackWalk(MozWalkStackCallback aCallback,
+ const void* aFirstFramePC, uint32_t aMaxFrames,
+ void* aClosure);
+
+typedef struct {
+ /*
+ * The name of the shared library or executable containing an
+ * address and the address's offset within that library, or empty
+ * string and zero if unknown.
+ */
+ char library[256];
+ ptrdiff_t loffset;
+ /*
+ * The name of the file name and line number of the code
+ * corresponding to the address, or empty string and zero if
+ * unknown.
+ */
+ char filename[256];
+ unsigned long lineno;
+ /*
+ * The name of the function containing an address and the address's
+ * offset within that function, or empty string and zero if unknown.
+ */
+ char function[256];
+ ptrdiff_t foffset;
+} MozCodeAddressDetails;
+
+/**
+ * For a given pointer to code, fill in the pieces of information used
+ * when printing a stack trace.
+ *
+ * @param aPC The code address.
+ * @param aDetails A structure to be filled in with the result.
+ */
+MFBT_API bool MozDescribeCodeAddress(void* aPC,
+ MozCodeAddressDetails* aDetails);
+
+/**
+ * Format the information about a code address in a format suitable for
+ * stack traces on the current platform. When available, this string
+ * should contain the function name, source file, and line number. When
+ * these are not available, library and offset should be reported, if
+ * possible.
+ *
+ * Note that this output is parsed by several scripts including the fix*.py and
+ * make-tree.pl scripts in tools/rb/. It should only be change with care, and
+ * in conjunction with those scripts.
+ *
+ * @param aBuffer A string to be filled in with the description.
+ * The string will always be null-terminated.
+ * @param aBufferSize The size, in bytes, of aBuffer, including
+ * room for the terminating null. If the information
+ * to be printed would be larger than aBuffer, it
+ * will be truncated so that aBuffer[aBufferSize-1]
+ * is the terminating null.
+ * @param aFrameNumber The frame number.
+ * @param aPC The code address.
+ * @param aFunction The function name. Possibly null or the empty string.
+ * @param aLibrary The library name. Possibly null or the empty string.
+ * @param aLOffset The library offset.
+ * @param aFileName The filename. Possibly null or the empty string.
+ * @param aLineNo The line number. Possibly zero.
+ * @return The minimum number of characters necessary to format
+ * the frame information, without the terminating null.
+ * The buffer will have been truncated if the returned
+ * value is greater than aBufferSize-1.
+ */
+MFBT_API int MozFormatCodeAddress(char* aBuffer, uint32_t aBufferSize,
+ uint32_t aFrameNumber, const void* aPC,
+ const char* aFunction, const char* aLibrary,
+ ptrdiff_t aLOffset, const char* aFileName,
+ uint32_t aLineNo);
+
+/**
+ * Format the information about a code address in the same fashion as
+ * MozFormatCodeAddress.
+ *
+ * @param aBuffer A string to be filled in with the description.
+ * The string will always be null-terminated.
+ * @param aBufferSize The size, in bytes, of aBuffer, including
+ * room for the terminating null. If the information
+ * to be printed would be larger than aBuffer, it
+ * will be truncated so that aBuffer[aBufferSize-1]
+ * is the terminating null.
+ * @param aFrameNumber The frame number.
+ * @param aPC The code address.
+ * @param aDetails The value filled in by MozDescribeCodeAddress(aPC).
+ * @return The minimum number of characters necessary to format
+ * the frame information, without the terminating null.
+ * The buffer will have been truncated if the returned
+ * value is greater than aBufferSize-1.
+ */
+MFBT_API int MozFormatCodeAddressDetails(char* aBuffer, uint32_t aBufferSize,
+ uint32_t aFrameNumber, void* aPC,
+ const MozCodeAddressDetails* aDetails);
+
+#ifdef __cplusplus
+# define FRAMES_DEFAULT = 0
+#else
+# define FRAMES_DEFAULT
+#endif
+/**
+ * Walk the stack and print the stack trace to the given stream.
+ *
+ * @param aStream A stdio stream.
+ * @param aFirstFramePC Position of the Program Counter where the trace
+ * starts from. All frames seen before reaching that
+ * address are skipped. Nullptr means that the first
+ * callback will be for the caller of MozWalkTheStack.
+ * @param aMaxFrames Maximum number of frames to trace. 0 means no limit.
+ */
+MFBT_API void MozWalkTheStack(FILE* aStream,
+ const void* aFirstFramePC FRAMES_DEFAULT,
+ uint32_t aMaxFrames FRAMES_DEFAULT);
+
+/**
+ * Walk the stack and send each stack trace line to a callback writer.
+ * Each line string is null terminated but doesn't contain a '\n' character.
+ *
+ * @param aWriter The callback.
+ * @param aFirstFramePC Position of the Program Counter where the trace
+ * starts from. All frames seen before reaching that
+ * address are skipped. Nullptr means that the first
+ * callback will be for the caller of
+ * MozWalkTheStackWithWriter.
+ * @param aMaxFrames Maximum number of frames to trace. 0 means no limit.
+ */
+MFBT_API void MozWalkTheStackWithWriter(
+ void (*aWriter)(const char*), const void* aFirstFramePC FRAMES_DEFAULT,
+ uint32_t aMaxFrames FRAMES_DEFAULT);
+
+#undef FRAMES_DEFAULT
+
+MOZ_END_EXTERN_C
+
+#ifdef __cplusplus
+namespace mozilla {
+
+MFBT_API void FramePointerStackWalk(MozWalkStackCallback aCallback,
+ uint32_t aMaxFrames, void* aClosure,
+ void** aBp, void* aStackEnd);
+
+# if defined(XP_LINUX) || defined(XP_FREEBSD)
+MFBT_API void DemangleSymbol(const char* aSymbol, char* aBuffer, int aBufLen);
+# endif
+
+} // namespace mozilla
+#endif
+
+#endif
diff --git a/mozglue/misc/StackWalkThread.h b/mozglue/misc/StackWalkThread.h
new file mode 100644
index 0000000000..1db789de35
--- /dev/null
+++ b/mozglue/misc/StackWalkThread.h
@@ -0,0 +1,34 @@
+/* -*- 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/. */
+
+/* APIs for getting a stack trace of an arbitrary thread */
+
+#ifndef mozilla_StackWalkThread_h
+#define mozilla_StackWalkThread_h
+
+#include "mozilla/StackWalk.h"
+
+#include <windows.h>
+
+/**
+ * Like MozStackWalk, but walks the stack for another thread.
+ * Call aCallback for each stack frame on the current thread, from
+ * the caller of MozStackWalk to main (or above).
+ *
+ * @param aCallback Same as for MozStackWalk().
+ * @param aMaxFrames Same as for MozStackWalk().
+ * @param aClosure Same as for MozStackWalk().
+ * @param aThread The handle of the thread whose stack is to be walked.
+ * If 0, walks the current thread.
+ * @param aContext A CONTEXT, presumably obtained with GetThreadContext()
+ * after suspending the thread with SuspendThread(). If
+ * null, the CONTEXT will be re-obtained.
+ */
+MFBT_API void MozStackWalkThread(MozWalkStackCallback aCallback,
+ uint32_t aMaxFrames, void* aClosure,
+ HANDLE aThread, CONTEXT* aContext);
+
+#endif
diff --git a/mozglue/misc/StackWalk_windows.h b/mozglue/misc/StackWalk_windows.h
new file mode 100644
index 0000000000..dca4d41064
--- /dev/null
+++ b/mozglue/misc/StackWalk_windows.h
@@ -0,0 +1,34 @@
+/* -*- 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/. */
+
+#ifndef mozilla_StackWalk_windows_h
+#define mozilla_StackWalk_windows_h
+
+#include "mozilla/Types.h"
+
+#if defined(_M_AMD64) || defined(_M_ARM64)
+/**
+ * Allow stack walkers to work around the egregious win64 dynamic lookup table
+ * list API by locking around SuspendThread to avoid deadlock.
+ *
+ * See comment in StackWalk.cpp
+ */
+struct MOZ_RAII AutoSuppressStackWalking {
+ MFBT_API AutoSuppressStackWalking();
+ MFBT_API ~AutoSuppressStackWalking();
+};
+
+# if defined(IMPL_MFBT)
+void SuppressStackWalking();
+void DesuppressStackWalking();
+# endif // defined(IMPL_MFBT)
+
+MFBT_API void RegisterJitCodeRegion(uint8_t* aStart, size_t size);
+
+MFBT_API void UnregisterJitCodeRegion(uint8_t* aStart, size_t size);
+#endif // _M_AMD64
+
+#endif // mozilla_StackWalk_windows_h
diff --git a/mozglue/misc/TimeStamp.cpp b/mozglue/misc/TimeStamp.cpp
new file mode 100644
index 0000000000..4133234617
--- /dev/null
+++ b/mozglue/misc/TimeStamp.cpp
@@ -0,0 +1,85 @@
+/* -*- 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/. */
+
+/*
+ * Implementation of the OS-independent methods of the TimeStamp class
+ */
+
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Uptime.h"
+#include <string.h>
+#include <stdlib.h>
+
+namespace mozilla {
+
+/**
+ * Wrapper class used to initialize static data used by the TimeStamp class
+ */
+struct TimeStampInitialization {
+ /**
+ * First timestamp taken when the class static initializers are run. This
+ * timestamp is used to sanitize timestamps coming from different sources.
+ */
+ TimeStamp mFirstTimeStamp;
+
+ /**
+ * Timestamp representing the time when the process was created. This field
+ * is populated lazily the first time this information is required and is
+ * replaced every time the process is restarted.
+ */
+ TimeStamp mProcessCreation;
+
+ TimeStampInitialization() {
+ TimeStamp::Startup();
+ mFirstTimeStamp = TimeStamp::Now();
+ // On Windows < 10, initializing the uptime requires `mFirstTimeStamp` to be
+ // valid.
+ mozilla::InitializeUptime();
+ };
+
+ ~TimeStampInitialization() { TimeStamp::Shutdown(); };
+};
+
+static TimeStampInitialization sInitOnce;
+
+MFBT_API TimeStamp TimeStamp::ProcessCreation() {
+ if (sInitOnce.mProcessCreation.IsNull()) {
+ char* mozAppRestart = getenv("MOZ_APP_RESTART");
+ TimeStamp ts;
+
+ /* When calling PR_SetEnv() with an empty value the existing variable may
+ * be unset or set to the empty string depending on the underlying platform
+ * thus we have to check if the variable is present and not empty. */
+ if (mozAppRestart && (strcmp(mozAppRestart, "") != 0)) {
+ /* Firefox was restarted, use the first time-stamp we've taken as the new
+ * process startup time. */
+ ts = sInitOnce.mFirstTimeStamp;
+ } else {
+ TimeStamp now = Now();
+ uint64_t uptime = ComputeProcessUptime();
+
+ ts = now - TimeDuration::FromMicroseconds(static_cast<double>(uptime));
+
+ if ((ts > sInitOnce.mFirstTimeStamp) || (uptime == 0)) {
+ ts = sInitOnce.mFirstTimeStamp;
+ }
+ }
+
+ sInitOnce.mProcessCreation = ts;
+ }
+
+ return sInitOnce.mProcessCreation;
+}
+
+void TimeStamp::RecordProcessRestart() {
+ sInitOnce.mProcessCreation = TimeStamp();
+}
+
+MFBT_API TimeStamp TimeStamp::FirstTimeStamp() {
+ return sInitOnce.mFirstTimeStamp;
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/TimeStamp.h b/mozglue/misc/TimeStamp.h
new file mode 100644
index 0000000000..102116815d
--- /dev/null
+++ b/mozglue/misc/TimeStamp.h
@@ -0,0 +1,603 @@
+/* -*- 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/. */
+
+#ifndef mozilla_TimeStamp_h
+#define mozilla_TimeStamp_h
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/Types.h"
+#include <algorithm> // for std::min, std::max
+#include <ostream>
+#include <stdint.h>
+#include <type_traits>
+
+namespace IPC {
+template <typename T>
+struct ParamTraits;
+} // namespace IPC
+
+#ifdef XP_WIN
+// defines TimeStampValue as a complex value keeping both
+// GetTickCount and QueryPerformanceCounter values
+# include "TimeStamp_windows.h"
+
+# include "mozilla/Maybe.h" // For TimeStamp::RawQueryPerformanceCounterValue
+#endif
+
+namespace mozilla {
+
+#ifndef XP_WIN
+typedef uint64_t TimeStampValue;
+#endif
+
+class TimeStamp;
+
+/**
+ * Platform-specific implementation details of BaseTimeDuration.
+ */
+class BaseTimeDurationPlatformUtils {
+ public:
+ static MFBT_API double ToSeconds(int64_t aTicks);
+ static MFBT_API double ToSecondsSigDigits(int64_t aTicks);
+ static MFBT_API int64_t TicksFromMilliseconds(double aMilliseconds);
+ static MFBT_API int64_t ResolutionInTicks();
+};
+
+/**
+ * Instances of this class represent the length of an interval of time.
+ * Negative durations are allowed, meaning the end is before the start.
+ *
+ * Internally the duration is stored as a int64_t in units of
+ * PR_TicksPerSecond() when building with NSPR interval timers, or a
+ * system-dependent unit when building with system clocks. The
+ * system-dependent unit must be constant, otherwise the semantics of
+ * this class would be broken.
+ *
+ * The ValueCalculator template parameter determines how arithmetic
+ * operations are performed on the integer count of ticks (mValue).
+ */
+template <typename ValueCalculator>
+class BaseTimeDuration {
+ public:
+ // The default duration is 0.
+ constexpr BaseTimeDuration() : mValue(0) {}
+ // Allow construction using '0' as the initial value, for readability,
+ // but no other numbers (so we don't have any implicit unit conversions).
+ struct _SomethingVeryRandomHere;
+ MOZ_IMPLICIT BaseTimeDuration(_SomethingVeryRandomHere* aZero) : mValue(0) {
+ MOZ_ASSERT(!aZero, "Who's playing funny games here?");
+ }
+ // Default copy-constructor and assignment are OK
+
+ // Converting copy-constructor and assignment operator
+ template <typename E>
+ explicit BaseTimeDuration(const BaseTimeDuration<E>& aOther)
+ : mValue(aOther.mValue) {}
+
+ template <typename E>
+ BaseTimeDuration& operator=(const BaseTimeDuration<E>& aOther) {
+ mValue = aOther.mValue;
+ return *this;
+ }
+
+ double ToSeconds() const {
+ if (mValue == INT64_MAX) {
+ return PositiveInfinity<double>();
+ }
+ if (mValue == INT64_MIN) {
+ return NegativeInfinity<double>();
+ }
+ return BaseTimeDurationPlatformUtils::ToSeconds(mValue);
+ }
+ // Return a duration value that includes digits of time we think to
+ // be significant. This method should be used when displaying a
+ // time to humans.
+ double ToSecondsSigDigits() const {
+ if (mValue == INT64_MAX) {
+ return PositiveInfinity<double>();
+ }
+ if (mValue == INT64_MIN) {
+ return NegativeInfinity<double>();
+ }
+ return BaseTimeDurationPlatformUtils::ToSecondsSigDigits(mValue);
+ }
+ double ToMilliseconds() const { return ToSeconds() * 1000.0; }
+ double ToMicroseconds() const { return ToMilliseconds() * 1000.0; }
+
+ // Using a double here is safe enough; with 53 bits we can represent
+ // durations up to over 280,000 years exactly. If the units of
+ // mValue do not allow us to represent durations of that length,
+ // long durations are clamped to the max/min representable value
+ // instead of overflowing.
+ static inline BaseTimeDuration FromSeconds(double aSeconds) {
+ return FromMilliseconds(aSeconds * 1000.0);
+ }
+ static BaseTimeDuration FromMilliseconds(double aMilliseconds) {
+ if (aMilliseconds == PositiveInfinity<double>()) {
+ return Forever();
+ }
+ if (aMilliseconds == NegativeInfinity<double>()) {
+ return FromTicks(INT64_MIN);
+ }
+ return FromTicks(
+ BaseTimeDurationPlatformUtils::TicksFromMilliseconds(aMilliseconds));
+ }
+ static inline BaseTimeDuration FromMicroseconds(double aMicroseconds) {
+ return FromMilliseconds(aMicroseconds / 1000.0);
+ }
+
+ static constexpr BaseTimeDuration Forever() { return FromTicks(INT64_MAX); }
+
+ BaseTimeDuration operator+(const BaseTimeDuration& aOther) const {
+ return FromTicks(ValueCalculator::Add(mValue, aOther.mValue));
+ }
+ BaseTimeDuration operator-(const BaseTimeDuration& aOther) const {
+ return FromTicks(ValueCalculator::Subtract(mValue, aOther.mValue));
+ }
+ BaseTimeDuration& operator+=(const BaseTimeDuration& aOther) {
+ mValue = ValueCalculator::Add(mValue, aOther.mValue);
+ return *this;
+ }
+ BaseTimeDuration& operator-=(const BaseTimeDuration& aOther) {
+ mValue = ValueCalculator::Subtract(mValue, aOther.mValue);
+ return *this;
+ }
+ BaseTimeDuration operator-() const {
+ // We don't just use FromTicks(ValueCalculator::Subtract(0, mValue))
+ // since that won't give the correct result for -TimeDuration::Forever().
+ int64_t ticks;
+ if (mValue == INT64_MAX) {
+ ticks = INT64_MIN;
+ } else if (mValue == INT64_MIN) {
+ ticks = INT64_MAX;
+ } else {
+ ticks = -mValue;
+ }
+
+ return FromTicks(ticks);
+ }
+
+ static BaseTimeDuration Max(const BaseTimeDuration& aA,
+ const BaseTimeDuration& aB) {
+ return FromTicks(std::max(aA.mValue, aB.mValue));
+ }
+ static BaseTimeDuration Min(const BaseTimeDuration& aA,
+ const BaseTimeDuration& aB) {
+ return FromTicks(std::min(aA.mValue, aB.mValue));
+ }
+
+#if defined(DEBUG)
+ int64_t GetValue() const { return mValue; }
+#endif
+
+ private:
+ // Block double multiplier (slower, imprecise if long duration) - Bug 853398.
+ // If required, use MultDouble explicitly and with care.
+ BaseTimeDuration operator*(const double aMultiplier) const = delete;
+
+ // Block double divisor (for the same reason, and because dividing by
+ // fractional values would otherwise invoke the int64_t variant, and rounding
+ // the passed argument can then cause divide-by-zero) - Bug 1147491.
+ BaseTimeDuration operator/(const double aDivisor) const = delete;
+
+ public:
+ BaseTimeDuration MultDouble(double aMultiplier) const {
+ return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+ }
+ BaseTimeDuration operator*(const int32_t aMultiplier) const {
+ return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+ }
+ BaseTimeDuration operator*(const uint32_t aMultiplier) const {
+ return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+ }
+ BaseTimeDuration operator*(const int64_t aMultiplier) const {
+ return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+ }
+ BaseTimeDuration operator*(const uint64_t aMultiplier) const {
+ if (aMultiplier > INT64_MAX) {
+ return Forever();
+ }
+ return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+ }
+ BaseTimeDuration operator/(const int64_t aDivisor) const {
+ MOZ_ASSERT(aDivisor != 0, "Division by zero");
+ return FromTicks(ValueCalculator::Divide(mValue, aDivisor));
+ }
+ double operator/(const BaseTimeDuration& aOther) const {
+ MOZ_ASSERT(aOther.mValue != 0, "Division by zero");
+ return ValueCalculator::DivideDouble(mValue, aOther.mValue);
+ }
+ BaseTimeDuration operator%(const BaseTimeDuration& aOther) const {
+ MOZ_ASSERT(aOther.mValue != 0, "Division by zero");
+ return FromTicks(ValueCalculator::Modulo(mValue, aOther.mValue));
+ }
+
+ template <typename E>
+ bool operator<(const BaseTimeDuration<E>& aOther) const {
+ return mValue < aOther.mValue;
+ }
+ template <typename E>
+ bool operator<=(const BaseTimeDuration<E>& aOther) const {
+ return mValue <= aOther.mValue;
+ }
+ template <typename E>
+ bool operator>=(const BaseTimeDuration<E>& aOther) const {
+ return mValue >= aOther.mValue;
+ }
+ template <typename E>
+ bool operator>(const BaseTimeDuration<E>& aOther) const {
+ return mValue > aOther.mValue;
+ }
+ template <typename E>
+ bool operator==(const BaseTimeDuration<E>& aOther) const {
+ return mValue == aOther.mValue;
+ }
+ template <typename E>
+ bool operator!=(const BaseTimeDuration<E>& aOther) const {
+ return mValue != aOther.mValue;
+ }
+ bool IsZero() const { return mValue == 0; }
+ explicit operator bool() const { return mValue != 0; }
+
+ friend std::ostream& operator<<(std::ostream& aStream,
+ const BaseTimeDuration& aDuration) {
+ return aStream << aDuration.ToMilliseconds() << " ms";
+ }
+
+ // Return a best guess at the system's current timing resolution,
+ // which might be variable. BaseTimeDurations below this order of
+ // magnitude are meaningless, and those at the same order of
+ // magnitude or just above are suspect.
+ static BaseTimeDuration Resolution() {
+ return FromTicks(BaseTimeDurationPlatformUtils::ResolutionInTicks());
+ }
+
+ // We could define additional operators here:
+ // -- convert to/from other time units
+ // -- scale duration by a float
+ // but let's do that on demand.
+ // Comparing durations for equality will only lead to bugs on
+ // platforms with high-resolution timers.
+
+ private:
+ friend class TimeStamp;
+ friend struct IPC::ParamTraits<mozilla::BaseTimeDuration<ValueCalculator>>;
+ template <typename>
+ friend class BaseTimeDuration;
+
+ static BaseTimeDuration FromTicks(int64_t aTicks) {
+ BaseTimeDuration t;
+ t.mValue = aTicks;
+ return t;
+ }
+
+ static BaseTimeDuration FromTicks(double aTicks) {
+ // NOTE: this MUST be a >= test, because int64_t(double(INT64_MAX))
+ // overflows and gives INT64_MIN.
+ if (aTicks >= double(INT64_MAX)) {
+ return FromTicks(INT64_MAX);
+ }
+
+ // This MUST be a <= test.
+ if (aTicks <= double(INT64_MIN)) {
+ return FromTicks(INT64_MIN);
+ }
+
+ return FromTicks(int64_t(aTicks));
+ }
+
+ // Duration, result is implementation-specific difference of two TimeStamps
+ int64_t mValue;
+};
+
+/**
+ * Perform arithmetic operations on the value of a BaseTimeDuration without
+ * doing strict checks on the range of values.
+ */
+class TimeDurationValueCalculator {
+ public:
+ static int64_t Add(int64_t aA, int64_t aB) { return aA + aB; }
+ static int64_t Subtract(int64_t aA, int64_t aB) { return aA - aB; }
+
+ template <typename T>
+ static int64_t Multiply(int64_t aA, T aB) {
+ static_assert(std::is_integral_v<T>,
+ "Using integer multiplication routine with non-integer type."
+ " Further specialization required");
+ return aA * static_cast<int64_t>(aB);
+ }
+
+ static int64_t Divide(int64_t aA, int64_t aB) { return aA / aB; }
+ static double DivideDouble(int64_t aA, int64_t aB) {
+ return static_cast<double>(aA) / aB;
+ }
+ static int64_t Modulo(int64_t aA, int64_t aB) { return aA % aB; }
+};
+
+template <>
+inline int64_t TimeDurationValueCalculator::Multiply<double>(int64_t aA,
+ double aB) {
+ return static_cast<int64_t>(aA * aB);
+}
+
+/**
+ * Specialization of BaseTimeDuration that uses TimeDurationValueCalculator for
+ * arithmetic on the mValue member.
+ *
+ * Use this class for time durations that are *not* expected to hold values of
+ * Forever (or the negative equivalent) or when such time duration are *not*
+ * expected to be used in arithmetic operations.
+ */
+typedef BaseTimeDuration<TimeDurationValueCalculator> TimeDuration;
+
+/**
+ * Instances of this class represent moments in time, or a special
+ * "null" moment. We do not use the non-monotonic system clock or
+ * local time, since they can be reset, causing apparent backward
+ * travel in time, which can confuse algorithms. Instead we measure
+ * elapsed time according to the system. This time can never go
+ * backwards (i.e. it never wraps around, at least not in less than
+ * five million years of system elapsed time). It might not advance
+ * while the system is sleeping. If TimeStamp::SetNow() is not called
+ * at all for hours or days, we might not notice the passage of some
+ * of that time.
+ *
+ * We deliberately do not expose a way to convert TimeStamps to some
+ * particular unit. All you can do is compute a difference between two
+ * TimeStamps to get a TimeDuration. You can also add a TimeDuration
+ * to a TimeStamp to get a new TimeStamp. You can't do something
+ * meaningless like add two TimeStamps.
+ *
+ * Internally this is implemented as either a wrapper around
+ * - high-resolution, monotonic, system clocks if they exist on this
+ * platform
+ * - PRIntervalTime otherwise. We detect wraparounds of
+ * PRIntervalTime and work around them.
+ *
+ * This class is similar to C++11's time_point, however it is
+ * explicitly nullable and provides an IsNull() method. time_point
+ * is initialized to the clock's epoch and provides a
+ * time_since_epoch() method that functions similiarly. i.e.
+ * t.IsNull() is equivalent to t.time_since_epoch() ==
+ * decltype(t)::duration::zero();
+ *
+ * Note that, since TimeStamp objects are small, prefer to pass them by value
+ * unless there is a specific reason not to do so.
+ */
+class TimeStamp {
+ public:
+ /**
+ * Initialize to the "null" moment
+ */
+ constexpr TimeStamp() : mValue(0) {}
+ // Default copy-constructor and assignment are OK
+
+ /**
+ * The system timestamps are the same as the TimeStamp
+ * retrieved by mozilla::TimeStamp. Since we need this for
+ * vsync timestamps, we enable the creation of mozilla::TimeStamps
+ * on platforms that support vsync aligned refresh drivers / compositors
+ * Verified true as of Jan 31, 2015: B2G and OS X
+ * False on Windows 7
+ * Android's event time uses CLOCK_MONOTONIC via SystemClock.uptimeMilles.
+ * So it is same value of TimeStamp posix implementation.
+ * Wayland/GTK event time also uses CLOCK_MONOTONIC on Weston/Mutter
+ * compositors.
+ * UNTESTED ON OTHER PLATFORMS
+ */
+#if defined(XP_DARWIN) || defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK)
+ static TimeStamp FromSystemTime(int64_t aSystemTime) {
+ static_assert(sizeof(aSystemTime) == sizeof(TimeStampValue),
+ "System timestamp should be same units as TimeStampValue");
+ return TimeStamp(aSystemTime);
+ }
+#endif
+
+ /**
+ * Return true if this is the "null" moment
+ */
+ bool IsNull() const { return mValue == 0; }
+
+ /**
+ * Return true if this is not the "null" moment, may be used in tests, e.g.:
+ * |if (timestamp) { ... }|
+ */
+ explicit operator bool() const { return mValue != 0; }
+
+ /**
+ * Return a timestamp reflecting the current elapsed system time. This
+ * is monotonically increasing (i.e., does not decrease) over the
+ * lifetime of this process' XPCOM session.
+ *
+ * Now() is trying to ensure the best possible precision on each platform,
+ * at least one millisecond.
+ *
+ * NowLoRes() has been introduced to workaround performance problems of
+ * QueryPerformanceCounter on the Windows platform. NowLoRes() is giving
+ * lower precision, usually 15.6 ms, but with very good performance benefit.
+ * Use it for measurements of longer times, like >200ms timeouts.
+ */
+ static TimeStamp Now() { return Now(true); }
+ static TimeStamp NowLoRes() { return Now(false); }
+
+ /**
+ * Return a timestamp representing the time when the current process was
+ * created which will be comparable with other timestamps taken with this
+ * class.
+ *
+ * @returns A timestamp representing the time when the process was created
+ */
+ static MFBT_API TimeStamp ProcessCreation();
+
+ /**
+ * Return the very first timestamp that was taken. This can be used instead
+ * of TimeStamp::ProcessCreation() by code that might not allow running the
+ * complex logic required to compute the real process creation. This will
+ * necessarily have been recorded sometimes after TimeStamp::ProcessCreation()
+ * or at best should be equal to it.
+ *
+ * @returns The first tiemstamp that was taken by this process
+ */
+ static MFBT_API TimeStamp FirstTimeStamp();
+
+ /**
+ * Records a process restart. After this call ProcessCreation() will return
+ * the time when the browser was restarted instead of the actual time when
+ * the process was created.
+ */
+ static MFBT_API void RecordProcessRestart();
+
+#ifdef XP_LINUX
+ uint64_t RawClockMonotonicNanosecondsSinceBoot() {
+ return static_cast<uint64_t>(mValue);
+ }
+#endif
+
+#ifdef XP_MACOSX
+ uint64_t RawMachAbsoluteTimeValue() { return static_cast<uint64_t>(mValue); }
+#endif
+
+#ifdef XP_WIN
+ Maybe<uint64_t> RawQueryPerformanceCounterValue() {
+ // mQPC is stored in `mt` i.e. QueryPerformanceCounter * 1000
+ // so divide out the 1000
+ return mValue.mHasQPC ? Some(mValue.mQPC / 1000ULL) : Nothing();
+ }
+#endif
+
+ /**
+ * Compute the difference between two timestamps. Both must be non-null.
+ */
+ TimeDuration operator-(const TimeStamp& aOther) const {
+ MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
+ MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
+ static_assert(-INT64_MAX > INT64_MIN, "int64_t sanity check");
+ int64_t ticks = int64_t(mValue - aOther.mValue);
+ // Check for overflow.
+ if (mValue > aOther.mValue) {
+ if (ticks < 0) {
+ ticks = INT64_MAX;
+ }
+ } else {
+ if (ticks > 0) {
+ ticks = INT64_MIN;
+ }
+ }
+ return TimeDuration::FromTicks(ticks);
+ }
+
+ TimeStamp operator+(const TimeDuration& aOther) const {
+ TimeStamp result = *this;
+ result += aOther;
+ return result;
+ }
+ TimeStamp operator-(const TimeDuration& aOther) const {
+ TimeStamp result = *this;
+ result -= aOther;
+ return result;
+ }
+ TimeStamp& operator+=(const TimeDuration& aOther) {
+ MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
+ TimeStampValue value = mValue + aOther.mValue;
+ // Check for underflow.
+ // (We don't check for overflow because it's not obvious what the error
+ // behavior should be in that case.)
+ if (aOther.mValue < 0 && value > mValue) {
+ value = 0;
+ }
+ mValue = value;
+ return *this;
+ }
+ TimeStamp& operator-=(const TimeDuration& aOther) {
+ MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
+ TimeStampValue value = mValue - aOther.mValue;
+ // Check for underflow.
+ // (We don't check for overflow because it's not obvious what the error
+ // behavior should be in that case.)
+ if (aOther.mValue > 0 && value > mValue) {
+ value = 0;
+ }
+ mValue = value;
+ return *this;
+ }
+
+ bool operator<(const TimeStamp& aOther) const {
+ MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
+ MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
+ return mValue < aOther.mValue;
+ }
+ bool operator<=(const TimeStamp& aOther) const {
+ MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
+ MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
+ return mValue <= aOther.mValue;
+ }
+ bool operator>=(const TimeStamp& aOther) const {
+ MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
+ MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
+ return mValue >= aOther.mValue;
+ }
+ bool operator>(const TimeStamp& aOther) const {
+ MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
+ MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
+ return mValue > aOther.mValue;
+ }
+ bool operator==(const TimeStamp& aOther) const {
+ return IsNull() ? aOther.IsNull()
+ : !aOther.IsNull() && mValue == aOther.mValue;
+ }
+ bool operator!=(const TimeStamp& aOther) const { return !(*this == aOther); }
+
+ // Comparing TimeStamps for equality should be discouraged. Adding
+ // two TimeStamps, or scaling TimeStamps, is nonsense and must never
+ // be allowed.
+
+ static MFBT_API void Startup();
+ static MFBT_API void Shutdown();
+
+#if defined(DEBUG)
+ TimeStampValue GetValue() const { return mValue; }
+#endif
+
+ private:
+ friend struct IPC::ParamTraits<mozilla::TimeStamp>;
+ friend struct TimeStampInitialization;
+
+ MOZ_IMPLICIT
+ TimeStamp(TimeStampValue aValue) : mValue(aValue) {}
+
+ static MFBT_API TimeStamp Now(bool aHighResolution);
+
+ /**
+ * Computes the uptime of the current process in microseconds. The result
+ * is platform-dependent and needs to be checked against existing timestamps
+ * for consistency.
+ *
+ * @returns The number of microseconds since the calling process was started
+ * or 0 if an error was encountered while computing the uptime
+ */
+ static MFBT_API uint64_t ComputeProcessUptime();
+
+ /**
+ * When built with PRIntervalTime, a value of 0 means this instance
+ * is "null". Otherwise, the low 32 bits represent a PRIntervalTime,
+ * and the high 32 bits represent a counter of the number of
+ * rollovers of PRIntervalTime that we've seen. This counter starts
+ * at 1 to avoid a real time colliding with the "null" value.
+ *
+ * PR_INTERVAL_MAX is set at 100,000 ticks per second. So the minimum
+ * time to wrap around is about 2^64/100000 seconds, i.e. about
+ * 5,849,424 years.
+ *
+ * When using a system clock, a value is system dependent.
+ */
+ TimeStampValue mValue;
+};
+
+} // namespace mozilla
+
+#endif /* mozilla_TimeStamp_h */
diff --git a/mozglue/misc/TimeStamp_darwin.cpp b/mozglue/misc/TimeStamp_darwin.cpp
new file mode 100644
index 0000000000..896ac8ae92
--- /dev/null
+++ b/mozglue/misc/TimeStamp_darwin.cpp
@@ -0,0 +1,187 @@
+/* -*- 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/. */
+
+//
+// Implement TimeStamp::Now() with mach_absolute_time
+//
+// The "tick" unit for mach_absolute_time is defined using mach_timebase_info()
+// which gives a conversion ratio to nanoseconds. For more information see
+// Apple's QA1398.
+//
+// This code is inspired by Chromium's time_mac.cc. The biggest
+// differences are that we explicitly initialize using
+// TimeStamp::Initialize() instead of lazily in Now() and that
+// we store the time value in ticks and convert when needed instead
+// of storing the time value in nanoseconds.
+
+#include <mach/mach_time.h>
+#include <sys/time.h>
+#include <sys/sysctl.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Uptime.h"
+
+// Estimate of the smallest duration of time we can measure.
+static uint64_t sResolution;
+static uint64_t sResolutionSigDigs;
+
+static const uint64_t kNsPerMs = 1000000;
+static const uint64_t kUsPerSec = 1000000;
+static const double kNsPerMsd = 1000000.0;
+static const double kNsPerSecd = 1000000000.0;
+
+static bool gInitialized = false;
+static double sNsPerTick;
+
+static uint64_t ClockTime() {
+ // mach_absolute_time is it when it comes to ticks on the Mac. Other calls
+ // with less precision (such as TickCount) just call through to
+ // mach_absolute_time.
+ //
+ // At the time of writing mach_absolute_time returns the number of nanoseconds
+ // since boot. This won't overflow 64bits for 500+ years so we aren't going
+ // to worry about that possiblity
+ return mach_absolute_time();
+}
+
+static uint64_t ClockResolutionNs() {
+ uint64_t start = ClockTime();
+ uint64_t end = ClockTime();
+ uint64_t minres = (end - start);
+
+ // 10 total trials is arbitrary: what we're trying to avoid by
+ // looping is getting unlucky and being interrupted by a context
+ // switch or signal, or being bitten by paging/cache effects
+ for (int i = 0; i < 9; ++i) {
+ start = ClockTime();
+ end = ClockTime();
+
+ uint64_t candidate = (start - end);
+ if (candidate < minres) {
+ minres = candidate;
+ }
+ }
+
+ if (0 == minres) {
+ // measurable resolution is either incredibly low, ~1ns, or very
+ // high. fall back on NSPR's resolution assumption
+ minres = 1 * kNsPerMs;
+ }
+
+ return minres;
+}
+
+namespace mozilla {
+
+double BaseTimeDurationPlatformUtils::ToSeconds(int64_t aTicks) {
+ MOZ_ASSERT(gInitialized, "calling TimeDuration too early");
+ return (aTicks * sNsPerTick) / kNsPerSecd;
+}
+
+double BaseTimeDurationPlatformUtils::ToSecondsSigDigits(int64_t aTicks) {
+ MOZ_ASSERT(gInitialized, "calling TimeDuration too early");
+ // don't report a value < mResolution ...
+ int64_t valueSigDigs = sResolution * (aTicks / sResolution);
+ // and chop off insignificant digits
+ valueSigDigs = sResolutionSigDigs * (valueSigDigs / sResolutionSigDigs);
+ return (valueSigDigs * sNsPerTick) / kNsPerSecd;
+}
+
+int64_t BaseTimeDurationPlatformUtils::TicksFromMilliseconds(
+ double aMilliseconds) {
+ MOZ_ASSERT(gInitialized, "calling TimeDuration too early");
+ double result = (aMilliseconds * kNsPerMsd) / sNsPerTick;
+ if (result > double(INT64_MAX)) {
+ return INT64_MAX;
+ } else if (result < double(INT64_MIN)) {
+ return INT64_MIN;
+ }
+
+ return result;
+}
+
+int64_t BaseTimeDurationPlatformUtils::ResolutionInTicks() {
+ MOZ_ASSERT(gInitialized, "calling TimeDuration too early");
+ return static_cast<int64_t>(sResolution);
+}
+
+void TimeStamp::Startup() {
+ if (gInitialized) {
+ return;
+ }
+
+ mach_timebase_info_data_t timebaseInfo;
+ // Apple's QA1398 suggests that the output from mach_timebase_info
+ // will not change while a program is running, so it should be safe
+ // to cache the result.
+ kern_return_t kr = mach_timebase_info(&timebaseInfo);
+ if (kr != KERN_SUCCESS) {
+ MOZ_RELEASE_ASSERT(false, "mach_timebase_info failed");
+ }
+
+ sNsPerTick = double(timebaseInfo.numer) / timebaseInfo.denom;
+
+ sResolution = ClockResolutionNs();
+
+ // find the number of significant digits in sResolution, for the
+ // sake of ToSecondsSigDigits()
+ for (sResolutionSigDigs = 1; !(sResolutionSigDigs == sResolution ||
+ 10 * sResolutionSigDigs > sResolution);
+ sResolutionSigDigs *= 10)
+ ;
+
+ gInitialized = true;
+
+ return;
+}
+
+void TimeStamp::Shutdown() {}
+
+TimeStamp TimeStamp::Now(bool aHighResolution) {
+ return TimeStamp(ClockTime());
+}
+
+// Computes and returns the process uptime in microseconds.
+// Returns 0 if an error was encountered.
+uint64_t TimeStamp::ComputeProcessUptime() {
+ struct timeval tv;
+ int rv = gettimeofday(&tv, nullptr);
+
+ if (rv == -1) {
+ return 0;
+ }
+
+ int mib[] = {
+ CTL_KERN,
+ KERN_PROC,
+ KERN_PROC_PID,
+ getpid(),
+ };
+ u_int mibLen = sizeof(mib) / sizeof(mib[0]);
+
+ struct kinfo_proc proc;
+ size_t bufferSize = sizeof(proc);
+ rv = sysctl(mib, mibLen, &proc, &bufferSize, nullptr, 0);
+
+ if (rv == -1) {
+ return 0;
+ }
+
+ uint64_t startTime =
+ ((uint64_t)proc.kp_proc.p_un.__p_starttime.tv_sec * kUsPerSec) +
+ proc.kp_proc.p_un.__p_starttime.tv_usec;
+ uint64_t now = (tv.tv_sec * kUsPerSec) + tv.tv_usec;
+
+ if (startTime > now) {
+ return 0;
+ }
+
+ return now - startTime;
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/TimeStamp_posix.cpp b/mozglue/misc/TimeStamp_posix.cpp
new file mode 100644
index 0000000000..10c046d046
--- /dev/null
+++ b/mozglue/misc/TimeStamp_posix.cpp
@@ -0,0 +1,337 @@
+/* -*- 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/. */
+
+//
+// Implement TimeStamp::Now() with POSIX clocks.
+//
+// The "tick" unit for POSIX clocks is simply a nanosecond, as this is
+// the smallest unit of time representable by struct timespec. That
+// doesn't mean that a nanosecond is the resolution of TimeDurations
+// obtained with this API; see TimeDuration::Resolution;
+//
+
+#include <sys/syscall.h>
+#include <time.h>
+#include <unistd.h>
+#include <string.h>
+
+#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
+ defined(__OpenBSD__)
+# include <sys/param.h>
+# include <sys/sysctl.h>
+#endif
+
+#if defined(__DragonFly__) || defined(__FreeBSD__)
+# include <sys/user.h>
+#endif
+
+#if defined(__NetBSD__)
+# undef KERN_PROC
+# define KERN_PROC KERN_PROC2
+# define KINFO_PROC struct kinfo_proc2
+#else
+# define KINFO_PROC struct kinfo_proc
+#endif
+
+#if defined(__DragonFly__)
+# define KP_START_SEC kp_start.tv_sec
+# define KP_START_USEC kp_start.tv_usec
+#elif defined(__FreeBSD__)
+# define KP_START_SEC ki_start.tv_sec
+# define KP_START_USEC ki_start.tv_usec
+#else
+# define KP_START_SEC p_ustart_sec
+# define KP_START_USEC p_ustart_usec
+#endif
+
+#include "mozilla/Sprintf.h"
+#include "mozilla/TimeStamp.h"
+
+#if !defined(__wasi__)
+# include <pthread.h>
+#endif
+
+// Estimate of the smallest duration of time we can measure.
+static uint64_t sResolution;
+static uint64_t sResolutionSigDigs;
+
+#if !defined(__wasi__)
+static const uint16_t kNsPerUs = 1000;
+#endif
+
+static const uint64_t kNsPerMs = 1000000;
+static const uint64_t kNsPerSec = 1000000000;
+static const double kNsPerMsd = 1000000.0;
+static const double kNsPerSecd = 1000000000.0;
+
+static uint64_t TimespecToNs(const struct timespec& aTs) {
+ uint64_t baseNs = uint64_t(aTs.tv_sec) * kNsPerSec;
+ return baseNs + uint64_t(aTs.tv_nsec);
+}
+
+static uint64_t ClockTimeNs() {
+ struct timespec ts;
+ // this can't fail: we know &ts is valid, and TimeStamp::Startup()
+ // checks that CLOCK_MONOTONIC is supported (and aborts if not)
+ clock_gettime(CLOCK_MONOTONIC, &ts);
+
+ // tv_sec is defined to be relative to an arbitrary point in time,
+ // but it would be madness for that point in time to be earlier than
+ // the Epoch. So we can safely assume that even if time_t is 32
+ // bits, tv_sec won't overflow while the browser is open. Revisit
+ // this argument if we're still building with 32-bit time_t around
+ // the year 2037.
+ return TimespecToNs(ts);
+}
+
+static uint64_t ClockResolutionNs() {
+ // NB: why not rely on clock_getres()? Two reasons: (i) it might
+ // lie, and (ii) it might return an "ideal" resolution that while
+ // theoretically true, could never be measured in practice. Since
+ // clock_gettime() likely involves a system call on your platform,
+ // the "actual" timing resolution shouldn't be lower than syscall
+ // overhead.
+
+ uint64_t start = ClockTimeNs();
+ uint64_t end = ClockTimeNs();
+ uint64_t minres = (end - start);
+
+ // 10 total trials is arbitrary: what we're trying to avoid by
+ // looping is getting unlucky and being interrupted by a context
+ // switch or signal, or being bitten by paging/cache effects
+ for (int i = 0; i < 9; ++i) {
+ start = ClockTimeNs();
+ end = ClockTimeNs();
+
+ uint64_t candidate = (start - end);
+ if (candidate < minres) {
+ minres = candidate;
+ }
+ }
+
+ if (0 == minres) {
+ // measurable resolution is either incredibly low, ~1ns, or very
+ // high. fall back on clock_getres()
+ struct timespec ts;
+ if (0 == clock_getres(CLOCK_MONOTONIC, &ts)) {
+ minres = TimespecToNs(ts);
+ }
+ }
+
+ if (0 == minres) {
+ // clock_getres probably failed. fall back on NSPR's resolution
+ // assumption
+ minres = 1 * kNsPerMs;
+ }
+
+ return minres;
+}
+
+namespace mozilla {
+
+double BaseTimeDurationPlatformUtils::ToSeconds(int64_t aTicks) {
+ return double(aTicks) / kNsPerSecd;
+}
+
+double BaseTimeDurationPlatformUtils::ToSecondsSigDigits(int64_t aTicks) {
+ // don't report a value < mResolution ...
+ int64_t valueSigDigs = sResolution * (aTicks / sResolution);
+ // and chop off insignificant digits
+ valueSigDigs = sResolutionSigDigs * (valueSigDigs / sResolutionSigDigs);
+ return double(valueSigDigs) / kNsPerSecd;
+}
+
+int64_t BaseTimeDurationPlatformUtils::TicksFromMilliseconds(
+ double aMilliseconds) {
+ double result = aMilliseconds * kNsPerMsd;
+ if (result > double(INT64_MAX)) {
+ return INT64_MAX;
+ }
+ if (result < INT64_MIN) {
+ return INT64_MIN;
+ }
+
+ return result;
+}
+
+int64_t BaseTimeDurationPlatformUtils::ResolutionInTicks() {
+ return static_cast<int64_t>(sResolution);
+}
+
+static bool gInitialized = false;
+
+void TimeStamp::Startup() {
+ if (gInitialized) {
+ return;
+ }
+
+ struct timespec dummy;
+ if (clock_gettime(CLOCK_MONOTONIC, &dummy) != 0) {
+ MOZ_CRASH("CLOCK_MONOTONIC is absent!");
+ }
+
+ sResolution = ClockResolutionNs();
+
+ // find the number of significant digits in sResolution, for the
+ // sake of ToSecondsSigDigits()
+ for (sResolutionSigDigs = 1; !(sResolutionSigDigs == sResolution ||
+ 10 * sResolutionSigDigs > sResolution);
+ sResolutionSigDigs *= 10)
+ ;
+
+ gInitialized = true;
+}
+
+void TimeStamp::Shutdown() {}
+
+TimeStamp TimeStamp::Now(bool aHighResolution) {
+ return TimeStamp(ClockTimeNs());
+}
+
+#if defined(XP_LINUX) || defined(ANDROID)
+
+// Calculates the amount of jiffies that have elapsed since boot and up to the
+// starttime value of a specific process as found in its /proc/*/stat file.
+// Returns 0 if an error occurred.
+
+static uint64_t JiffiesSinceBoot(const char* aFile) {
+ char stat[512];
+
+ FILE* f = fopen(aFile, "r");
+ if (!f) {
+ return 0;
+ }
+
+ int n = fread(&stat, 1, sizeof(stat) - 1, f);
+
+ fclose(f);
+
+ if (n <= 0) {
+ return 0;
+ }
+
+ stat[n] = 0;
+
+ long long unsigned startTime = 0; // instead of uint64_t to keep GCC quiet
+ char* s = strrchr(stat, ')');
+
+ if (!s) {
+ return 0;
+ }
+
+ int rv = sscanf(s + 2,
+ "%*c %*d %*d %*d %*d %*d %*u %*u %*u %*u "
+ "%*u %*u %*u %*d %*d %*d %*d %*d %*d %llu",
+ &startTime);
+
+ if (rv != 1 || !startTime) {
+ return 0;
+ }
+
+ return startTime;
+}
+
+// Computes the interval that has elapsed between the thread creation and the
+// process creation by comparing the starttime fields in the respective
+// /proc/*/stat files. The resulting value will be a good approximation of the
+// process uptime. This value will be stored at the address pointed by aTime;
+// if an error occurred 0 will be stored instead.
+
+static void* ComputeProcessUptimeThread(void* aTime) {
+ uint64_t* uptime = static_cast<uint64_t*>(aTime);
+ long hz = sysconf(_SC_CLK_TCK);
+
+ *uptime = 0;
+
+ if (!hz) {
+ return nullptr;
+ }
+
+ char threadStat[40];
+ SprintfLiteral(threadStat, "/proc/self/task/%d/stat",
+ (pid_t)syscall(__NR_gettid));
+
+ uint64_t threadJiffies = JiffiesSinceBoot(threadStat);
+ uint64_t selfJiffies = JiffiesSinceBoot("/proc/self/stat");
+
+ if (!threadJiffies || !selfJiffies) {
+ return nullptr;
+ }
+
+ *uptime = ((threadJiffies - selfJiffies) * kNsPerSec) / hz;
+ return nullptr;
+}
+
+// Computes and returns the process uptime in us on Linux & its derivatives.
+// Returns 0 if an error was encountered.
+
+uint64_t TimeStamp::ComputeProcessUptime() {
+ uint64_t uptime = 0;
+ pthread_t uptime_pthread;
+
+ if (pthread_create(&uptime_pthread, nullptr, ComputeProcessUptimeThread,
+ &uptime)) {
+ MOZ_CRASH("Failed to create process uptime thread.");
+ return 0;
+ }
+
+ pthread_join(uptime_pthread, NULL);
+
+ return uptime / kNsPerUs;
+}
+
+#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
+ defined(__OpenBSD__)
+
+// Computes and returns the process uptime in us on various BSD flavors.
+// Returns 0 if an error was encountered.
+
+uint64_t TimeStamp::ComputeProcessUptime() {
+ struct timespec ts;
+ int rv = clock_gettime(CLOCK_REALTIME, &ts);
+
+ if (rv == -1) {
+ return 0;
+ }
+
+ int mib[] = {
+ CTL_KERN,
+ KERN_PROC,
+ KERN_PROC_PID,
+ getpid(),
+# if defined(__NetBSD__) || defined(__OpenBSD__)
+ sizeof(KINFO_PROC),
+ 1,
+# endif
+ };
+ u_int mibLen = sizeof(mib) / sizeof(mib[0]);
+
+ KINFO_PROC proc;
+ size_t bufferSize = sizeof(proc);
+ rv = sysctl(mib, mibLen, &proc, &bufferSize, nullptr, 0);
+
+ if (rv == -1) {
+ return 0;
+ }
+
+ uint64_t startTime = ((uint64_t)proc.KP_START_SEC * kNsPerSec) +
+ (proc.KP_START_USEC * kNsPerUs);
+ uint64_t now = ((uint64_t)ts.tv_sec * kNsPerSec) + ts.tv_nsec;
+
+ if (startTime > now) {
+ return 0;
+ }
+
+ return (now - startTime) / kNsPerUs;
+}
+
+#else
+
+uint64_t TimeStamp::ComputeProcessUptime() { return 0; }
+
+#endif
+
+} // namespace mozilla
diff --git a/mozglue/misc/TimeStamp_windows.cpp b/mozglue/misc/TimeStamp_windows.cpp
new file mode 100644
index 0000000000..89ebb48b79
--- /dev/null
+++ b/mozglue/misc/TimeStamp_windows.cpp
@@ -0,0 +1,527 @@
+/* -*- 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/. */
+
+// Implement TimeStamp::Now() with QueryPerformanceCounter() controlled with
+// values of GetTickCount64().
+
+#include "mozilla/DynamicallyLinkedFunctionPtr.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Uptime.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <intrin.h>
+#include <windows.h>
+
+// To enable logging define to your favorite logging API
+#define LOG(x)
+
+class AutoCriticalSection {
+ public:
+ explicit AutoCriticalSection(LPCRITICAL_SECTION aSection)
+ : mSection(aSection) {
+ ::EnterCriticalSection(mSection);
+ }
+ ~AutoCriticalSection() { ::LeaveCriticalSection(mSection); }
+
+ private:
+ LPCRITICAL_SECTION mSection;
+};
+
+// Estimate of the smallest duration of time we can measure.
+static volatile ULONGLONG sResolution;
+static volatile ULONGLONG sResolutionSigDigs;
+static const double kNsPerSecd = 1000000000.0;
+static const LONGLONG kNsPerMillisec = 1000000;
+
+// ----------------------------------------------------------------------------
+// Global constants
+// ----------------------------------------------------------------------------
+
+// Tolerance to failures settings.
+//
+// What is the interval we want to have failure free.
+// in [ms]
+static const uint32_t kFailureFreeInterval = 5000;
+// How many failures we are willing to tolerate in the interval.
+static const uint32_t kMaxFailuresPerInterval = 4;
+// What is the threshold to treat fluctuations as actual failures.
+// in [ms]
+static const uint32_t kFailureThreshold = 50;
+
+// If we are not able to get the value of GTC time increment, use this value
+// which is the most usual increment.
+static const DWORD kDefaultTimeIncrement = 156001;
+
+// ----------------------------------------------------------------------------
+// Global variables, not changing at runtime
+// ----------------------------------------------------------------------------
+
+// Result of QueryPerformanceFrequency
+// We use default of 1 for the case we can't use QueryPerformanceCounter
+// to make mt/ms conversions work despite that.
+static uint64_t sFrequencyPerSec = 1;
+
+namespace mozilla {
+
+MFBT_API uint64_t GetQueryPerformanceFrequencyPerSec() {
+ return sFrequencyPerSec;
+}
+
+} // namespace mozilla
+
+// How much we are tolerant to GTC occasional loose of resoltion.
+// This number says how many multiples of the minimal GTC resolution
+// detected on the system are acceptable. This number is empirical.
+static const LONGLONG kGTCTickLeapTolerance = 4;
+
+// Base tolerance (more: "inability of detection" range) threshold is calculated
+// dynamically, and kept in sGTCResolutionThreshold.
+//
+// Schematically, QPC worked "100%" correctly if ((GTC_now - GTC_epoch) -
+// (QPC_now - QPC_epoch)) was in [-sGTCResolutionThreshold,
+// sGTCResolutionThreshold] interval every time we'd compared two time stamps.
+// If not, then we check the overflow behind this basic threshold
+// is in kFailureThreshold. If not, we condider it as a QPC failure. If too
+// many failures in short time are detected, QPC is considered faulty and
+// disabled.
+//
+// Kept in [mt]
+static LONGLONG sGTCResolutionThreshold;
+
+// If QPC is found faulty for two stamps in this interval, we engage
+// the fault detection algorithm. For duration larger then this limit
+// we bypass using durations calculated from QPC when jitter is detected,
+// but don't touch the sUseQPC flag.
+//
+// Value is in [ms].
+static const uint32_t kHardFailureLimit = 2000;
+// Conversion to [mt]
+static LONGLONG sHardFailureLimit;
+
+// Conversion of kFailureFreeInterval and kFailureThreshold to [mt]
+static LONGLONG sFailureFreeInterval;
+static LONGLONG sFailureThreshold;
+
+// ----------------------------------------------------------------------------
+// Systemm status flags
+// ----------------------------------------------------------------------------
+
+// Flag for stable TSC that indicates platform where QPC is stable.
+static bool sHasStableTSC = false;
+
+// ----------------------------------------------------------------------------
+// Global state variables, changing at runtime
+// ----------------------------------------------------------------------------
+
+// Initially true, set to false when QPC is found unstable and never
+// returns back to true since that time.
+static bool volatile sUseQPC = true;
+
+// ----------------------------------------------------------------------------
+// Global lock
+// ----------------------------------------------------------------------------
+
+// Thread spin count before entering the full wait state for sTimeStampLock.
+// Inspired by Rob Arnold's work on PRMJ_Now().
+static const DWORD kLockSpinCount = 4096;
+
+// Common mutex (thanks the relative complexity of the logic, this is better
+// then using CMPXCHG8B.)
+// It is protecting the globals bellow.
+static CRITICAL_SECTION sTimeStampLock;
+
+// ----------------------------------------------------------------------------
+// Global lock protected variables
+// ----------------------------------------------------------------------------
+
+// Timestamp in future until QPC must behave correctly.
+// Set to now + kFailureFreeInterval on first QPC failure detection.
+// Set to now + E * kFailureFreeInterval on following errors,
+// where E is number of errors detected during last kFailureFreeInterval
+// milliseconds, calculated simply as:
+// E = (sFaultIntoleranceCheckpoint - now) / kFailureFreeInterval + 1.
+// When E > kMaxFailuresPerInterval -> disable QPC.
+//
+// Kept in [mt]
+static ULONGLONG sFaultIntoleranceCheckpoint = 0;
+
+namespace mozilla {
+
+// Result is in [mt]
+static inline ULONGLONG PerformanceCounter() {
+ LARGE_INTEGER pc;
+ ::QueryPerformanceCounter(&pc);
+
+ // QueryPerformanceCounter may slightly jitter (not be 100% monotonic.)
+ // This is a simple go-backward protection for such a faulty hardware.
+ AutoCriticalSection lock(&sTimeStampLock);
+
+ static decltype(LARGE_INTEGER::QuadPart) last;
+ if (last > pc.QuadPart) {
+ return last * 1000ULL;
+ }
+ last = pc.QuadPart;
+ return pc.QuadPart * 1000ULL;
+}
+
+static void InitThresholds() {
+ DWORD timeAdjustment = 0, timeIncrement = 0;
+ BOOL timeAdjustmentDisabled;
+ GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement,
+ &timeAdjustmentDisabled);
+
+ LOG(("TimeStamp: timeIncrement=%d [100ns]", timeIncrement));
+
+ if (!timeIncrement) {
+ timeIncrement = kDefaultTimeIncrement;
+ }
+
+ // Ceiling to a millisecond
+ // Example values: 156001, 210000
+ DWORD timeIncrementCeil = timeIncrement;
+ // Don't want to round up if already rounded, values will be: 156000, 209999
+ timeIncrementCeil -= 1;
+ // Convert to ms, values will be: 15, 20
+ timeIncrementCeil /= 10000;
+ // Round up, values will be: 16, 21
+ timeIncrementCeil += 1;
+ // Convert back to 100ns, values will be: 160000, 210000
+ timeIncrementCeil *= 10000;
+
+ // How many milli-ticks has the interval rounded up
+ LONGLONG ticksPerGetTickCountResolutionCeiling =
+ (int64_t(timeIncrementCeil) * sFrequencyPerSec) / 10000LL;
+
+ // GTC may jump by 32 (2*16) ms in two steps, therefor use the ceiling value.
+ sGTCResolutionThreshold =
+ LONGLONG(kGTCTickLeapTolerance * ticksPerGetTickCountResolutionCeiling);
+
+ sHardFailureLimit = ms2mt(kHardFailureLimit);
+ sFailureFreeInterval = ms2mt(kFailureFreeInterval);
+ sFailureThreshold = ms2mt(kFailureThreshold);
+}
+
+static void InitResolution() {
+ // 10 total trials is arbitrary: what we're trying to avoid by
+ // looping is getting unlucky and being interrupted by a context
+ // switch or signal, or being bitten by paging/cache effects
+
+ ULONGLONG minres = ~0ULL;
+ if (sUseQPC) {
+ int loops = 10;
+ do {
+ ULONGLONG start = PerformanceCounter();
+ ULONGLONG end = PerformanceCounter();
+
+ ULONGLONG candidate = (end - start);
+ if (candidate < minres) {
+ minres = candidate;
+ }
+ } while (--loops && minres);
+
+ if (0 == minres) {
+ minres = 1;
+ }
+ } else {
+ // GetTickCount has only ~16ms known resolution
+ minres = ms2mt(16);
+ }
+
+ // Converting minres that is in [mt] to nanosecods, multiplicating
+ // the argument to preserve resolution.
+ ULONGLONG result = mt2ms(minres * kNsPerMillisec);
+ if (0 == result) {
+ result = 1;
+ }
+
+ sResolution = result;
+
+ // find the number of significant digits in mResolution, for the
+ // sake of ToSecondsSigDigits()
+ ULONGLONG sigDigs;
+ for (sigDigs = 1; !(sigDigs == result || 10 * sigDigs > result);
+ sigDigs *= 10)
+ ;
+
+ sResolutionSigDigs = sigDigs;
+}
+
+// ----------------------------------------------------------------------------
+// TimeStampValue implementation
+// ----------------------------------------------------------------------------
+MFBT_API
+TimeStampValue::TimeStampValue(ULONGLONG aGTC, ULONGLONG aQPC, bool aHasQPC)
+ : mGTC(aGTC), mQPC(aQPC), mHasQPC(aHasQPC) {
+ mIsNull = aGTC == 0 && aQPC == 0;
+}
+
+MFBT_API TimeStampValue& TimeStampValue::operator+=(const int64_t aOther) {
+ mGTC += aOther;
+ mQPC += aOther;
+ return *this;
+}
+
+MFBT_API TimeStampValue& TimeStampValue::operator-=(const int64_t aOther) {
+ mGTC -= aOther;
+ mQPC -= aOther;
+ return *this;
+}
+
+// If the duration is less then two seconds, perform check of QPC stability
+// by comparing both GTC and QPC calculated durations of this and aOther.
+MFBT_API uint64_t TimeStampValue::CheckQPC(const TimeStampValue& aOther) const {
+ uint64_t deltaGTC = mGTC - aOther.mGTC;
+
+ if (!mHasQPC || !aOther.mHasQPC) { // Both not holding QPC
+ return deltaGTC;
+ }
+
+ uint64_t deltaQPC = mQPC - aOther.mQPC;
+
+ if (sHasStableTSC) { // For stable TSC there is no need to check
+ return deltaQPC;
+ }
+
+ // Check QPC is sane before using it.
+ int64_t diff = DeprecatedAbs(int64_t(deltaQPC) - int64_t(deltaGTC));
+ if (diff <= sGTCResolutionThreshold) {
+ return deltaQPC;
+ }
+
+ // Treat absolutely for calibration purposes
+ int64_t duration = DeprecatedAbs(int64_t(deltaGTC));
+ int64_t overflow = diff - sGTCResolutionThreshold;
+
+ LOG(("TimeStamp: QPC check after %llums with overflow %1.4fms",
+ mt2ms(duration), mt2ms_f(overflow)));
+
+ if (overflow <= sFailureThreshold) { // We are in the limit, let go.
+ return deltaQPC;
+ }
+
+ // QPC deviates, don't use it, since now this method may only return deltaGTC.
+
+ if (!sUseQPC) { // QPC already disabled, no need to run the fault tolerance
+ // algorithm.
+ return deltaGTC;
+ }
+
+ LOG(("TimeStamp: QPC jittered over failure threshold"));
+
+ if (duration < sHardFailureLimit) {
+ // Interval between the two time stamps is very short, consider
+ // QPC as unstable and record a failure.
+ uint64_t now = ms2mt(GetTickCount64());
+
+ AutoCriticalSection lock(&sTimeStampLock);
+
+ if (sFaultIntoleranceCheckpoint && sFaultIntoleranceCheckpoint > now) {
+ // There's already been an error in the last fault intollerant interval.
+ // Time since now to the checkpoint actually holds information on how many
+ // failures there were in the failure free interval we have defined.
+ uint64_t failureCount =
+ (sFaultIntoleranceCheckpoint - now + sFailureFreeInterval - 1) /
+ sFailureFreeInterval;
+ if (failureCount > kMaxFailuresPerInterval) {
+ sUseQPC = false;
+ LOG(("TimeStamp: QPC disabled"));
+ } else {
+ // Move the fault intolerance checkpoint more to the future, prolong it
+ // to reflect the number of detected failures.
+ ++failureCount;
+ sFaultIntoleranceCheckpoint = now + failureCount * sFailureFreeInterval;
+ LOG(("TimeStamp: recording %dth QPC failure", failureCount));
+ }
+ } else {
+ // Setup fault intolerance checkpoint in the future for first detected
+ // error.
+ sFaultIntoleranceCheckpoint = now + sFailureFreeInterval;
+ LOG(("TimeStamp: recording 1st QPC failure"));
+ }
+ }
+
+ return deltaGTC;
+}
+
+MFBT_API uint64_t
+TimeStampValue::operator-(const TimeStampValue& aOther) const {
+ if (IsNull() && aOther.IsNull()) {
+ return uint64_t(0);
+ }
+
+ return CheckQPC(aOther);
+}
+
+// ----------------------------------------------------------------------------
+// TimeDuration and TimeStamp implementation
+// ----------------------------------------------------------------------------
+
+MFBT_API double BaseTimeDurationPlatformUtils::ToSeconds(int64_t aTicks) {
+ // Converting before arithmetic avoids blocked store forward
+ return double(aTicks) / (double(sFrequencyPerSec) * 1000.0);
+}
+
+MFBT_API double BaseTimeDurationPlatformUtils::ToSecondsSigDigits(
+ int64_t aTicks) {
+ // don't report a value < mResolution ...
+ LONGLONG resolution = sResolution;
+ LONGLONG resolutionSigDigs = sResolutionSigDigs;
+ LONGLONG valueSigDigs = resolution * (aTicks / resolution);
+ // and chop off insignificant digits
+ valueSigDigs = resolutionSigDigs * (valueSigDigs / resolutionSigDigs);
+ return double(valueSigDigs) / kNsPerSecd;
+}
+
+MFBT_API int64_t
+BaseTimeDurationPlatformUtils::TicksFromMilliseconds(double aMilliseconds) {
+ double result = ms2mt(aMilliseconds);
+ if (result > double(INT64_MAX)) {
+ return INT64_MAX;
+ } else if (result < double(INT64_MIN)) {
+ return INT64_MIN;
+ }
+
+ return result;
+}
+
+MFBT_API int64_t BaseTimeDurationPlatformUtils::ResolutionInTicks() {
+ return static_cast<int64_t>(sResolution);
+}
+
+static bool HasStableTSC() {
+#if defined(_M_ARM64)
+ // AArch64 defines that its system counter run at a constant rate
+ // regardless of the current clock frequency of the system. See "The
+ // Generic Timer", section D7, in the ARMARM for ARMv8.
+ return true;
+#else
+ union {
+ int regs[4];
+ struct {
+ int nIds;
+ char cpuString[12];
+ };
+ } cpuInfo;
+
+ __cpuid(cpuInfo.regs, 0);
+ // Only allow Intel or AMD CPUs for now.
+ // The order of the registers is reg[1], reg[3], reg[2]. We just adjust the
+ // string so that we can compare in one go.
+ if (_strnicmp(cpuInfo.cpuString, "GenuntelineI", sizeof(cpuInfo.cpuString)) &&
+ _strnicmp(cpuInfo.cpuString, "AuthcAMDenti", sizeof(cpuInfo.cpuString))) {
+ return false;
+ }
+
+ int regs[4];
+
+ // detect if the Advanced Power Management feature is supported
+ __cpuid(regs, 0x80000000);
+ if ((unsigned int)regs[0] < 0x80000007) {
+ // XXX should we return true here? If there is no APM there may be
+ // no way how TSC can run out of sync among cores.
+ return false;
+ }
+
+ __cpuid(regs, 0x80000007);
+ // if bit 8 is set than TSC will run at a constant rate
+ // in all ACPI P-states, C-states and T-states
+ return regs[3] & (1 << 8);
+#endif
+}
+
+static bool gInitialized = false;
+
+MFBT_API void TimeStamp::Startup() {
+ if (gInitialized) {
+ return;
+ }
+
+ gInitialized = true;
+
+ // Decide which implementation to use for the high-performance timer.
+
+ InitializeCriticalSectionAndSpinCount(&sTimeStampLock, kLockSpinCount);
+
+ bool forceGTC = false;
+ bool forceQPC = false;
+
+ char* modevar = getenv("MOZ_TIMESTAMP_MODE");
+ if (modevar) {
+ if (!strcmp(modevar, "QPC")) {
+ forceQPC = true;
+ } else if (!strcmp(modevar, "GTC")) {
+ forceGTC = true;
+ }
+ }
+
+ LARGE_INTEGER freq;
+ sUseQPC = !forceGTC && ::QueryPerformanceFrequency(&freq);
+ if (!sUseQPC) {
+ // No Performance Counter. Fall back to use GetTickCount64.
+ InitResolution();
+
+ LOG(("TimeStamp: using GetTickCount64"));
+ return;
+ }
+
+ sHasStableTSC = forceQPC || HasStableTSC();
+ LOG(("TimeStamp: HasStableTSC=%d", sHasStableTSC));
+
+ sFrequencyPerSec = freq.QuadPart;
+ LOG(("TimeStamp: QPC frequency=%llu", sFrequencyPerSec));
+
+ InitThresholds();
+ InitResolution();
+
+ return;
+}
+
+MFBT_API void TimeStamp::Shutdown() { DeleteCriticalSection(&sTimeStampLock); }
+
+TimeStampValue NowInternal(bool aHighResolution) {
+ // sUseQPC is volatile
+ bool useQPC = (aHighResolution && sUseQPC);
+
+ // Both values are in [mt] units.
+ ULONGLONG QPC = useQPC ? PerformanceCounter() : uint64_t(0);
+ ULONGLONG GTC = ms2mt(GetTickCount64());
+ return TimeStampValue(GTC, QPC, useQPC);
+}
+
+MFBT_API TimeStamp TimeStamp::Now(bool aHighResolution) {
+ return TimeStamp(NowInternal(aHighResolution));
+}
+
+// Computes and returns the process uptime in microseconds.
+// Returns 0 if an error was encountered.
+
+MFBT_API uint64_t TimeStamp::ComputeProcessUptime() {
+ FILETIME start, foo, bar, baz;
+ bool success = GetProcessTimes(GetCurrentProcess(), &start, &foo, &bar, &baz);
+ if (!success) {
+ return 0;
+ }
+
+ static const StaticDynamicallyLinkedFunctionPtr<void(WINAPI*)(LPFILETIME)>
+ pGetSystemTimePreciseAsFileTime(L"kernel32.dll",
+ "GetSystemTimePreciseAsFileTime");
+
+ FILETIME now;
+ if (pGetSystemTimePreciseAsFileTime) {
+ pGetSystemTimePreciseAsFileTime(&now);
+ } else {
+ GetSystemTimeAsFileTime(&now);
+ }
+
+ ULARGE_INTEGER startUsec = {{start.dwLowDateTime, start.dwHighDateTime}};
+ ULARGE_INTEGER nowUsec = {{now.dwLowDateTime, now.dwHighDateTime}};
+
+ return (nowUsec.QuadPart - startUsec.QuadPart) / 10ULL;
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/TimeStamp_windows.h b/mozglue/misc/TimeStamp_windows.h
new file mode 100644
index 0000000000..9deabe52de
--- /dev/null
+++ b/mozglue/misc/TimeStamp_windows.h
@@ -0,0 +1,100 @@
+/* -*- 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/. */
+
+#ifndef mozilla_TimeStamp_windows_h
+#define mozilla_TimeStamp_windows_h
+
+#include "mozilla/Types.h"
+
+namespace mozilla {
+
+/**
+ * The [mt] unit:
+ *
+ * Many values are kept in ticks of the Performance Counter x 1000,
+ * further just referred as [mt], meaning milli-ticks.
+ *
+ * This is needed to preserve maximum precision of the performance frequency
+ * representation. GetTickCount64 values in milliseconds are multiplied with
+ * frequency per second. Therefore we need to multiply QPC value by 1000 to
+ * have the same units to allow simple arithmentic with both QPC and GTC.
+ */
+#define ms2mt(x) ((x)*mozilla::GetQueryPerformanceFrequencyPerSec())
+#define mt2ms(x) ((x) / mozilla::GetQueryPerformanceFrequencyPerSec())
+#define mt2ms_f(x) (double(x) / mozilla::GetQueryPerformanceFrequencyPerSec())
+
+MFBT_API uint64_t GetQueryPerformanceFrequencyPerSec();
+
+class TimeStamp;
+class TimeStampValue;
+
+TimeStampValue NowInternal(bool aHighResolution);
+
+class TimeStampValue {
+ friend TimeStampValue NowInternal(bool);
+ friend bool IsCanonicalTimeStamp(TimeStampValue);
+ friend struct IPC::ParamTraits<mozilla::TimeStampValue>;
+ friend class TimeStamp;
+
+ // Both QPC and GTC are kept in [mt] units.
+ uint64_t mGTC;
+ uint64_t mQPC;
+
+ bool mIsNull;
+ bool mHasQPC;
+
+ MFBT_API TimeStampValue(uint64_t aGTC, uint64_t aQPC, bool aHasQPC);
+
+ MFBT_API uint64_t CheckQPC(const TimeStampValue& aOther) const;
+
+ // This struct is used to allow doing TimeStampValue a = 0 and similar
+ struct _SomethingVeryRandomHere;
+ constexpr MOZ_IMPLICIT TimeStampValue(_SomethingVeryRandomHere* aNullValue)
+ : mGTC(0), mQPC(0), mIsNull(true), mHasQPC(false) {}
+
+ public:
+ MFBT_API uint64_t operator-(const TimeStampValue& aOther) const;
+
+ TimeStampValue operator+(const int64_t aOther) const {
+ return TimeStampValue(mGTC + aOther, mQPC + aOther, mHasQPC);
+ }
+ TimeStampValue operator-(const int64_t aOther) const {
+ return TimeStampValue(mGTC - aOther, mQPC - aOther, mHasQPC);
+ }
+ MFBT_API TimeStampValue& operator+=(const int64_t aOther);
+ MFBT_API TimeStampValue& operator-=(const int64_t aOther);
+
+ bool operator<(const TimeStampValue& aOther) const {
+ return int64_t(*this - aOther) < 0;
+ }
+ bool operator>(const TimeStampValue& aOther) const {
+ return int64_t(*this - aOther) > 0;
+ }
+ bool operator<=(const TimeStampValue& aOther) const {
+ return int64_t(*this - aOther) <= 0;
+ }
+ bool operator>=(const TimeStampValue& aOther) const {
+ return int64_t(*this - aOther) >= 0;
+ }
+ bool operator==(const TimeStampValue& aOther) const {
+ return int64_t(*this - aOther) == 0;
+ }
+ bool operator!=(const TimeStampValue& aOther) const {
+ return int64_t(*this - aOther) != 0;
+ }
+ bool IsNull() const { return mIsNull; }
+
+#if defined(DEBUG)
+ uint64_t GTC() const { return mGTC; }
+ uint64_t QPC() const { return mQPC; }
+
+ bool HasQPC() const { return mHasQPC; }
+#endif
+};
+
+} // namespace mozilla
+
+#endif /* mozilla_TimeStamp_h */
diff --git a/mozglue/misc/Uptime.cpp b/mozglue/misc/Uptime.cpp
new file mode 100644
index 0000000000..924b154359
--- /dev/null
+++ b/mozglue/misc/Uptime.cpp
@@ -0,0 +1,155 @@
+/* -*- 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/. */
+
+#include "Uptime.h"
+
+#ifdef XP_WIN
+# include "mozilla/DynamicallyLinkedFunctionPtr.h"
+#endif // XP_WIN
+
+#include <stdint.h>
+
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Assertions.h"
+
+using namespace mozilla;
+
+namespace {
+
+Maybe<uint64_t> NowIncludingSuspendMs();
+Maybe<uint64_t> NowExcludingSuspendMs();
+static Maybe<uint64_t> mStartExcludingSuspendMs;
+static Maybe<uint64_t> mStartIncludingSuspendMs;
+
+// Apple things
+#if defined(__APPLE__) && defined(__MACH__)
+# include <time.h>
+# include <sys/time.h>
+# include <sys/types.h>
+# include <mach/mach_time.h>
+
+const uint64_t kNSperMS = 1000000;
+
+Maybe<uint64_t> NowExcludingSuspendMs() {
+ return Some(clock_gettime_nsec_np(CLOCK_UPTIME_RAW) / kNSperMS);
+}
+
+Maybe<uint64_t> NowIncludingSuspendMs() {
+ return Some(clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW) / kNSperMS);
+}
+
+#elif defined(XP_WIN)
+
+// Number of hundreds of nanoseconds in a millisecond
+static constexpr uint64_t kHNSperMS = 10000;
+
+Maybe<uint64_t> NowExcludingSuspendMs() {
+ ULONGLONG interrupt_time;
+ if (!QueryUnbiasedInterruptTime(&interrupt_time)) {
+ return Nothing();
+ }
+ return Some(interrupt_time / kHNSperMS);
+}
+
+Maybe<uint64_t> NowIncludingSuspendMs() {
+ static const mozilla::StaticDynamicallyLinkedFunctionPtr<void(WINAPI*)(
+ PULONGLONG)>
+ pQueryInterruptTime(L"KernelBase.dll", "QueryInterruptTime");
+ if (!pQueryInterruptTime) {
+ // On Windows, this does include the time the computer was suspended so it's
+ // an adequate fallback.
+ TimeStamp processCreation = TimeStamp::ProcessCreation();
+ TimeStamp now = TimeStamp::Now();
+ if (!processCreation.IsNull() && !now.IsNull()) {
+ return Some(uint64_t((now - processCreation).ToMilliseconds()));
+ } else {
+ return Nothing();
+ }
+ }
+ ULONGLONG interrupt_time;
+ pQueryInterruptTime(&interrupt_time);
+ return Some(interrupt_time / kHNSperMS);
+}
+
+#elif defined(XP_UNIX) // including BSDs and Android
+# include <time.h>
+
+// Number of nanoseconds in a millisecond.
+static constexpr uint64_t kNSperMS = 1000000;
+
+uint64_t TimespecToMilliseconds(struct timespec aTs) {
+ return aTs.tv_sec * 1000 + aTs.tv_nsec / kNSperMS;
+}
+
+Maybe<uint64_t> NowExcludingSuspendMs() {
+ struct timespec ts = {0};
+
+# ifdef XP_OPENBSD
+ if (clock_gettime(CLOCK_UPTIME, &ts)) {
+# else
+ if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
+# endif
+ return Nothing();
+ }
+ return Some(TimespecToMilliseconds(ts));
+}
+
+Maybe<uint64_t> NowIncludingSuspendMs() {
+# ifndef CLOCK_BOOTTIME
+ return Nothing();
+# else
+ struct timespec ts = {0};
+
+ if (clock_gettime(CLOCK_BOOTTIME, &ts)) {
+ return Nothing();
+ }
+ return Some(TimespecToMilliseconds(ts));
+# endif
+}
+
+#else // catch all
+
+Maybe<uint64_t> NowExcludingSuspendMs() { return Nothing(); }
+Maybe<uint64_t> NowIncludingSuspendMs() { return Nothing(); }
+
+#endif
+
+}; // anonymous namespace
+
+namespace mozilla {
+
+void InitializeUptime() {
+ MOZ_RELEASE_ASSERT(mStartIncludingSuspendMs.isNothing() &&
+ mStartExcludingSuspendMs.isNothing(),
+ "Must not be called more than once");
+ mStartIncludingSuspendMs = NowIncludingSuspendMs();
+ mStartExcludingSuspendMs = NowExcludingSuspendMs();
+}
+
+Maybe<uint64_t> ProcessUptimeMs() {
+ if (!mStartIncludingSuspendMs) {
+ return Nothing();
+ }
+ Maybe<uint64_t> maybeNow = NowIncludingSuspendMs();
+ if (!maybeNow) {
+ return Nothing();
+ }
+ return Some(maybeNow.value() - mStartIncludingSuspendMs.value());
+}
+
+Maybe<uint64_t> ProcessUptimeExcludingSuspendMs() {
+ if (!mStartExcludingSuspendMs) {
+ return Nothing();
+ }
+ Maybe<uint64_t> maybeNow = NowExcludingSuspendMs();
+ if (!maybeNow) {
+ return Nothing();
+ }
+ return Some(maybeNow.value() - mStartExcludingSuspendMs.value());
+}
+
+}; // namespace mozilla
diff --git a/mozglue/misc/Uptime.h b/mozglue/misc/Uptime.h
new file mode 100644
index 0000000000..4438e0d6d1
--- /dev/null
+++ b/mozglue/misc/Uptime.h
@@ -0,0 +1,26 @@
+/* -*- 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/. */
+
+#ifndef mozilla_Uptime_h
+#define mozilla_Uptime_h
+
+#include <stdint.h>
+
+#include "mozilla/Maybe.h"
+
+namespace mozilla {
+
+// Called at the beginning of the process from TimeStamp::Startup.
+MFBT_API void InitializeUptime();
+// Returns the number of milliseconds the calling process has lived for.
+MFBT_API Maybe<uint64_t> ProcessUptimeMs();
+// Returns the number of milliseconds the calling process has lived for,
+// excluding the time period the system was suspended.
+MFBT_API Maybe<uint64_t> ProcessUptimeExcludingSuspendMs();
+
+}; // namespace mozilla
+
+#endif // mozilla_Uptime_h
diff --git a/mozglue/misc/WinUtils.h b/mozglue/misc/WinUtils.h
new file mode 100644
index 0000000000..2291a352a5
--- /dev/null
+++ b/mozglue/misc/WinUtils.h
@@ -0,0 +1,140 @@
+/* -*- 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/. */
+
+#ifndef mozilla_glue_MozglueUtils_h
+#define mozilla_glue_MozglueUtils_h
+
+#include <windows.h>
+
+#include "mozilla/Atomics.h"
+#include "mozilla/Attributes.h"
+
+namespace mozilla {
+namespace glue {
+
+#ifdef DEBUG
+
+class MOZ_STATIC_CLASS Win32SRWLock final {
+ public:
+ // Microsoft guarantees that '0' is never a valid thread id
+ // https://docs.microsoft.com/en-ca/windows/desktop/ProcThread/thread-handles-and-identifiers
+ static const DWORD kInvalidThreadId = 0;
+
+ constexpr Win32SRWLock()
+ : mExclusiveThreadId(kInvalidThreadId), mLock(SRWLOCK_INIT) {}
+
+ ~Win32SRWLock() { MOZ_ASSERT(mExclusiveThreadId == kInvalidThreadId); }
+
+ void LockShared() {
+ MOZ_ASSERT(
+ mExclusiveThreadId != GetCurrentThreadId(),
+ "Deadlock detected - A thread attempted to acquire a shared lock on "
+ "a SRWLOCK when it already owns the exclusive lock on it.");
+
+ ::AcquireSRWLockShared(&mLock);
+ }
+
+ void UnlockShared() { ::ReleaseSRWLockShared(&mLock); }
+
+ void LockExclusive() {
+ MOZ_ASSERT(
+ mExclusiveThreadId != GetCurrentThreadId(),
+ "Deadlock detected - A thread attempted to acquire an exclusive lock "
+ "on a SRWLOCK when it already owns the exclusive lock on it.");
+
+ ::AcquireSRWLockExclusive(&mLock);
+ mExclusiveThreadId = GetCurrentThreadId();
+ }
+
+ void UnlockExclusive() {
+ MOZ_ASSERT(mExclusiveThreadId == GetCurrentThreadId());
+
+ mExclusiveThreadId = kInvalidThreadId;
+ ::ReleaseSRWLockExclusive(&mLock);
+ }
+
+ Win32SRWLock(const Win32SRWLock&) = delete;
+ Win32SRWLock(Win32SRWLock&&) = delete;
+ Win32SRWLock& operator=(const Win32SRWLock&) = delete;
+ Win32SRWLock& operator=(Win32SRWLock&&) = delete;
+
+ private:
+ // "Relaxed" memory ordering is fine. Threads will see other thread IDs
+ // appear here in some non-deterministic ordering (or not at all) and simply
+ // ignore them.
+ //
+ // But a thread will only read its own ID if it previously wrote it, and a
+ // single thread doesn't need a memory barrier to read its own write.
+
+ Atomic<DWORD, Relaxed> mExclusiveThreadId;
+ SRWLOCK mLock;
+};
+
+#else // DEBUG
+
+class MOZ_STATIC_CLASS Win32SRWLock final {
+ public:
+ constexpr Win32SRWLock() : mLock(SRWLOCK_INIT) {}
+
+ void LockShared() { ::AcquireSRWLockShared(&mLock); }
+
+ void UnlockShared() { ::ReleaseSRWLockShared(&mLock); }
+
+ void LockExclusive() { ::AcquireSRWLockExclusive(&mLock); }
+
+ void UnlockExclusive() { ::ReleaseSRWLockExclusive(&mLock); }
+
+ ~Win32SRWLock() = default;
+
+ Win32SRWLock(const Win32SRWLock&) = delete;
+ Win32SRWLock(Win32SRWLock&&) = delete;
+ Win32SRWLock& operator=(const Win32SRWLock&) = delete;
+ Win32SRWLock& operator=(Win32SRWLock&&) = delete;
+
+ private:
+ SRWLOCK mLock;
+};
+
+#endif
+
+class MOZ_RAII AutoSharedLock final {
+ public:
+ explicit AutoSharedLock(Win32SRWLock& aLock) : mLock(aLock) {
+ mLock.LockShared();
+ }
+
+ ~AutoSharedLock() { mLock.UnlockShared(); }
+
+ AutoSharedLock(const AutoSharedLock&) = delete;
+ AutoSharedLock(AutoSharedLock&&) = delete;
+ AutoSharedLock& operator=(const AutoSharedLock&) = delete;
+ AutoSharedLock& operator=(AutoSharedLock&&) = delete;
+
+ private:
+ Win32SRWLock& mLock;
+};
+
+class MOZ_RAII AutoExclusiveLock final {
+ public:
+ explicit AutoExclusiveLock(Win32SRWLock& aLock) : mLock(aLock) {
+ mLock.LockExclusive();
+ }
+
+ ~AutoExclusiveLock() { mLock.UnlockExclusive(); }
+
+ AutoExclusiveLock(const AutoExclusiveLock&) = delete;
+ AutoExclusiveLock(AutoExclusiveLock&&) = delete;
+ AutoExclusiveLock& operator=(const AutoExclusiveLock&) = delete;
+ AutoExclusiveLock& operator=(AutoExclusiveLock&&) = delete;
+
+ private:
+ Win32SRWLock& mLock;
+};
+
+} // namespace glue
+} // namespace mozilla
+
+#endif // mozilla_glue_MozglueUtils_h
diff --git a/mozglue/misc/WindowsDllMain.cpp b/mozglue/misc/WindowsDllMain.cpp
new file mode 100644
index 0000000000..1baec678db
--- /dev/null
+++ b/mozglue/misc/WindowsDllMain.cpp
@@ -0,0 +1,20 @@
+/* -*- 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/. */
+
+#include <libloaderapi.h>
+
+BOOL WINAPI DllMain(HINSTANCE aInstDll, DWORD aReason, LPVOID) {
+ if (aReason == DLL_PROCESS_ATTACH) {
+ ::DisableThreadLibraryCalls(aInstDll);
+
+ // mozglue.dll imports RtlGenRandom from advapi32.dll as SystemFunction036,
+ // but the actual function is implemented in cryptbase.dll. To avoid
+ // loading a fake cryptbase.dll from the installation directory, we preload
+ // cryptbase.dll from the system directory.
+ ::LoadLibraryExW(L"cryptbase.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
+ }
+ return TRUE;
+}
diff --git a/mozglue/misc/WindowsDpiAwareness.h b/mozglue/misc/WindowsDpiAwareness.h
new file mode 100644
index 0000000000..104b135536
--- /dev/null
+++ b/mozglue/misc/WindowsDpiAwareness.h
@@ -0,0 +1,41 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef WindowsDpiAwareness_h_
+#define WindowsDpiAwareness_h_
+
+#include <windows.h>
+
+#if !defined(DPI_AWARENESS_CONTEXT_DECLARED) && \
+ !defined(DPI_AWARENESS_CONTEXT_UNAWARE)
+
+DECLARE_HANDLE(DPI_AWARENESS_CONTEXT);
+
+typedef enum DPI_AWARENESS {
+ DPI_AWARENESS_INVALID = -1,
+ DPI_AWARENESS_UNAWARE = 0,
+ DPI_AWARENESS_SYSTEM_AWARE = 1,
+ DPI_AWARENESS_PER_MONITOR_AWARE = 2
+} DPI_AWARENESS;
+
+# define DPI_AWARENESS_CONTEXT_UNAWARE ((DPI_AWARENESS_CONTEXT)-1)
+# define DPI_AWARENESS_CONTEXT_SYSTEM_AWARE ((DPI_AWARENESS_CONTEXT)-2)
+# define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE ((DPI_AWARENESS_CONTEXT)-3)
+
+# define DPI_AWARENESS_CONTEXT_DECLARED
+#endif // (DPI_AWARENESS_CONTEXT_DECLARED)
+
+#if WINVER < 0x0605
+WINUSERAPI DPI_AWARENESS_CONTEXT WINAPI GetThreadDpiAwarenessContext();
+WINUSERAPI BOOL WINAPI AreDpiAwarenessContextsEqual(DPI_AWARENESS_CONTEXT,
+ DPI_AWARENESS_CONTEXT);
+#endif /* WINVER < 0x0605 */
+typedef DPI_AWARENESS_CONTEXT(WINAPI* SetThreadDpiAwarenessContextProc)(
+ DPI_AWARENESS_CONTEXT);
+typedef BOOL(WINAPI* EnableNonClientDpiScalingProc)(HWND);
+typedef int(WINAPI* GetSystemMetricsForDpiProc)(int, UINT);
+
+#endif
diff --git a/mozglue/misc/WindowsDpiInitialization.cpp b/mozglue/misc/WindowsDpiInitialization.cpp
new file mode 100644
index 0000000000..2e957b5830
--- /dev/null
+++ b/mozglue/misc/WindowsDpiInitialization.cpp
@@ -0,0 +1,73 @@
+/* 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 "mozilla/WindowsDpiInitialization.h"
+
+#include "mozilla/DynamicallyLinkedFunctionPtr.h"
+#include "mozilla/WindowsProcessMitigations.h"
+#include "mozilla/WindowsVersion.h"
+
+#include <shellscalingapi.h>
+#include <windows.h>
+
+namespace mozilla {
+
+typedef HRESULT(WINAPI* SetProcessDpiAwarenessType)(PROCESS_DPI_AWARENESS);
+typedef BOOL(WINAPI* SetProcessDpiAwarenessContextType)(DPI_AWARENESS_CONTEXT);
+
+WindowsDpiInitializationResult WindowsDpiInitialization() {
+ // DPI Awareness can't be used in a Win32k Lockdown process, so there's
+ // nothing to do
+ if (IsWin32kLockedDown()) {
+ return WindowsDpiInitializationResult::Success;
+ }
+
+ // From MSDN:
+ // SetProcessDpiAwarenessContext() was added in the Win10 Anniversary Update
+ // SetProcessDpiAwareness() was added in Windows 8.1
+ // SetProcessDpiAware() was added in Windows Vista
+ //
+ // DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 wasn't added later until
+ // the Creators Update, so if it fails we just fall back to
+ // DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE
+ if (IsWin10AnniversaryUpdateOrLater()) {
+ DynamicallyLinkedFunctionPtr<SetProcessDpiAwarenessContextType>
+ setProcessDpiAwarenessContext(L"user32.dll",
+ "SetProcessDpiAwarenessContext");
+ if (!setProcessDpiAwarenessContext) {
+ return WindowsDpiInitializationResult::
+ FindSetProcessDpiAwarenessContextFailed;
+ }
+
+ if (!setProcessDpiAwarenessContext(
+ DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) &&
+ !setProcessDpiAwarenessContext(
+ DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE)) {
+ return WindowsDpiInitializationResult::
+ SetProcessDpiAwarenessContextFailed;
+ }
+
+ return WindowsDpiInitializationResult::Success;
+ } else if (IsWin8Point1OrLater()) {
+ DynamicallyLinkedFunctionPtr<SetProcessDpiAwarenessType>
+ setProcessDpiAwareness(L"Shcore.dll", "SetProcessDpiAwareness");
+ if (!setProcessDpiAwareness) {
+ return WindowsDpiInitializationResult::FindSetProcessDpiAwarenessFailed;
+ }
+
+ if (FAILED(setProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE))) {
+ return WindowsDpiInitializationResult::SetProcessDpiAwarenessFailed;
+ }
+
+ return WindowsDpiInitializationResult::Success;
+ } else {
+ if (!SetProcessDPIAware()) {
+ return WindowsDpiInitializationResult::SetProcessDPIAwareFailed;
+ }
+
+ return WindowsDpiInitializationResult::Success;
+ }
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/WindowsDpiInitialization.h b/mozglue/misc/WindowsDpiInitialization.h
new file mode 100644
index 0000000000..5943d50526
--- /dev/null
+++ b/mozglue/misc/WindowsDpiInitialization.h
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; 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 MOZILLA_MOZGLUE_MISC_WINDOWSDPIINITIALIZATION_H_
+#define MOZILLA_MOZGLUE_MISC_WINDOWSDPIINITIALIZATION_H_
+#include "mozilla/Types.h"
+
+namespace mozilla {
+
+// The result codes that may be returned from WindowsDpiInitialization()
+enum class WindowsDpiInitializationResult : uint32_t {
+ Success,
+ FindSetProcessDpiAwarenessContextFailed,
+ SetProcessDpiAwarenessContextFailed,
+ FindSetProcessDpiAwarenessFailed,
+ SetProcessDpiAwarenessFailed,
+ SetProcessDPIAwareFailed,
+};
+
+// Get a string representation of any WindowsDpiInitializationResult value
+inline const char* WindowsDpiInitializationResultString(
+ WindowsDpiInitializationResult result) {
+ switch (result) {
+ case WindowsDpiInitializationResult::Success:
+ return "Success";
+ case WindowsDpiInitializationResult::
+ FindSetProcessDpiAwarenessContextFailed:
+ return "Failed to find SetProcessDpiAwarenessContext";
+ case WindowsDpiInitializationResult::SetProcessDpiAwarenessContextFailed:
+ return "SetProcessDpiAwarenessContext failed";
+ case WindowsDpiInitializationResult::FindSetProcessDpiAwarenessFailed:
+ return "Failed to find SetProcessDpiAwareness";
+ case WindowsDpiInitializationResult::SetProcessDpiAwarenessFailed:
+ return "SetProcessDpiAwareness failed";
+ case WindowsDpiInitializationResult::SetProcessDPIAwareFailed:
+ return "SetProcessDPIAware failed";
+ default:
+ return "Unknown result";
+ }
+}
+
+// Initialize DPI awareness to the best available for the current OS
+// According to MSDN, this will be:
+// Per-Monitor V2 for Windows 10 Creators Update (1703) and later
+// Per-Monitor V1 for Windows 8.1 and later
+// System DPI for Vista and later (we don't support anything older)
+// https://docs.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows
+MFBT_API WindowsDpiInitializationResult WindowsDpiInitialization();
+
+} // namespace mozilla
+
+#endif // MOZILLA_MOZGLUE_MISC_WINDOWSDPIINITIALIZATION_H_
diff --git a/mozglue/misc/WindowsEnumProcessModules.h b/mozglue/misc/WindowsEnumProcessModules.h
new file mode 100644
index 0000000000..573b0dbdfa
--- /dev/null
+++ b/mozglue/misc/WindowsEnumProcessModules.h
@@ -0,0 +1,61 @@
+/* -*- 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/. */
+
+#ifndef mozilla_WindowsEnumProcessModules_h
+#define mozilla_WindowsEnumProcessModules_h
+
+#include <windows.h>
+#include <psapi.h>
+
+#include "mozilla/FunctionRef.h"
+#include "mozilla/NativeNt.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/WinHeaderOnlyUtils.h"
+
+namespace mozilla {
+
+// Why don't we use CreateToolhelp32Snapshot instead of EnumProcessModules?
+// CreateToolhelp32Snapshot gets the ANSI versions of module path strings
+// via ntdll!RtlQueryProcessDebugInformation and stores them into a snapshot.
+// Module32FirstW/Module32NextW re-converts ANSI into Unicode, but it cannot
+// restore lost information. This means we still need GetModuleFileNameEx
+// even when we use CreateToolhelp32Snapshot, but EnumProcessModules is faster.
+inline bool EnumerateProcessModules(
+ const FunctionRef<void(const wchar_t*, HMODULE)>& aCallback) {
+ DWORD modulesSize;
+ if (!::EnumProcessModules(nt::kCurrentProcess, nullptr, 0, &modulesSize)) {
+ return false;
+ }
+
+ DWORD modulesNum = modulesSize / sizeof(HMODULE);
+ UniquePtr<HMODULE[]> modules = MakeUnique<HMODULE[]>(modulesNum);
+ if (!::EnumProcessModules(nt::kCurrentProcess, modules.get(),
+ modulesNum * sizeof(HMODULE), &modulesSize)) {
+ return false;
+ }
+
+ // The list may have shrunk between calls
+ if (modulesSize / sizeof(HMODULE) < modulesNum) {
+ modulesNum = modulesSize / sizeof(HMODULE);
+ }
+
+ for (DWORD i = 0; i < modulesNum; ++i) {
+ UniquePtr<wchar_t[]> modulePath = GetFullModulePath(modules[i]);
+ if (!modulePath) {
+ continue;
+ }
+
+ // Please note that modules[i] could be invalid if the module
+ // was unloaded after GetFullModulePath succeeded.
+ aCallback(modulePath.get(), modules[i]);
+ }
+
+ return true;
+}
+
+} // namespace mozilla
+
+#endif // mozilla_WindowsEnumProcessModules_h
diff --git a/mozglue/misc/WindowsMapRemoteView.cpp b/mozglue/misc/WindowsMapRemoteView.cpp
new file mode 100644
index 0000000000..aca9979ab6
--- /dev/null
+++ b/mozglue/misc/WindowsMapRemoteView.cpp
@@ -0,0 +1,124 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/WindowsMapRemoteView.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/DynamicallyLinkedFunctionPtr.h"
+
+#include <winternl.h>
+
+#if (NTDDI_VERSION < NTDDI_WIN10_RS2)
+
+// MapViewOfFile2 is just an inline function that calls MapViewOfFileNuma2 with
+// its preferred node set to NUMA_NO_PREFERRED_NODE
+WINBASEAPI PVOID WINAPI MapViewOfFileNuma2(HANDLE aFileMapping, HANDLE aProcess,
+ ULONG64 aOffset, PVOID aBaseAddress,
+ SIZE_T aViewSize,
+ ULONG aAllocationType,
+ ULONG aPageProtection,
+ ULONG aPreferredNode);
+
+WINBASEAPI BOOL WINAPI UnmapViewOfFile2(HANDLE aProcess, PVOID aBaseAddress,
+ ULONG aUnmapFlags);
+
+#endif // (NTDDI_VERSION < NTDDI_WIN10_RS2)
+
+enum SECTION_INHERIT { ViewShare = 1, ViewUnmap = 2 };
+
+NTSTATUS NTAPI NtMapViewOfSection(
+ HANDLE aSection, HANDLE aProcess, PVOID* aBaseAddress, ULONG_PTR aZeroBits,
+ SIZE_T aCommitSize, PLARGE_INTEGER aSectionOffset, PSIZE_T aViewSize,
+ SECTION_INHERIT aInheritDisposition, ULONG aAllocationType,
+ ULONG aProtectionFlags);
+
+NTSTATUS NTAPI NtUnmapViewOfSection(HANDLE aProcess, PVOID aBaseAddress);
+
+static DWORD GetWin32ErrorCode(NTSTATUS aNtStatus) {
+ static const mozilla::StaticDynamicallyLinkedFunctionPtr<
+ decltype(&RtlNtStatusToDosError)>
+ pRtlNtStatusToDosError(L"ntdll.dll", "RtlNtStatusToDosError");
+
+ MOZ_ASSERT(!!pRtlNtStatusToDosError);
+ if (!pRtlNtStatusToDosError) {
+ return ERROR_GEN_FAILURE;
+ }
+
+ return pRtlNtStatusToDosError(aNtStatus);
+}
+
+namespace mozilla {
+
+MFBT_API void* MapRemoteViewOfFile(HANDLE aFileMapping, HANDLE aProcess,
+ ULONG64 aOffset, PVOID aBaseAddress,
+ SIZE_T aViewSize, ULONG aAllocationType,
+ ULONG aProtectionFlags) {
+ static const StaticDynamicallyLinkedFunctionPtr<decltype(&MapViewOfFileNuma2)>
+ pMapViewOfFileNuma2(L"Api-ms-win-core-memory-l1-1-5.dll",
+ "MapViewOfFileNuma2");
+
+ if (!!pMapViewOfFileNuma2) {
+ return pMapViewOfFileNuma2(aFileMapping, aProcess, aOffset, aBaseAddress,
+ aViewSize, aAllocationType, aProtectionFlags,
+ NUMA_NO_PREFERRED_NODE);
+ }
+
+ static const StaticDynamicallyLinkedFunctionPtr<decltype(&NtMapViewOfSection)>
+ pNtMapViewOfSection(L"ntdll.dll", "NtMapViewOfSection");
+
+ MOZ_ASSERT(!!pNtMapViewOfSection);
+ if (!pNtMapViewOfSection) {
+ return nullptr;
+ }
+
+ // For the sake of consistency, we only permit the same flags that
+ // MapViewOfFileNuma2 allows
+ if (aAllocationType != 0 && aAllocationType != MEM_RESERVE &&
+ aAllocationType != MEM_LARGE_PAGES) {
+ ::SetLastError(ERROR_INVALID_PARAMETER);
+ return nullptr;
+ }
+
+ NTSTATUS ntStatus;
+
+ LARGE_INTEGER offset;
+ offset.QuadPart = aOffset;
+
+ ntStatus = pNtMapViewOfSection(aFileMapping, aProcess, &aBaseAddress, 0, 0,
+ &offset, &aViewSize, ViewUnmap,
+ aAllocationType, aProtectionFlags);
+ if (NT_SUCCESS(ntStatus)) {
+ ::SetLastError(ERROR_SUCCESS);
+ return aBaseAddress;
+ }
+
+ ::SetLastError(GetWin32ErrorCode(ntStatus));
+ return nullptr;
+}
+
+MFBT_API bool UnmapRemoteViewOfFile(HANDLE aProcess, PVOID aBaseAddress) {
+ static const StaticDynamicallyLinkedFunctionPtr<decltype(&UnmapViewOfFile2)>
+ pUnmapViewOfFile2(L"kernel32.dll", "UnmapViewOfFile2");
+
+ if (!!pUnmapViewOfFile2) {
+ return !!pUnmapViewOfFile2(aProcess, aBaseAddress, 0);
+ }
+
+ static const StaticDynamicallyLinkedFunctionPtr<
+ decltype(&NtUnmapViewOfSection)>
+ pNtUnmapViewOfSection(L"ntdll.dll", "NtUnmapViewOfSection");
+
+ MOZ_ASSERT(!!pNtUnmapViewOfSection);
+ if (!pNtUnmapViewOfSection) {
+ return false;
+ }
+
+ NTSTATUS ntStatus = pNtUnmapViewOfSection(aProcess, aBaseAddress);
+ ::SetLastError(GetWin32ErrorCode(ntStatus));
+ return NT_SUCCESS(ntStatus);
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/WindowsMapRemoteView.h b/mozglue/misc/WindowsMapRemoteView.h
new file mode 100644
index 0000000000..6ab88074b5
--- /dev/null
+++ b/mozglue/misc/WindowsMapRemoteView.h
@@ -0,0 +1,25 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_WindowsMapRemoteView_h
+#define mozilla_WindowsMapRemoteView_h
+
+#include "mozilla/Types.h"
+
+#include <windows.h>
+
+namespace mozilla {
+
+MFBT_API PVOID MapRemoteViewOfFile(HANDLE aFileMapping, HANDLE aProcess,
+ ULONG64 aOffset, PVOID aBaseAddress,
+ SIZE_T aViewSize, ULONG aAllocationType,
+ ULONG aProtectionFlags);
+
+MFBT_API bool UnmapRemoteViewOfFile(HANDLE aProcess, PVOID aBaseAddress);
+
+} // namespace mozilla
+
+#endif // mozilla_WindowsMapRemoteView_h
diff --git a/mozglue/misc/WindowsProcessMitigations.cpp b/mozglue/misc/WindowsProcessMitigations.cpp
new file mode 100644
index 0000000000..f528738b77
--- /dev/null
+++ b/mozglue/misc/WindowsProcessMitigations.cpp
@@ -0,0 +1,91 @@
+/* -*- 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/. */
+
+#include "mozilla/WindowsProcessMitigations.h"
+
+#include <processthreadsapi.h>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/DynamicallyLinkedFunctionPtr.h"
+
+static_assert(sizeof(PROCESS_MITIGATION_DYNAMIC_CODE_POLICY) == 4);
+
+#if (_WIN32_WINNT < 0x0602)
+BOOL WINAPI GetProcessMitigationPolicy(
+ HANDLE hProcess, PROCESS_MITIGATION_POLICY MitigationPolicy, PVOID lpBuffer,
+ SIZE_T dwLength);
+#endif // (_WIN32_WINNT < 0x0602)
+
+namespace mozilla {
+
+static decltype(&::GetProcessMitigationPolicy)
+FetchGetProcessMitigationPolicyFunc() {
+ static const StaticDynamicallyLinkedFunctionPtr<
+ decltype(&::GetProcessMitigationPolicy)>
+ pGetProcessMitigationPolicy(L"kernel32.dll",
+ "GetProcessMitigationPolicy");
+ return pGetProcessMitigationPolicy;
+}
+
+static bool sWin32kLockedDownInPolicy = false;
+
+MFBT_API bool IsWin32kLockedDown() {
+ static bool sWin32kLockedDown = []() {
+ auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
+
+ PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY polInfo;
+ if (!pGetProcessMitigationPolicy ||
+ !pGetProcessMitigationPolicy(::GetCurrentProcess(),
+ ProcessSystemCallDisablePolicy, &polInfo,
+ sizeof(polInfo))) {
+ // We failed to get pointer to GetProcessMitigationPolicy or the call
+ // to it failed, so just return what the sandbox policy says.
+ return sWin32kLockedDownInPolicy;
+ }
+
+ return !!polInfo.DisallowWin32kSystemCalls;
+ }();
+
+ return sWin32kLockedDown;
+}
+
+MFBT_API void SetWin32kLockedDownInPolicy() {
+ sWin32kLockedDownInPolicy = true;
+}
+
+MFBT_API bool IsDynamicCodeDisabled() {
+ auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
+ if (!pGetProcessMitigationPolicy) {
+ return false;
+ }
+
+ PROCESS_MITIGATION_DYNAMIC_CODE_POLICY polInfo;
+ if (!pGetProcessMitigationPolicy(::GetCurrentProcess(),
+ ProcessDynamicCodePolicy, &polInfo,
+ sizeof(polInfo))) {
+ return false;
+ }
+
+ return polInfo.ProhibitDynamicCode;
+}
+
+MFBT_API bool IsEafPlusEnabled() {
+ auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
+ if (!pGetProcessMitigationPolicy) {
+ return false;
+ }
+
+ PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY polInfo;
+ if (!pGetProcessMitigationPolicy(::GetCurrentProcess(),
+ ProcessPayloadRestrictionPolicy, &polInfo,
+ sizeof(polInfo))) {
+ return false;
+ }
+
+ return polInfo.EnableExportAddressFilterPlus;
+}
+
+} // namespace mozilla
diff --git a/mozglue/misc/WindowsProcessMitigations.h b/mozglue/misc/WindowsProcessMitigations.h
new file mode 100644
index 0000000000..2f02553617
--- /dev/null
+++ b/mozglue/misc/WindowsProcessMitigations.h
@@ -0,0 +1,21 @@
+/* -*- 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/. */
+
+#ifndef mozilla_WindowsProcessMitigations_h
+#define mozilla_WindowsProcessMitigations_h
+
+#include "mozilla/Types.h"
+
+namespace mozilla {
+
+MFBT_API bool IsWin32kLockedDown();
+MFBT_API void SetWin32kLockedDownInPolicy();
+MFBT_API bool IsDynamicCodeDisabled();
+MFBT_API bool IsEafPlusEnabled();
+
+} // namespace mozilla
+
+#endif // mozilla_WindowsProcessMitigations_h
diff --git a/mozglue/misc/WindowsStackCookie.h b/mozglue/misc/WindowsStackCookie.h
new file mode 100644
index 0000000000..c4196b3853
--- /dev/null
+++ b/mozglue/misc/WindowsStackCookie.h
@@ -0,0 +1,63 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_WindowsStackCookie_h
+#define mozilla_WindowsStackCookie_h
+
+#if defined(DEBUG) && defined(_M_X64) && !defined(__MINGW64__)
+
+# include <windows.h>
+# include <winnt.h>
+
+# include <cstdint>
+
+# include "mozilla/Types.h"
+
+namespace mozilla {
+
+// This function does pattern matching on the instructions generated for a
+// given function, to detect whether it uses stack buffers. More specifically,
+// it looks for instructions that characterize the presence of stack cookie
+// checks. When this function returns true, it can be a false positive, but we
+// use a rather long pattern to make false positives very unlikely.
+// Note: Do not use this function inside the function that lives at
+// aFunctionAddress, as that could introduce stack buffers.
+// Note: The pattern we use does not work for MinGW builds.
+inline bool HasStackCookieCheck(uintptr_t aFunctionAddress) {
+ DWORD64 imageBase{};
+ auto entry = ::RtlLookupFunctionEntry(
+ reinterpret_cast<DWORD64>(aFunctionAddress), &imageBase, nullptr);
+ if (entry && entry->EndAddress > entry->BeginAddress + 14) {
+ auto begin = reinterpret_cast<uint8_t*>(imageBase + entry->BeginAddress);
+ auto end = reinterpret_cast<uint8_t*>(imageBase + entry->EndAddress - 14);
+ for (auto pc = begin; pc != end; ++pc) {
+ // 48 8b 05 XX XX XX XX: mov rax, qword ptr [rip + XXXXXXXX]
+ if ((pc[0] == 0x48 && pc[1] == 0x8b && pc[2] == 0x05) &&
+ // 48 31 e0: xor rax, rsp
+ (pc[7] == 0x48 && pc[8] == 0x31 && pc[9] == 0xe0) &&
+ // 48 89 (8|4)4 24 ...: mov qword ptr [rsp + ...], rax
+ (pc[10] == 0x48 && pc[11] == 0x89 &&
+ (pc[12] == 0x44 || pc[12] == 0x84) && pc[13] == 0x24)) {
+ return true;
+ }
+ }
+ }
+ // In x64, if there is no entry, then there is no stack allocation, hence
+ // there is no stack cookie check: "Table-based exception handling requires a
+ // table entry for all functions that allocate stack space or call another
+ // function (for example, nonleaf functions)."
+ // https://learn.microsoft.com/en-us/cpp/build/exception-handling-x64
+ // Similarly, if the gap between begin and end is less than 14 bytes, then
+ // the function cannot contain the pattern we are looking for, therefore it
+ // has no cookie check either.
+ return false;
+}
+
+} // namespace mozilla
+
+#endif // defined(DEBUG) && defined(_M_X64) && !defined(__MINGW64__)
+
+#endif // mozilla_WindowsStackCookie_h
diff --git a/mozglue/misc/WindowsUnicode.cpp b/mozglue/misc/WindowsUnicode.cpp
new file mode 100644
index 0000000000..464380b6da
--- /dev/null
+++ b/mozglue/misc/WindowsUnicode.cpp
@@ -0,0 +1,59 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#include "WindowsUnicode.h"
+
+#include <windows.h>
+// For UNICODE_STRING
+#include <winternl.h>
+
+#include <string.h>
+
+namespace mozilla {
+namespace glue {
+
+mozilla::UniquePtr<char[]> WideToUTF8(const wchar_t* aStr,
+ const size_t aStrLenExclNul) {
+ int numConv = ::WideCharToMultiByte(CP_UTF8, 0, aStr, aStrLenExclNul, nullptr,
+ 0, nullptr, nullptr);
+ if (!numConv) {
+ return nullptr;
+ }
+
+ // Include room for the null terminator by adding one
+ auto buf = mozilla::MakeUnique<char[]>(numConv + 1);
+
+ numConv = ::WideCharToMultiByte(CP_UTF8, 0, aStr, aStrLenExclNul, buf.get(),
+ numConv, nullptr, nullptr);
+ if (!numConv) {
+ return nullptr;
+ }
+
+ // Add null termination. numConv does not include the terminator, so we don't
+ // subtract 1 when indexing into buf.
+ buf[numConv] = 0;
+
+ return buf;
+}
+
+mozilla::UniquePtr<char[]> WideToUTF8(const wchar_t* aStr) {
+ return WideToUTF8(aStr, wcslen(aStr));
+}
+
+mozilla::UniquePtr<char[]> WideToUTF8(const std::wstring& aStr) {
+ return WideToUTF8(aStr.data(), aStr.length());
+}
+
+mozilla::UniquePtr<char[]> WideToUTF8(PCUNICODE_STRING aStr) {
+ if (!aStr) {
+ return nullptr;
+ }
+
+ return WideToUTF8(aStr->Buffer, aStr->Length / sizeof(WCHAR));
+}
+
+} // namespace glue
+} // namespace mozilla
diff --git a/mozglue/misc/WindowsUnicode.h b/mozglue/misc/WindowsUnicode.h
new file mode 100644
index 0000000000..77fc376b92
--- /dev/null
+++ b/mozglue/misc/WindowsUnicode.h
@@ -0,0 +1,35 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_glue_WindowsUnicode_h
+#define mozilla_glue_WindowsUnicode_h
+
+#include "mozilla/UniquePtr.h"
+
+#include <string>
+
+struct _UNICODE_STRING;
+
+namespace mozilla {
+namespace glue {
+
+mozilla::UniquePtr<char[]> WideToUTF8(const wchar_t* aStr,
+ const size_t aStrLenExclNul);
+
+mozilla::UniquePtr<char[]> WideToUTF8(const wchar_t* aStr);
+mozilla::UniquePtr<char[]> WideToUTF8(const std::wstring& aStr);
+mozilla::UniquePtr<char[]> WideToUTF8(const _UNICODE_STRING* aStr);
+
+#if defined(bstr_t)
+inline mozilla::UniquePtr<char[]> WideToUTF8(const _bstr_t& aStr) {
+ return WideToUTF8(static_cast<const wchar_t*>(aStr), aStr.length());
+}
+#endif // defined(bstr_t)
+
+} // namespace glue
+} // namespace mozilla
+
+#endif // mozilla_glue_WindowsUnicode_h
diff --git a/mozglue/misc/WindowsUnwindInfo.h b/mozglue/misc/WindowsUnwindInfo.h
new file mode 100644
index 0000000000..3667b5f2bc
--- /dev/null
+++ b/mozglue/misc/WindowsUnwindInfo.h
@@ -0,0 +1,329 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_WindowsUnwindInfo_h
+#define mozilla_WindowsUnwindInfo_h
+
+#ifdef _M_X64
+
+# include <cstdint>
+
+# include "mozilla/Assertions.h"
+# include "mozilla/UniquePtr.h"
+
+namespace mozilla {
+
+// On Windows x64, there is no standard function prologue, hence extra
+// information that describes the prologue must be added for each non-leaf
+// function in order to properly unwind the stack. This extra information is
+// grouped into so-called function tables.
+//
+// A function table is a contiguous array of one or more RUNTIME_FUNCTION
+// entries. Each RUNTIME_FUNCTION entry associates a start and end offset in
+// code with specific unwind information. The function table is present in the
+// .pdata section of binaries for static code, and added dynamically with
+// RtlAddFunctionTable or RtlInstallFunctionTableCallback for dynamic code.
+// RUNTIME_FUNCTION entries point to the unwind information, which can thus
+// live at a different location in memory, for example it lives in the .xdata
+// section for static code.
+//
+// Contrary to RUNTIME_FUNCTION, Microsoft provides no standard structure
+// definition to map the unwind information. This file thus provides some
+// helpers to read this data, originally based on breakpad code. The unwind
+// information is partially documented at:
+// https://learn.microsoft.com/en-us/cpp/build/exception-handling-x64.
+
+// The unwind information stores a bytecode in UnwindInfo.unwind_code[] that
+// describes how the instructions in the function prologue interact with the
+// stack. An instruction in this bytecode is called an unwind code.
+// UnwindCodeOperationCodes enumerates all opcodes used by this bytecode.
+// Unwind codes are stored in contiguous slots of 16 bits, where each unwind
+// code can span either 1, 2, or 3 slots depending on the opcode it uses.
+enum UnwindOperationCodes : uint8_t {
+ // UnwindCode.operation_info == register number
+ UWOP_PUSH_NONVOL = 0,
+ // UnwindCode.operation_info == 0 or 1,
+ // alloc size in next slot (if 0) or next 2 slots (if 1)
+ UWOP_ALLOC_LARGE = 1,
+ // UnwindCode.operation_info == size of allocation / 8 - 1
+ UWOP_ALLOC_SMALL = 2,
+ // no UnwindCode.operation_info; register number UnwindInfo.frame_register
+ // receives (rsp + UnwindInfo.frame_offset*16)
+ UWOP_SET_FPREG = 3,
+ // UnwindCode.operation_info == register number, offset in next slot
+ UWOP_SAVE_NONVOL = 4,
+ // UnwindCode.operation_info == register number, offset in next 2 slots
+ UWOP_SAVE_NONVOL_FAR = 5,
+ // Version 1; undocumented; not meant for x64
+ UWOP_SAVE_XMM = 6,
+ // Version 2; undocumented
+ UWOP_EPILOG = 6,
+ // Version 1; undocumented; not meant for x64
+ UWOP_SAVE_XMM_FAR = 7,
+ // Version 2; undocumented
+ UWOP_SPARE = 7,
+ // UnwindCode.operation_info == XMM reg number, offset in next slot
+ UWOP_SAVE_XMM128 = 8,
+ // UnwindCode.operation_info == XMM reg number, offset in next 2 slots
+ UWOP_SAVE_XMM128_FAR = 9,
+ // UnwindCode.operation_info == 0: no error-code, 1: error-code
+ UWOP_PUSH_MACHFRAME = 10
+};
+
+// Strictly speaking, UnwindCode represents a slot -- not a full unwind code.
+union UnwindCode {
+ struct {
+ uint8_t offset_in_prolog;
+ UnwindOperationCodes unwind_operation_code : 4;
+ uint8_t operation_info : 4;
+ };
+ uint16_t frame_offset;
+};
+
+// UnwindInfo is a variable-sized struct meant for C-style direct access to the
+// unwind information. Be careful:
+// - prefer using the size() helper method to using sizeof;
+// - don't construct objects of this type, cast pointers instead;
+// - consider using the IterableUnwindInfo helpers to iterate over unwind
+// codes.
+struct UnwindInfo {
+ uint8_t version : 3;
+ uint8_t flags : 5; // either 0, UNW_FLAG_CHAININFO, or a combination of
+ // UNW_FLAG_EHANDLER and UNW_FLAG_UHANDLER
+ uint8_t size_of_prolog;
+ uint8_t count_of_codes; // contains the length of the unwind_code[] array
+ uint8_t frame_register : 4;
+ uint8_t frame_offset : 4;
+ UnwindCode unwind_code[1]; // variable length
+ // Note: There is extra data after the variable length array if using flags
+ // UNW_FLAG_EHANDLER, UNW_FLAG_UHANDLER, or UNW_FLAG_CHAININFO. We
+ // ignore the extra data at the moment. For more details, see:
+ // https://learn.microsoft.com/en-us/cpp/build/exception-handling-x64.
+ //
+ // When using UNW_FLAG_EHANDLER or UNW_FLAG_UHANDLER, the extra data
+ // includes handler data of unspecificied size: only the handler knows
+ // the correct size for this data. This makes it difficult to know the
+ // size of the full unwind information or to copy it in this particular
+ // case.
+
+ UnwindInfo(const UnwindInfo&) = delete;
+ UnwindInfo& operator=(const UnwindInfo&) = delete;
+ UnwindInfo(UnwindInfo&&) = delete;
+ UnwindInfo& operator=(UnwindInfo&&) = delete;
+ ~UnwindInfo() = delete;
+
+ // Size of this structure, including the variable length unwind_code array
+ // but NOT including the extra data related to flags UNW_FLAG_EHANDLER,
+ // UNW_FLAG_UHANDLER, and UNW_FLAG_CHAININFO.
+ //
+ // The places where we currently use these helpers read unwind information at
+ // function entry points; as such we expect that they may encounter
+ // UNW_FLAG_EHANDLER and/or UNW_FLAG_UHANDLER but won't need to use the
+ // associated extra data, and it is expected that they should not encounter
+ // UNW_FLAG_CHAININFO. UNW_FLAG_CHAININFO is typically used for code that
+ // lives separately from the entry point of the function to which it belongs,
+ // this code then has chained unwind info pointing to the entry point.
+ inline size_t Size() const {
+ return offsetof(UnwindInfo, unwind_code) +
+ count_of_codes * sizeof(UnwindCode);
+ }
+
+ // Note: We currently do not copy the extra data related to flags
+ // UNW_FLAG_EHANDLER, UNW_FLAG_UHANDLER, and UNW_FLAG_CHAININFO.
+ UniquePtr<uint8_t[]> Copy() const {
+ auto s = Size();
+ auto result = MakeUnique<uint8_t[]>(s);
+ std::memcpy(result.get(), reinterpret_cast<const void*>(this), s);
+ return result;
+ }
+
+ // An unwind code spans a number of slots in the unwind_code array that can
+ // vary from 1 to 3. This method assumes that the index parameter points to
+ // a slot that is the start of an unwind code. If the unwind code is
+ // well-formed, it returns true and sets its second parameter to the number
+ // of slots that the unwind code occupies.
+ //
+ // This function returns false if the unwind code is ill-formed, i.e.:
+ // - either the index points out of bounds;
+ // - or the opcode is invalid, or unexpected (e.g. UWOP_SAVE_XMM and
+ // UWOP_SAVE_XMM_FAR in version 1);
+ // - or using the correct slots count for the opcode would go out of bounds.
+ bool GetSlotsCountForCodeAt(uint8_t aIndex, uint8_t* aSlotsCount) const {
+ if (aIndex >= count_of_codes) {
+ MOZ_ASSERT_UNREACHABLE("The index is out of bounds");
+ return false;
+ }
+
+ const UnwindCode& unwindCode = unwind_code[aIndex];
+ uint8_t slotsCount = 0;
+
+ // See https://learn.microsoft.com/en-us/cpp/build/exception-handling-x64
+ switch (unwindCode.unwind_operation_code) {
+ // Start with fixed-size opcodes common to versions 1 and 2
+ case UWOP_SAVE_NONVOL_FAR:
+ case UWOP_SAVE_XMM128_FAR:
+ slotsCount = 3;
+ break;
+
+ case UWOP_SAVE_NONVOL:
+ case UWOP_SAVE_XMM128:
+ slotsCount = 2;
+ break;
+
+ case UWOP_PUSH_NONVOL:
+ case UWOP_ALLOC_SMALL:
+ case UWOP_SET_FPREG:
+ case UWOP_PUSH_MACHFRAME:
+ slotsCount = 1;
+ break;
+
+ // UWOP_ALLOC_LARGE is the only variable-sized opcode. It is common to
+ // versions 1 and 2. It is ill-formed if the info is not 0 or 1.
+ case UWOP_ALLOC_LARGE:
+ if (unwindCode.operation_info > 1) {
+ MOZ_ASSERT_UNREACHABLE(
+ "Operation UWOP_ALLOC_LARGE is used, but operation_info "
+ "is not 0 or 1");
+ return false;
+ }
+ slotsCount = 2 + unwindCode.operation_info;
+ break;
+
+ case UWOP_SPARE:
+ if (version != 2) {
+ MOZ_ASSERT_UNREACHABLE(
+ "Operation code UWOP_SPARE is used, but version is not 2");
+ return false;
+ }
+ slotsCount = 3;
+ break;
+
+ case UWOP_EPILOG:
+ if (version != 2) {
+ MOZ_ASSERT_UNREACHABLE(
+ "Operation code UWOP_EPILOG is used, but version is not 2");
+ return false;
+ }
+ slotsCount = 2;
+ break;
+
+ default:
+ MOZ_ASSERT_UNREACHABLE("An unknown operation code is used");
+ return false;
+ }
+
+ // The unwind code is ill-formed if using the correct number of slots for
+ // the opcode would go out of bounds.
+ if (count_of_codes - aIndex < slotsCount) {
+ MOZ_ASSERT_UNREACHABLE(
+ "A valid operation code is used, but it spans too many slots");
+ return false;
+ }
+
+ *aSlotsCount = slotsCount;
+ return true;
+ }
+};
+
+class IterableUnwindInfo {
+ class Iterator {
+ public:
+ UnwindInfo& Info() { return mInfo; }
+
+ uint8_t Index() const {
+ MOZ_ASSERT(IsValid());
+ return mIndex;
+ }
+
+ uint8_t SlotsCount() const {
+ MOZ_ASSERT(IsValid());
+ return mSlotsCount;
+ }
+
+ // An iterator is valid if it points to a well-formed unwind code.
+ // The end iterator is invalid as it does not point to any unwind code.
+ // All invalid iterators compare equal, which allows comparison with the
+ // end iterator to exit loops as soon as an ill-formed unwind code is met.
+ bool IsValid() const { return mIsValid; }
+
+ bool IsAtEnd() const { return mIndex >= mInfo.count_of_codes; }
+
+ bool operator==(const Iterator& aOther) const {
+ if (mIsValid != aOther.mIsValid) {
+ return false;
+ }
+ // Comparing two invalid iterators.
+ if (!mIsValid) {
+ return true;
+ }
+ // Comparing two valid iterators.
+ return mIndex == aOther.mIndex;
+ }
+
+ bool operator!=(const Iterator& aOther) const { return !(*this == aOther); }
+
+ Iterator& operator++() {
+ MOZ_ASSERT(IsValid());
+ mIndex += mSlotsCount;
+ if (mIndex < mInfo.count_of_codes) {
+ mIsValid = mInfo.GetSlotsCountForCodeAt(mIndex, &mSlotsCount);
+ MOZ_ASSERT(IsValid());
+ } else {
+ mIsValid = false;
+ }
+ return *this;
+ }
+
+ const UnwindCode& operator*() {
+ MOZ_ASSERT(IsValid());
+ return mInfo.unwind_code[mIndex];
+ }
+
+ private:
+ friend class IterableUnwindInfo;
+
+ Iterator(UnwindInfo& aInfo, uint8_t aIndex, uint8_t aSlotsCount,
+ bool aIsValid)
+ : mInfo(aInfo),
+ mIndex(aIndex),
+ mSlotsCount(aSlotsCount),
+ mIsValid(aIsValid){};
+
+ UnwindInfo& mInfo;
+ uint8_t mIndex;
+ uint8_t mSlotsCount;
+ bool mIsValid;
+ };
+
+ public:
+ explicit IterableUnwindInfo(UnwindInfo& aInfo)
+ : mBegin(aInfo, 0, 0, false),
+ mEnd(aInfo, aInfo.count_of_codes, 0, false) {
+ if (aInfo.count_of_codes) {
+ mBegin.mIsValid = aInfo.GetSlotsCountForCodeAt(0, &mBegin.mSlotsCount);
+ MOZ_ASSERT(mBegin.mIsValid);
+ }
+ }
+
+ explicit IterableUnwindInfo(uint8_t* aInfo)
+ : IterableUnwindInfo(*reinterpret_cast<UnwindInfo*>(aInfo)) {}
+
+ UnwindInfo& Info() { return mBegin.Info(); }
+
+ const Iterator& begin() { return mBegin; }
+
+ const Iterator& end() { return mEnd; }
+
+ private:
+ Iterator mBegin;
+ Iterator mEnd;
+};
+
+} // namespace mozilla
+
+#endif // _M_X64
+
+#endif // mozilla_WindowsUnwindInfo_h
diff --git a/mozglue/misc/decimal/Decimal.cpp b/mozglue/misc/decimal/Decimal.cpp
new file mode 100644
index 0000000000..cc828e2843
--- /dev/null
+++ b/mozglue/misc/decimal/Decimal.cpp
@@ -0,0 +1,1063 @@
+/*
+ * Copyright (C) 2012 Google Inc. 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.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * 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
+ * OWNER 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.
+ */
+
+#include "Decimal.h"
+#include "moz-decimal-utils.h"
+#include "DoubleConversion.h"
+
+using namespace moz_decimal_utils;
+
+#include <algorithm>
+#include <float.h>
+
+namespace blink {
+
+namespace DecimalPrivate {
+
+static int const ExponentMax = 1023;
+static int const ExponentMin = -1023;
+static int const Precision = 18;
+
+static const uint64_t MaxCoefficient = UINT64_C(0xDE0B6B3A763FFFF); // 999999999999999999 == 18 9's
+
+// This class handles Decimal special values.
+class SpecialValueHandler {
+ STACK_ALLOCATED();
+ WTF_MAKE_NONCOPYABLE(SpecialValueHandler);
+public:
+ enum HandleResult {
+ BothFinite,
+ BothInfinity,
+ EitherNaN,
+ LHSIsInfinity,
+ RHSIsInfinity,
+ };
+
+ SpecialValueHandler(const Decimal& lhs, const Decimal& rhs);
+ HandleResult handle();
+ Decimal value() const;
+
+private:
+ enum Result {
+ ResultIsLHS,
+ ResultIsRHS,
+ ResultIsUnknown,
+ };
+
+ const Decimal& m_lhs;
+ const Decimal& m_rhs;
+ Result m_result;
+};
+
+SpecialValueHandler::SpecialValueHandler(const Decimal& lhs, const Decimal& rhs)
+ : m_lhs(lhs), m_rhs(rhs), m_result(ResultIsUnknown)
+{
+}
+
+SpecialValueHandler::HandleResult SpecialValueHandler::handle()
+{
+ if (m_lhs.isFinite() && m_rhs.isFinite())
+ return BothFinite;
+
+ const Decimal::EncodedData::FormatClass lhsClass = m_lhs.value().formatClass();
+ const Decimal::EncodedData::FormatClass rhsClass = m_rhs.value().formatClass();
+ if (lhsClass == Decimal::EncodedData::ClassNaN) {
+ m_result = ResultIsLHS;
+ return EitherNaN;
+ }
+
+ if (rhsClass == Decimal::EncodedData::ClassNaN) {
+ m_result = ResultIsRHS;
+ return EitherNaN;
+ }
+
+ if (lhsClass == Decimal::EncodedData::ClassInfinity)
+ return rhsClass == Decimal::EncodedData::ClassInfinity ? BothInfinity : LHSIsInfinity;
+
+ if (rhsClass == Decimal::EncodedData::ClassInfinity)
+ return RHSIsInfinity;
+
+ ASSERT_NOT_REACHED();
+ return BothFinite;
+}
+
+Decimal SpecialValueHandler::value() const
+{
+ switch (m_result) {
+ case ResultIsLHS:
+ return m_lhs;
+ case ResultIsRHS:
+ return m_rhs;
+ case ResultIsUnknown:
+ default:
+ ASSERT_NOT_REACHED();
+ return m_lhs;
+ }
+}
+
+// This class is used for 128 bit unsigned integer arithmetic.
+class UInt128 {
+public:
+ UInt128(uint64_t low, uint64_t high)
+ : m_high(high), m_low(low)
+ {
+ }
+
+ UInt128& operator/=(uint32_t);
+
+ uint64_t high() const { return m_high; }
+ uint64_t low() const { return m_low; }
+
+ static UInt128 multiply(uint64_t u, uint64_t v) { return UInt128(u * v, multiplyHigh(u, v)); }
+
+private:
+ static uint32_t highUInt32(uint64_t x) { return static_cast<uint32_t>(x >> 32); }
+ static uint32_t lowUInt32(uint64_t x) { return static_cast<uint32_t>(x & ((static_cast<uint64_t>(1) << 32) - 1)); }
+ static uint64_t makeUInt64(uint32_t low, uint32_t high) { return low | (static_cast<uint64_t>(high) << 32); }
+
+ static uint64_t multiplyHigh(uint64_t, uint64_t);
+
+ uint64_t m_high;
+ uint64_t m_low;
+};
+
+UInt128& UInt128::operator/=(const uint32_t divisor)
+{
+ ASSERT(divisor);
+
+ if (!m_high) {
+ m_low /= divisor;
+ return *this;
+ }
+
+ uint32_t dividend[4];
+ dividend[0] = lowUInt32(m_low);
+ dividend[1] = highUInt32(m_low);
+ dividend[2] = lowUInt32(m_high);
+ dividend[3] = highUInt32(m_high);
+
+ uint32_t quotient[4];
+ uint32_t remainder = 0;
+ for (int i = 3; i >= 0; --i) {
+ const uint64_t work = makeUInt64(dividend[i], remainder);
+ remainder = static_cast<uint32_t>(work % divisor);
+ quotient[i] = static_cast<uint32_t>(work / divisor);
+ }
+ m_low = makeUInt64(quotient[0], quotient[1]);
+ m_high = makeUInt64(quotient[2], quotient[3]);
+ return *this;
+}
+
+// Returns high 64bit of 128bit product.
+uint64_t UInt128::multiplyHigh(uint64_t u, uint64_t v)
+{
+ const uint64_t uLow = lowUInt32(u);
+ const uint64_t uHigh = highUInt32(u);
+ const uint64_t vLow = lowUInt32(v);
+ const uint64_t vHigh = highUInt32(v);
+ const uint64_t partialProduct = uHigh * vLow + highUInt32(uLow * vLow);
+ return uHigh * vHigh + highUInt32(partialProduct) + highUInt32(uLow * vHigh + lowUInt32(partialProduct));
+}
+
+static int countDigits(uint64_t x)
+{
+ int numberOfDigits = 0;
+ for (uint64_t powerOfTen = 1; x >= powerOfTen; powerOfTen *= 10) {
+ ++numberOfDigits;
+ if (powerOfTen >= std::numeric_limits<uint64_t>::max() / 10)
+ break;
+ }
+ return numberOfDigits;
+}
+
+static uint64_t scaleDown(uint64_t x, int n)
+{
+ ASSERT(n >= 0);
+ while (n > 0 && x) {
+ x /= 10;
+ --n;
+ }
+ return x;
+}
+
+static uint64_t scaleUp(uint64_t x, int n)
+{
+ ASSERT(n >= 0);
+ ASSERT(n <= Precision);
+
+ uint64_t y = 1;
+ uint64_t z = 10;
+ for (;;) {
+ if (n & 1)
+ y = y * z;
+
+ n >>= 1;
+ if (!n)
+ return x * y;
+
+ z = z * z;
+ }
+}
+
+} // namespace DecimalPrivate
+
+using namespace DecimalPrivate;
+
+Decimal::EncodedData::EncodedData(Sign sign, FormatClass formatClass)
+ : m_coefficient(0)
+ , m_exponent(0)
+ , m_formatClass(formatClass)
+ , m_sign(sign)
+{
+}
+
+Decimal::EncodedData::EncodedData(Sign sign, int exponent, uint64_t coefficient)
+ : m_formatClass(coefficient ? ClassNormal : ClassZero)
+ , m_sign(sign)
+{
+ if (exponent >= ExponentMin && exponent <= ExponentMax) {
+ while (coefficient > MaxCoefficient) {
+ coefficient /= 10;
+ ++exponent;
+ }
+ }
+
+ if (exponent > ExponentMax) {
+ m_coefficient = 0;
+ m_exponent = 0;
+ m_formatClass = ClassInfinity;
+ return;
+ }
+
+ if (exponent < ExponentMin) {
+ m_coefficient = 0;
+ m_exponent = 0;
+ m_formatClass = ClassZero;
+ return;
+ }
+
+ m_coefficient = coefficient;
+ m_exponent = static_cast<int16_t>(exponent);
+}
+
+bool Decimal::EncodedData::operator==(const EncodedData& another) const
+{
+ return m_sign == another.m_sign
+ && m_formatClass == another.m_formatClass
+ && m_exponent == another.m_exponent
+ && m_coefficient == another.m_coefficient;
+}
+
+Decimal::Decimal(int32_t i32)
+ : m_data(i32 < 0 ? Negative : Positive, 0, i32 < 0 ? static_cast<uint64_t>(-static_cast<int64_t>(i32)) : static_cast<uint64_t>(i32))
+{
+}
+
+Decimal::Decimal(Sign sign, int exponent, uint64_t coefficient)
+ : m_data(sign, coefficient ? exponent : 0, coefficient)
+{
+}
+
+Decimal::Decimal(const EncodedData& data)
+ : m_data(data)
+{
+}
+
+Decimal::Decimal(const Decimal& other)
+ : m_data(other.m_data)
+{
+}
+
+Decimal& Decimal::operator=(const Decimal& other)
+{
+ m_data = other.m_data;
+ return *this;
+}
+
+Decimal& Decimal::operator+=(const Decimal& other)
+{
+ m_data = (*this + other).m_data;
+ return *this;
+}
+
+Decimal& Decimal::operator-=(const Decimal& other)
+{
+ m_data = (*this - other).m_data;
+ return *this;
+}
+
+Decimal& Decimal::operator*=(const Decimal& other)
+{
+ m_data = (*this * other).m_data;
+ return *this;
+}
+
+Decimal& Decimal::operator/=(const Decimal& other)
+{
+ m_data = (*this / other).m_data;
+ return *this;
+}
+
+Decimal Decimal::operator-() const
+{
+ if (isNaN())
+ return *this;
+
+ Decimal result(*this);
+ result.m_data.setSign(invertSign(m_data.sign()));
+ return result;
+}
+
+Decimal Decimal::operator+(const Decimal& rhs) const
+{
+ const Decimal& lhs = *this;
+ const Sign lhsSign = lhs.sign();
+ const Sign rhsSign = rhs.sign();
+
+ SpecialValueHandler handler(lhs, rhs);
+ switch (handler.handle()) {
+ case SpecialValueHandler::BothFinite:
+ break;
+
+ case SpecialValueHandler::BothInfinity:
+ return lhsSign == rhsSign ? lhs : nan();
+
+ case SpecialValueHandler::EitherNaN:
+ return handler.value();
+
+ case SpecialValueHandler::LHSIsInfinity:
+ return lhs;
+
+ case SpecialValueHandler::RHSIsInfinity:
+ return rhs;
+ }
+
+ const AlignedOperands alignedOperands = alignOperands(lhs, rhs);
+
+ const uint64_t result = lhsSign == rhsSign
+ ? alignedOperands.lhsCoefficient + alignedOperands.rhsCoefficient
+ : alignedOperands.lhsCoefficient - alignedOperands.rhsCoefficient;
+
+ if (lhsSign == Negative && rhsSign == Positive && !result)
+ return Decimal(Positive, alignedOperands.exponent, 0);
+
+ return static_cast<int64_t>(result) >= 0
+ ? Decimal(lhsSign, alignedOperands.exponent, result)
+ : Decimal(invertSign(lhsSign), alignedOperands.exponent, -static_cast<int64_t>(result));
+}
+
+Decimal Decimal::operator-(const Decimal& rhs) const
+{
+ const Decimal& lhs = *this;
+ const Sign lhsSign = lhs.sign();
+ const Sign rhsSign = rhs.sign();
+
+ SpecialValueHandler handler(lhs, rhs);
+ switch (handler.handle()) {
+ case SpecialValueHandler::BothFinite:
+ break;
+
+ case SpecialValueHandler::BothInfinity:
+ return lhsSign == rhsSign ? nan() : lhs;
+
+ case SpecialValueHandler::EitherNaN:
+ return handler.value();
+
+ case SpecialValueHandler::LHSIsInfinity:
+ return lhs;
+
+ case SpecialValueHandler::RHSIsInfinity:
+ return infinity(invertSign(rhsSign));
+ }
+
+ const AlignedOperands alignedOperands = alignOperands(lhs, rhs);
+
+ const uint64_t result = lhsSign == rhsSign
+ ? alignedOperands.lhsCoefficient - alignedOperands.rhsCoefficient
+ : alignedOperands.lhsCoefficient + alignedOperands.rhsCoefficient;
+
+ if (lhsSign == Negative && rhsSign == Negative && !result)
+ return Decimal(Positive, alignedOperands.exponent, 0);
+
+ return static_cast<int64_t>(result) >= 0
+ ? Decimal(lhsSign, alignedOperands.exponent, result)
+ : Decimal(invertSign(lhsSign), alignedOperands.exponent, -static_cast<int64_t>(result));
+}
+
+Decimal Decimal::operator*(const Decimal& rhs) const
+{
+ const Decimal& lhs = *this;
+ const Sign lhsSign = lhs.sign();
+ const Sign rhsSign = rhs.sign();
+ const Sign resultSign = lhsSign == rhsSign ? Positive : Negative;
+
+ SpecialValueHandler handler(lhs, rhs);
+ switch (handler.handle()) {
+ case SpecialValueHandler::BothFinite: {
+ const uint64_t lhsCoefficient = lhs.m_data.coefficient();
+ const uint64_t rhsCoefficient = rhs.m_data.coefficient();
+ int resultExponent = lhs.exponent() + rhs.exponent();
+ UInt128 work(UInt128::multiply(lhsCoefficient, rhsCoefficient));
+ while (work.high()) {
+ work /= 10;
+ ++resultExponent;
+ }
+ return Decimal(resultSign, resultExponent, work.low());
+ }
+
+ case SpecialValueHandler::BothInfinity:
+ return infinity(resultSign);
+
+ case SpecialValueHandler::EitherNaN:
+ return handler.value();
+
+ case SpecialValueHandler::LHSIsInfinity:
+ return rhs.isZero() ? nan() : infinity(resultSign);
+
+ case SpecialValueHandler::RHSIsInfinity:
+ return lhs.isZero() ? nan() : infinity(resultSign);
+ }
+
+ ASSERT_NOT_REACHED();
+ return nan();
+}
+
+Decimal Decimal::operator/(const Decimal& rhs) const
+{
+ const Decimal& lhs = *this;
+ const Sign lhsSign = lhs.sign();
+ const Sign rhsSign = rhs.sign();
+ const Sign resultSign = lhsSign == rhsSign ? Positive : Negative;
+
+ SpecialValueHandler handler(lhs, rhs);
+ switch (handler.handle()) {
+ case SpecialValueHandler::BothFinite:
+ break;
+
+ case SpecialValueHandler::BothInfinity:
+ return nan();
+
+ case SpecialValueHandler::EitherNaN:
+ return handler.value();
+
+ case SpecialValueHandler::LHSIsInfinity:
+ return infinity(resultSign);
+
+ case SpecialValueHandler::RHSIsInfinity:
+ return zero(resultSign);
+ }
+
+ ASSERT(lhs.isFinite());
+ ASSERT(rhs.isFinite());
+
+ if (rhs.isZero())
+ return lhs.isZero() ? nan() : infinity(resultSign);
+
+ int resultExponent = lhs.exponent() - rhs.exponent();
+
+ if (lhs.isZero())
+ return Decimal(resultSign, resultExponent, 0);
+
+ uint64_t remainder = lhs.m_data.coefficient();
+ const uint64_t divisor = rhs.m_data.coefficient();
+ uint64_t result = 0;
+ for (;;) {
+ while (remainder < divisor && result < MaxCoefficient / 10) {
+ remainder *= 10;
+ result *= 10;
+ --resultExponent;
+ }
+ if (remainder < divisor)
+ break;
+ uint64_t quotient = remainder / divisor;
+ if (result > MaxCoefficient - quotient)
+ break;
+ result += quotient;
+ remainder %= divisor;
+ if (!remainder)
+ break;
+ }
+
+ if (remainder > divisor / 2)
+ ++result;
+
+ return Decimal(resultSign, resultExponent, result);
+}
+
+bool Decimal::operator==(const Decimal& rhs) const
+{
+ if (isNaN() || rhs.isNaN())
+ return false;
+ return m_data == rhs.m_data || compareTo(rhs).isZero();
+}
+
+bool Decimal::operator!=(const Decimal& rhs) const
+{
+ if (isNaN() || rhs.isNaN())
+ return true;
+ if (m_data == rhs.m_data)
+ return false;
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return !result.isZero();
+}
+
+bool Decimal::operator<(const Decimal& rhs) const
+{
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return !result.isZero() && result.isNegative();
+}
+
+bool Decimal::operator<=(const Decimal& rhs) const
+{
+ if (isNaN() || rhs.isNaN())
+ return false;
+ if (m_data == rhs.m_data)
+ return true;
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return result.isZero() || result.isNegative();
+}
+
+bool Decimal::operator>(const Decimal& rhs) const
+{
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return !result.isZero() && result.isPositive();
+}
+
+bool Decimal::operator>=(const Decimal& rhs) const
+{
+ if (isNaN() || rhs.isNaN())
+ return false;
+ if (m_data == rhs.m_data)
+ return true;
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return result.isZero() || !result.isNegative();
+}
+
+Decimal Decimal::abs() const
+{
+ Decimal result(*this);
+ result.m_data.setSign(Positive);
+ return result;
+}
+
+Decimal::AlignedOperands Decimal::alignOperands(const Decimal& lhs, const Decimal& rhs)
+{
+ ASSERT(lhs.isFinite());
+ ASSERT(rhs.isFinite());
+
+ const int lhsExponent = lhs.exponent();
+ const int rhsExponent = rhs.exponent();
+ int exponent = std::min(lhsExponent, rhsExponent);
+ uint64_t lhsCoefficient = lhs.m_data.coefficient();
+ uint64_t rhsCoefficient = rhs.m_data.coefficient();
+
+ if (lhsExponent > rhsExponent) {
+ const int numberOfLHSDigits = countDigits(lhsCoefficient);
+ if (numberOfLHSDigits) {
+ const int lhsShiftAmount = lhsExponent - rhsExponent;
+ const int overflow = numberOfLHSDigits + lhsShiftAmount - Precision;
+ if (overflow <= 0) {
+ lhsCoefficient = scaleUp(lhsCoefficient, lhsShiftAmount);
+ } else {
+ lhsCoefficient = scaleUp(lhsCoefficient, lhsShiftAmount - overflow);
+ rhsCoefficient = scaleDown(rhsCoefficient, overflow);
+ exponent += overflow;
+ }
+ }
+
+ } else if (lhsExponent < rhsExponent) {
+ const int numberOfRHSDigits = countDigits(rhsCoefficient);
+ if (numberOfRHSDigits) {
+ const int rhsShiftAmount = rhsExponent - lhsExponent;
+ const int overflow = numberOfRHSDigits + rhsShiftAmount - Precision;
+ if (overflow <= 0) {
+ rhsCoefficient = scaleUp(rhsCoefficient, rhsShiftAmount);
+ } else {
+ rhsCoefficient = scaleUp(rhsCoefficient, rhsShiftAmount - overflow);
+ lhsCoefficient = scaleDown(lhsCoefficient, overflow);
+ exponent += overflow;
+ }
+ }
+ }
+
+ AlignedOperands alignedOperands;
+ alignedOperands.exponent = exponent;
+ alignedOperands.lhsCoefficient = lhsCoefficient;
+ alignedOperands.rhsCoefficient = rhsCoefficient;
+ return alignedOperands;
+}
+
+static bool isMultiplePowersOfTen(uint64_t coefficient, int n)
+{
+ return !coefficient || !(coefficient % scaleUp(1, n));
+}
+
+// Round toward positive infinity.
+Decimal Decimal::ceil() const
+{
+ if (isSpecial())
+ return *this;
+
+ if (exponent() >= 0)
+ return *this;
+
+ uint64_t result = m_data.coefficient();
+ const int numberOfDigits = countDigits(result);
+ const int numberOfDropDigits = -exponent();
+ if (numberOfDigits <= numberOfDropDigits)
+ return isPositive() ? Decimal(1) : zero(Positive);
+
+ result = scaleDown(result, numberOfDropDigits);
+ if (isPositive() && !isMultiplePowersOfTen(m_data.coefficient(), numberOfDropDigits))
+ ++result;
+ return Decimal(sign(), 0, result);
+}
+
+Decimal Decimal::compareTo(const Decimal& rhs) const
+{
+ const Decimal result(*this - rhs);
+ switch (result.m_data.formatClass()) {
+ case EncodedData::ClassInfinity:
+ return result.isNegative() ? Decimal(-1) : Decimal(1);
+
+ case EncodedData::ClassNaN:
+ case EncodedData::ClassNormal:
+ return result;
+
+ case EncodedData::ClassZero:
+ return zero(Positive);
+
+ default:
+ ASSERT_NOT_REACHED();
+ return nan();
+ }
+}
+
+// Round toward negative infinity.
+Decimal Decimal::floor() const
+{
+ if (isSpecial())
+ return *this;
+
+ if (exponent() >= 0)
+ return *this;
+
+ uint64_t result = m_data.coefficient();
+ const int numberOfDigits = countDigits(result);
+ const int numberOfDropDigits = -exponent();
+ if (numberOfDigits < numberOfDropDigits)
+ return isPositive() ? zero(Positive) : Decimal(-1);
+
+ result = scaleDown(result, numberOfDropDigits);
+ if (isNegative() && !isMultiplePowersOfTen(m_data.coefficient(), numberOfDropDigits))
+ ++result;
+ return Decimal(sign(), 0, result);
+}
+
+Decimal Decimal::fromDouble(double doubleValue)
+{
+ if (std::isfinite(doubleValue))
+ return fromString(mozToString(doubleValue));
+
+ if (std::isinf(doubleValue))
+ return infinity(doubleValue < 0 ? Negative : Positive);
+
+ return nan();
+}
+
+Decimal Decimal::fromString(const String& str)
+{
+ int exponent = 0;
+ Sign exponentSign = Positive;
+ int numberOfDigits = 0;
+ int numberOfDigitsAfterDot = 0;
+ int numberOfExtraDigits = 0;
+ Sign sign = Positive;
+
+ enum {
+ StateDigit,
+ StateDot,
+ StateDotDigit,
+ StateE,
+ StateEDigit,
+ StateESign,
+ StateSign,
+ StateStart,
+ StateZero,
+ } state = StateStart;
+
+#define HandleCharAndBreak(expected, nextState) \
+ if (ch == expected) { \
+ state = nextState; \
+ break; \
+ }
+
+#define HandleTwoCharsAndBreak(expected1, expected2, nextState) \
+ if (ch == expected1 || ch == expected2) { \
+ state = nextState; \
+ break; \
+ }
+
+ uint64_t accumulator = 0;
+ for (unsigned index = 0; index < str.length(); ++index) {
+ const int ch = str[index];
+ switch (state) {
+ case StateDigit:
+ if (ch >= '0' && ch <= '9') {
+ if (numberOfDigits < Precision) {
+ ++numberOfDigits;
+ accumulator *= 10;
+ accumulator += ch - '0';
+ } else {
+ ++numberOfExtraDigits;
+ }
+ break;
+ }
+
+ HandleCharAndBreak('.', StateDot);
+ HandleTwoCharsAndBreak('E', 'e', StateE);
+ return nan();
+
+ case StateDot:
+ case StateDotDigit:
+ if (ch >= '0' && ch <= '9') {
+ if (numberOfDigits < Precision) {
+ ++numberOfDigits;
+ ++numberOfDigitsAfterDot;
+ accumulator *= 10;
+ accumulator += ch - '0';
+ }
+ state = StateDotDigit;
+ break;
+ }
+
+ HandleTwoCharsAndBreak('E', 'e', StateE);
+ return nan();
+
+ case StateE:
+ if (ch == '+') {
+ exponentSign = Positive;
+ state = StateESign;
+ break;
+ }
+
+ if (ch == '-') {
+ exponentSign = Negative;
+ state = StateESign;
+ break;
+ }
+
+ if (ch >= '0' && ch <= '9') {
+ exponent = ch - '0';
+ state = StateEDigit;
+ break;
+ }
+
+ return nan();
+
+ case StateEDigit:
+ if (ch >= '0' && ch <= '9') {
+ exponent *= 10;
+ exponent += ch - '0';
+ if (exponent > ExponentMax + Precision) {
+ if (accumulator)
+ return exponentSign == Negative ? zero(Positive) : infinity(sign);
+ return zero(sign);
+ }
+ state = StateEDigit;
+ break;
+ }
+
+ return nan();
+
+ case StateESign:
+ if (ch >= '0' && ch <= '9') {
+ exponent = ch - '0';
+ state = StateEDigit;
+ break;
+ }
+
+ return nan();
+
+ case StateSign:
+ if (ch >= '1' && ch <= '9') {
+ accumulator = ch - '0';
+ numberOfDigits = 1;
+ state = StateDigit;
+ break;
+ }
+
+ HandleCharAndBreak('0', StateZero);
+ return nan();
+
+ case StateStart:
+ if (ch >= '1' && ch <= '9') {
+ accumulator = ch - '0';
+ numberOfDigits = 1;
+ state = StateDigit;
+ break;
+ }
+
+ if (ch == '-') {
+ sign = Negative;
+ state = StateSign;
+ break;
+ }
+
+ if (ch == '+') {
+ sign = Positive;
+ state = StateSign;
+ break;
+ }
+
+ HandleCharAndBreak('0', StateZero);
+ HandleCharAndBreak('.', StateDot);
+ return nan();
+
+ case StateZero:
+ if (ch == '0')
+ break;
+
+ if (ch >= '1' && ch <= '9') {
+ accumulator = ch - '0';
+ numberOfDigits = 1;
+ state = StateDigit;
+ break;
+ }
+
+ HandleCharAndBreak('.', StateDot);
+ HandleTwoCharsAndBreak('E', 'e', StateE);
+ return nan();
+
+ default:
+ ASSERT_NOT_REACHED();
+ return nan();
+ }
+ }
+
+ if (state == StateZero)
+ return zero(sign);
+
+ if (state == StateDigit || state == StateEDigit || state == StateDotDigit) {
+ int resultExponent = exponent * (exponentSign == Negative ? -1 : 1) - numberOfDigitsAfterDot + numberOfExtraDigits;
+ if (resultExponent < ExponentMin)
+ return zero(Positive);
+
+ const int overflow = resultExponent - ExponentMax + 1;
+ if (overflow > 0) {
+ if (overflow + numberOfDigits - numberOfDigitsAfterDot > Precision)
+ return infinity(sign);
+ accumulator = scaleUp(accumulator, overflow);
+ resultExponent -= overflow;
+ }
+
+ return Decimal(sign, resultExponent, accumulator);
+ }
+
+ return nan();
+}
+
+Decimal Decimal::infinity(const Sign sign)
+{
+ return Decimal(EncodedData(sign, EncodedData::ClassInfinity));
+}
+
+Decimal Decimal::nan()
+{
+ return Decimal(EncodedData(Positive, EncodedData::ClassNaN));
+}
+
+Decimal Decimal::remainder(const Decimal& rhs) const
+{
+ const Decimal quotient = *this / rhs;
+ return quotient.isSpecial() ? quotient : *this - (quotient.isNegative() ? quotient.ceil() : quotient.floor()) * rhs;
+}
+
+Decimal Decimal::round() const
+{
+ if (isSpecial())
+ return *this;
+
+ if (exponent() >= 0)
+ return *this;
+
+ uint64_t result = m_data.coefficient();
+ const int numberOfDigits = countDigits(result);
+ const int numberOfDropDigits = -exponent();
+ if (numberOfDigits < numberOfDropDigits)
+ return zero(Positive);
+
+ result = scaleDown(result, numberOfDropDigits - 1);
+ if (result % 10 >= 5)
+ result += 10;
+ result /= 10;
+ return Decimal(sign(), 0, result);
+}
+
+double Decimal::toDouble() const
+{
+ if (isFinite()) {
+ bool valid;
+ const double doubleValue = mozToDouble(toString(), &valid);
+ return valid ? doubleValue : std::numeric_limits<double>::quiet_NaN();
+ }
+
+ if (isInfinity())
+ return isNegative() ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity();
+
+ return std::numeric_limits<double>::quiet_NaN();
+}
+
+String Decimal::toString() const
+{
+ switch (m_data.formatClass()) {
+ case EncodedData::ClassInfinity:
+ return sign() ? "-Infinity" : "Infinity";
+
+ case EncodedData::ClassNaN:
+ return "NaN";
+
+ case EncodedData::ClassNormal:
+ case EncodedData::ClassZero:
+ break;
+
+ default:
+ ASSERT_NOT_REACHED();
+ return "";
+ }
+
+ StringBuilder builder;
+ if (sign())
+ builder.append('-');
+
+ int originalExponent = exponent();
+ uint64_t coefficient = m_data.coefficient();
+
+ if (originalExponent < 0) {
+ const int maxDigits = DBL_DIG;
+ uint64_t lastDigit = 0;
+ while (countDigits(coefficient) > maxDigits) {
+ lastDigit = coefficient % 10;
+ coefficient /= 10;
+ ++originalExponent;
+ }
+
+ if (lastDigit >= 5)
+ ++coefficient;
+
+ while (originalExponent < 0 && coefficient && !(coefficient % 10)) {
+ coefficient /= 10;
+ ++originalExponent;
+ }
+ }
+
+ const String digits = mozToString(coefficient);
+ int coefficientLength = static_cast<int>(digits.length());
+ const int adjustedExponent = originalExponent + coefficientLength - 1;
+ if (originalExponent <= 0 && adjustedExponent >= -6) {
+ if (!originalExponent) {
+ builder.append(digits);
+ return builder.toString();
+ }
+
+ if (adjustedExponent >= 0) {
+ for (int i = 0; i < coefficientLength; ++i) {
+ builder.append(digits[i]);
+ if (i == adjustedExponent)
+ builder.append('.');
+ }
+ return builder.toString();
+ }
+
+ builder.appendLiteral("0.");
+ for (int i = adjustedExponent + 1; i < 0; ++i)
+ builder.append('0');
+
+ builder.append(digits);
+
+ } else {
+ builder.append(digits[0]);
+ while (coefficientLength >= 2 && digits[coefficientLength - 1] == '0')
+ --coefficientLength;
+ if (coefficientLength >= 2) {
+ builder.append('.');
+ for (int i = 1; i < coefficientLength; ++i)
+ builder.append(digits[i]);
+ }
+
+ if (adjustedExponent) {
+ builder.append(adjustedExponent < 0 ? "e" : "e+");
+ builder.appendNumber(adjustedExponent);
+ }
+ }
+ return builder.toString();
+}
+
+bool Decimal::toString(char* strBuf, size_t bufLength) const
+{
+ ASSERT(bufLength > 0);
+ String str = toString();
+ size_t length = str.copy(strBuf, bufLength);
+ if (length < bufLength) {
+ strBuf[length] = '\0';
+ return true;
+ }
+ strBuf[bufLength - 1] = '\0';
+ return false;
+}
+
+Decimal Decimal::zero(Sign sign)
+{
+ return Decimal(EncodedData(sign, EncodedData::ClassZero));
+}
+
+} // namespace blink
+
+// Implementation of DoubleConversion.h:
+
+namespace mozilla {
+
+Maybe<double> StringToDouble(Span<const char> aStringSpan) {
+ bool valid = false;
+ double result = mozToDouble(aStringSpan, &valid);
+ return valid ? Some(result) : Nothing();
+}
+
+}
diff --git a/mozglue/misc/decimal/Decimal.h b/mozglue/misc/decimal/Decimal.h
new file mode 100644
index 0000000000..10d0e2c7ce
--- /dev/null
+++ b/mozglue/misc/decimal/Decimal.h
@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2012 Google Inc. 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.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * 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
+ * OWNER 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.
+ */
+
+/**
+ * Imported from:
+ * https://chromium.googlesource.com/chromium/src.git/+/master/third_party/WebKit/Source/platform/Decimal.h
+ * Check UPSTREAM-GIT-SHA for the commit ID of the last update from Blink core.
+ */
+
+#ifndef Decimal_h
+#define Decimal_h
+
+#include "mozilla/Assertions.h"
+#include <stdint.h>
+#include "mozilla/Types.h"
+
+#include <string>
+
+#ifndef ASSERT
+#define DEFINED_ASSERT_FOR_DECIMAL_H 1
+#define ASSERT MOZ_ASSERT
+#endif
+
+#define PLATFORM_EXPORT
+
+// To use USING_FAST_MALLOC we'd need:
+// https://chromium.googlesource.com/chromium/src.git/+/master/third_party/WebKit/Source/wtf/Allocator.h
+// Since we don't allocate Decimal objects, no need.
+#define USING_FAST_MALLOC(type) \
+ void ignore_this_dummy_method() = delete
+
+#define DISALLOW_NEW() \
+ private: \
+ void* operator new(size_t) = delete; \
+ void* operator new(size_t, void*) = delete; \
+ public:
+
+namespace blink {
+
+namespace DecimalPrivate {
+class SpecialValueHandler;
+}
+
+// This class represents decimal base floating point number.
+//
+// FIXME: Once all C++ compiler support decimal type, we should replace this
+// class to compiler supported one. See below URI for current status of decimal
+// type for C++: // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1977.html
+class PLATFORM_EXPORT Decimal {
+ USING_FAST_MALLOC(Decimal);
+public:
+ enum Sign {
+ Positive,
+ Negative,
+ };
+
+ // You should not use EncodedData other than unit testing.
+ class EncodedData {
+ DISALLOW_NEW();
+ // For accessing FormatClass.
+ friend class Decimal;
+ friend class DecimalPrivate::SpecialValueHandler;
+ public:
+ EncodedData(Sign, int exponent, uint64_t coefficient);
+
+ bool operator==(const EncodedData&) const;
+ bool operator!=(const EncodedData& another) const { return !operator==(another); }
+
+ uint64_t coefficient() const { return m_coefficient; }
+ int countDigits() const;
+ int exponent() const { return m_exponent; }
+ bool isFinite() const { return !isSpecial(); }
+ bool isInfinity() const { return m_formatClass == ClassInfinity; }
+ bool isNaN() const { return m_formatClass == ClassNaN; }
+ bool isSpecial() const { return m_formatClass == ClassInfinity || m_formatClass == ClassNaN; }
+ bool isZero() const { return m_formatClass == ClassZero; }
+ Sign sign() const { return m_sign; }
+ void setSign(Sign sign) { m_sign = sign; }
+
+ private:
+ enum FormatClass {
+ ClassInfinity,
+ ClassNormal,
+ ClassNaN,
+ ClassZero,
+ };
+
+ EncodedData(Sign, FormatClass);
+ FormatClass formatClass() const { return m_formatClass; }
+
+ uint64_t m_coefficient;
+ int16_t m_exponent;
+ FormatClass m_formatClass;
+ Sign m_sign;
+ };
+
+ MFBT_API explicit Decimal(int32_t = 0);
+ MFBT_API Decimal(Sign, int exponent, uint64_t coefficient);
+ MFBT_API Decimal(const Decimal&);
+
+ MFBT_API Decimal& operator=(const Decimal&);
+ MFBT_API Decimal& operator+=(const Decimal&);
+ MFBT_API Decimal& operator-=(const Decimal&);
+ MFBT_API Decimal& operator*=(const Decimal&);
+ MFBT_API Decimal& operator/=(const Decimal&);
+
+ MFBT_API Decimal operator-() const;
+
+ MFBT_API bool operator==(const Decimal&) const;
+ MFBT_API bool operator!=(const Decimal&) const;
+ MFBT_API bool operator<(const Decimal&) const;
+ MFBT_API bool operator<=(const Decimal&) const;
+ MFBT_API bool operator>(const Decimal&) const;
+ MFBT_API bool operator>=(const Decimal&) const;
+
+ MFBT_API Decimal operator+(const Decimal&) const;
+ MFBT_API Decimal operator-(const Decimal&) const;
+ MFBT_API Decimal operator*(const Decimal&) const;
+ MFBT_API Decimal operator/(const Decimal&) const;
+
+ int exponent() const
+ {
+ ASSERT(isFinite());
+ return m_data.exponent();
+ }
+
+ bool isFinite() const { return m_data.isFinite(); }
+ bool isInfinity() const { return m_data.isInfinity(); }
+ bool isNaN() const { return m_data.isNaN(); }
+ bool isNegative() const { return sign() == Negative; }
+ bool isPositive() const { return sign() == Positive; }
+ bool isSpecial() const { return m_data.isSpecial(); }
+ bool isZero() const { return m_data.isZero(); }
+
+ MFBT_API Decimal abs() const;
+ MFBT_API Decimal ceil() const;
+ MFBT_API Decimal floor() const;
+ MFBT_API Decimal remainder(const Decimal&) const;
+ MFBT_API Decimal round() const;
+
+ MFBT_API double toDouble() const;
+ // Note: toString method supports infinity and nan but fromString not.
+ MFBT_API std::string toString() const;
+ MFBT_API bool toString(char* strBuf, size_t bufLength) const;
+
+ static MFBT_API Decimal fromDouble(double);
+ // fromString supports following syntax EBNF:
+ // number ::= sign? digit+ ('.' digit*) (exponent-marker sign? digit+)?
+ // | sign? '.' digit+ (exponent-marker sign? digit+)?
+ // sign ::= '+' | '-'
+ // exponent-marker ::= 'e' | 'E'
+ // digit ::= '0' | '1' | ... | '9'
+ // Note: fromString doesn't support "infinity" and "nan".
+ static MFBT_API Decimal fromString(const std::string& aValue);
+ static MFBT_API Decimal infinity(Sign);
+ static MFBT_API Decimal nan();
+ static MFBT_API Decimal zero(Sign);
+
+ // You should not use below methods. We expose them for unit testing.
+ MFBT_API explicit Decimal(const EncodedData&);
+ const EncodedData& value() const { return m_data; }
+
+private:
+ struct AlignedOperands {
+ uint64_t lhsCoefficient;
+ uint64_t rhsCoefficient;
+ int exponent;
+ };
+
+ MFBT_API explicit Decimal(double);
+ MFBT_API Decimal compareTo(const Decimal&) const;
+
+ static MFBT_API AlignedOperands alignOperands(const Decimal& lhs, const Decimal& rhs);
+ static inline Sign invertSign(Sign sign) { return sign == Negative ? Positive : Negative; }
+
+ Sign sign() const { return m_data.sign(); }
+
+ EncodedData m_data;
+};
+
+} // namespace blink
+
+namespace mozilla {
+typedef blink::Decimal Decimal;
+} // namespace mozilla
+
+#undef USING_FAST_MALLOC
+
+#ifdef DEFINED_ASSERT_FOR_DECIMAL_H
+#undef DEFINED_ASSERT_FOR_DECIMAL_H
+#undef ASSERT
+#endif
+
+#endif // Decimal_h
diff --git a/mozglue/misc/decimal/DoubleConversion.h b/mozglue/misc/decimal/DoubleConversion.h
new file mode 100644
index 0000000000..14c19e2540
--- /dev/null
+++ b/mozglue/misc/decimal/DoubleConversion.h
@@ -0,0 +1,27 @@
+/* -*- 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/. */
+
+/* A utility function that converts a string to a double independent of OS locale. */
+
+#ifndef MOZILLA_DOUBLECONVERSION_H
+#define MOZILLA_DOUBLECONVERSION_H
+
+#include "mozilla/Maybe.h"
+#include "mozilla/Span.h"
+
+#include <string>
+
+namespace mozilla {
+
+// Parses aStringSpan into a double floating point value. Always treats . as the
+// decimal separator, regardless of OS locale. Consumes the entire string;
+// trailing garbage is invalid. Returns Nothing() for invalid input.
+// The implementation uses double_conversion::StringToDoubleConverter with
+// NO_FLAGS, see double-conversion/string-to-double.h for more documentation.
+Maybe<double> StringToDouble(Span<const char> aStringSpan);
+
+}
+
+#endif // MOZILLA_DOUBLECONVERSION_H
diff --git a/mozglue/misc/decimal/UPSTREAM-GIT-SHA b/mozglue/misc/decimal/UPSTREAM-GIT-SHA
new file mode 100644
index 0000000000..ed86150b28
--- /dev/null
+++ b/mozglue/misc/decimal/UPSTREAM-GIT-SHA
@@ -0,0 +1 @@
+cad4c9e3b3c9e80bb189059373db528272bca96f
diff --git a/mozglue/misc/decimal/add-doubleconversion-impl.patch b/mozglue/misc/decimal/add-doubleconversion-impl.patch
new file mode 100644
index 0000000000..1cf0fb6ff1
--- /dev/null
+++ b/mozglue/misc/decimal/add-doubleconversion-impl.patch
@@ -0,0 +1,42 @@
+diff --git a/mozglue/misc/decimal/Decimal.cpp b/mozglue/misc/decimal/Decimal.cpp
+--- a/mozglue/misc/decimal/Decimal.cpp
++++ b/mozglue/misc/decimal/Decimal.cpp
+@@ -25,16 +25,17 @@
+ * 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.
+ */
+
+ #include "Decimal.h"
+ #include "moz-decimal-utils.h"
++#include "DoubleConversion.h"
+
+ using namespace moz_decimal_utils;
+
+ #include <algorithm>
+ #include <float.h>
+
+ namespace blink {
+
+@@ -1043,8 +1044,20 @@ bool Decimal::toString(char* strBuf, siz
+ }
+
+ Decimal Decimal::zero(Sign sign)
+ {
+ return Decimal(EncodedData(sign, EncodedData::ClassZero));
+ }
+
+ } // namespace blink
++
++// Implementation of DoubleConversion.h:
++
++namespace mozilla {
++
++Maybe<double> StringToDouble(Span<const char> aStringSpan) {
++ bool valid = false;
++ double result = mozToDouble(aStringSpan, &valid);
++ return valid ? Some(result) : Nothing();
++}
++
++}
diff --git a/mozglue/misc/decimal/comparison-with-nan.patch b/mozglue/misc/decimal/comparison-with-nan.patch
new file mode 100644
index 0000000000..0e274ce033
--- /dev/null
+++ b/mozglue/misc/decimal/comparison-with-nan.patch
@@ -0,0 +1,67 @@
+diff --git a/mozglue/misc/decimal/Decimal.cpp b/mozglue/misc/decimal/Decimal.cpp
+--- a/mozglue/misc/decimal/Decimal.cpp
++++ b/mozglue/misc/decimal/Decimal.cpp
+@@ -509,21 +509,25 @@ Decimal Decimal::operator/(const Decimal
+ if (remainder > divisor / 2)
+ ++result;
+
+ return Decimal(resultSign, resultExponent, result);
+ }
+
+ bool Decimal::operator==(const Decimal& rhs) const
+ {
++ if (isNaN() || rhs.isNaN())
++ return false;
+ return m_data == rhs.m_data || compareTo(rhs).isZero();
+ }
+
+ bool Decimal::operator!=(const Decimal& rhs) const
+ {
++ if (isNaN() || rhs.isNaN())
++ return true;
+ if (m_data == rhs.m_data)
+ return false;
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return !result.isZero();
+ }
+
+@@ -532,16 +536,18 @@ bool Decimal::operator<(const Decimal& r
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return !result.isZero() && result.isNegative();
+ }
+
+ bool Decimal::operator<=(const Decimal& rhs) const
+ {
++ if (isNaN() || rhs.isNaN())
++ return false;
+ if (m_data == rhs.m_data)
+ return true;
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return result.isZero() || result.isNegative();
+ }
+
+@@ -550,16 +556,18 @@ bool Decimal::operator>(const Decimal& r
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return !result.isZero() && result.isPositive();
+ }
+
+ bool Decimal::operator>=(const Decimal& rhs) const
+ {
++ if (isNaN() || rhs.isNaN())
++ return false;
+ if (m_data == rhs.m_data)
+ return true;
+ const Decimal result = compareTo(rhs);
+ if (result.isNaN())
+ return false;
+ return result.isZero() || !result.isNegative();
+ }
+
diff --git a/mozglue/misc/decimal/fix-wshadow-warnings.patch b/mozglue/misc/decimal/fix-wshadow-warnings.patch
new file mode 100644
index 0000000000..465c61a223
--- /dev/null
+++ b/mozglue/misc/decimal/fix-wshadow-warnings.patch
@@ -0,0 +1,171 @@
+diff --git a/mozglue/misc/decimal/Decimal.cpp b/mozglue/misc/decimal/Decimal.cpp
+--- a/mozglue/misc/decimal/Decimal.cpp
++++ b/mozglue/misc/decimal/Decimal.cpp
+@@ -118,18 +118,18 @@ Decimal SpecialValueHandler::value() con
+ ASSERT_NOT_REACHED();
+ return m_lhs;
+ }
+ }
+
+ // This class is used for 128 bit unsigned integer arithmetic.
+ class UInt128 {
+ public:
+- UInt128(uint64_t low, uint64_t high)
+- : m_high(high), m_low(low)
++ UInt128(uint64_t aLow, uint64_t aHigh)
++ : m_high(aHigh), m_low(aLow)
+ {
+ }
+
+ UInt128& operator/=(uint32_t);
+
+ uint64_t high() const { return m_high; }
+ uint64_t low() const { return m_low; }
+
+@@ -224,68 +224,68 @@ static uint64_t scaleUp(uint64_t x, int
+ z = z * z;
+ }
+ }
+
+ } // namespace DecimalPrivate
+
+ using namespace DecimalPrivate;
+
+-Decimal::EncodedData::EncodedData(Sign sign, FormatClass formatClass)
++Decimal::EncodedData::EncodedData(Sign aSign, FormatClass aFormatClass)
+ : m_coefficient(0)
+ , m_exponent(0)
+- , m_formatClass(formatClass)
+- , m_sign(sign)
++ , m_formatClass(aFormatClass)
++ , m_sign(aSign)
+ {
+ }
+
+-Decimal::EncodedData::EncodedData(Sign sign, int exponent, uint64_t coefficient)
+- : m_formatClass(coefficient ? ClassNormal : ClassZero)
+- , m_sign(sign)
++Decimal::EncodedData::EncodedData(Sign aSign, int aExponent, uint64_t aCoefficient)
++ : m_formatClass(aCoefficient ? ClassNormal : ClassZero)
++ , m_sign(aSign)
+ {
+- if (exponent >= ExponentMin && exponent <= ExponentMax) {
+- while (coefficient > MaxCoefficient) {
+- coefficient /= 10;
+- ++exponent;
++ if (aExponent >= ExponentMin && aExponent <= ExponentMax) {
++ while (aCoefficient > MaxCoefficient) {
++ aCoefficient /= 10;
++ ++aExponent;
+ }
+ }
+
+- if (exponent > ExponentMax) {
++ if (aExponent > ExponentMax) {
+ m_coefficient = 0;
+ m_exponent = 0;
+ m_formatClass = ClassInfinity;
+ return;
+ }
+
+- if (exponent < ExponentMin) {
++ if (aExponent < ExponentMin) {
+ m_coefficient = 0;
+ m_exponent = 0;
+ m_formatClass = ClassZero;
+ return;
+ }
+
+- m_coefficient = coefficient;
+- m_exponent = static_cast<int16_t>(exponent);
++ m_coefficient = aCoefficient;
++ m_exponent = static_cast<int16_t>(aExponent);
+ }
+
+ bool Decimal::EncodedData::operator==(const EncodedData& another) const
+ {
+ return m_sign == another.m_sign
+ && m_formatClass == another.m_formatClass
+ && m_exponent == another.m_exponent
+ && m_coefficient == another.m_coefficient;
+ }
+
+ Decimal::Decimal(int32_t i32)
+ : m_data(i32 < 0 ? Negative : Positive, 0, i32 < 0 ? static_cast<uint64_t>(-static_cast<int64_t>(i32)) : static_cast<uint64_t>(i32))
+ {
+ }
+
+-Decimal::Decimal(Sign sign, int exponent, uint64_t coefficient)
+- : m_data(sign, coefficient ? exponent : 0, coefficient)
++Decimal::Decimal(Sign aSign, int aExponent, uint64_t aCoefficient)
++ : m_data(aSign, aCoefficient ? aExponent : 0, aCoefficient)
+ {
+ }
+
+ Decimal::Decimal(const EncodedData& data)
+ : m_data(data)
+ {
+ }
+
+@@ -479,32 +479,32 @@ Decimal Decimal::operator/(const Decimal
+ if (rhs.isZero())
+ return lhs.isZero() ? nan() : infinity(resultSign);
+
+ int resultExponent = lhs.exponent() - rhs.exponent();
+
+ if (lhs.isZero())
+ return Decimal(resultSign, resultExponent, 0);
+
+- uint64_t remainder = lhs.m_data.coefficient();
++ uint64_t lhsRemainder = lhs.m_data.coefficient();
+ const uint64_t divisor = rhs.m_data.coefficient();
+ uint64_t result = 0;
+ while (result < MaxCoefficient / 100) {
+- while (remainder < divisor) {
+- remainder *= 10;
++ while (lhsRemainder < divisor) {
++ lhsRemainder *= 10;
+ result *= 10;
+ --resultExponent;
+ }
+- result += remainder / divisor;
+- remainder %= divisor;
+- if (!remainder)
++ result += lhsRemainder / divisor;
++ lhsRemainder %= divisor;
++ if (!lhsRemainder)
+ break;
+ }
+
+- if (remainder > divisor / 2)
++ if (lhsRemainder > divisor / 2)
+ ++result;
+
+ return Decimal(resultSign, resultExponent, result);
+ }
+
+ bool Decimal::operator==(const Decimal& rhs) const
+ {
+ if (isNaN() || rhs.isNaN())
+diff --git a/mozglue/misc/decimal/Decimal.h b/mozglue/misc/decimal/Decimal.h
+--- a/mozglue/misc/decimal/Decimal.h
++++ b/mozglue/misc/decimal/Decimal.h
+@@ -88,17 +88,17 @@ public:
+ int countDigits() const;
+ int exponent() const { return m_exponent; }
+ bool isFinite() const { return !isSpecial(); }
+ bool isInfinity() const { return m_formatClass == ClassInfinity; }
+ bool isNaN() const { return m_formatClass == ClassNaN; }
+ bool isSpecial() const { return m_formatClass == ClassInfinity || m_formatClass == ClassNaN; }
+ bool isZero() const { return m_formatClass == ClassZero; }
+ Sign sign() const { return m_sign; }
+- void setSign(Sign sign) { m_sign = sign; }
++ void setSign(Sign aSign) { m_sign = aSign; }
+
+ private:
+ enum FormatClass {
+ ClassInfinity,
+ ClassNormal,
+ ClassNaN,
+ ClassZero,
+ };
diff --git a/mozglue/misc/decimal/mfbt-abi-markers.patch b/mozglue/misc/decimal/mfbt-abi-markers.patch
new file mode 100644
index 0000000000..1d50d3d643
--- /dev/null
+++ b/mozglue/misc/decimal/mfbt-abi-markers.patch
@@ -0,0 +1,150 @@
+diff --git a/mozglue/misc/decimal/Decimal.h b/mozglue/misc/decimal/Decimal.h
+--- a/mozglue/misc/decimal/Decimal.h
++++ b/mozglue/misc/decimal/Decimal.h
+@@ -26,16 +26,18 @@
+ * 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.
+ */
+
+ #ifndef Decimal_h
+ #define Decimal_h
+
++#include "mozilla/Types.h"
++
+ #include "platform/PlatformExport.h"
+ #include "wtf/Allocator.h"
+ #include "wtf/Assertions.h"
+ #include "wtf/text/WTFString.h"
+ #include <stdint.h>
+
+ namespace blink {
+
+@@ -91,92 +93,92 @@ public:
+ FormatClass formatClass() const { return m_formatClass; }
+
+ uint64_t m_coefficient;
+ int16_t m_exponent;
+ FormatClass m_formatClass;
+ Sign m_sign;
+ };
+
+- Decimal(int32_t = 0);
+- Decimal(Sign, int exponent, uint64_t coefficient);
+- Decimal(const Decimal&);
++ MFBT_API explicit Decimal(int32_t = 0);
++ MFBT_API Decimal(Sign, int exponent, uint64_t coefficient);
++ MFBT_API Decimal(const Decimal&);
+
+- Decimal& operator=(const Decimal&);
+- Decimal& operator+=(const Decimal&);
+- Decimal& operator-=(const Decimal&);
+- Decimal& operator*=(const Decimal&);
+- Decimal& operator/=(const Decimal&);
++ MFBT_API Decimal& operator=(const Decimal&);
++ MFBT_API Decimal& operator+=(const Decimal&);
++ MFBT_API Decimal& operator-=(const Decimal&);
++ MFBT_API Decimal& operator*=(const Decimal&);
++ MFBT_API Decimal& operator/=(const Decimal&);
+
+- Decimal operator-() const;
++ MFBT_API Decimal operator-() const;
+
+- bool operator==(const Decimal&) const;
+- bool operator!=(const Decimal&) const;
+- bool operator<(const Decimal&) const;
+- bool operator<=(const Decimal&) const;
+- bool operator>(const Decimal&) const;
+- bool operator>=(const Decimal&) const;
++ MFBT_API bool operator==(const Decimal&) const;
++ MFBT_API bool operator!=(const Decimal&) const;
++ MFBT_API bool operator<(const Decimal&) const;
++ MFBT_API bool operator<=(const Decimal&) const;
++ MFBT_API bool operator>(const Decimal&) const;
++ MFBT_API bool operator>=(const Decimal&) const;
+
+- Decimal operator+(const Decimal&) const;
+- Decimal operator-(const Decimal&) const;
+- Decimal operator*(const Decimal&) const;
+- Decimal operator/(const Decimal&) const;
++ MFBT_API Decimal operator+(const Decimal&) const;
++ MFBT_API Decimal operator-(const Decimal&) const;
++ MFBT_API Decimal operator*(const Decimal&) const;
++ MFBT_API Decimal operator/(const Decimal&) const;
+
+ int exponent() const
+ {
+ ASSERT(isFinite());
+ return m_data.exponent();
+ }
+
+ bool isFinite() const { return m_data.isFinite(); }
+ bool isInfinity() const { return m_data.isInfinity(); }
+ bool isNaN() const { return m_data.isNaN(); }
+ bool isNegative() const { return sign() == Negative; }
+ bool isPositive() const { return sign() == Positive; }
+ bool isSpecial() const { return m_data.isSpecial(); }
+ bool isZero() const { return m_data.isZero(); }
+
+- Decimal abs() const;
+- Decimal ceil() const;
+- Decimal floor() const;
+- Decimal remainder(const Decimal&) const;
+- Decimal round() const;
++ MFBT_API Decimal abs() const;
++ MFBT_API Decimal ceil() const;
++ MFBT_API Decimal floor() const;
++ MFBT_API Decimal remainder(const Decimal&) const;
++ MFBT_API Decimal round() const;
+
+- double toDouble() const;
++ MFBT_API double toDouble() const;
+ // Note: toString method supports infinity and nan but fromString not.
+- String toString() const;
++ MFBT_API String toString() const;
+
+- static Decimal fromDouble(double);
++ static MFBT_API Decimal fromDouble(double);
+ // fromString supports following syntax EBNF:
+ // number ::= sign? digit+ ('.' digit*) (exponent-marker sign? digit+)?
+ // | sign? '.' digit+ (exponent-marker sign? digit+)?
+ // sign ::= '+' | '-'
+ // exponent-marker ::= 'e' | 'E'
+ // digit ::= '0' | '1' | ... | '9'
+ // Note: fromString doesn't support "infinity" and "nan".
+- static Decimal fromString(const String&);
+- static Decimal infinity(Sign);
+- static Decimal nan();
+- static Decimal zero(Sign);
++ static MFBT_API Decimal fromString(const String&);
++ static MFBT_API Decimal infinity(Sign);
++ static MFBT_API Decimal nan();
++ static MFBT_API Decimal zero(Sign);
+
+ // You should not use below methods. We expose them for unit testing.
+- explicit Decimal(const EncodedData&);
++ MFBT_API explicit Decimal(const EncodedData&);
+ const EncodedData& value() const { return m_data; }
+
+ private:
+ struct AlignedOperands {
+ uint64_t lhsCoefficient;
+ uint64_t rhsCoefficient;
+ int exponent;
+ };
+
+- Decimal(double);
+- Decimal compareTo(const Decimal&) const;
++ MFBT_API explicit Decimal(double);
++ MFBT_API Decimal compareTo(const Decimal&) const;
+
+- static AlignedOperands alignOperands(const Decimal& lhs, const Decimal& rhs);
++ static MFBT_API AlignedOperands alignOperands(const Decimal& lhs, const Decimal& rhs);
+ static inline Sign invertSign(Sign sign) { return sign == Negative ? Positive : Negative; }
+
+ Sign sign() const { return m_data.sign(); }
+
+ EncodedData m_data;
+ };
+
+ } // namespace blink
diff --git a/mozglue/misc/decimal/moz-decimal-utils.h b/mozglue/misc/decimal/moz-decimal-utils.h
new file mode 100644
index 0000000000..05ea61e4bd
--- /dev/null
+++ b/mozglue/misc/decimal/moz-decimal-utils.h
@@ -0,0 +1,110 @@
+/* -*- 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 MOZ_DECIMAL_UTILS_H
+#define MOZ_DECIMAL_UTILS_H
+
+// This file contains extra includes, defines and typedefs to allow compilation
+// of Decimal.cpp under the Mozilla source without blink core dependencies. Do
+// not include it into any file other than Decimal.cpp.
+
+#include "double-conversion/double-conversion.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Casting.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/Span.h"
+
+#include <cmath>
+#include <cstring>
+#include <iomanip>
+#include <limits>
+#include <sstream>
+
+#ifndef UINT64_C
+// For Android toolchain
+#define UINT64_C(c) (c ## ULL)
+#endif
+
+#ifdef ASSERT
+#undef ASSERT
+#endif
+#define ASSERT MOZ_ASSERT
+
+#define ASSERT_NOT_REACHED() MOZ_ASSERT_UNREACHABLE("moz-decimal-utils.h")
+
+#define STACK_ALLOCATED() DISALLOW_NEW()
+
+#define WTF_MAKE_NONCOPYABLE(ClassName) \
+ private: \
+ ClassName(const ClassName&) = delete; \
+ void operator=(const ClassName&) = delete;
+
+typedef std::string String;
+
+double mozToDouble(mozilla::Span<const char> aStr, bool *valid) {
+ double_conversion::StringToDoubleConverter converter(
+ double_conversion::StringToDoubleConverter::NO_FLAGS,
+ mozilla::UnspecifiedNaN<double>(), mozilla::UnspecifiedNaN<double>(), nullptr, nullptr);
+ const char* str = aStr.Elements();
+ int length = mozilla::AssertedCast<int>(aStr.Length());
+ int processed_char_count; // unused - NO_FLAGS requires the whole string to parse
+ double result = converter.StringToDouble(str, length, &processed_char_count);
+ *valid = std::isfinite(result);
+ return result;
+}
+
+double mozToDouble(const String &aStr, bool *valid) {
+ return mozToDouble(mozilla::MakeStringSpan(aStr.c_str()), valid);
+}
+
+String mozToString(double aNum) {
+ char buffer[64];
+ int buffer_length = mozilla::ArrayLength(buffer);
+ const double_conversion::DoubleToStringConverter& converter =
+ double_conversion::DoubleToStringConverter::EcmaScriptConverter();
+ double_conversion::StringBuilder builder(buffer, buffer_length);
+ converter.ToShortest(aNum, &builder);
+ return String(builder.Finalize());
+}
+
+String mozToString(int64_t aNum) {
+ std::ostringstream o;
+ o << std::setprecision(std::numeric_limits<int64_t>::digits10) << aNum;
+ return o.str();
+}
+
+String mozToString(uint64_t aNum) {
+ std::ostringstream o;
+ o << std::setprecision(std::numeric_limits<uint64_t>::digits10) << aNum;
+ return o.str();
+}
+
+namespace moz_decimal_utils {
+
+class StringBuilder
+{
+public:
+ void append(char c) {
+ mStr += c;
+ }
+ void appendLiteral(const char *aStr) {
+ mStr += aStr;
+ }
+ void appendNumber(int aNum) {
+ mStr += mozToString(int64_t(aNum));
+ }
+ void append(const String& aStr) {
+ mStr += aStr;
+ }
+ std::string toString() const {
+ return mStr;
+ }
+private:
+ std::string mStr;
+};
+
+} // namespace moz_decimal_utils
+
+#endif
diff --git a/mozglue/misc/decimal/to-moz-dependencies.patch b/mozglue/misc/decimal/to-moz-dependencies.patch
new file mode 100644
index 0000000000..bf19a6da96
--- /dev/null
+++ b/mozglue/misc/decimal/to-moz-dependencies.patch
@@ -0,0 +1,224 @@
+diff --git a/mozglue/misc/decimal/Decimal.cpp b/mozglue/misc/decimal/Decimal.cpp
+--- a/mozglue/misc/decimal/Decimal.cpp
++++ b/mozglue/misc/decimal/Decimal.cpp
+@@ -23,22 +23,20 @@
+ * 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.
+ */
+
+-#include "platform/Decimal.h"
++#include "Decimal.h"
++#include "moz-decimal-utils.h"
+
+-#include "wtf/Allocator.h"
+-#include "wtf/MathExtras.h"
+-#include "wtf/Noncopyable.h"
+-#include "wtf/text/StringBuilder.h"
++using namespace moz_decimal_utils;
+
+ #include <algorithm>
+ #include <float.h>
+
+ namespace blink {
+
+ namespace DecimalPrivate {
+
+@@ -690,17 +688,17 @@ Decimal Decimal::floor() const
+ if (isNegative() && !isMultiplePowersOfTen(m_data.coefficient(), numberOfDropDigits))
+ ++result;
+ return Decimal(sign(), 0, result);
+ }
+
+ Decimal Decimal::fromDouble(double doubleValue)
+ {
+ if (std::isfinite(doubleValue))
+- return fromString(String::numberToStringECMAScript(doubleValue));
++ return fromString(mozToString(doubleValue));
+
+ if (std::isinf(doubleValue))
+ return infinity(doubleValue < 0 ? Negative : Positive);
+
+ return nan();
+ }
+
+ Decimal Decimal::fromString(const String& str)
+@@ -931,17 +929,17 @@ Decimal Decimal::round() const
+ result /= 10;
+ return Decimal(sign(), 0, result);
+ }
+
+ double Decimal::toDouble() const
+ {
+ if (isFinite()) {
+ bool valid;
+- const double doubleValue = toString().toDouble(&valid);
++ const double doubleValue = mozToDouble(toString(), &valid);
+ return valid ? doubleValue : std::numeric_limits<double>::quiet_NaN();
+ }
+
+ if (isInfinity())
+ return isNegative() ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity();
+
+ return std::numeric_limits<double>::quiet_NaN();
+ }
+@@ -984,17 +982,17 @@ String Decimal::toString() const
+ ++coefficient;
+
+ while (originalExponent < 0 && coefficient && !(coefficient % 10)) {
+ coefficient /= 10;
+ ++originalExponent;
+ }
+ }
+
+- const String digits = String::number(coefficient);
++ const String digits = mozToString(coefficient);
+ int coefficientLength = static_cast<int>(digits.length());
+ const int adjustedExponent = originalExponent + coefficientLength - 1;
+ if (originalExponent <= 0 && adjustedExponent >= -6) {
+ if (!originalExponent) {
+ builder.append(digits);
+ return builder.toString();
+ }
+
+@@ -1026,14 +1024,27 @@ String Decimal::toString() const
+ if (adjustedExponent) {
+ builder.append(adjustedExponent < 0 ? "e" : "e+");
+ builder.appendNumber(adjustedExponent);
+ }
+ }
+ return builder.toString();
+ }
+
++bool Decimal::toString(char* strBuf, size_t bufLength) const
++{
++ ASSERT(bufLength > 0);
++ String str = toString();
++ size_t length = str.copy(strBuf, bufLength);
++ if (length < bufLength) {
++ strBuf[length] = '\0';
++ return true;
++ }
++ strBuf[bufLength - 1] = '\0';
++ return false;
++}
++
+ Decimal Decimal::zero(Sign sign)
+ {
+ return Decimal(EncodedData(sign, EncodedData::ClassZero));
+ }
+
+ } // namespace blink
+diff --git a/mozglue/misc/decimal/Decimal.h b/mozglue/misc/decimal/Decimal.h
+--- a/mozglue/misc/decimal/Decimal.h
++++ b/mozglue/misc/decimal/Decimal.h
+@@ -23,26 +23,49 @@
+ * 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.
+ */
+
++/**
++ * Imported from:
++ * https://chromium.googlesource.com/chromium/src.git/+/master/third_party/WebKit/Source/platform/Decimal.h
++ * Check UPSTREAM-GIT-SHA for the commit ID of the last update from Blink core.
++ */
++
+ #ifndef Decimal_h
+ #define Decimal_h
+
++#include "mozilla/Assertions.h"
++#include <stdint.h>
+ #include "mozilla/Types.h"
+
+-#include "platform/PlatformExport.h"
+-#include "wtf/Allocator.h"
+-#include "wtf/Assertions.h"
+-#include "wtf/text/WTFString.h"
+-#include <stdint.h>
++#include <string>
++
++#ifndef ASSERT
++#define DEFINED_ASSERT_FOR_DECIMAL_H 1
++#define ASSERT MOZ_ASSERT
++#endif
++
++#define PLATFORM_EXPORT
++
++// To use USING_FAST_MALLOC we'd need:
++// https://chromium.googlesource.com/chromium/src.git/+/master/third_party/WebKit/Source/wtf/Allocator.h
++// Since we don't allocate Decimal objects, no need.
++#define USING_FAST_MALLOC(type) \
++ void ignore_this_dummy_method() = delete
++
++#define DISALLOW_NEW() \
++ private: \
++ void* operator new(size_t) = delete; \
++ void* operator new(size_t, void*) = delete; \
++ public:
+
+ namespace blink {
+
+ namespace DecimalPrivate {
+ class SpecialValueHandler;
+ }
+
+ // This class represents decimal base floating point number.
+@@ -139,27 +162,28 @@ public:
+ MFBT_API Decimal abs() const;
+ MFBT_API Decimal ceil() const;
+ MFBT_API Decimal floor() const;
+ MFBT_API Decimal remainder(const Decimal&) const;
+ MFBT_API Decimal round() const;
+
+ MFBT_API double toDouble() const;
+ // Note: toString method supports infinity and nan but fromString not.
+- MFBT_API String toString() const;
++ MFBT_API std::string toString() const;
++ MFBT_API bool toString(char* strBuf, size_t bufLength) const;
+
+ static MFBT_API Decimal fromDouble(double);
+ // fromString supports following syntax EBNF:
+ // number ::= sign? digit+ ('.' digit*) (exponent-marker sign? digit+)?
+ // | sign? '.' digit+ (exponent-marker sign? digit+)?
+ // sign ::= '+' | '-'
+ // exponent-marker ::= 'e' | 'E'
+ // digit ::= '0' | '1' | ... | '9'
+ // Note: fromString doesn't support "infinity" and "nan".
+- static MFBT_API Decimal fromString(const String&);
++ static MFBT_API Decimal fromString(const std::string& aValue);
+ static MFBT_API Decimal infinity(Sign);
+ static MFBT_API Decimal nan();
+ static MFBT_API Decimal zero(Sign);
+
+ // You should not use below methods. We expose them for unit testing.
+ MFBT_API explicit Decimal(const EncodedData&);
+ const EncodedData& value() const { return m_data; }
+
+@@ -178,9 +202,20 @@ private:
+
+ Sign sign() const { return m_data.sign(); }
+
+ EncodedData m_data;
+ };
+
+ } // namespace blink
+
++namespace mozilla {
++typedef blink::Decimal Decimal;
++} // namespace mozilla
++
++#undef USING_FAST_MALLOC
++
++#ifdef DEFINED_ASSERT_FOR_DECIMAL_H
++#undef DEFINED_ASSERT_FOR_DECIMAL_H
++#undef ASSERT
++#endif
++
+ #endif // Decimal_h
diff --git a/mozglue/misc/decimal/update.sh b/mozglue/misc/decimal/update.sh
new file mode 100755
index 0000000000..23748ebe2c
--- /dev/null
+++ b/mozglue/misc/decimal/update.sh
@@ -0,0 +1,60 @@
+# Usage: ./update.sh [blink-core-source-directory]
+#
+# Copies the needed files from a directory containing the original
+# Decimal.h and Decimal.cpp source that we need.
+# If [blink-core-source-directory] is not specified, this script will
+# attempt to download the latest versions using git.
+
+set -e
+
+FILES=(
+ "Decimal.h"
+ "Decimal.cpp"
+)
+
+OWN_NAME=`basename $0`
+
+if [ $# -gt 1 ]; then
+ echo "$OWN_NAME: Too many arguments">&2
+ exit 1
+fi
+
+if [ $# -eq 1 ]; then
+ BLINK_CORE_DIR="$1"
+ for F in "${FILES[@]}"
+ do
+ P="$BLINK_CORE_DIR/$F"
+ if [ ! -f "$P" ]; then
+ echo "$OWN_NAME: Couldn't find file: $P">&2
+ exit 1
+ fi
+ done
+ for F in "${FILES[@]}"
+ do
+ P="$BLINK_CORE_DIR/$F"
+ cp "$P" .
+ done
+else
+ #LATEST_SHA=$(cat UPSTREAM-GIT-SHA)
+ LATEST_SHA=$(git ls-remote https://chromium.googlesource.com/chromium/src.git/ | awk "/refs\/heads\/master/ {print \$1}")
+ REPO_PATH="https://chromium.googlesource.com/chromium/src.git/+/$LATEST_SHA/third_party/WebKit/Source/platform"
+ #REPO_PATH="https://github.com/WebKit/webkit/tree/master/Source/WebCore/platform"
+ for F in "${FILES[@]}"
+ do
+ printf "Downloading `basename $F`..."
+ curl "$REPO_PATH/${F}?format=TEXT" | base64 -D > "$F"
+ echo done.
+ done
+ echo $LATEST_SHA > UPSTREAM-GIT-SHA
+fi
+
+# Apply patches:
+
+patch -p4 < zero-serialization.patch
+patch -p4 < comparison-with-nan.patch
+patch -p4 < mfbt-abi-markers.patch
+patch -p4 < to-moz-dependencies.patch
+patch -p4 < add-doubleconversion-impl.patch
+# The following is disabled. See
+# https://bugzilla.mozilla.org/show_bug.cgi?id=1208357#c7
+#patch -p4 < fix-wshadow-warnings.patch
diff --git a/mozglue/misc/decimal/zero-serialization.patch b/mozglue/misc/decimal/zero-serialization.patch
new file mode 100644
index 0000000000..b8de9241bd
--- /dev/null
+++ b/mozglue/misc/decimal/zero-serialization.patch
@@ -0,0 +1,22 @@
+diff --git a/mozglue/misc/decimal/Decimal.cpp b/mozglue/misc/decimal/Decimal.cpp
+--- a/mozglue/misc/decimal/Decimal.cpp
++++ b/mozglue/misc/decimal/Decimal.cpp
+@@ -277,17 +277,17 @@ bool Decimal::EncodedData::operator==(co
+ }
+
+ Decimal::Decimal(int32_t i32)
+ : m_data(i32 < 0 ? Negative : Positive, 0, i32 < 0 ? static_cast<uint64_t>(-static_cast<int64_t>(i32)) : static_cast<uint64_t>(i32))
+ {
+ }
+
+ Decimal::Decimal(Sign sign, int exponent, uint64_t coefficient)
+- : m_data(sign, exponent, coefficient)
++ : m_data(sign, coefficient ? exponent : 0, coefficient)
+ {
+ }
+
+ Decimal::Decimal(const EncodedData& data)
+ : m_data(data)
+ {
+ }
+
diff --git a/mozglue/misc/moz.build b/mozglue/misc/moz.build
new file mode 100644
index 0000000000..2e6669c2bf
--- /dev/null
+++ b/mozglue/misc/moz.build
@@ -0,0 +1,156 @@
+# -*- Mode: python; 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/.
+
+FINAL_LIBRARY = "mozglue"
+
+EXPORTS.mozilla += [
+ "AutoProfilerLabel.h",
+ "AwakeTimeStamp.h",
+ "decimal/Decimal.h",
+ "decimal/DoubleConversion.h",
+ "IntegerPrintfMacros.h",
+ "MmapFaultHandler.h",
+ "PlatformConditionVariable.h",
+ "PlatformMutex.h",
+ "PlatformRWLock.h",
+ "Printf.h",
+ "SIMD.h",
+ "Sprintf.h",
+ "SSE.h",
+ "StackWalk.h",
+ "TimeStamp.h",
+ "Uptime.h",
+]
+
+EXPORTS.mozilla.glue += [
+ "Debug.h",
+ "WinUtils.h",
+]
+
+if CONFIG["OS_ARCH"] == "WINNT":
+ EXPORTS.mozilla += [
+ "GetKnownFolderPath.h",
+ "PreXULSkeletonUI.h",
+ "StackWalk_windows.h",
+ "StackWalkThread.h",
+ "TimeStamp_windows.h",
+ "WindowsDpiAwareness.h",
+ ]
+
+SOURCES += [
+ "AutoProfilerLabel.cpp",
+ "AwakeTimeStamp.cpp",
+ "MmapFaultHandler.cpp",
+ "Printf.cpp",
+ "SIMD.cpp",
+ "StackWalk.cpp",
+ "TimeStamp.cpp",
+ "Uptime.cpp",
+]
+
+if CONFIG["CPU_ARCH"].startswith("x86"):
+ SOURCES += [
+ "SIMD_avx2.cpp",
+ "SSE.cpp",
+ ]
+ SOURCES["SIMD_avx2.cpp"].flags += ["-mavx2"]
+
+if not CONFIG["JS_STANDALONE"]:
+ EXPORTS.mozilla += [
+ "ProcessType.h",
+ "RuntimeExceptionModule.h",
+ ]
+
+ SOURCES += [
+ "ProcessType.cpp",
+ "RuntimeExceptionModule.cpp",
+ ]
+
+OS_LIBS += CONFIG["REALTIME_LIBS"]
+
+if CONFIG["OS_ARCH"] == "WINNT":
+ EXPORTS.mozilla += [
+ "DynamicallyLinkedFunctionPtr.h",
+ "ImportDir.h",
+ "NativeNt.h",
+ "WindowsDpiInitialization.h",
+ "WindowsEnumProcessModules.h",
+ "WindowsMapRemoteView.h",
+ "WindowsProcessMitigations.h",
+ "WindowsStackCookie.h",
+ "WindowsUnwindInfo.h",
+ ]
+ EXPORTS.mozilla.glue += [
+ "WindowsUnicode.h",
+ ]
+ SOURCES += [
+ "GetKnownFolderPath.cpp",
+ "TimeStamp_windows.cpp",
+ "WindowsDllMain.cpp",
+ "WindowsDpiInitialization.cpp",
+ "WindowsMapRemoteView.cpp",
+ "WindowsProcessMitigations.cpp",
+ "WindowsUnicode.cpp",
+ ]
+
+ OS_LIBS += [
+ "dbghelp",
+ "oleaut32",
+ "ole32",
+ ]
+
+ if not CONFIG["JS_STANDALONE"]:
+ SOURCES += [
+ "/ipc/mscom/COMWrappers.cpp",
+ "/ipc/mscom/ProcessRuntime.cpp",
+ "PreXULSkeletonUI.cpp",
+ ]
+
+elif CONFIG["HAVE_CLOCK_MONOTONIC"]:
+ SOURCES += [
+ "TimeStamp_posix.cpp",
+ ]
+elif CONFIG["OS_ARCH"] == "Darwin":
+ SOURCES += [
+ "TimeStamp_darwin.cpp",
+ ]
+elif CONFIG["COMPILE_ENVIRONMENT"]:
+ error("No TimeStamp implementation on this platform. Build will not succeed")
+
+if CONFIG["OS_ARCH"] == "WINNT":
+ SOURCES += [
+ "ConditionVariable_windows.cpp",
+ "Mutex_windows.cpp",
+ "RWLock_windows.cpp",
+ ]
+# WASI hasn't supported cond vars and mutexes yet so noop implementation is used.
+elif CONFIG["OS_ARCH"] == "WASI":
+ SOURCES += [
+ "ConditionVariable_noop.cpp",
+ "Mutex_noop.cpp",
+ ]
+else:
+ SOURCES += [
+ "ConditionVariable_posix.cpp",
+ "Mutex_posix.cpp",
+ "RWLock_posix.cpp",
+ ]
+
+if CONFIG["MOZ_LINKER"] and CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+ LOCAL_INCLUDES += [
+ "/mozglue/linker",
+ ]
+
+SOURCES += [
+ "decimal/Decimal.cpp",
+]
+
+if CONFIG["CC_TYPE"] in ("clang", "clang-cl"):
+ # Suppress warnings from third-party V8 Decimal code.
+ SOURCES["decimal/Decimal.cpp"].flags += ["-Wno-implicit-fallthrough"]
+
+for var in ("MOZ_APP_BASENAME", "MOZ_APP_VENDOR"):
+ DEFINES[var] = '"%s"' % CONFIG[var]
diff --git a/mozglue/moz.build b/mozglue/moz.build
new file mode 100644
index 0000000000..7a85aa922f
--- /dev/null
+++ b/mozglue/moz.build
@@ -0,0 +1,26 @@
+# -*- Mode: python; 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/.
+
+with Files("**"):
+ BUG_COMPONENT = ("Core", "mozglue")
+
+if CONFIG["MOZ_LINKER"] or CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+ DIRS += ["linker"]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+ DIRS += ["android"]
+
+if CONFIG["OS_ARCH"] == "Linux" and not CONFIG["FUZZING_SNAPSHOT"]:
+ DIRS += ["interposers"]
+
+DIRS += [
+ "baseprofiler",
+ "build",
+ "misc",
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"]:
+ TEST_DIRS += ["tests"]
diff --git a/mozglue/static/README b/mozglue/static/README
new file mode 100644
index 0000000000..e52c716166
--- /dev/null
+++ b/mozglue/static/README
@@ -0,0 +1,2 @@
+mozglue/static contains parts of the mozglue library that can/should be
+statically linked to e.g. js/Gecko.
diff --git a/mozglue/static/rust/Cargo.toml b/mozglue/static/rust/Cargo.toml
new file mode 100644
index 0000000000..d0307a5bda
--- /dev/null
+++ b/mozglue/static/rust/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "mozglue-static"
+version = "0.1.0"
+edition = "2018"
+license = "MPL-2.0"
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+arrayvec = "0.7"
+
+[build-dependencies]
+mozbuild = "0.1"
+cc = "1"
+rustc_version = "0.4"
+
+[features]
+moz_memory = []
diff --git a/mozglue/static/rust/build.rs b/mozglue/static/rust/build.rs
new file mode 100644
index 0000000000..4df483da0a
--- /dev/null
+++ b/mozglue/static/rust/build.rs
@@ -0,0 +1,32 @@
+/* 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/. */
+
+use rustc_version::{version, Version};
+
+fn main() {
+ let mut build = cc::Build::new();
+ build.cpp(true);
+ // For js-confdefs.h, see wrappers.cpp.
+ build.include(mozbuild::TOPOBJDIR.join("js").join("src"));
+ build.include(mozbuild::TOPOBJDIR.join("dist").join("include"));
+ build.define("MOZ_HAS_MOZGLUE", None);
+ build.file("wrappers.cpp");
+ build.compile("wrappers");
+ println!("cargo:rerun-if-changed=wrappers.cpp");
+
+ let ver = version().unwrap();
+ let max_oom_hook_version = Version::parse("1.71.0-alpha").unwrap();
+ // The new alloc error panic feature was temporarily reverted. We kept the
+ // code in tree, but the version here is such that it's effectively never used.
+ let max_alloc_error_panic_version = Version::parse("1.71.0-alpha").unwrap();
+
+ if ver < max_oom_hook_version {
+ println!("cargo:rustc-cfg=feature=\"oom_with_hook\"");
+ } else if ver < max_alloc_error_panic_version {
+ println!("cargo:rustc-cfg=feature=\"oom_with_alloc_error_panic\"");
+ } else if std::env::var("MOZ_AUTOMATION").is_ok() {
+ panic!("Builds on automation must use a version of rust for which we know how to hook OOM: want < {}, have {}",
+ max_alloc_error_panic_version, ver);
+ }
+}
diff --git a/mozglue/static/rust/lib.rs b/mozglue/static/rust/lib.rs
new file mode 100644
index 0000000000..001b920766
--- /dev/null
+++ b/mozglue/static/rust/lib.rs
@@ -0,0 +1,221 @@
+/* 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/. */
+
+#![cfg_attr(feature = "oom_with_hook", feature(alloc_error_hook))]
+#![cfg_attr(feature = "oom_with_alloc_error_panic", feature(panic_oom_payload))]
+
+use arrayvec::ArrayString;
+use std::cmp;
+use std::ops::Deref;
+use std::os::raw::c_char;
+use std::os::raw::c_int;
+use std::panic;
+
+#[link(name = "wrappers")]
+extern "C" {
+ // We can't use MOZ_Crash directly because it may be weakly linked
+ // and rust can't handle that.
+ fn RustMozCrash(filename: *const c_char, line: c_int, reason: *const c_char) -> !;
+}
+
+/// Truncate a string at the closest unicode character boundary
+/// ```
+/// assert_eq!(str_truncate_valid("éà", 3), "é");
+/// assert_eq!(str_truncate_valid("éà", 4), "éè");
+/// ```
+fn str_truncate_valid(s: &str, mut mid: usize) -> &str {
+ loop {
+ if let Some(res) = s.get(..mid) {
+ return res;
+ }
+ mid -= 1;
+ }
+}
+
+/// Similar to ArrayString, but with terminating nul character.
+#[derive(Debug, PartialEq)]
+struct ArrayCString<const CAP: usize> {
+ inner: ArrayString<CAP>,
+}
+
+impl<S: AsRef<str>, const CAP: usize> From<S> for ArrayCString<CAP> {
+ /// Contrary to ArrayString::from, truncates at the closest unicode
+ /// character boundary.
+ /// ```
+ /// assert_eq!(ArrayCString::<4>::from("éà"),
+ /// ArrayCString::<4>::from("é"));
+ /// assert_eq!(&*ArrayCString::<4>::from("éà"), "é\0");
+ /// ```
+ fn from(s: S) -> Self {
+ let s = s.as_ref();
+ let len = cmp::min(s.len(), CAP - 1);
+ let mut result = Self {
+ inner: ArrayString::from(str_truncate_valid(s, len)).unwrap(),
+ };
+ result.inner.push('\0');
+ result
+ }
+}
+
+impl<const CAP: usize> Deref for ArrayCString<CAP> {
+ type Target = str;
+
+ fn deref(&self) -> &str {
+ self.inner.as_str()
+ }
+}
+
+fn panic_hook(info: &panic::PanicInfo) {
+ // Try to handle &str/String payloads, which should handle 99% of cases.
+ let payload = info.payload();
+ let message = if let Some(layout) = oom_hook::oom_layout(payload) {
+ unsafe {
+ oom_hook::RustHandleOOM(layout.size());
+ }
+ } else if let Some(s) = payload.downcast_ref::<&str>() {
+ s
+ } else if let Some(s) = payload.downcast_ref::<String>() {
+ s.as_str()
+ } else {
+ // Not the most helpful thing, but seems unlikely to happen
+ // in practice.
+ "Unhandled rust panic payload!"
+ };
+ let (filename, line) = if let Some(loc) = info.location() {
+ (loc.file(), loc.line())
+ } else {
+ ("unknown.rs", 0)
+ };
+ // Copy the message and filename to the stack in order to safely add
+ // a terminating nul character (since rust strings don't come with one
+ // and RustMozCrash wants one).
+ let message = ArrayCString::<512>::from(message);
+ let filename = ArrayCString::<512>::from(filename);
+ unsafe {
+ RustMozCrash(
+ filename.as_ptr() as *const c_char,
+ line as c_int,
+ message.as_ptr() as *const c_char,
+ );
+ }
+}
+
+/// Configure a panic hook to redirect rust panics to MFBT's MOZ_Crash.
+#[no_mangle]
+pub extern "C" fn install_rust_hooks() {
+ panic::set_hook(Box::new(panic_hook));
+ #[cfg(feature = "oom_with_hook")]
+ use std::alloc::set_alloc_error_hook;
+ #[cfg(feature = "oom_with_hook")]
+ set_alloc_error_hook(oom_hook::hook);
+}
+
+mod oom_hook {
+ #[cfg(feature = "oom_with_alloc_error_panic")]
+ use std::alloc::AllocErrorPanicPayload;
+ use std::alloc::Layout;
+ use std::any::Any;
+
+ #[inline(always)]
+ pub fn oom_layout(_payload: &dyn Any) -> Option<Layout> {
+ #[cfg(feature = "oom_with_alloc_error_panic")]
+ return _payload
+ .downcast_ref::<AllocErrorPanicPayload>()
+ .map(|p| p.layout());
+ #[cfg(not(feature = "oom_with_alloc_error_panic"))]
+ return None;
+ }
+
+ extern "C" {
+ pub fn RustHandleOOM(size: usize) -> !;
+ }
+
+ #[cfg(feature = "oom_with_hook")]
+ pub fn hook(layout: Layout) {
+ unsafe {
+ RustHandleOOM(layout.size());
+ }
+ }
+}
+
+#[cfg(feature = "moz_memory")]
+mod moz_memory {
+ use std::alloc::{GlobalAlloc, Layout};
+ use std::os::raw::c_void;
+
+ extern "C" {
+ fn malloc(size: usize) -> *mut c_void;
+
+ fn free(ptr: *mut c_void);
+
+ fn calloc(nmemb: usize, size: usize) -> *mut c_void;
+
+ fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void;
+
+ #[cfg(windows)]
+ fn _aligned_malloc(size: usize, align: usize) -> *mut c_void;
+
+ #[cfg(not(windows))]
+ fn memalign(align: usize, size: usize) -> *mut c_void;
+ }
+
+ #[cfg(windows)]
+ unsafe fn memalign(align: usize, size: usize) -> *mut c_void {
+ _aligned_malloc(size, align)
+ }
+
+ pub struct GeckoAlloc;
+
+ #[inline(always)]
+ fn need_memalign(layout: Layout) -> bool {
+ // mozjemalloc guarantees a minimum alignment of 16 for all sizes, except
+ // for size classes below 16 (4 and 8).
+ layout.align() > layout.size() || layout.align() > 16
+ }
+
+ unsafe impl GlobalAlloc for GeckoAlloc {
+ unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+ if need_memalign(layout) {
+ memalign(layout.align(), layout.size()) as *mut u8
+ } else {
+ malloc(layout.size()) as *mut u8
+ }
+ }
+
+ unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
+ free(ptr as *mut c_void)
+ }
+
+ unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+ if need_memalign(layout) {
+ let ptr = self.alloc(layout);
+ if !ptr.is_null() {
+ std::ptr::write_bytes(ptr, 0, layout.size());
+ }
+ ptr
+ } else {
+ calloc(1, layout.size()) as *mut u8
+ }
+ }
+
+ unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+ let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
+ if need_memalign(new_layout) {
+ let new_ptr = self.alloc(new_layout);
+ if !new_ptr.is_null() {
+ let size = std::cmp::min(layout.size(), new_size);
+ std::ptr::copy_nonoverlapping(ptr, new_ptr, size);
+ self.dealloc(ptr, layout);
+ }
+ new_ptr
+ } else {
+ realloc(ptr as *mut c_void, new_size) as *mut u8
+ }
+ }
+ }
+}
+
+#[cfg(feature = "moz_memory")]
+#[global_allocator]
+static A: moz_memory::GeckoAlloc = moz_memory::GeckoAlloc;
diff --git a/mozglue/static/rust/moz_asserts/Cargo.toml b/mozglue/static/rust/moz_asserts/Cargo.toml
new file mode 100644
index 0000000000..27e336f7c7
--- /dev/null
+++ b/mozglue/static/rust/moz_asserts/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "moz_asserts"
+version = "0.1.0"
+edition = "2018"
+license = "MPL-2.0"
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+mozbuild = "0.1"
diff --git a/mozglue/static/rust/moz_asserts/lib.rs b/mozglue/static/rust/moz_asserts/lib.rs
new file mode 100644
index 0000000000..f4b00a5ad2
--- /dev/null
+++ b/mozglue/static/rust/moz_asserts/lib.rs
@@ -0,0 +1,103 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+// Implementation note: It seems tempting to use if cfg!(feature = ...) directly
+// in the macro, but that doesn't work, as the feature would be evaluated
+// against the dependent crate.
+//
+// It'd also seem tempting to export different macros depending on the features
+// enabled, but that's also not great because it causes warnings when the
+// features are enabled, e.g.:
+//
+// nightly_panic!("foo");
+// return SAFE_VALUE;
+//
+// would cause an unreachable code warning for Nightly builds. So instead we
+// choose an exported constant to guard the condition. (For reference, this
+// is also how rust's `debug_assert!` is implemented)
+
+/// Whether Nightly-only assertions are enabled.
+pub use mozbuild::config::NIGHTLY_BUILD;
+
+/// Whether diagnostic assertions are enabled.
+pub use mozbuild::config::MOZ_DIAGNOSTIC_ASSERT_ENABLED;
+
+/// assert! on Nightly, gets compiled out otherwise.
+#[macro_export]
+macro_rules! nightly_assert {
+ ($($arg:tt)*) => (if $crate::NIGHTLY_BUILD { assert!($($arg)*); })
+}
+
+/// assert_eq! on Nightly, gets compiled out otherwise.
+#[macro_export]
+macro_rules! nightly_assert_eq {
+ ($($arg:tt)*) => (if $crate::NIGHTLY_BUILD { assert_eq!($($arg)*); })
+}
+
+/// assert_ne! on Nightly, gets compiled out otherwise.
+#[macro_export]
+macro_rules! nightly_assert_ne {
+ ($($arg:tt)*) => (if $crate::NIGHTLY_BUILD { assert_ne!($($arg)*); })
+}
+
+/// panic! on Nightly, gets compiled out otherwise.
+#[macro_export]
+macro_rules! nightly_panic {
+ ($($arg:tt)*) => (if $crate::NIGHTLY_BUILD { panic!($($arg)*); })
+}
+
+/// unreachable! on Nightly, `std::hint::unreachable_unchecked()` otherwise.
+///
+/// Use carefully! Consider using nightly_panic! and handling the failure
+/// gracefully if you can't prove it's really unreachable.
+///
+/// See https://doc.rust-lang.org/std/hint/fn.unreachable_unchecked.html#safety
+/// for safety details.
+#[macro_export]
+macro_rules! nightly_unreachable {
+ ($($arg:tt)*) => {
+ if $crate::NIGHTLY_BUILD {
+ unreachable!($($arg)*);
+ } else {
+ std::hint::unreachable_unchecked()
+ }
+ }
+}
+
+/// assert! when diagnostic asserts are enabled, gets compiled out otherwise.
+#[macro_export]
+macro_rules! diagnostic_assert {
+ ($($arg:tt)*) => (if $crate::MOZ_DIAGNOSTIC_ASSERT_ENABLED { assert!($($arg)*); })
+}
+
+/// assert_eq! when diagnostic asserts are enabled, gets compiled out otherwise.
+#[macro_export]
+macro_rules! diagnostic_assert_eq {
+ ($($arg:tt)*) => (if $crate::MOZ_DIAGNOSTIC_ASSERT_ENABLED { assert_eq!($($arg)*); })
+}
+
+/// assert_ne! when diagnostic asserts are enabled, gets compiled out otherwise.
+#[macro_export]
+macro_rules! diagnostic_assert_ne {
+ ($($arg:tt)*) => (if $crate::MOZ_DIAGNOSTIC_ASSERT_ENABLED { assert_ne!($($arg)*); })
+}
+
+/// unreachable! when diagnostic asserts are enabled,
+/// `std::hint::unreachable_unchecked()` otherwise.
+///
+/// Use carefully! Consider using diagnostic_panic! and handling the failure
+/// gracefully if you can't prove it's really unreachable.
+///
+/// See https://doc.rust-lang.org/std/hint/fn.unreachable_unchecked.html#safety
+/// for safety details.
+#[macro_export]
+macro_rules! diagnostic_unreachable {
+ ($($arg:tt)*) => {
+ if $crate::MOZ_DIAGNOSTIC_ASSERT_ENABLED {
+ unreachable!($($arg)*);
+ } else {
+ std::hint::unreachable_unchecked()
+ }
+ }
+}
diff --git a/mozglue/static/rust/wrappers.cpp b/mozglue/static/rust/wrappers.cpp
new file mode 100644
index 0000000000..926593f871
--- /dev/null
+++ b/mozglue/static/rust/wrappers.cpp
@@ -0,0 +1,23 @@
+/* -*- 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/. */
+
+// This ensures the right configuration for e.g. MOZ_GLUE_IN_PROGRAM,
+// used in the MFBT headers included further below. We use js-confdefs.h
+// instead of mozilla-config.h because the latter is not present in
+// spidermonkey standalone builds while the former is always present.
+#include "js-confdefs.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Types.h"
+#include "mozilla/mozalloc_oom.h"
+
+// MOZ_Crash wrapper for use by rust, since MOZ_Crash is an inline function.
+extern "C" void RustMozCrash(const char* aFilename, int aLine,
+ const char* aReason) {
+ MOZ_Crash(aFilename, aLine, aReason);
+}
+
+// mozalloc_handle_oom wrapper for use by rust, because mozalloc_handle_oom is
+// MFBT_API, that rust can't respect.
+extern "C" void RustHandleOOM(size_t size) { mozalloc_handle_oom(size); }
diff --git a/mozglue/tests/ShowSSEConfig.cpp b/mozglue/tests/ShowSSEConfig.cpp
new file mode 100644
index 0000000000..a19b30198c
--- /dev/null
+++ b/mozglue/tests/ShowSSEConfig.cpp
@@ -0,0 +1,125 @@
+/* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
+/* 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 "mozilla/SSE.h"
+#include <stdio.h>
+
+#if defined(XP_WIN)
+int wmain()
+#else
+int main()
+#endif // defined(XP_WIN)
+{
+ printf("CPUID detection present: %s\n",
+#ifdef MOZILLA_SSE_HAVE_CPUID_DETECTION
+ "yes"
+#else
+ "no"
+#endif
+ );
+
+#ifdef MOZILLA_COMPILE_WITH_MMX
+# define COMPILE_MMX_STRING "Y"
+#else
+# define COMPILE_MMX_STRING "-"
+#endif
+#ifdef MOZILLA_PRESUME_MMX
+# define PRESUME_MMX_STRING "Y"
+#else
+# define PRESUME_MMX_STRING "-"
+#endif
+
+#ifdef MOZILLA_COMPILE_WITH_SSE
+# define COMPILE_SSE_STRING "Y"
+#else
+# define COMPILE_SSE_STRING "-"
+#endif
+#ifdef MOZILLA_PRESUME_SSE
+# define PRESUME_SSE_STRING "Y"
+#else
+# define PRESUME_SSE_STRING "-"
+#endif
+
+#ifdef MOZILLA_COMPILE_WITH_SSE2
+# define COMPILE_SSE2_STRING "Y"
+#else
+# define COMPILE_SSE2_STRING "-"
+#endif
+#ifdef MOZILLA_PRESUME_SSE2
+# define PRESUME_SSE2_STRING "Y"
+#else
+# define PRESUME_SSE2_STRING "-"
+#endif
+
+#ifdef MOZILLA_COMPILE_WITH_SSE3
+# define COMPILE_SSE3_STRING "Y"
+#else
+# define COMPILE_SSE3_STRING "-"
+#endif
+#ifdef MOZILLA_PRESUME_SSE3
+# define PRESUME_SSE3_STRING "Y"
+#else
+# define PRESUME_SSE3_STRING "-"
+#endif
+
+#ifdef MOZILLA_COMPILE_WITH_SSSE3
+# define COMPILE_SSSE3_STRING "Y"
+#else
+# define COMPILE_SSSE3_STRING "-"
+#endif
+#ifdef MOZILLA_PRESUME_SSSE3
+# define PRESUME_SSSE3_STRING "Y"
+#else
+# define PRESUME_SSSE3_STRING "-"
+#endif
+
+#ifdef MOZILLA_COMPILE_WITH_SSE4A
+# define COMPILE_SSE4A_STRING "Y"
+#else
+# define COMPILE_SSE4A_STRING "-"
+#endif
+#ifdef MOZILLA_PRESUME_SSE4A
+# define PRESUME_SSE4A_STRING "Y"
+#else
+# define PRESUME_SSE4A_STRING "-"
+#endif
+
+#ifdef MOZILLA_COMPILE_WITH_SSE4_1
+# define COMPILE_SSE4_1_STRING "Y"
+#else
+# define COMPILE_SSE4_1_STRING "-"
+#endif
+#ifdef MOZILLA_PRESUME_SSE4_1
+# define PRESUME_SSE4_1_STRING "Y"
+#else
+# define PRESUME_SSE4_1_STRING "-"
+#endif
+
+#ifdef MOZILLA_COMPILE_WITH_SSE4_2
+# define COMPILE_SSE4_2_STRING "Y"
+#else
+# define COMPILE_SSE4_2_STRING "-"
+#endif
+#ifdef MOZILLA_PRESUME_SSE4_2
+# define PRESUME_SSE4_2_STRING "Y"
+#else
+# define PRESUME_SSE4_2_STRING "-"
+#endif
+
+ printf("Feature Presume Compile Support Use\n");
+#define SHOW_INFO(featurelc_, featureuc_) \
+ printf("%7s %1s %1s %1s\n", #featurelc_, \
+ PRESUME_##featureuc_##_STRING, COMPILE_##featureuc_##_STRING, \
+ (mozilla::supports_##featurelc_() ? "Y" : "-"));
+ SHOW_INFO(mmx, MMX)
+ SHOW_INFO(sse, SSE)
+ SHOW_INFO(sse2, SSE2)
+ SHOW_INFO(sse3, SSE3)
+ SHOW_INFO(ssse3, SSSE3)
+ SHOW_INFO(sse4a, SSE4A)
+ SHOW_INFO(sse4_1, SSE4_1)
+ SHOW_INFO(sse4_2, SSE4_2)
+ return 0;
+}
diff --git a/mozglue/tests/TestBaseProfiler.cpp b/mozglue/tests/TestBaseProfiler.cpp
new file mode 100644
index 0000000000..03b2076ebc
--- /dev/null
+++ b/mozglue/tests/TestBaseProfiler.cpp
@@ -0,0 +1,5732 @@
+/* -*- 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/. */
+
+#include "BaseProfiler.h"
+
+#include "mozilla/Attributes.h"
+#include "mozilla/BaseAndGeckoProfilerDetail.h"
+#include "mozilla/BaseProfileJSONWriter.h"
+#include "mozilla/BaseProfilerDetail.h"
+#include "mozilla/FailureLatch.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/ProgressLogger.h"
+#include "mozilla/ProportionValue.h"
+
+#ifdef MOZ_GECKO_PROFILER
+# include "mozilla/BaseProfilerMarkerTypes.h"
+# include "mozilla/BlocksRingBuffer.h"
+# include "mozilla/leb128iterator.h"
+# include "mozilla/ModuloBuffer.h"
+# include "mozilla/mozalloc.h"
+# include "mozilla/PowerOfTwo.h"
+# include "mozilla/ProfileBufferChunk.h"
+# include "mozilla/ProfileBufferChunkManagerSingle.h"
+# include "mozilla/ProfileBufferChunkManagerWithLocalLimit.h"
+# include "mozilla/ProfileBufferControlledChunkManager.h"
+# include "mozilla/ProfileChunkedBuffer.h"
+# include "mozilla/Vector.h"
+#endif // MOZ_GECKO_PROFILER
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+# include <windows.h>
+# include <mmsystem.h>
+# include <process.h>
+#else
+# include <errno.h>
+# include <time.h>
+#endif
+
+#include <algorithm>
+#include <atomic>
+#include <iostream>
+#include <random>
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+void TestFailureLatch() {
+ printf("TestFailureLatch...\n");
+
+ // Test infallible latch.
+ {
+ mozilla::FailureLatchInfallibleSource& infallibleLatch =
+ mozilla::FailureLatchInfallibleSource::Singleton();
+
+ MOZ_RELEASE_ASSERT(!infallibleLatch.Fallible());
+ MOZ_RELEASE_ASSERT(!infallibleLatch.Failed());
+ MOZ_RELEASE_ASSERT(!infallibleLatch.GetFailure());
+ MOZ_RELEASE_ASSERT(&infallibleLatch.SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ MOZ_RELEASE_ASSERT(&std::as_const(infallibleLatch).SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ }
+
+ // Test failure latch basic functions.
+ {
+ mozilla::FailureLatchSource failureLatch;
+
+ MOZ_RELEASE_ASSERT(failureLatch.Fallible());
+ MOZ_RELEASE_ASSERT(!failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(!failureLatch.GetFailure());
+ MOZ_RELEASE_ASSERT(&failureLatch.SourceFailureLatch() == &failureLatch);
+ MOZ_RELEASE_ASSERT(&std::as_const(failureLatch).SourceFailureLatch() ==
+ &failureLatch);
+
+ failureLatch.SetFailure("error");
+
+ MOZ_RELEASE_ASSERT(failureLatch.Fallible());
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(failureLatch.GetFailure());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "error") == 0);
+
+ failureLatch.SetFailure("later error");
+
+ MOZ_RELEASE_ASSERT(failureLatch.Fallible());
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(failureLatch.GetFailure());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "error") == 0);
+ }
+
+ // Test SetFailureFrom.
+ {
+ mozilla::FailureLatchSource failureLatch;
+
+ MOZ_RELEASE_ASSERT(!failureLatch.Failed());
+ failureLatch.SetFailureFrom(failureLatch);
+ MOZ_RELEASE_ASSERT(!failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(!failureLatch.GetFailure());
+
+ // SetFailureFrom with no error.
+ {
+ mozilla::FailureLatchSource failureLatchInnerOk;
+ MOZ_RELEASE_ASSERT(!failureLatchInnerOk.Failed());
+ MOZ_RELEASE_ASSERT(!failureLatchInnerOk.GetFailure());
+
+ MOZ_RELEASE_ASSERT(!failureLatch.Failed());
+ failureLatch.SetFailureFrom(failureLatchInnerOk);
+ MOZ_RELEASE_ASSERT(!failureLatch.Failed());
+
+ MOZ_RELEASE_ASSERT(!failureLatchInnerOk.Failed());
+ MOZ_RELEASE_ASSERT(!failureLatchInnerOk.GetFailure());
+ }
+ MOZ_RELEASE_ASSERT(!failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(!failureLatch.GetFailure());
+
+ // SetFailureFrom with error.
+ {
+ mozilla::FailureLatchSource failureLatchInnerError;
+ MOZ_RELEASE_ASSERT(!failureLatchInnerError.Failed());
+ MOZ_RELEASE_ASSERT(!failureLatchInnerError.GetFailure());
+
+ failureLatchInnerError.SetFailure("inner error");
+ MOZ_RELEASE_ASSERT(failureLatchInnerError.Failed());
+ MOZ_RELEASE_ASSERT(
+ strcmp(failureLatchInnerError.GetFailure(), "inner error") == 0);
+
+ MOZ_RELEASE_ASSERT(!failureLatch.Failed());
+ failureLatch.SetFailureFrom(failureLatchInnerError);
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+
+ MOZ_RELEASE_ASSERT(failureLatchInnerError.Failed());
+ MOZ_RELEASE_ASSERT(
+ strcmp(failureLatchInnerError.GetFailure(), "inner error") == 0);
+ }
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "inner error") == 0);
+
+ failureLatch.SetFailureFrom(failureLatch);
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "inner error") == 0);
+
+ // SetFailureFrom with error again, ignored.
+ {
+ mozilla::FailureLatchSource failureLatchInnerError;
+ failureLatchInnerError.SetFailure("later inner error");
+ MOZ_RELEASE_ASSERT(failureLatchInnerError.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatchInnerError.GetFailure(),
+ "later inner error") == 0);
+
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ failureLatch.SetFailureFrom(failureLatchInnerError);
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+
+ MOZ_RELEASE_ASSERT(failureLatchInnerError.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatchInnerError.GetFailure(),
+ "later inner error") == 0);
+ }
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "inner error") == 0);
+ }
+
+ // Test FAILURELATCH_IMPL_PROXY
+ {
+ class Proxy final : public mozilla::FailureLatch {
+ public:
+ explicit Proxy(mozilla::FailureLatch& aFailureLatch)
+ : mFailureLatch(WrapNotNull(&aFailureLatch)) {}
+
+ void Set(mozilla::FailureLatch& aFailureLatch) {
+ mFailureLatch = WrapNotNull(&aFailureLatch);
+ }
+
+ FAILURELATCH_IMPL_PROXY(*mFailureLatch)
+
+ private:
+ mozilla::NotNull<mozilla::FailureLatch*> mFailureLatch;
+ };
+
+ Proxy proxy{mozilla::FailureLatchInfallibleSource::Singleton()};
+
+ MOZ_RELEASE_ASSERT(!proxy.Fallible());
+ MOZ_RELEASE_ASSERT(!proxy.Failed());
+ MOZ_RELEASE_ASSERT(!proxy.GetFailure());
+ MOZ_RELEASE_ASSERT(&proxy.SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ MOZ_RELEASE_ASSERT(&std::as_const(proxy).SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+
+ // Error from proxy.
+ {
+ mozilla::FailureLatchSource failureLatch;
+ proxy.Set(failureLatch);
+ MOZ_RELEASE_ASSERT(proxy.Fallible());
+ MOZ_RELEASE_ASSERT(!proxy.Failed());
+ MOZ_RELEASE_ASSERT(!proxy.GetFailure());
+ MOZ_RELEASE_ASSERT(&proxy.SourceFailureLatch() == &failureLatch);
+ MOZ_RELEASE_ASSERT(&std::as_const(proxy).SourceFailureLatch() ==
+ &failureLatch);
+
+ proxy.SetFailure("error");
+ MOZ_RELEASE_ASSERT(proxy.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(proxy.GetFailure(), "error") == 0);
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "error") == 0);
+
+ // Don't forget to stop pointing at soon-to-be-destroyed object.
+ proxy.Set(mozilla::FailureLatchInfallibleSource::Singleton());
+ }
+
+ // Error from proxy's origin.
+ {
+ mozilla::FailureLatchSource failureLatch;
+ proxy.Set(failureLatch);
+ MOZ_RELEASE_ASSERT(proxy.Fallible());
+ MOZ_RELEASE_ASSERT(!proxy.Failed());
+ MOZ_RELEASE_ASSERT(!proxy.GetFailure());
+ MOZ_RELEASE_ASSERT(&proxy.SourceFailureLatch() == &failureLatch);
+ MOZ_RELEASE_ASSERT(&std::as_const(proxy).SourceFailureLatch() ==
+ &failureLatch);
+
+ failureLatch.SetFailure("error");
+ MOZ_RELEASE_ASSERT(proxy.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(proxy.GetFailure(), "error") == 0);
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "error") == 0);
+
+ // Don't forget to stop pointing at soon-to-be-destroyed object.
+ proxy.Set(mozilla::FailureLatchInfallibleSource::Singleton());
+ }
+
+ MOZ_RELEASE_ASSERT(!proxy.Fallible());
+ MOZ_RELEASE_ASSERT(!proxy.Failed());
+ MOZ_RELEASE_ASSERT(!proxy.GetFailure());
+ MOZ_RELEASE_ASSERT(&proxy.SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ MOZ_RELEASE_ASSERT(&std::as_const(proxy).SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ }
+
+ // Test FAILURELATCH_IMPL_PROXY_OR_INFALLIBLE
+ {
+ class ProxyOrNull final : public mozilla::FailureLatch {
+ public:
+ ProxyOrNull() = default;
+
+ void Set(mozilla::FailureLatch* aFailureLatchOrNull) {
+ mFailureLatchOrNull = aFailureLatchOrNull;
+ }
+
+ FAILURELATCH_IMPL_PROXY_OR_INFALLIBLE(mFailureLatchOrNull, ProxyOrNull)
+
+ private:
+ mozilla::FailureLatch* mFailureLatchOrNull = nullptr;
+ };
+
+ ProxyOrNull proxy;
+
+ MOZ_RELEASE_ASSERT(!proxy.Fallible());
+ MOZ_RELEASE_ASSERT(!proxy.Failed());
+ MOZ_RELEASE_ASSERT(!proxy.GetFailure());
+ MOZ_RELEASE_ASSERT(&proxy.SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ MOZ_RELEASE_ASSERT(&std::as_const(proxy).SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+
+ // Error from proxy.
+ {
+ mozilla::FailureLatchSource failureLatch;
+ proxy.Set(&failureLatch);
+ MOZ_RELEASE_ASSERT(proxy.Fallible());
+ MOZ_RELEASE_ASSERT(!proxy.Failed());
+ MOZ_RELEASE_ASSERT(!proxy.GetFailure());
+ MOZ_RELEASE_ASSERT(&proxy.SourceFailureLatch() == &failureLatch);
+ MOZ_RELEASE_ASSERT(&std::as_const(proxy).SourceFailureLatch() ==
+ &failureLatch);
+
+ proxy.SetFailure("error");
+ MOZ_RELEASE_ASSERT(proxy.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(proxy.GetFailure(), "error") == 0);
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "error") == 0);
+
+ // Don't forget to stop pointing at soon-to-be-destroyed object.
+ proxy.Set(nullptr);
+ }
+
+ // Error from proxy's origin.
+ {
+ mozilla::FailureLatchSource failureLatch;
+ proxy.Set(&failureLatch);
+ MOZ_RELEASE_ASSERT(proxy.Fallible());
+ MOZ_RELEASE_ASSERT(!proxy.Failed());
+ MOZ_RELEASE_ASSERT(!proxy.GetFailure());
+ MOZ_RELEASE_ASSERT(&proxy.SourceFailureLatch() == &failureLatch);
+ MOZ_RELEASE_ASSERT(&std::as_const(proxy).SourceFailureLatch() ==
+ &failureLatch);
+
+ failureLatch.SetFailure("error");
+ MOZ_RELEASE_ASSERT(proxy.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(proxy.GetFailure(), "error") == 0);
+ MOZ_RELEASE_ASSERT(failureLatch.Failed());
+ MOZ_RELEASE_ASSERT(strcmp(failureLatch.GetFailure(), "error") == 0);
+
+ // Don't forget to stop pointing at soon-to-be-destroyed object.
+ proxy.Set(nullptr);
+ }
+
+ MOZ_RELEASE_ASSERT(!proxy.Fallible());
+ MOZ_RELEASE_ASSERT(!proxy.Failed());
+ MOZ_RELEASE_ASSERT(!proxy.GetFailure());
+ MOZ_RELEASE_ASSERT(&proxy.SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ MOZ_RELEASE_ASSERT(&std::as_const(proxy).SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ }
+
+ printf("TestFailureLatch done\n");
+}
+
+void TestProfilerUtils() {
+ printf("TestProfilerUtils...\n");
+
+ {
+ using mozilla::baseprofiler::BaseProfilerProcessId;
+ using Number = BaseProfilerProcessId::NumberType;
+ static constexpr Number scMaxNumber = std::numeric_limits<Number>::max();
+
+ static_assert(
+ BaseProfilerProcessId{}.ToNumber() == 0,
+ "These tests assume that the unspecified process id number is 0; "
+ "if this fails, please update these tests accordingly");
+
+ static_assert(!BaseProfilerProcessId{}.IsSpecified());
+ static_assert(!BaseProfilerProcessId::FromNumber(0).IsSpecified());
+ static_assert(BaseProfilerProcessId::FromNumber(1).IsSpecified());
+ static_assert(BaseProfilerProcessId::FromNumber(123).IsSpecified());
+ static_assert(BaseProfilerProcessId::FromNumber(scMaxNumber).IsSpecified());
+
+ static_assert(BaseProfilerProcessId::FromNumber(Number(1)).ToNumber() ==
+ Number(1));
+ static_assert(BaseProfilerProcessId::FromNumber(Number(123)).ToNumber() ==
+ Number(123));
+ static_assert(BaseProfilerProcessId::FromNumber(scMaxNumber).ToNumber() ==
+ scMaxNumber);
+
+ static_assert(BaseProfilerProcessId{} == BaseProfilerProcessId{});
+ static_assert(BaseProfilerProcessId::FromNumber(Number(123)) ==
+ BaseProfilerProcessId::FromNumber(Number(123)));
+ static_assert(BaseProfilerProcessId{} !=
+ BaseProfilerProcessId::FromNumber(Number(123)));
+ static_assert(BaseProfilerProcessId::FromNumber(Number(123)) !=
+ BaseProfilerProcessId{});
+ static_assert(BaseProfilerProcessId::FromNumber(Number(123)) !=
+ BaseProfilerProcessId::FromNumber(scMaxNumber));
+ static_assert(BaseProfilerProcessId::FromNumber(scMaxNumber) !=
+ BaseProfilerProcessId::FromNumber(Number(123)));
+
+ // Verify trivial-copyability by memcpy'ing to&from same-size storage.
+ static_assert(std::is_trivially_copyable_v<BaseProfilerProcessId>);
+ BaseProfilerProcessId pid;
+ MOZ_RELEASE_ASSERT(!pid.IsSpecified());
+ Number pidStorage;
+ static_assert(sizeof(pidStorage) == sizeof(pid));
+ // Copy from BaseProfilerProcessId to storage. Note: We cannot assume that
+ // this is equal to what ToNumber() gives us. All we can do is verify that
+ // copying from storage back to BaseProfilerProcessId works as expected.
+ std::memcpy(&pidStorage, &pid, sizeof(pidStorage));
+ BaseProfilerProcessId pid2 = BaseProfilerProcessId::FromNumber(2);
+ MOZ_RELEASE_ASSERT(pid2.IsSpecified());
+ std::memcpy(&pid2, &pidStorage, sizeof(pid));
+ MOZ_RELEASE_ASSERT(!pid2.IsSpecified());
+
+ pid = BaseProfilerProcessId::FromNumber(123);
+ std::memcpy(&pidStorage, &pid, sizeof(pidStorage));
+ pid2 = BaseProfilerProcessId{};
+ MOZ_RELEASE_ASSERT(!pid2.IsSpecified());
+ std::memcpy(&pid2, &pidStorage, sizeof(pid));
+ MOZ_RELEASE_ASSERT(pid2.IsSpecified());
+ MOZ_RELEASE_ASSERT(pid2.ToNumber() == 123);
+
+ // No conversions to/from numbers.
+ static_assert(!std::is_constructible_v<BaseProfilerProcessId, Number>);
+ static_assert(!std::is_assignable_v<BaseProfilerProcessId, Number>);
+ static_assert(!std::is_constructible_v<Number, BaseProfilerProcessId>);
+ static_assert(!std::is_assignable_v<Number, BaseProfilerProcessId>);
+
+ static_assert(
+ std::is_same_v<
+ decltype(mozilla::baseprofiler::profiler_current_process_id()),
+ BaseProfilerProcessId>);
+ MOZ_RELEASE_ASSERT(
+ mozilla::baseprofiler::profiler_current_process_id().IsSpecified());
+ }
+
+ {
+ mozilla::baseprofiler::profiler_init_main_thread_id();
+
+ using mozilla::baseprofiler::BaseProfilerThreadId;
+ using Number = BaseProfilerThreadId::NumberType;
+ static constexpr Number scMaxNumber = std::numeric_limits<Number>::max();
+
+ static_assert(
+ BaseProfilerThreadId{}.ToNumber() == 0,
+ "These tests assume that the unspecified thread id number is 0; "
+ "if this fails, please update these tests accordingly");
+
+ static_assert(!BaseProfilerThreadId{}.IsSpecified());
+ static_assert(!BaseProfilerThreadId::FromNumber(0).IsSpecified());
+ static_assert(BaseProfilerThreadId::FromNumber(1).IsSpecified());
+ static_assert(BaseProfilerThreadId::FromNumber(123).IsSpecified());
+ static_assert(BaseProfilerThreadId::FromNumber(scMaxNumber).IsSpecified());
+
+ static_assert(BaseProfilerThreadId::FromNumber(Number(1)).ToNumber() ==
+ Number(1));
+ static_assert(BaseProfilerThreadId::FromNumber(Number(123)).ToNumber() ==
+ Number(123));
+ static_assert(BaseProfilerThreadId::FromNumber(scMaxNumber).ToNumber() ==
+ scMaxNumber);
+
+ static_assert(BaseProfilerThreadId{} == BaseProfilerThreadId{});
+ static_assert(BaseProfilerThreadId::FromNumber(Number(123)) ==
+ BaseProfilerThreadId::FromNumber(Number(123)));
+ static_assert(BaseProfilerThreadId{} !=
+ BaseProfilerThreadId::FromNumber(Number(123)));
+ static_assert(BaseProfilerThreadId::FromNumber(Number(123)) !=
+ BaseProfilerThreadId{});
+ static_assert(BaseProfilerThreadId::FromNumber(Number(123)) !=
+ BaseProfilerThreadId::FromNumber(scMaxNumber));
+ static_assert(BaseProfilerThreadId::FromNumber(scMaxNumber) !=
+ BaseProfilerThreadId::FromNumber(Number(123)));
+
+ // Verify trivial-copyability by memcpy'ing to&from same-size storage.
+ static_assert(std::is_trivially_copyable_v<BaseProfilerThreadId>);
+ BaseProfilerThreadId tid;
+ MOZ_RELEASE_ASSERT(!tid.IsSpecified());
+ Number tidStorage;
+ static_assert(sizeof(tidStorage) == sizeof(tid));
+ // Copy from BaseProfilerThreadId to storage. Note: We cannot assume that
+ // this is equal to what ToNumber() gives us. All we can do is verify that
+ // copying from storage back to BaseProfilerThreadId works as expected.
+ std::memcpy(&tidStorage, &tid, sizeof(tidStorage));
+ BaseProfilerThreadId tid2 = BaseProfilerThreadId::FromNumber(2);
+ MOZ_RELEASE_ASSERT(tid2.IsSpecified());
+ std::memcpy(&tid2, &tidStorage, sizeof(tid));
+ MOZ_RELEASE_ASSERT(!tid2.IsSpecified());
+
+ tid = BaseProfilerThreadId::FromNumber(Number(123));
+ std::memcpy(&tidStorage, &tid, sizeof(tidStorage));
+ tid2 = BaseProfilerThreadId{};
+ MOZ_RELEASE_ASSERT(!tid2.IsSpecified());
+ std::memcpy(&tid2, &tidStorage, sizeof(tid));
+ MOZ_RELEASE_ASSERT(tid2.IsSpecified());
+ MOZ_RELEASE_ASSERT(tid2.ToNumber() == Number(123));
+
+ // No conversions to/from numbers.
+ static_assert(!std::is_constructible_v<BaseProfilerThreadId, Number>);
+ static_assert(!std::is_assignable_v<BaseProfilerThreadId, Number>);
+ static_assert(!std::is_constructible_v<Number, BaseProfilerThreadId>);
+ static_assert(!std::is_assignable_v<Number, BaseProfilerThreadId>);
+
+ static_assert(std::is_same_v<
+ decltype(mozilla::baseprofiler::profiler_current_thread_id()),
+ BaseProfilerThreadId>);
+ BaseProfilerThreadId mainTestThreadId =
+ mozilla::baseprofiler::profiler_current_thread_id();
+ MOZ_RELEASE_ASSERT(mainTestThreadId.IsSpecified());
+
+ BaseProfilerThreadId mainThreadId =
+ mozilla::baseprofiler::profiler_main_thread_id();
+ MOZ_RELEASE_ASSERT(mainThreadId.IsSpecified());
+
+ MOZ_RELEASE_ASSERT(mainThreadId == mainTestThreadId,
+ "Test should run on the main thread");
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::profiler_is_main_thread());
+
+ std::thread testThread([&]() {
+ const BaseProfilerThreadId testThreadId =
+ mozilla::baseprofiler::profiler_current_thread_id();
+ MOZ_RELEASE_ASSERT(testThreadId.IsSpecified());
+ MOZ_RELEASE_ASSERT(testThreadId != mainThreadId);
+ MOZ_RELEASE_ASSERT(!mozilla::baseprofiler::profiler_is_main_thread());
+ });
+ testThread.join();
+ }
+
+ // No conversions between processes and threads.
+ static_assert(
+ !std::is_constructible_v<mozilla::baseprofiler::BaseProfilerThreadId,
+ mozilla::baseprofiler::BaseProfilerProcessId>);
+ static_assert(
+ !std::is_assignable_v<mozilla::baseprofiler::BaseProfilerThreadId,
+ mozilla::baseprofiler::BaseProfilerProcessId>);
+ static_assert(
+ !std::is_constructible_v<mozilla::baseprofiler::BaseProfilerProcessId,
+ mozilla::baseprofiler::BaseProfilerThreadId>);
+ static_assert(
+ !std::is_assignable_v<mozilla::baseprofiler::BaseProfilerProcessId,
+ mozilla::baseprofiler::BaseProfilerThreadId>);
+
+ printf("TestProfilerUtils done\n");
+}
+
+void TestBaseAndProfilerDetail() {
+ printf("TestBaseAndProfilerDetail...\n");
+
+ {
+ using mozilla::profiler::detail::FilterHasPid;
+
+ const auto pid123 =
+ mozilla::baseprofiler::BaseProfilerProcessId::FromNumber(123);
+ MOZ_RELEASE_ASSERT(FilterHasPid("pid:123", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid(" ", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("123", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid:", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid=123", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid:123 ", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid: 123", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid:0123", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid:0000000000000000000000123", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid:12", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid:1234", pid123));
+ MOZ_RELEASE_ASSERT(!FilterHasPid("pid:0", pid123));
+
+ using PidNumber = mozilla::baseprofiler::BaseProfilerProcessId::NumberType;
+ const PidNumber maxNumber = std::numeric_limits<PidNumber>::max();
+ const auto maxPid =
+ mozilla::baseprofiler::BaseProfilerProcessId::FromNumber(maxNumber);
+ const std::string maxPidString = "pid:" + std::to_string(maxNumber);
+ MOZ_RELEASE_ASSERT(FilterHasPid(maxPidString.c_str(), maxPid));
+
+ const std::string tooBigPidString = maxPidString + "0";
+ MOZ_RELEASE_ASSERT(!FilterHasPid(tooBigPidString.c_str(), maxPid));
+ }
+
+ {
+ using mozilla::profiler::detail::FiltersExcludePid;
+ const auto pid123 =
+ mozilla::baseprofiler::BaseProfilerProcessId::FromNumber(123);
+
+ MOZ_RELEASE_ASSERT(
+ !FiltersExcludePid(mozilla::Span<const char*>{}, pid123));
+
+ {
+ const char* const filters[] = {"main"};
+ MOZ_RELEASE_ASSERT(!FiltersExcludePid(filters, pid123));
+ }
+
+ {
+ const char* const filters[] = {"main", "pid:123"};
+ MOZ_RELEASE_ASSERT(!FiltersExcludePid(filters, pid123));
+ }
+
+ {
+ const char* const filters[] = {"main", "pid:456"};
+ MOZ_RELEASE_ASSERT(!FiltersExcludePid(filters, pid123));
+ }
+
+ {
+ const char* const filters[] = {"pid:123"};
+ MOZ_RELEASE_ASSERT(!FiltersExcludePid(filters, pid123));
+ }
+
+ {
+ const char* const filters[] = {"pid:123", "pid:456"};
+ MOZ_RELEASE_ASSERT(!FiltersExcludePid(filters, pid123));
+ }
+
+ {
+ const char* const filters[] = {"pid:456", "pid:123"};
+ MOZ_RELEASE_ASSERT(!FiltersExcludePid(filters, pid123));
+ }
+
+ {
+ const char* const filters[] = {"pid:456"};
+ MOZ_RELEASE_ASSERT(FiltersExcludePid(filters, pid123));
+ }
+
+ {
+ const char* const filters[] = {"pid:456", "pid:789"};
+ MOZ_RELEASE_ASSERT(FiltersExcludePid(filters, pid123));
+ }
+ }
+
+ printf("TestBaseAndProfilerDetail done\n");
+}
+
+void TestSharedMutex() {
+ printf("TestSharedMutex...\n");
+
+ mozilla::baseprofiler::detail::BaseProfilerSharedMutex sm;
+
+ // First round of minimal tests in this thread.
+
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+
+ sm.LockExclusive();
+ MOZ_RELEASE_ASSERT(sm.IsLockedExclusiveOnCurrentThread());
+ sm.UnlockExclusive();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+
+ sm.LockShared();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ sm.UnlockShared();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+
+ {
+ mozilla::baseprofiler::detail::BaseProfilerAutoLockExclusive exclusiveLock{
+ sm};
+ MOZ_RELEASE_ASSERT(sm.IsLockedExclusiveOnCurrentThread());
+ }
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+
+ {
+ mozilla::baseprofiler::detail::BaseProfilerAutoLockShared sharedLock{sm};
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ }
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+
+ // The following will run actions between two threads, to verify that
+ // exclusive and shared locks work as expected.
+
+ // These actions will happen from top to bottom.
+ // This will test all possible lock interactions.
+ enum NextAction { // State of the lock:
+ t1Starting, // (x=exclusive, s=shared, ?=blocked)
+ t2Starting, // t1 t2
+ t1LockExclusive, // x
+ t2LockExclusiveAndBlock, // x x? - Can't have two exclusives.
+ t1UnlockExclusive, // x
+ t2UnblockedAfterT1Unlock, // x
+ t1LockSharedAndBlock, // s? x - Can't have shared during excl
+ t2UnlockExclusive, // s
+ t1UnblockedAfterT2Unlock, // s
+ t2LockShared, // s s - Can have multiple shared locks
+ t1UnlockShared, // s
+ t2StillLockedShared, // s
+ t1LockExclusiveAndBlock, // x? s - Can't have excl during shared
+ t2UnlockShared, // x
+ t1UnblockedAfterT2UnlockShared, // x
+ t2CheckAfterT1Lock, // x
+ t1LastUnlockExclusive, // (unlocked)
+ done
+ };
+
+ // Each thread will repeatedly read this `nextAction`, and run actions that
+ // target it...
+ std::atomic<NextAction> nextAction{static_cast<NextAction>(0)};
+ // ... and advance to the next available action (which should usually be for
+ // the other thread).
+ auto AdvanceAction = [&nextAction]() {
+ MOZ_RELEASE_ASSERT(nextAction <= done);
+ nextAction = static_cast<NextAction>(static_cast<int>(nextAction) + 1);
+ };
+
+ std::thread t1{[&]() {
+ for (;;) {
+ switch (nextAction) {
+ case t1Starting:
+ AdvanceAction();
+ break;
+ case t1LockExclusive:
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ sm.LockExclusive();
+ MOZ_RELEASE_ASSERT(sm.IsLockedExclusiveOnCurrentThread());
+ AdvanceAction();
+ break;
+ case t1UnlockExclusive:
+ MOZ_RELEASE_ASSERT(sm.IsLockedExclusiveOnCurrentThread());
+ // Advance first, before unlocking, so that t2 sees the new state.
+ AdvanceAction();
+ sm.UnlockExclusive();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ break;
+ case t1LockSharedAndBlock:
+ // Advance action before attempting to lock after t2's exclusive lock.
+ AdvanceAction();
+ sm.LockShared();
+ // We will only acquire the lock after t1 unlocks.
+ MOZ_RELEASE_ASSERT(nextAction == t1UnblockedAfterT2Unlock);
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ AdvanceAction();
+ break;
+ case t1UnlockShared:
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ // Advance first, before unlocking, so that t2 sees the new state.
+ AdvanceAction();
+ sm.UnlockShared();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ break;
+ case t1LockExclusiveAndBlock:
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ // Advance action before attempting to lock after t2's shared lock.
+ AdvanceAction();
+ sm.LockExclusive();
+ // We will only acquire the lock after t2 unlocks.
+ MOZ_RELEASE_ASSERT(nextAction == t1UnblockedAfterT2UnlockShared);
+ MOZ_RELEASE_ASSERT(sm.IsLockedExclusiveOnCurrentThread());
+ AdvanceAction();
+ break;
+ case t1LastUnlockExclusive:
+ MOZ_RELEASE_ASSERT(sm.IsLockedExclusiveOnCurrentThread());
+ // Advance first, before unlocking, so that t2 sees the new state.
+ AdvanceAction();
+ sm.UnlockExclusive();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ break;
+ case done:
+ return;
+ default:
+ // Ignore other actions intended for t2.
+ break;
+ }
+ }
+ }};
+
+ std::thread t2{[&]() {
+ for (;;) {
+ switch (nextAction) {
+ case t2Starting:
+ AdvanceAction();
+ break;
+ case t2LockExclusiveAndBlock:
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ // Advance action before attempting to lock after t1's exclusive lock.
+ AdvanceAction();
+ sm.LockExclusive();
+ // We will only acquire the lock after t1 unlocks.
+ MOZ_RELEASE_ASSERT(nextAction == t2UnblockedAfterT1Unlock);
+ MOZ_RELEASE_ASSERT(sm.IsLockedExclusiveOnCurrentThread());
+ AdvanceAction();
+ break;
+ case t2UnlockExclusive:
+ MOZ_RELEASE_ASSERT(sm.IsLockedExclusiveOnCurrentThread());
+ // Advance first, before unlocking, so that t1 sees the new state.
+ AdvanceAction();
+ sm.UnlockExclusive();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ break;
+ case t2LockShared:
+ sm.LockShared();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ AdvanceAction();
+ break;
+ case t2StillLockedShared:
+ AdvanceAction();
+ break;
+ case t2UnlockShared:
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ // Advance first, before unlocking, so that t1 sees the new state.
+ AdvanceAction();
+ sm.UnlockShared();
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ break;
+ case t2CheckAfterT1Lock:
+ MOZ_RELEASE_ASSERT(!sm.IsLockedExclusiveOnCurrentThread());
+ AdvanceAction();
+ break;
+ case done:
+ return;
+ default:
+ // Ignore other actions intended for t1.
+ break;
+ }
+ }
+ }};
+
+ t1.join();
+ t2.join();
+
+ printf("TestSharedMutex done\n");
+}
+
+void TestProportionValue() {
+ printf("TestProportionValue...\n");
+
+ using mozilla::ProportionValue;
+
+#define STATIC_ASSERT_EQ(a, b) \
+ static_assert((a) == (b)); \
+ MOZ_RELEASE_ASSERT((a) == (b));
+
+#define STATIC_ASSERT(e) STATIC_ASSERT_EQ(e, true)
+
+ // Conversion from&to double.
+ STATIC_ASSERT_EQ(ProportionValue().ToDouble(), 0.0);
+ STATIC_ASSERT_EQ(ProportionValue(0.0).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ(ProportionValue(0.5).ToDouble(), 0.5);
+ STATIC_ASSERT_EQ(ProportionValue(1.0).ToDouble(), 1.0);
+
+ // Clamping.
+ STATIC_ASSERT_EQ(
+ ProportionValue(std::numeric_limits<double>::min()).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ(
+ ProportionValue(std::numeric_limits<long double>::min()).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ(ProportionValue(-1.0).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ(ProportionValue(-0.01).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ(ProportionValue(-0.0).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ(ProportionValue(1.01).ToDouble(), 1.0);
+ STATIC_ASSERT_EQ(
+ ProportionValue(std::numeric_limits<double>::max()).ToDouble(), 1.0);
+
+ // User-defined literal.
+ {
+ using namespace mozilla::literals::ProportionValue_literals;
+ STATIC_ASSERT_EQ(0_pc, ProportionValue(0.0));
+ STATIC_ASSERT_EQ(0._pc, ProportionValue(0.0));
+ STATIC_ASSERT_EQ(50_pc, ProportionValue(0.5));
+ STATIC_ASSERT_EQ(50._pc, ProportionValue(0.5));
+ STATIC_ASSERT_EQ(100_pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(100._pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(101_pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(100.01_pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(1000_pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(1000._pc, ProportionValue(1.0));
+ }
+ {
+ // ProportionValue_literals is an inline namespace of mozilla::literals, so
+ // it's optional.
+ using namespace mozilla::literals;
+ STATIC_ASSERT_EQ(0_pc, ProportionValue(0.0));
+ STATIC_ASSERT_EQ(0._pc, ProportionValue(0.0));
+ STATIC_ASSERT_EQ(50_pc, ProportionValue(0.5));
+ STATIC_ASSERT_EQ(50._pc, ProportionValue(0.5));
+ STATIC_ASSERT_EQ(100_pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(100._pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(101_pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(100.01_pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(1000_pc, ProportionValue(1.0));
+ STATIC_ASSERT_EQ(1000._pc, ProportionValue(1.0));
+ }
+
+ // Invalid construction, conversion to double NaN.
+ MOZ_RELEASE_ASSERT(std::isnan(ProportionValue::MakeInvalid().ToDouble()));
+
+ using namespace mozilla::literals::ProportionValue_literals;
+
+ // Conversion to&from underlying integral number.
+ STATIC_ASSERT_EQ(
+ ProportionValue::FromUnderlyingType((0_pc).ToUnderlyingType()).ToDouble(),
+ 0.0);
+ STATIC_ASSERT_EQ(
+ ProportionValue::FromUnderlyingType((50_pc).ToUnderlyingType())
+ .ToDouble(),
+ 0.5);
+ STATIC_ASSERT_EQ(
+ ProportionValue::FromUnderlyingType((100_pc).ToUnderlyingType())
+ .ToDouble(),
+ 1.0);
+ STATIC_ASSERT(ProportionValue::FromUnderlyingType(
+ ProportionValue::MakeInvalid().ToUnderlyingType())
+ .IsInvalid());
+
+ // IsExactlyZero.
+ STATIC_ASSERT(ProportionValue().IsExactlyZero());
+ STATIC_ASSERT((0_pc).IsExactlyZero());
+ STATIC_ASSERT(!(50_pc).IsExactlyZero());
+ STATIC_ASSERT(!(100_pc).IsExactlyZero());
+ STATIC_ASSERT(!ProportionValue::MakeInvalid().IsExactlyZero());
+
+ // IsExactlyOne.
+ STATIC_ASSERT(!ProportionValue().IsExactlyOne());
+ STATIC_ASSERT(!(0_pc).IsExactlyOne());
+ STATIC_ASSERT(!(50_pc).IsExactlyOne());
+ STATIC_ASSERT((100_pc).IsExactlyOne());
+ STATIC_ASSERT(!ProportionValue::MakeInvalid().IsExactlyOne());
+
+ // IsValid.
+ STATIC_ASSERT(ProportionValue().IsValid());
+ STATIC_ASSERT((0_pc).IsValid());
+ STATIC_ASSERT((50_pc).IsValid());
+ STATIC_ASSERT((100_pc).IsValid());
+ STATIC_ASSERT(!ProportionValue::MakeInvalid().IsValid());
+
+ // IsInvalid.
+ STATIC_ASSERT(!ProportionValue().IsInvalid());
+ STATIC_ASSERT(!(0_pc).IsInvalid());
+ STATIC_ASSERT(!(50_pc).IsInvalid());
+ STATIC_ASSERT(!(100_pc).IsInvalid());
+ STATIC_ASSERT(ProportionValue::MakeInvalid().IsInvalid());
+
+ // Addition.
+ STATIC_ASSERT_EQ((0_pc + 0_pc).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ((0_pc + 100_pc).ToDouble(), 1.0);
+ STATIC_ASSERT_EQ((100_pc + 0_pc).ToDouble(), 1.0);
+ STATIC_ASSERT_EQ((100_pc + 100_pc).ToDouble(), 1.0);
+ STATIC_ASSERT((ProportionValue::MakeInvalid() + 50_pc).IsInvalid());
+ STATIC_ASSERT((50_pc + ProportionValue::MakeInvalid()).IsInvalid());
+
+ // Subtraction.
+ STATIC_ASSERT_EQ((0_pc - 0_pc).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ((0_pc - 100_pc).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ((100_pc - 0_pc).ToDouble(), 1.0);
+ STATIC_ASSERT_EQ((100_pc - 100_pc).ToDouble(), 0.0);
+ STATIC_ASSERT((ProportionValue::MakeInvalid() - 50_pc).IsInvalid());
+ STATIC_ASSERT((50_pc - ProportionValue::MakeInvalid()).IsInvalid());
+
+ // Multiplication.
+ STATIC_ASSERT_EQ((0_pc * 0_pc).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ((0_pc * 100_pc).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ((50_pc * 50_pc).ToDouble(), 0.25);
+ STATIC_ASSERT_EQ((50_pc * 100_pc).ToDouble(), 0.5);
+ STATIC_ASSERT_EQ((100_pc * 50_pc).ToDouble(), 0.5);
+ STATIC_ASSERT_EQ((100_pc * 0_pc).ToDouble(), 0.0);
+ STATIC_ASSERT_EQ((100_pc * 100_pc).ToDouble(), 1.0);
+ STATIC_ASSERT((ProportionValue::MakeInvalid() * 50_pc).IsInvalid());
+ STATIC_ASSERT((50_pc * ProportionValue::MakeInvalid()).IsInvalid());
+
+ // Division by a positive integer value.
+ STATIC_ASSERT_EQ((100_pc / 1u).ToDouble(), 1.0);
+ STATIC_ASSERT_EQ((100_pc / 2u).ToDouble(), 0.5);
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(6u) / 2u).ToUnderlyingType(), 3u);
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(5u) / 2u).ToUnderlyingType(), 2u);
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(1u) / 2u).ToUnderlyingType(), 0u);
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(0u) / 2u).ToUnderlyingType(), 0u);
+ STATIC_ASSERT((100_pc / 0u).IsInvalid());
+ STATIC_ASSERT((ProportionValue::MakeInvalid() / 2u).IsInvalid());
+
+ // Multiplication by a positive integer value.
+ STATIC_ASSERT_EQ((100_pc * 1u).ToDouble(), 1.0);
+ STATIC_ASSERT_EQ((50_pc * 1u).ToDouble(), 0.5);
+ STATIC_ASSERT_EQ((50_pc * 2u).ToDouble(), 1.0);
+ STATIC_ASSERT_EQ((50_pc * 3u).ToDouble(), 1.0); // Clamped.
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(1u) * 2u).ToUnderlyingType(), 2u);
+ STATIC_ASSERT((ProportionValue::MakeInvalid() * 2u).IsInvalid());
+
+ // Verifying PV - u < (PV / u) * u <= PV, with n=3, PV between 6 and 9 :
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(6u) / 3u).ToUnderlyingType(), 2u);
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(7u) / 3u).ToUnderlyingType(), 2u);
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(8u) / 3u).ToUnderlyingType(), 2u);
+ STATIC_ASSERT_EQ(
+ (ProportionValue::FromUnderlyingType(9u) / 3u).ToUnderlyingType(), 3u);
+
+ // Direct comparisons.
+ STATIC_ASSERT_EQ(0_pc, 0_pc);
+ STATIC_ASSERT(0_pc == 0_pc);
+ STATIC_ASSERT(!(0_pc == 100_pc));
+ STATIC_ASSERT(0_pc != 100_pc);
+ STATIC_ASSERT(!(0_pc != 0_pc));
+ STATIC_ASSERT(0_pc < 100_pc);
+ STATIC_ASSERT(!(0_pc < 0_pc));
+ STATIC_ASSERT(0_pc <= 0_pc);
+ STATIC_ASSERT(0_pc <= 100_pc);
+ STATIC_ASSERT(!(100_pc <= 0_pc));
+ STATIC_ASSERT(100_pc > 0_pc);
+ STATIC_ASSERT(!(100_pc > 100_pc));
+ STATIC_ASSERT(100_pc >= 0_pc);
+ STATIC_ASSERT(100_pc >= 100_pc);
+ STATIC_ASSERT(!(0_pc >= 100_pc));
+ // 0.5 is binary-friendly, so we can double it and compare it exactly.
+ STATIC_ASSERT_EQ(50_pc + 50_pc, 100_pc);
+
+#undef STATIC_ASSERT_EQ
+
+ printf("TestProportionValue done\n");
+}
+
+template <typename Arg0, typename... Args>
+bool AreAllEqual(Arg0&& aArg0, Args&&... aArgs) {
+ return ((aArg0 == aArgs) && ...);
+}
+
+void TestProgressLogger() {
+ printf("TestProgressLogger...\n");
+
+ using mozilla::ProgressLogger;
+ using mozilla::ProportionValue;
+ using namespace mozilla::literals::ProportionValue_literals;
+
+ auto progressRefPtr = mozilla::MakeRefPtr<ProgressLogger::SharedProgress>();
+ MOZ_RELEASE_ASSERT(progressRefPtr);
+ MOZ_RELEASE_ASSERT(progressRefPtr->Progress().IsExactlyZero());
+
+ {
+ ProgressLogger pl(progressRefPtr, "Started", "All done");
+ MOZ_RELEASE_ASSERT(progressRefPtr->Progress().IsExactlyZero());
+ MOZ_RELEASE_ASSERT(pl.GetGlobalProgress().IsExactlyZero());
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->LastLocation(),
+ pl.GetLastGlobalLocation(), "Started"));
+
+ // At this top level, the scale is 1:1.
+ pl.SetLocalProgress(10_pc, "Top 10%");
+ MOZ_RELEASE_ASSERT(
+ AreAllEqual(progressRefPtr->Progress(), pl.GetGlobalProgress(), 10_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->LastLocation(),
+ pl.GetLastGlobalLocation(), "Top 10%"));
+
+ pl.SetLocalProgress(0_pc, "Restarted");
+ MOZ_RELEASE_ASSERT(
+ AreAllEqual(progressRefPtr->Progress(), pl.GetGlobalProgress(), 0_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->LastLocation(),
+ pl.GetLastGlobalLocation(), "Restarted"));
+
+ {
+ // Create a sub-logger for the whole global range. Notice that this is
+ // moving the current progress back to 0.
+ ProgressLogger plSub1 =
+ pl.CreateSubLoggerFromTo(0_pc, "Sub1 started", 100_pc, "Sub1 ended");
+ MOZ_RELEASE_ASSERT(progressRefPtr->Progress().IsExactlyZero());
+ MOZ_RELEASE_ASSERT(pl.GetGlobalProgress().IsExactlyZero());
+ MOZ_RELEASE_ASSERT(plSub1.GetGlobalProgress().IsExactlyZero());
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), "Sub1 started"));
+
+ // At this level, the scale is still 1:1.
+ plSub1.SetLocalProgress(10_pc, "Sub1 10%");
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->Progress(),
+ pl.GetGlobalProgress(),
+ plSub1.GetGlobalProgress(), 10_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), "Sub1 10%"));
+
+ {
+ // Create a sub-logger half the global range.
+ // 0 0.25 0.375 0.5 0.625 0.75 1
+ // |---------------|-------|-------|-------|-------|---------------|
+ // plSub2: 0 0.25 0.5 0.75 1
+ ProgressLogger plSub2 = plSub1.CreateSubLoggerFromTo(
+ 25_pc, "Sub2 started", 75_pc, "Sub2 ended");
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->Progress(), pl.GetGlobalProgress(),
+ plSub1.GetGlobalProgress(), plSub2.GetGlobalProgress(), 25_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), plSub2.GetLastGlobalLocation(),
+ "Sub2 started"));
+
+ plSub2.SetLocalProgress(25_pc, "Sub2 25%");
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->Progress(), pl.GetGlobalProgress(),
+ plSub1.GetGlobalProgress(), plSub2.GetGlobalProgress(), 37.5_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), plSub2.GetLastGlobalLocation(),
+ "Sub2 25%"));
+
+ plSub2.SetLocalProgress(50_pc, "Sub2 50%");
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->Progress(), pl.GetGlobalProgress(),
+ plSub1.GetGlobalProgress(), plSub2.GetGlobalProgress(), 50_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), plSub2.GetLastGlobalLocation(),
+ "Sub2 50%"));
+
+ {
+ // Create a sub-logger half the parent range.
+ // 0 0.25 0.375 0.5 0.625 0.75 1
+ // |---------------|-------|-------|-------|-------|---------------|
+ // plSub2: 0 0.25 0.5 0.75 1
+ // plSub3: 0 0.5 1
+ ProgressLogger plSub3 = plSub2.CreateSubLoggerTo(
+ "Sub3 started", 100_pc, ProgressLogger::NO_LOCATION_UPDATE);
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->Progress(), pl.GetGlobalProgress(),
+ plSub1.GetGlobalProgress(), plSub2.GetGlobalProgress(),
+ plSub3.GetGlobalProgress(), 50_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), plSub2.GetLastGlobalLocation(),
+ plSub3.GetLastGlobalLocation(), "Sub3 started"));
+
+ plSub3.SetLocalProgress(50_pc, "Sub3 50%");
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->Progress(), pl.GetGlobalProgress(),
+ plSub1.GetGlobalProgress(), plSub2.GetGlobalProgress(),
+ plSub3.GetGlobalProgress(), 62.5_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), plSub2.GetLastGlobalLocation(),
+ plSub3.GetLastGlobalLocation(), "Sub3 50%"));
+ } // End of plSub3
+
+ // When plSub3 ends, progress moves to its 100%, which is also plSub2's
+ // 100%, which is plSub1's and the global progress of 75%
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->Progress(), pl.GetGlobalProgress(),
+ plSub1.GetGlobalProgress(), plSub2.GetGlobalProgress(), 75_pc));
+ // But location is still at the last explicit update.
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), plSub2.GetLastGlobalLocation(),
+ "Sub3 50%"));
+ } // End of plSub2
+
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->Progress(),
+ pl.GetGlobalProgress(),
+ plSub1.GetGlobalProgress(), 75_pc));
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ plSub1.GetLastGlobalLocation(), "Sub2 ended"));
+ } // End of plSub1
+
+ MOZ_RELEASE_ASSERT(progressRefPtr->Progress().IsExactlyOne());
+ MOZ_RELEASE_ASSERT(pl.GetGlobalProgress().IsExactlyOne());
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->LastLocation(),
+ pl.GetLastGlobalLocation(), "Sub1 ended"));
+
+ const auto loopStart = 75_pc;
+ const auto loopEnd = 87.5_pc;
+ const uint32_t loopCount = 8;
+ uint32_t expectedIndex = 0u;
+ auto expectedIterationStart = loopStart;
+ const auto iterationIncrement = (loopEnd - loopStart) / loopCount;
+ for (auto&& [index, loopPL] : pl.CreateLoopSubLoggersFromTo(
+ loopStart, loopEnd, loopCount, "looping...")) {
+ MOZ_RELEASE_ASSERT(index == expectedIndex);
+ ++expectedIndex;
+ MOZ_RELEASE_ASSERT(
+ AreAllEqual(progressRefPtr->Progress(), pl.GetGlobalProgress(),
+ loopPL.GetGlobalProgress(), expectedIterationStart));
+ MOZ_RELEASE_ASSERT(AreAllEqual(
+ progressRefPtr->LastLocation(), pl.GetLastGlobalLocation(),
+ loopPL.GetLastGlobalLocation(), "looping..."));
+
+ loopPL.SetLocalProgress(50_pc, "half");
+ MOZ_RELEASE_ASSERT(loopPL.GetGlobalProgress() ==
+ expectedIterationStart + iterationIncrement / 2u);
+ MOZ_RELEASE_ASSERT(
+ AreAllEqual(progressRefPtr->Progress(), pl.GetGlobalProgress(),
+ loopPL.GetGlobalProgress(),
+ expectedIterationStart + iterationIncrement / 2u));
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->LastLocation(),
+ pl.GetLastGlobalLocation(),
+ loopPL.GetLastGlobalLocation(), "half"));
+
+ expectedIterationStart = expectedIterationStart + iterationIncrement;
+ }
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->Progress(),
+ pl.GetGlobalProgress(),
+ expectedIterationStart));
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->LastLocation(),
+ pl.GetLastGlobalLocation(), "looping..."));
+ } // End of pl
+ MOZ_RELEASE_ASSERT(progressRefPtr->Progress().IsExactlyOne());
+ MOZ_RELEASE_ASSERT(AreAllEqual(progressRefPtr->LastLocation(), "All done"));
+
+ printf("TestProgressLogger done\n");
+}
+
+#ifdef MOZ_GECKO_PROFILER
+
+MOZ_MAYBE_UNUSED static void SleepMilli(unsigned aMilliseconds) {
+# if defined(_MSC_VER) || defined(__MINGW32__)
+ Sleep(aMilliseconds);
+# else
+ struct timespec ts = {/* .tv_sec */ static_cast<time_t>(aMilliseconds / 1000),
+ /* ts.tv_nsec */ long(aMilliseconds % 1000) * 1000000};
+ struct timespec tr = {0, 0};
+ while (nanosleep(&ts, &tr)) {
+ if (errno == EINTR) {
+ ts = tr;
+ } else {
+ printf("nanosleep() -> %s\n", strerror(errno));
+ exit(1);
+ }
+ }
+# endif
+}
+
+MOZ_MAYBE_UNUSED static void WaitUntilTimeStampChanges(
+ const mozilla::TimeStamp& aTimeStampToCompare = mozilla::TimeStamp::Now()) {
+ while (aTimeStampToCompare == mozilla::TimeStamp::Now()) {
+ SleepMilli(1);
+ }
+}
+
+using namespace mozilla;
+
+void TestPowerOfTwoMask() {
+ printf("TestPowerOfTwoMask...\n");
+
+ static_assert(MakePowerOfTwoMask<uint32_t, 0>().MaskValue() == 0);
+ constexpr PowerOfTwoMask<uint32_t> c0 = MakePowerOfTwoMask<uint32_t, 0>();
+ MOZ_RELEASE_ASSERT(c0.MaskValue() == 0);
+
+ static_assert(MakePowerOfTwoMask<uint32_t, 0xFFu>().MaskValue() == 0xFFu);
+ constexpr PowerOfTwoMask<uint32_t> cFF =
+ MakePowerOfTwoMask<uint32_t, 0xFFu>();
+ MOZ_RELEASE_ASSERT(cFF.MaskValue() == 0xFFu);
+
+ static_assert(MakePowerOfTwoMask<uint32_t, 0xFFFFFFFFu>().MaskValue() ==
+ 0xFFFFFFFFu);
+ constexpr PowerOfTwoMask<uint32_t> cFFFFFFFF =
+ MakePowerOfTwoMask<uint32_t, 0xFFFFFFFFu>();
+ MOZ_RELEASE_ASSERT(cFFFFFFFF.MaskValue() == 0xFFFFFFFFu);
+
+ struct TestDataU32 {
+ uint32_t mInput;
+ uint32_t mMask;
+ };
+ // clang-format off
+ TestDataU32 tests[] = {
+ { 0, 0 },
+ { 1, 1 },
+ { 2, 3 },
+ { 3, 3 },
+ { 4, 7 },
+ { 5, 7 },
+ { (1u << 31) - 1, (1u << 31) - 1 },
+ { (1u << 31), uint32_t(-1) },
+ { (1u << 31) + 1, uint32_t(-1) },
+ { uint32_t(-1), uint32_t(-1) }
+ };
+ // clang-format on
+ for (const TestDataU32& test : tests) {
+ PowerOfTwoMask<uint32_t> p2m(test.mInput);
+ MOZ_RELEASE_ASSERT(p2m.MaskValue() == test.mMask);
+ for (const TestDataU32& inner : tests) {
+ if (p2m.MaskValue() != uint32_t(-1)) {
+ MOZ_RELEASE_ASSERT((inner.mInput % p2m) ==
+ (inner.mInput % (p2m.MaskValue() + 1)));
+ }
+ MOZ_RELEASE_ASSERT((inner.mInput & p2m) == (inner.mInput % p2m));
+ MOZ_RELEASE_ASSERT((p2m & inner.mInput) == (inner.mInput & p2m));
+ }
+ }
+
+ printf("TestPowerOfTwoMask done\n");
+}
+
+void TestPowerOfTwo() {
+ printf("TestPowerOfTwo...\n");
+
+ static_assert(MakePowerOfTwo<uint32_t, 1>().Value() == 1);
+ constexpr PowerOfTwo<uint32_t> c1 = MakePowerOfTwo<uint32_t, 1>();
+ MOZ_RELEASE_ASSERT(c1.Value() == 1);
+ static_assert(MakePowerOfTwo<uint32_t, 1>().Mask().MaskValue() == 0);
+
+ static_assert(MakePowerOfTwo<uint32_t, 128>().Value() == 128);
+ constexpr PowerOfTwo<uint32_t> c128 = MakePowerOfTwo<uint32_t, 128>();
+ MOZ_RELEASE_ASSERT(c128.Value() == 128);
+ static_assert(MakePowerOfTwo<uint32_t, 128>().Mask().MaskValue() == 127);
+
+ static_assert(MakePowerOfTwo<uint32_t, 0x80000000u>().Value() == 0x80000000u);
+ constexpr PowerOfTwo<uint32_t> cMax = MakePowerOfTwo<uint32_t, 0x80000000u>();
+ MOZ_RELEASE_ASSERT(cMax.Value() == 0x80000000u);
+ static_assert(MakePowerOfTwo<uint32_t, 0x80000000u>().Mask().MaskValue() ==
+ 0x7FFFFFFFu);
+
+ struct TestDataU32 {
+ uint32_t mInput;
+ uint32_t mValue;
+ uint32_t mMask;
+ };
+ // clang-format off
+ TestDataU32 tests[] = {
+ { 0, 1, 0 },
+ { 1, 1, 0 },
+ { 2, 2, 1 },
+ { 3, 4, 3 },
+ { 4, 4, 3 },
+ { 5, 8, 7 },
+ { (1u << 31) - 1, (1u << 31), (1u << 31) - 1 },
+ { (1u << 31), (1u << 31), (1u << 31) - 1 },
+ { (1u << 31) + 1, (1u << 31), (1u << 31) - 1 },
+ { uint32_t(-1), (1u << 31), (1u << 31) - 1 }
+ };
+ // clang-format on
+ for (const TestDataU32& test : tests) {
+ PowerOfTwo<uint32_t> p2(test.mInput);
+ MOZ_RELEASE_ASSERT(p2.Value() == test.mValue);
+ MOZ_RELEASE_ASSERT(p2.MaskValue() == test.mMask);
+ PowerOfTwoMask<uint32_t> p2m = p2.Mask();
+ MOZ_RELEASE_ASSERT(p2m.MaskValue() == test.mMask);
+ for (const TestDataU32& inner : tests) {
+ MOZ_RELEASE_ASSERT((inner.mInput % p2) == (inner.mInput % p2.Value()));
+ }
+ }
+
+ printf("TestPowerOfTwo done\n");
+}
+
+void TestLEB128() {
+ printf("TestLEB128...\n");
+
+ MOZ_RELEASE_ASSERT(ULEB128MaxSize<uint8_t>() == 2);
+ MOZ_RELEASE_ASSERT(ULEB128MaxSize<uint16_t>() == 3);
+ MOZ_RELEASE_ASSERT(ULEB128MaxSize<uint32_t>() == 5);
+ MOZ_RELEASE_ASSERT(ULEB128MaxSize<uint64_t>() == 10);
+
+ struct TestDataU64 {
+ uint64_t mValue;
+ unsigned mSize;
+ const char* mBytes;
+ };
+ // clang-format off
+ TestDataU64 tests[] = {
+ // Small numbers should keep their normal byte representation.
+ { 0u, 1, "\0" },
+ { 1u, 1, "\x01" },
+
+ // 0111 1111 (127, or 0x7F) is the highest number that fits into a single
+ // LEB128 byte. It gets encoded as 0111 1111, note the most significant bit
+ // is off.
+ { 0x7Fu, 1, "\x7F" },
+
+ // Next number: 128, or 0x80.
+ // Original data representation: 1000 0000
+ // Broken up into groups of 7: 1 0000000
+ // Padded with 0 (msB) or 1 (lsB): 00000001 10000000
+ // Byte representation: 0x01 0x80
+ // Little endian order: -> 0x80 0x01
+ { 0x80u, 2, "\x80\x01" },
+
+ // Next: 129, or 0x81 (showing that we don't lose low bits.)
+ // Original data representation: 1000 0001
+ // Broken up into groups of 7: 1 0000001
+ // Padded with 0 (msB) or 1 (lsB): 00000001 10000001
+ // Byte representation: 0x01 0x81
+ // Little endian order: -> 0x81 0x01
+ { 0x81u, 2, "\x81\x01" },
+
+ // Highest 8-bit number: 255, or 0xFF.
+ // Original data representation: 1111 1111
+ // Broken up into groups of 7: 1 1111111
+ // Padded with 0 (msB) or 1 (lsB): 00000001 11111111
+ // Byte representation: 0x01 0xFF
+ // Little endian order: -> 0xFF 0x01
+ { 0xFFu, 2, "\xFF\x01" },
+
+ // Next: 256, or 0x100.
+ // Original data representation: 1 0000 0000
+ // Broken up into groups of 7: 10 0000000
+ // Padded with 0 (msB) or 1 (lsB): 00000010 10000000
+ // Byte representation: 0x10 0x80
+ // Little endian order: -> 0x80 0x02
+ { 0x100u, 2, "\x80\x02" },
+
+ // Highest 32-bit number: 0xFFFFFFFF (8 bytes, all bits set).
+ // Original: 1111 1111 1111 1111 1111 1111 1111 1111
+ // Groups: 1111 1111111 1111111 1111111 1111111
+ // Padded: 00001111 11111111 11111111 11111111 11111111
+ // Bytes: 0x0F 0xFF 0xFF 0xFF 0xFF
+ // Little Endian: -> 0xFF 0xFF 0xFF 0xFF 0x0F
+ { 0xFFFFFFFFu, 5, "\xFF\xFF\xFF\xFF\x0F" },
+
+ // Highest 64-bit number: 0xFFFFFFFFFFFFFFFF (16 bytes, all bits set).
+ // 64 bits, that's 9 groups of 7 bits, plus 1 (most significant) bit.
+ { 0xFFFFFFFFFFFFFFFFu, 10, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01" }
+ };
+ // clang-format on
+
+ for (const TestDataU64& test : tests) {
+ MOZ_RELEASE_ASSERT(ULEB128Size(test.mValue) == test.mSize);
+ // Prepare a buffer that can accomodate the largest-possible LEB128.
+ uint8_t buffer[ULEB128MaxSize<uint64_t>()];
+ // Use a pointer into the buffer as iterator.
+ uint8_t* p = buffer;
+ // And write the LEB128.
+ WriteULEB128(test.mValue, p);
+ // Pointer (iterator) should have advanced just past the expected LEB128
+ // size.
+ MOZ_RELEASE_ASSERT(p == buffer + test.mSize);
+ // Check expected bytes.
+ for (unsigned i = 0; i < test.mSize; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t(test.mBytes[i]));
+ }
+
+ // Move pointer (iterator) back to start of buffer.
+ p = buffer;
+ // And read the LEB128 we wrote above.
+ uint64_t read = ReadULEB128<uint64_t>(p);
+ // Pointer (iterator) should have also advanced just past the expected
+ // LEB128 size.
+ MOZ_RELEASE_ASSERT(p == buffer + test.mSize);
+ // And check the read value.
+ MOZ_RELEASE_ASSERT(read == test.mValue);
+
+ // Testing ULEB128 reader.
+ ULEB128Reader<uint64_t> reader;
+ MOZ_RELEASE_ASSERT(!reader.IsComplete());
+ // Move pointer back to start of buffer.
+ p = buffer;
+ for (;;) {
+ // Read a byte and feed it to the reader.
+ if (reader.FeedByteIsComplete(*p++)) {
+ break;
+ }
+ // Not complete yet, we shouldn't have reached the end pointer.
+ MOZ_RELEASE_ASSERT(!reader.IsComplete());
+ MOZ_RELEASE_ASSERT(p < buffer + test.mSize);
+ }
+ MOZ_RELEASE_ASSERT(reader.IsComplete());
+ // Pointer should have advanced just past the expected LEB128 size.
+ MOZ_RELEASE_ASSERT(p == buffer + test.mSize);
+ // And check the read value.
+ MOZ_RELEASE_ASSERT(reader.Value() == test.mValue);
+
+ // And again after a Reset.
+ reader.Reset();
+ MOZ_RELEASE_ASSERT(!reader.IsComplete());
+ p = buffer;
+ for (;;) {
+ if (reader.FeedByteIsComplete(*p++)) {
+ break;
+ }
+ MOZ_RELEASE_ASSERT(!reader.IsComplete());
+ MOZ_RELEASE_ASSERT(p < buffer + test.mSize);
+ }
+ MOZ_RELEASE_ASSERT(reader.IsComplete());
+ MOZ_RELEASE_ASSERT(p == buffer + test.mSize);
+ MOZ_RELEASE_ASSERT(reader.Value() == test.mValue);
+ }
+
+ printf("TestLEB128 done\n");
+}
+
+struct StringWriteFunc final : public JSONWriteFunc {
+ std::string mString;
+
+ void Write(const mozilla::Span<const char>& aStr) final {
+ mString.append(aStr.data(), aStr.size());
+ }
+};
+
+void CheckJSON(mozilla::baseprofiler::SpliceableJSONWriter& aWriter,
+ const char* aExpected, int aLine) {
+ const std::string& actual =
+ static_cast<StringWriteFunc&>(aWriter.WriteFunc()).mString;
+ if (strcmp(aExpected, actual.c_str()) != 0) {
+ fprintf(stderr,
+ "---- EXPECTED ---- (line %d)\n<<<%s>>>\n"
+ "---- ACTUAL ----\n<<<%s>>>\n",
+ aLine, aExpected, actual.c_str());
+ MOZ_RELEASE_ASSERT(false, "expected and actual output don't match");
+ }
+}
+
+void TestJSONTimeOutput() {
+ printf("TestJSONTimeOutput...\n");
+
+# define TEST(in, out) \
+ do { \
+ mozilla::baseprofiler::SpliceableJSONWriter writer( \
+ mozilla::MakeUnique<StringWriteFunc>(), \
+ FailureLatchInfallibleSource::Singleton()); \
+ writer.Start(); \
+ writer.TimeDoubleMsProperty("time_ms", (in)); \
+ writer.End(); \
+ CheckJSON(writer, "{\"time_ms\":" out "}", __LINE__); \
+ } while (false);
+
+ TEST(0, "0");
+
+ TEST(0.000'000'1, "0");
+ TEST(0.000'000'4, "0");
+ TEST(0.000'000'499, "0");
+ TEST(0.000'000'5, "0.000001");
+ TEST(0.000'001, "0.000001");
+ TEST(0.000'01, "0.00001");
+ TEST(0.000'1, "0.0001");
+ TEST(0.001, "0.001");
+ TEST(0.01, "0.01");
+ TEST(0.1, "0.1");
+ TEST(1, "1");
+ TEST(2, "2");
+ TEST(10, "10");
+ TEST(100, "100");
+ TEST(1'000, "1000");
+ TEST(10'000, "10000");
+ TEST(100'000, "100000");
+ TEST(1'000'000, "1000000");
+ // 2^53-2 ns in ms. 2^53-1 is the highest integer value representable in
+ // double, -1 again because we're adding 0.5 before truncating.
+ // That's 104 days, after which the nanosecond precision would decrease.
+ TEST(9'007'199'254.740'990, "9007199254.74099");
+
+ TEST(-0.000'000'1, "0");
+ TEST(-0.000'000'4, "0");
+ TEST(-0.000'000'499, "0");
+ TEST(-0.000'000'5, "-0.000001");
+ TEST(-0.000'001, "-0.000001");
+ TEST(-0.000'01, "-0.00001");
+ TEST(-0.000'1, "-0.0001");
+ TEST(-0.001, "-0.001");
+ TEST(-0.01, "-0.01");
+ TEST(-0.1, "-0.1");
+ TEST(-1, "-1");
+ TEST(-2, "-2");
+ TEST(-10, "-10");
+ TEST(-100, "-100");
+ TEST(-1'000, "-1000");
+ TEST(-10'000, "-10000");
+ TEST(-100'000, "-100000");
+ TEST(-1'000'000, "-1000000");
+ TEST(-9'007'199'254.740'990, "-9007199254.74099");
+
+# undef TEST
+
+ printf("TestJSONTimeOutput done\n");
+}
+
+template <uint8_t byte, uint8_t... tail>
+constexpr bool TestConstexprULEB128Reader(ULEB128Reader<uint64_t>& aReader) {
+ if (aReader.IsComplete()) {
+ return false;
+ }
+ const bool isComplete = aReader.FeedByteIsComplete(byte);
+ if (aReader.IsComplete() != isComplete) {
+ return false;
+ }
+ if constexpr (sizeof...(tail) == 0) {
+ return isComplete;
+ } else {
+ if (isComplete) {
+ return false;
+ }
+ return TestConstexprULEB128Reader<tail...>(aReader);
+ }
+}
+
+template <uint64_t expected, uint8_t... bytes>
+constexpr bool TestConstexprULEB128Reader() {
+ ULEB128Reader<uint64_t> reader;
+ if (!TestConstexprULEB128Reader<bytes...>(reader)) {
+ return false;
+ }
+ if (!reader.IsComplete()) {
+ return false;
+ }
+ if (reader.Value() != expected) {
+ return false;
+ }
+
+ reader.Reset();
+ if (!TestConstexprULEB128Reader<bytes...>(reader)) {
+ return false;
+ }
+ if (!reader.IsComplete()) {
+ return false;
+ }
+ if (reader.Value() != expected) {
+ return false;
+ }
+
+ return true;
+}
+
+static_assert(TestConstexprULEB128Reader<0x0u, 0x0u>());
+static_assert(!TestConstexprULEB128Reader<0x0u, 0x0u, 0x0u>());
+static_assert(TestConstexprULEB128Reader<0x1u, 0x1u>());
+static_assert(TestConstexprULEB128Reader<0x7Fu, 0x7Fu>());
+static_assert(TestConstexprULEB128Reader<0x80u, 0x80u, 0x01u>());
+static_assert(!TestConstexprULEB128Reader<0x80u, 0x80u>());
+static_assert(!TestConstexprULEB128Reader<0x80u, 0x01u>());
+static_assert(TestConstexprULEB128Reader<0x81u, 0x81u, 0x01u>());
+static_assert(TestConstexprULEB128Reader<0xFFu, 0xFFu, 0x01u>());
+static_assert(TestConstexprULEB128Reader<0x100u, 0x80u, 0x02u>());
+static_assert(TestConstexprULEB128Reader<0xFFFFFFFFu, 0xFFu, 0xFFu, 0xFFu,
+ 0xFFu, 0x0Fu>());
+static_assert(
+ !TestConstexprULEB128Reader<0xFFFFFFFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu>());
+static_assert(!TestConstexprULEB128Reader<0xFFFFFFFFu, 0xFFu, 0xFFu, 0xFFu,
+ 0xFFu, 0xFFu, 0x0Fu>());
+static_assert(
+ TestConstexprULEB128Reader<0xFFFFFFFFFFFFFFFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu,
+ 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0x01u>());
+static_assert(
+ !TestConstexprULEB128Reader<0xFFFFFFFFFFFFFFFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu,
+ 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu>());
+
+static void TestChunk() {
+ printf("TestChunk...\n");
+
+ static_assert(!std::is_default_constructible_v<ProfileBufferChunk>,
+ "ProfileBufferChunk should not be default-constructible");
+ static_assert(
+ !std::is_constructible_v<ProfileBufferChunk, ProfileBufferChunk::Length>,
+ "ProfileBufferChunk should not be constructible from Length");
+
+ static_assert(
+ sizeof(ProfileBufferChunk::Header) ==
+ sizeof(ProfileBufferChunk::Header::mOffsetFirstBlock) +
+ sizeof(ProfileBufferChunk::Header::mOffsetPastLastBlock) +
+ sizeof(ProfileBufferChunk::Header::mStartTimeStamp) +
+ sizeof(ProfileBufferChunk::Header::mDoneTimeStamp) +
+ sizeof(ProfileBufferChunk::Header::mBufferBytes) +
+ sizeof(ProfileBufferChunk::Header::mBlockCount) +
+ sizeof(ProfileBufferChunk::Header::mRangeStart) +
+ sizeof(ProfileBufferChunk::Header::mProcessId) +
+ sizeof(ProfileBufferChunk::Header::mPADDING),
+ "ProfileBufferChunk::Header may have unwanted padding, please review");
+ // Note: The above static_assert is an attempt at keeping
+ // ProfileBufferChunk::Header tightly packed, but some changes could make this
+ // impossible to achieve (most probably due to alignment) -- Just do your
+ // best!
+
+ constexpr ProfileBufferChunk::Length TestLen = 1000;
+
+ // Basic allocations of different sizes.
+ for (ProfileBufferChunk::Length len = 0; len <= TestLen; ++len) {
+ auto chunk = ProfileBufferChunk::Create(len);
+ static_assert(
+ std::is_same_v<decltype(chunk), UniquePtr<ProfileBufferChunk>>,
+ "ProfileBufferChunk::Create() should return a "
+ "UniquePtr<ProfileBufferChunk>");
+ MOZ_RELEASE_ASSERT(!!chunk, "OOM!?");
+ MOZ_RELEASE_ASSERT(chunk->BufferBytes() >= len);
+ MOZ_RELEASE_ASSERT(chunk->ChunkBytes() >=
+ len + ProfileBufferChunk::SizeofChunkMetadata());
+ MOZ_RELEASE_ASSERT(chunk->RemainingBytes() == chunk->BufferBytes());
+ MOZ_RELEASE_ASSERT(chunk->OffsetFirstBlock() == 0);
+ MOZ_RELEASE_ASSERT(chunk->OffsetPastLastBlock() == 0);
+ MOZ_RELEASE_ASSERT(chunk->BlockCount() == 0);
+ MOZ_RELEASE_ASSERT(chunk->ProcessId() == 0);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 0);
+ MOZ_RELEASE_ASSERT(chunk->BufferSpan().LengthBytes() ==
+ chunk->BufferBytes());
+ MOZ_RELEASE_ASSERT(!chunk->GetNext());
+ MOZ_RELEASE_ASSERT(!chunk->ReleaseNext());
+ MOZ_RELEASE_ASSERT(chunk->Last() == chunk.get());
+ }
+
+ // Allocate the main test Chunk.
+ auto chunkA = ProfileBufferChunk::Create(TestLen);
+ MOZ_RELEASE_ASSERT(!!chunkA, "OOM!?");
+ MOZ_RELEASE_ASSERT(chunkA->BufferBytes() >= TestLen);
+ MOZ_RELEASE_ASSERT(chunkA->ChunkBytes() >=
+ TestLen + ProfileBufferChunk::SizeofChunkMetadata());
+ MOZ_RELEASE_ASSERT(!chunkA->GetNext());
+ MOZ_RELEASE_ASSERT(!chunkA->ReleaseNext());
+
+ constexpr ProfileBufferIndex chunkARangeStart = 12345;
+ chunkA->SetRangeStart(chunkARangeStart);
+ MOZ_RELEASE_ASSERT(chunkA->RangeStart() == chunkARangeStart);
+
+ // Get a read-only span over its buffer.
+ auto bufferA = chunkA->BufferSpan();
+ static_assert(
+ std::is_same_v<decltype(bufferA), Span<const ProfileBufferChunk::Byte>>,
+ "BufferSpan() should return a Span<const Byte>");
+ MOZ_RELEASE_ASSERT(bufferA.LengthBytes() == chunkA->BufferBytes());
+
+ // Add the initial tail block.
+ constexpr ProfileBufferChunk::Length initTailLen = 10;
+ auto initTail = chunkA->ReserveInitialBlockAsTail(initTailLen);
+ static_assert(
+ std::is_same_v<decltype(initTail), Span<ProfileBufferChunk::Byte>>,
+ "ReserveInitialBlockAsTail() should return a Span<Byte>");
+ MOZ_RELEASE_ASSERT(initTail.LengthBytes() == initTailLen);
+ MOZ_RELEASE_ASSERT(initTail.Elements() == bufferA.Elements());
+ MOZ_RELEASE_ASSERT(chunkA->OffsetFirstBlock() == initTailLen);
+ MOZ_RELEASE_ASSERT(chunkA->OffsetPastLastBlock() == initTailLen);
+
+ // Add the first complete block.
+ constexpr ProfileBufferChunk::Length block1Len = 20;
+ auto block1 = chunkA->ReserveBlock(block1Len);
+ static_assert(
+ std::is_same_v<decltype(block1), ProfileBufferChunk::ReserveReturn>,
+ "ReserveBlock() should return a ReserveReturn");
+ MOZ_RELEASE_ASSERT(block1.mBlockRangeIndex.ConvertToProfileBufferIndex() ==
+ chunkARangeStart + initTailLen);
+ MOZ_RELEASE_ASSERT(block1.mSpan.LengthBytes() == block1Len);
+ MOZ_RELEASE_ASSERT(block1.mSpan.Elements() ==
+ bufferA.Elements() + initTailLen);
+ MOZ_RELEASE_ASSERT(chunkA->OffsetFirstBlock() == initTailLen);
+ MOZ_RELEASE_ASSERT(chunkA->OffsetPastLastBlock() == initTailLen + block1Len);
+ MOZ_RELEASE_ASSERT(chunkA->RemainingBytes() != 0);
+
+ // Add another block to over-fill the ProfileBufferChunk.
+ const ProfileBufferChunk::Length remaining =
+ chunkA->BufferBytes() - (initTailLen + block1Len);
+ constexpr ProfileBufferChunk::Length overfill = 30;
+ const ProfileBufferChunk::Length block2Len = remaining + overfill;
+ ProfileBufferChunk::ReserveReturn block2 = chunkA->ReserveBlock(block2Len);
+ MOZ_RELEASE_ASSERT(block2.mBlockRangeIndex.ConvertToProfileBufferIndex() ==
+ chunkARangeStart + initTailLen + block1Len);
+ MOZ_RELEASE_ASSERT(block2.mSpan.LengthBytes() == remaining);
+ MOZ_RELEASE_ASSERT(block2.mSpan.Elements() ==
+ bufferA.Elements() + initTailLen + block1Len);
+ MOZ_RELEASE_ASSERT(chunkA->OffsetFirstBlock() == initTailLen);
+ MOZ_RELEASE_ASSERT(chunkA->OffsetPastLastBlock() == chunkA->BufferBytes());
+ MOZ_RELEASE_ASSERT(chunkA->RemainingBytes() == 0);
+
+ // Block must be marked "done" before it can be recycled.
+ chunkA->MarkDone();
+
+ // It must be marked "recycled" before data can be added to it again.
+ chunkA->MarkRecycled();
+
+ // Add an empty initial tail block.
+ Span<ProfileBufferChunk::Byte> initTail2 =
+ chunkA->ReserveInitialBlockAsTail(0);
+ MOZ_RELEASE_ASSERT(initTail2.LengthBytes() == 0);
+ MOZ_RELEASE_ASSERT(initTail2.Elements() == bufferA.Elements());
+ MOZ_RELEASE_ASSERT(chunkA->OffsetFirstBlock() == 0);
+ MOZ_RELEASE_ASSERT(chunkA->OffsetPastLastBlock() == 0);
+
+ // Block must be marked "done" before it can be destroyed.
+ chunkA->MarkDone();
+
+ chunkA->SetProcessId(123);
+ MOZ_RELEASE_ASSERT(chunkA->ProcessId() == 123);
+
+ printf("TestChunk done\n");
+}
+
+static void TestChunkManagerSingle() {
+ printf("TestChunkManagerSingle...\n");
+
+ // Construct a ProfileBufferChunkManagerSingle for one chunk of size >=1000.
+ constexpr ProfileBufferChunk::Length ChunkMinBufferBytes = 1000;
+ ProfileBufferChunkManagerSingle cms{ChunkMinBufferBytes};
+
+ // Reference to base class, to exercize virtual methods.
+ ProfileBufferChunkManager& cm = cms;
+
+# ifdef DEBUG
+ const char* chunkManagerRegisterer = "TestChunkManagerSingle";
+ cm.RegisteredWith(chunkManagerRegisterer);
+# endif // DEBUG
+
+ const auto maxTotalSize = cm.MaxTotalSize();
+ MOZ_RELEASE_ASSERT(maxTotalSize >= ChunkMinBufferBytes);
+
+ cm.SetChunkDestroyedCallback([](const ProfileBufferChunk&) {
+ MOZ_RELEASE_ASSERT(
+ false,
+ "ProfileBufferChunkManagerSingle should never destroy its one chunk");
+ });
+
+ UniquePtr<ProfileBufferChunk> extantReleasedChunks =
+ cm.GetExtantReleasedChunks();
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Unexpected released chunk(s)");
+
+ // First request.
+ UniquePtr<ProfileBufferChunk> chunk = cm.GetChunk();
+ MOZ_RELEASE_ASSERT(!!chunk, "First chunk request should always work");
+ MOZ_RELEASE_ASSERT(chunk->BufferBytes() >= ChunkMinBufferBytes,
+ "Unexpected chunk size");
+ MOZ_RELEASE_ASSERT(!chunk->GetNext(), "There should only be one chunk");
+
+ // Keep address, for later checks.
+ const uintptr_t chunkAddress = reinterpret_cast<uintptr_t>(chunk.get());
+
+ extantReleasedChunks = cm.GetExtantReleasedChunks();
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Unexpected released chunk(s)");
+
+ // Second request.
+ MOZ_RELEASE_ASSERT(!cm.GetChunk(), "Second chunk request should always fail");
+
+ extantReleasedChunks = cm.GetExtantReleasedChunks();
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Unexpected released chunk(s)");
+
+ // Add some data to the chunk (to verify recycling later on).
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetFirstBlock == 0);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetPastLastBlock == 0);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 0);
+ chunk->SetRangeStart(100);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 100);
+ Unused << chunk->ReserveInitialBlockAsTail(1);
+ Unused << chunk->ReserveBlock(2);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetFirstBlock == 1);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetPastLastBlock == 1 + 2);
+
+ // Release the first chunk.
+ chunk->MarkDone();
+ cm.ReleaseChunk(std::move(chunk));
+ MOZ_RELEASE_ASSERT(!chunk, "chunk UniquePtr should have been moved-from");
+
+ // Request after release.
+ MOZ_RELEASE_ASSERT(!cm.GetChunk(),
+ "Chunk request after release should also fail");
+
+ // Check released chunk.
+ extantReleasedChunks = cm.GetExtantReleasedChunks();
+ MOZ_RELEASE_ASSERT(!!extantReleasedChunks,
+ "Could not retrieve released chunk");
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks->GetNext(),
+ "There should only be one released chunk");
+ MOZ_RELEASE_ASSERT(
+ reinterpret_cast<uintptr_t>(extantReleasedChunks.get()) == chunkAddress,
+ "Released chunk should be first requested one");
+
+ MOZ_RELEASE_ASSERT(!cm.GetExtantReleasedChunks(),
+ "Unexpected extra released chunk(s)");
+
+ // Another request after release.
+ MOZ_RELEASE_ASSERT(!cm.GetChunk(),
+ "Chunk request after release should also fail");
+
+ MOZ_RELEASE_ASSERT(
+ cm.MaxTotalSize() == maxTotalSize,
+ "MaxTotalSize() should not change after requests&releases");
+
+ // Reset the chunk manager. (Single-only non-virtual function.)
+ cms.Reset(std::move(extantReleasedChunks));
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks,
+ "Released chunk UniquePtr should have been moved-from");
+
+ MOZ_RELEASE_ASSERT(
+ cm.MaxTotalSize() == maxTotalSize,
+ "MaxTotalSize() should not change when resetting with the same chunk");
+
+ // 2nd round, first request. Theoretically async, but this implementation just
+ // immediately runs the callback.
+ bool ran = false;
+ cm.RequestChunk([&](UniquePtr<ProfileBufferChunk> aChunk) {
+ ran = true;
+ MOZ_RELEASE_ASSERT(!!aChunk);
+ chunk = std::move(aChunk);
+ });
+ MOZ_RELEASE_ASSERT(ran, "RequestChunk callback not called immediately");
+ ran = false;
+ cm.FulfillChunkRequests();
+ MOZ_RELEASE_ASSERT(!ran, "FulfillChunkRequests should not have any effects");
+ MOZ_RELEASE_ASSERT(!!chunk, "First chunk request should always work");
+ MOZ_RELEASE_ASSERT(chunk->BufferBytes() >= ChunkMinBufferBytes,
+ "Unexpected chunk size");
+ MOZ_RELEASE_ASSERT(!chunk->GetNext(), "There should only be one chunk");
+ MOZ_RELEASE_ASSERT(reinterpret_cast<uintptr_t>(chunk.get()) == chunkAddress,
+ "Requested chunk should be first requested one");
+ // Verify that chunk is empty and usable.
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetFirstBlock == 0);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetPastLastBlock == 0);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 0);
+ chunk->SetRangeStart(200);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 200);
+ Unused << chunk->ReserveInitialBlockAsTail(3);
+ Unused << chunk->ReserveBlock(4);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetFirstBlock == 3);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetPastLastBlock == 3 + 4);
+
+ // Second request.
+ ran = false;
+ cm.RequestChunk([&](UniquePtr<ProfileBufferChunk> aChunk) {
+ ran = true;
+ MOZ_RELEASE_ASSERT(!aChunk, "Second chunk request should always fail");
+ });
+ MOZ_RELEASE_ASSERT(ran, "RequestChunk callback not called");
+
+ // This one does nothing.
+ cm.ForgetUnreleasedChunks();
+
+ // Don't forget to mark chunk "Done" before letting it die.
+ chunk->MarkDone();
+ chunk = nullptr;
+
+ // Create a tiny chunk and reset the chunk manager with it.
+ chunk = ProfileBufferChunk::Create(1);
+ MOZ_RELEASE_ASSERT(!!chunk);
+ auto tinyChunkSize = chunk->BufferBytes();
+ MOZ_RELEASE_ASSERT(tinyChunkSize >= 1);
+ MOZ_RELEASE_ASSERT(tinyChunkSize < ChunkMinBufferBytes);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 0);
+ chunk->SetRangeStart(300);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 300);
+ cms.Reset(std::move(chunk));
+ MOZ_RELEASE_ASSERT(!chunk, "chunk UniquePtr should have been moved-from");
+ MOZ_RELEASE_ASSERT(cm.MaxTotalSize() == tinyChunkSize,
+ "MaxTotalSize() should match the new chunk size");
+ chunk = cm.GetChunk();
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 0, "Got non-recycled chunk");
+
+ // Enough testing! Clean-up.
+ Unused << chunk->ReserveInitialBlockAsTail(0);
+ chunk->MarkDone();
+ cm.ForgetUnreleasedChunks();
+
+# ifdef DEBUG
+ cm.DeregisteredFrom(chunkManagerRegisterer);
+# endif // DEBUG
+
+ printf("TestChunkManagerSingle done\n");
+}
+
+static void TestChunkManagerWithLocalLimit() {
+ printf("TestChunkManagerWithLocalLimit...\n");
+
+ // Construct a ProfileBufferChunkManagerWithLocalLimit with chunk of minimum
+ // size >=100, up to 1000 bytes.
+ constexpr ProfileBufferChunk::Length MaxTotalBytes = 1000;
+ constexpr ProfileBufferChunk::Length ChunkMinBufferBytes = 100;
+ ProfileBufferChunkManagerWithLocalLimit cmll{MaxTotalBytes,
+ ChunkMinBufferBytes};
+
+ // Reference to base class, to exercize virtual methods.
+ ProfileBufferChunkManager& cm = cmll;
+
+# ifdef DEBUG
+ const char* chunkManagerRegisterer = "TestChunkManagerWithLocalLimit";
+ cm.RegisteredWith(chunkManagerRegisterer);
+# endif // DEBUG
+
+ MOZ_RELEASE_ASSERT(cm.MaxTotalSize() == MaxTotalBytes,
+ "Max total size should be exactly as given");
+
+ unsigned destroyedChunks = 0;
+ unsigned destroyedBytes = 0;
+ cm.SetChunkDestroyedCallback([&](const ProfileBufferChunk& aChunks) {
+ for (const ProfileBufferChunk* chunk = &aChunks; chunk;
+ chunk = chunk->GetNext()) {
+ destroyedChunks += 1;
+ destroyedBytes += chunk->BufferBytes();
+ }
+ });
+
+ UniquePtr<ProfileBufferChunk> extantReleasedChunks =
+ cm.GetExtantReleasedChunks();
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Unexpected released chunk(s)");
+
+ // First request.
+ UniquePtr<ProfileBufferChunk> chunk = cm.GetChunk();
+ MOZ_RELEASE_ASSERT(!!chunk,
+ "First chunk immediate request should always work");
+ const auto chunkActualBufferBytes = chunk->BufferBytes();
+ MOZ_RELEASE_ASSERT(chunkActualBufferBytes >= ChunkMinBufferBytes,
+ "Unexpected chunk size");
+ MOZ_RELEASE_ASSERT(!chunk->GetNext(), "There should only be one chunk");
+
+ // Keep address, for later checks.
+ const uintptr_t chunk1Address = reinterpret_cast<uintptr_t>(chunk.get());
+
+ extantReleasedChunks = cm.GetExtantReleasedChunks();
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Unexpected released chunk(s)");
+
+ // Verify that ReleaseChunk accepts zero chunks.
+ cm.ReleaseChunk(nullptr);
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Unexpected released chunk(s)");
+
+ // For this test, we need to be able to get at least 2 chunks without hitting
+ // the limit. (If this failed, it wouldn't necessary be a problem with
+ // ProfileBufferChunkManagerWithLocalLimit, fiddle with constants at the top
+ // of this test.)
+ MOZ_RELEASE_ASSERT(chunkActualBufferBytes < 2 * MaxTotalBytes);
+
+ unsigned chunk1ReuseCount = 0;
+
+ // We will do enough loops to go through the maximum size a number of times.
+ const unsigned Rollovers = 3;
+ const unsigned Loops = Rollovers * MaxTotalBytes / chunkActualBufferBytes;
+ for (unsigned i = 0; i < Loops; ++i) {
+ // Add some data to the chunk.
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetFirstBlock == 0);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetPastLastBlock == 0);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == 0);
+ const ProfileBufferIndex index = 1 + i * chunkActualBufferBytes;
+ chunk->SetRangeStart(index);
+ MOZ_RELEASE_ASSERT(chunk->RangeStart() == index);
+ Unused << chunk->ReserveInitialBlockAsTail(1);
+ Unused << chunk->ReserveBlock(2);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetFirstBlock == 1);
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mOffsetPastLastBlock == 1 + 2);
+
+ // Request a new chunk.
+ bool ran = false;
+ UniquePtr<ProfileBufferChunk> newChunk;
+ cm.RequestChunk([&](UniquePtr<ProfileBufferChunk> aChunk) {
+ ran = true;
+ newChunk = std::move(aChunk);
+ });
+ MOZ_RELEASE_ASSERT(
+ !ran, "RequestChunk should not immediately fulfill the request");
+ cm.FulfillChunkRequests();
+ MOZ_RELEASE_ASSERT(ran, "FulfillChunkRequests should invoke the callback");
+ MOZ_RELEASE_ASSERT(!!newChunk, "Chunk request should always work");
+ MOZ_RELEASE_ASSERT(newChunk->BufferBytes() == chunkActualBufferBytes,
+ "Unexpected chunk size");
+ MOZ_RELEASE_ASSERT(!newChunk->GetNext(), "There should only be one chunk");
+
+ // Mark previous chunk done and release it.
+ WaitUntilTimeStampChanges(); // Force "done" timestamp to change.
+ chunk->MarkDone();
+ cm.ReleaseChunk(std::move(chunk));
+
+ // And cycle to the new chunk.
+ chunk = std::move(newChunk);
+
+ if (reinterpret_cast<uintptr_t>(chunk.get()) == chunk1Address) {
+ ++chunk1ReuseCount;
+ }
+ }
+
+ // Expect all rollovers except 1 to destroy chunks.
+ MOZ_RELEASE_ASSERT(destroyedChunks >= (Rollovers - 1) * MaxTotalBytes /
+ chunkActualBufferBytes,
+ "Not enough destroyed chunks");
+ MOZ_RELEASE_ASSERT(destroyedBytes == destroyedChunks * chunkActualBufferBytes,
+ "Mismatched destroyed chunks and bytes");
+ MOZ_RELEASE_ASSERT(chunk1ReuseCount >= (Rollovers - 1),
+ "Not enough reuse of the first chunks");
+
+ // Check that chunk manager is reentrant from request callback.
+ bool ran = false;
+ bool ranInner = false;
+ UniquePtr<ProfileBufferChunk> newChunk;
+ cm.RequestChunk([&](UniquePtr<ProfileBufferChunk> aChunk) {
+ ran = true;
+ MOZ_RELEASE_ASSERT(!!aChunk, "Chunk request should always work");
+ Unused << aChunk->ReserveInitialBlockAsTail(0);
+ WaitUntilTimeStampChanges(); // Force "done" timestamp to change.
+ aChunk->MarkDone();
+ UniquePtr<ProfileBufferChunk> anotherChunk = cm.GetChunk();
+ MOZ_RELEASE_ASSERT(!!anotherChunk);
+ Unused << anotherChunk->ReserveInitialBlockAsTail(0);
+ WaitUntilTimeStampChanges(); // Force "done" timestamp to change.
+ anotherChunk->MarkDone();
+ cm.RequestChunk([&](UniquePtr<ProfileBufferChunk> aChunk) {
+ ranInner = true;
+ MOZ_RELEASE_ASSERT(!!aChunk, "Chunk request should always work");
+ Unused << aChunk->ReserveInitialBlockAsTail(0);
+ WaitUntilTimeStampChanges(); // Force "done" timestamp to change.
+ aChunk->MarkDone();
+ });
+ MOZ_RELEASE_ASSERT(
+ !ranInner, "RequestChunk should not immediately fulfill the request");
+ });
+ MOZ_RELEASE_ASSERT(!ran,
+ "RequestChunk should not immediately fulfill the request");
+ MOZ_RELEASE_ASSERT(
+ !ranInner,
+ "RequestChunk should not immediately fulfill the inner request");
+ cm.FulfillChunkRequests();
+ MOZ_RELEASE_ASSERT(ran, "FulfillChunkRequests should invoke the callback");
+ MOZ_RELEASE_ASSERT(!ranInner,
+ "FulfillChunkRequests should not immediately fulfill "
+ "the inner request");
+ cm.FulfillChunkRequests();
+ MOZ_RELEASE_ASSERT(
+ ran, "2nd FulfillChunkRequests should invoke the inner request callback");
+
+ // Enough testing! Clean-up.
+ Unused << chunk->ReserveInitialBlockAsTail(0);
+ WaitUntilTimeStampChanges(); // Force "done" timestamp to change.
+ chunk->MarkDone();
+ cm.ForgetUnreleasedChunks();
+
+ // Special testing of the release algorithm, to make sure released chunks get
+ // sorted.
+ constexpr unsigned RandomReleaseChunkLoop = 100;
+ // Build a vector of chunks, and mark them "done", ready to be released.
+ Vector<UniquePtr<ProfileBufferChunk>> chunksToRelease;
+ MOZ_RELEASE_ASSERT(chunksToRelease.reserve(RandomReleaseChunkLoop));
+ Vector<TimeStamp> chunksTimeStamps;
+ MOZ_RELEASE_ASSERT(chunksTimeStamps.reserve(RandomReleaseChunkLoop));
+ for (unsigned i = 0; i < RandomReleaseChunkLoop; ++i) {
+ UniquePtr<ProfileBufferChunk> chunk = cm.GetChunk();
+ MOZ_RELEASE_ASSERT(chunk);
+ Unused << chunk->ReserveInitialBlockAsTail(0);
+ chunk->MarkDone();
+ MOZ_RELEASE_ASSERT(!chunk->ChunkHeader().mDoneTimeStamp.IsNull());
+ chunksTimeStamps.infallibleEmplaceBack(chunk->ChunkHeader().mDoneTimeStamp);
+ chunksToRelease.infallibleEmplaceBack(std::move(chunk));
+ if (i % 10 == 0) {
+ // "Done" timestamps should *usually* increase, let's make extra sure some
+ // timestamps are actually different.
+ WaitUntilTimeStampChanges();
+ }
+ }
+ // Shuffle the list.
+ std::random_device randomDevice;
+ std::mt19937 generator(randomDevice());
+ std::shuffle(chunksToRelease.begin(), chunksToRelease.end(), generator);
+ // And release chunks one by one, checking that the list of released chunks
+ // is always sorted.
+ printf("TestChunkManagerWithLocalLimit - Shuffle test timestamps:");
+ for (unsigned i = 0; i < RandomReleaseChunkLoop; ++i) {
+ printf(" %f", (chunksToRelease[i]->ChunkHeader().mDoneTimeStamp -
+ TimeStamp::ProcessCreation())
+ .ToMicroseconds());
+ cm.ReleaseChunk(std::move(chunksToRelease[i]));
+ cm.PeekExtantReleasedChunks([i](const ProfileBufferChunk* releasedChunks) {
+ MOZ_RELEASE_ASSERT(releasedChunks);
+ unsigned releasedChunkCount = 1;
+ for (;;) {
+ const ProfileBufferChunk* nextChunk = releasedChunks->GetNext();
+ if (!nextChunk) {
+ break;
+ }
+ ++releasedChunkCount;
+ MOZ_RELEASE_ASSERT(releasedChunks->ChunkHeader().mDoneTimeStamp <=
+ nextChunk->ChunkHeader().mDoneTimeStamp);
+ releasedChunks = nextChunk;
+ }
+ MOZ_RELEASE_ASSERT(releasedChunkCount == i + 1);
+ });
+ }
+ printf("\n");
+ // Finally, the whole list of released chunks should have the exact same
+ // timestamps as the initial list of "done" chunks.
+ extantReleasedChunks = cm.GetExtantReleasedChunks();
+ for (unsigned i = 0; i < RandomReleaseChunkLoop; ++i) {
+ MOZ_RELEASE_ASSERT(extantReleasedChunks, "Not enough released chunks");
+ MOZ_RELEASE_ASSERT(extantReleasedChunks->ChunkHeader().mDoneTimeStamp ==
+ chunksTimeStamps[i]);
+ Unused << std::exchange(extantReleasedChunks,
+ extantReleasedChunks->ReleaseNext());
+ }
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Too many released chunks");
+
+# ifdef DEBUG
+ cm.DeregisteredFrom(chunkManagerRegisterer);
+# endif // DEBUG
+
+ printf("TestChunkManagerWithLocalLimit done\n");
+}
+
+static bool IsSameMetadata(
+ const ProfileBufferControlledChunkManager::ChunkMetadata& a1,
+ const ProfileBufferControlledChunkManager::ChunkMetadata& a2) {
+ return a1.mDoneTimeStamp == a2.mDoneTimeStamp &&
+ a1.mBufferBytes == a2.mBufferBytes;
+};
+
+static bool IsSameUpdate(
+ const ProfileBufferControlledChunkManager::Update& a1,
+ const ProfileBufferControlledChunkManager::Update& a2) {
+ // Final and not-an-update don't carry other data, so we can test these two
+ // states first.
+ if (a1.IsFinal() || a2.IsFinal()) {
+ return a1.IsFinal() && a2.IsFinal();
+ }
+ if (a1.IsNotUpdate() || a2.IsNotUpdate()) {
+ return a1.IsNotUpdate() && a2.IsNotUpdate();
+ }
+
+ // Here, both are "normal" udpates, check member variables:
+
+ if (a1.UnreleasedBytes() != a2.UnreleasedBytes()) {
+ return false;
+ }
+ if (a1.ReleasedBytes() != a2.ReleasedBytes()) {
+ return false;
+ }
+ if (a1.OldestDoneTimeStamp() != a2.OldestDoneTimeStamp()) {
+ return false;
+ }
+ if (a1.NewlyReleasedChunksRef().size() !=
+ a2.NewlyReleasedChunksRef().size()) {
+ return false;
+ }
+ for (unsigned i = 0; i < a1.NewlyReleasedChunksRef().size(); ++i) {
+ if (!IsSameMetadata(a1.NewlyReleasedChunksRef()[i],
+ a2.NewlyReleasedChunksRef()[i])) {
+ return false;
+ }
+ }
+ return true;
+}
+
+static void TestControlledChunkManagerUpdate() {
+ printf("TestControlledChunkManagerUpdate...\n");
+
+ using Update = ProfileBufferControlledChunkManager::Update;
+
+ // Default construction.
+ Update update1;
+ MOZ_RELEASE_ASSERT(update1.IsNotUpdate());
+ MOZ_RELEASE_ASSERT(!update1.IsFinal());
+
+ // Clear an already-cleared update.
+ update1.Clear();
+ MOZ_RELEASE_ASSERT(update1.IsNotUpdate());
+ MOZ_RELEASE_ASSERT(!update1.IsFinal());
+
+ // Final construction with nullptr.
+ const Update final(nullptr);
+ MOZ_RELEASE_ASSERT(final.IsFinal());
+ MOZ_RELEASE_ASSERT(!final.IsNotUpdate());
+
+ // Copy final to cleared.
+ update1 = final;
+ MOZ_RELEASE_ASSERT(update1.IsFinal());
+ MOZ_RELEASE_ASSERT(!update1.IsNotUpdate());
+
+ // Copy final to final.
+ update1 = final;
+ MOZ_RELEASE_ASSERT(update1.IsFinal());
+ MOZ_RELEASE_ASSERT(!update1.IsNotUpdate());
+
+ // Clear a final update.
+ update1.Clear();
+ MOZ_RELEASE_ASSERT(update1.IsNotUpdate());
+ MOZ_RELEASE_ASSERT(!update1.IsFinal());
+
+ // Move final to cleared.
+ update1 = Update(nullptr);
+ MOZ_RELEASE_ASSERT(update1.IsFinal());
+ MOZ_RELEASE_ASSERT(!update1.IsNotUpdate());
+
+ // Move final to final.
+ update1 = Update(nullptr);
+ MOZ_RELEASE_ASSERT(update1.IsFinal());
+ MOZ_RELEASE_ASSERT(!update1.IsNotUpdate());
+
+ // Move from not-an-update (effectively same as Clear).
+ update1 = Update();
+ MOZ_RELEASE_ASSERT(update1.IsNotUpdate());
+ MOZ_RELEASE_ASSERT(!update1.IsFinal());
+
+ auto CreateBiggerChunkAfter = [](const ProfileBufferChunk& aChunkToBeat) {
+ while (TimeStamp::Now() <= aChunkToBeat.ChunkHeader().mDoneTimeStamp) {
+ ::SleepMilli(1);
+ }
+ auto chunk = ProfileBufferChunk::Create(aChunkToBeat.BufferBytes() * 2);
+ MOZ_RELEASE_ASSERT(!!chunk);
+ MOZ_RELEASE_ASSERT(chunk->BufferBytes() >= aChunkToBeat.BufferBytes() * 2);
+ Unused << chunk->ReserveInitialBlockAsTail(0);
+ chunk->MarkDone();
+ MOZ_RELEASE_ASSERT(chunk->ChunkHeader().mDoneTimeStamp >
+ aChunkToBeat.ChunkHeader().mDoneTimeStamp);
+ return chunk;
+ };
+
+ update1 = Update(1, 2, nullptr, nullptr);
+
+ // Create initial update with 2 released chunks and 1 unreleased chunk.
+ auto released = ProfileBufferChunk::Create(10);
+ ProfileBufferChunk* c1 = released.get();
+ Unused << c1->ReserveInitialBlockAsTail(0);
+ c1->MarkDone();
+
+ released->SetLast(CreateBiggerChunkAfter(*c1));
+ ProfileBufferChunk* c2 = c1->GetNext();
+
+ auto unreleased = CreateBiggerChunkAfter(*c2);
+ ProfileBufferChunk* c3 = unreleased.get();
+
+ Update update2(c3->BufferBytes(), c1->BufferBytes() + c2->BufferBytes(), c1,
+ c1);
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update2,
+ Update(c3->BufferBytes(), c1->BufferBytes() + c2->BufferBytes(),
+ c1->ChunkHeader().mDoneTimeStamp,
+ {{c1->ChunkHeader().mDoneTimeStamp, c1->BufferBytes()},
+ {c2->ChunkHeader().mDoneTimeStamp, c2->BufferBytes()}})));
+ // Check every field, this time only, after that we'll trust that the
+ // `SameUpdate` test will be enough.
+ MOZ_RELEASE_ASSERT(!update2.IsNotUpdate());
+ MOZ_RELEASE_ASSERT(!update2.IsFinal());
+ MOZ_RELEASE_ASSERT(update2.UnreleasedBytes() == c3->BufferBytes());
+ MOZ_RELEASE_ASSERT(update2.ReleasedBytes() ==
+ c1->BufferBytes() + c2->BufferBytes());
+ MOZ_RELEASE_ASSERT(update2.OldestDoneTimeStamp() ==
+ c1->ChunkHeader().mDoneTimeStamp);
+ MOZ_RELEASE_ASSERT(update2.NewlyReleasedChunksRef().size() == 2);
+ MOZ_RELEASE_ASSERT(
+ IsSameMetadata(update2.NewlyReleasedChunksRef()[0],
+ {c1->ChunkHeader().mDoneTimeStamp, c1->BufferBytes()}));
+ MOZ_RELEASE_ASSERT(
+ IsSameMetadata(update2.NewlyReleasedChunksRef()[1],
+ {c2->ChunkHeader().mDoneTimeStamp, c2->BufferBytes()}));
+
+ // Fold into not-an-update.
+ update1.Fold(std::move(update2));
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update1,
+ Update(c3->BufferBytes(), c1->BufferBytes() + c2->BufferBytes(),
+ c1->ChunkHeader().mDoneTimeStamp,
+ {{c1->ChunkHeader().mDoneTimeStamp, c1->BufferBytes()},
+ {c2->ChunkHeader().mDoneTimeStamp, c2->BufferBytes()}})));
+
+ // Pretend nothing happened.
+ update2 = Update(c3->BufferBytes(), c1->BufferBytes() + c2->BufferBytes(), c1,
+ nullptr);
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update2, Update(c3->BufferBytes(), c1->BufferBytes() + c2->BufferBytes(),
+ c1->ChunkHeader().mDoneTimeStamp, {})));
+ update1.Fold(std::move(update2));
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update1,
+ Update(c3->BufferBytes(), c1->BufferBytes() + c2->BufferBytes(),
+ c1->ChunkHeader().mDoneTimeStamp,
+ {{c1->ChunkHeader().mDoneTimeStamp, c1->BufferBytes()},
+ {c2->ChunkHeader().mDoneTimeStamp, c2->BufferBytes()}})));
+
+ // Pretend there's a new unreleased chunk.
+ c3->SetLast(CreateBiggerChunkAfter(*c3));
+ ProfileBufferChunk* c4 = c3->GetNext();
+ update2 = Update(c3->BufferBytes() + c4->BufferBytes(),
+ c1->BufferBytes() + c2->BufferBytes(), c1, nullptr);
+ MOZ_RELEASE_ASSERT(
+ IsSameUpdate(update2, Update(c3->BufferBytes() + c4->BufferBytes(),
+ c1->BufferBytes() + c2->BufferBytes(),
+ c1->ChunkHeader().mDoneTimeStamp, {})));
+ update1.Fold(std::move(update2));
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update1,
+ Update(c3->BufferBytes() + c4->BufferBytes(),
+ c1->BufferBytes() + c2->BufferBytes(),
+ c1->ChunkHeader().mDoneTimeStamp,
+ {{c1->ChunkHeader().mDoneTimeStamp, c1->BufferBytes()},
+ {c2->ChunkHeader().mDoneTimeStamp, c2->BufferBytes()}})));
+
+ // Pretend the first unreleased chunk c3 has been released.
+ released->SetLast(std::exchange(unreleased, unreleased->ReleaseNext()));
+ update2 =
+ Update(c4->BufferBytes(),
+ c1->BufferBytes() + c2->BufferBytes() + c3->BufferBytes(), c1, c3);
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update2,
+ Update(c4->BufferBytes(),
+ c1->BufferBytes() + c2->BufferBytes() + c3->BufferBytes(),
+ c1->ChunkHeader().mDoneTimeStamp,
+ {{c3->ChunkHeader().mDoneTimeStamp, c3->BufferBytes()}})));
+ update1.Fold(std::move(update2));
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update1,
+ Update(c4->BufferBytes(),
+ c1->BufferBytes() + c2->BufferBytes() + c3->BufferBytes(),
+ c1->ChunkHeader().mDoneTimeStamp,
+ {{c1->ChunkHeader().mDoneTimeStamp, c1->BufferBytes()},
+ {c2->ChunkHeader().mDoneTimeStamp, c2->BufferBytes()},
+ {c3->ChunkHeader().mDoneTimeStamp, c3->BufferBytes()}})));
+
+ // Pretend c1 has been destroyed, so the oldest timestamp is now at c2.
+ released = released->ReleaseNext();
+ c1 = nullptr;
+ update2 = Update(c4->BufferBytes(), c2->BufferBytes() + c3->BufferBytes(), c2,
+ nullptr);
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update2, Update(c4->BufferBytes(), c2->BufferBytes() + c3->BufferBytes(),
+ c2->ChunkHeader().mDoneTimeStamp, {})));
+ update1.Fold(std::move(update2));
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update1,
+ Update(c4->BufferBytes(), c2->BufferBytes() + c3->BufferBytes(),
+ c2->ChunkHeader().mDoneTimeStamp,
+ {{c2->ChunkHeader().mDoneTimeStamp, c2->BufferBytes()},
+ {c3->ChunkHeader().mDoneTimeStamp, c3->BufferBytes()}})));
+
+ // Pretend c2 has been recycled to make unreleased c5, and c4 has been
+ // released.
+ auto recycled = std::exchange(released, released->ReleaseNext());
+ recycled->MarkRecycled();
+ Unused << recycled->ReserveInitialBlockAsTail(0);
+ recycled->MarkDone();
+ released->SetLast(std::move(unreleased));
+ unreleased = std::move(recycled);
+ ProfileBufferChunk* c5 = c2;
+ c2 = nullptr;
+ update2 =
+ Update(c5->BufferBytes(), c3->BufferBytes() + c4->BufferBytes(), c3, c4);
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update2,
+ Update(c5->BufferBytes(), c3->BufferBytes() + c4->BufferBytes(),
+ c3->ChunkHeader().mDoneTimeStamp,
+ {{c4->ChunkHeader().mDoneTimeStamp, c4->BufferBytes()}})));
+ update1.Fold(std::move(update2));
+ MOZ_RELEASE_ASSERT(IsSameUpdate(
+ update1,
+ Update(c5->BufferBytes(), c3->BufferBytes() + c4->BufferBytes(),
+ c3->ChunkHeader().mDoneTimeStamp,
+ {{c3->ChunkHeader().mDoneTimeStamp, c3->BufferBytes()},
+ {c4->ChunkHeader().mDoneTimeStamp, c4->BufferBytes()}})));
+
+ // And send a final update.
+ update1.Fold(Update(nullptr));
+ MOZ_RELEASE_ASSERT(update1.IsFinal());
+ MOZ_RELEASE_ASSERT(!update1.IsNotUpdate());
+
+ printf("TestControlledChunkManagerUpdate done\n");
+}
+
+static void TestControlledChunkManagerWithLocalLimit() {
+ printf("TestControlledChunkManagerWithLocalLimit...\n");
+
+ // Construct a ProfileBufferChunkManagerWithLocalLimit with chunk of minimum
+ // size >=100, up to 1000 bytes.
+ constexpr ProfileBufferChunk::Length MaxTotalBytes = 1000;
+ constexpr ProfileBufferChunk::Length ChunkMinBufferBytes = 100;
+ ProfileBufferChunkManagerWithLocalLimit cmll{MaxTotalBytes,
+ ChunkMinBufferBytes};
+
+ // Reference to chunk manager base class.
+ ProfileBufferChunkManager& cm = cmll;
+
+ // Reference to controlled chunk manager base class.
+ ProfileBufferControlledChunkManager& ccm = cmll;
+
+# ifdef DEBUG
+ const char* chunkManagerRegisterer =
+ "TestControlledChunkManagerWithLocalLimit";
+ cm.RegisteredWith(chunkManagerRegisterer);
+# endif // DEBUG
+
+ MOZ_RELEASE_ASSERT(cm.MaxTotalSize() == MaxTotalBytes,
+ "Max total size should be exactly as given");
+
+ unsigned destroyedChunks = 0;
+ unsigned destroyedBytes = 0;
+ cm.SetChunkDestroyedCallback([&](const ProfileBufferChunk& aChunks) {
+ for (const ProfileBufferChunk* chunk = &aChunks; chunk;
+ chunk = chunk->GetNext()) {
+ destroyedChunks += 1;
+ destroyedBytes += chunk->BufferBytes();
+ }
+ });
+
+ using Update = ProfileBufferControlledChunkManager::Update;
+ unsigned updateCount = 0;
+ ProfileBufferControlledChunkManager::Update update;
+ MOZ_RELEASE_ASSERT(update.IsNotUpdate());
+ auto updateCallback = [&](Update&& aUpdate) {
+ ++updateCount;
+ update.Fold(std::move(aUpdate));
+ };
+ ccm.SetUpdateCallback(updateCallback);
+ MOZ_RELEASE_ASSERT(updateCount == 1,
+ "SetUpdateCallback should have triggered an update");
+ MOZ_RELEASE_ASSERT(IsSameUpdate(update, Update(0, 0, TimeStamp{}, {})));
+ updateCount = 0;
+ update.Clear();
+
+ UniquePtr<ProfileBufferChunk> extantReleasedChunks =
+ cm.GetExtantReleasedChunks();
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Unexpected released chunk(s)");
+ MOZ_RELEASE_ASSERT(updateCount == 1,
+ "GetExtantReleasedChunks should have triggered an update");
+ MOZ_RELEASE_ASSERT(IsSameUpdate(update, Update(0, 0, TimeStamp{}, {})));
+ updateCount = 0;
+ update.Clear();
+
+ // First request.
+ UniquePtr<ProfileBufferChunk> chunk = cm.GetChunk();
+ MOZ_RELEASE_ASSERT(!!chunk,
+ "First chunk immediate request should always work");
+ const auto chunkActualBufferBytes = chunk->BufferBytes();
+ MOZ_RELEASE_ASSERT(updateCount == 1,
+ "GetChunk should have triggered an update");
+ MOZ_RELEASE_ASSERT(
+ IsSameUpdate(update, Update(chunk->BufferBytes(), 0, TimeStamp{}, {})));
+ updateCount = 0;
+ update.Clear();
+
+ extantReleasedChunks = cm.GetExtantReleasedChunks();
+ MOZ_RELEASE_ASSERT(!extantReleasedChunks, "Unexpected released chunk(s)");
+ MOZ_RELEASE_ASSERT(updateCount == 1,
+ "GetExtantReleasedChunks should have triggered an update");
+ MOZ_RELEASE_ASSERT(
+ IsSameUpdate(update, Update(chunk->BufferBytes(), 0, TimeStamp{}, {})));
+ updateCount = 0;
+ update.Clear();
+
+ // For this test, we need to be able to get at least 2 chunks without hitting
+ // the limit. (If this failed, it wouldn't necessary be a problem with
+ // ProfileBufferChunkManagerWithLocalLimit, fiddle with constants at the top
+ // of this test.)
+ MOZ_RELEASE_ASSERT(chunkActualBufferBytes < 2 * MaxTotalBytes);
+
+ ProfileBufferChunk::Length previousUnreleasedBytes = chunk->BufferBytes();
+ ProfileBufferChunk::Length previousReleasedBytes = 0;
+ TimeStamp previousOldestDoneTimeStamp;
+
+ // We will do enough loops to go through the maximum size a number of times.
+ const unsigned Rollovers = 3;
+ const unsigned Loops = Rollovers * MaxTotalBytes / chunkActualBufferBytes;
+ for (unsigned i = 0; i < Loops; ++i) {
+ // Add some data to the chunk.
+ const ProfileBufferIndex index =
+ ProfileBufferIndex(chunkActualBufferBytes) * i + 1;
+ chunk->SetRangeStart(index);
+ Unused << chunk->ReserveInitialBlockAsTail(1);
+ Unused << chunk->ReserveBlock(2);
+
+ // Request a new chunk.
+ UniquePtr<ProfileBufferChunk> newChunk;
+ cm.RequestChunk([&](UniquePtr<ProfileBufferChunk> aChunk) {
+ newChunk = std::move(aChunk);
+ });
+ MOZ_RELEASE_ASSERT(updateCount == 0,
+ "RequestChunk() shouldn't have triggered an update");
+ cm.FulfillChunkRequests();
+ MOZ_RELEASE_ASSERT(!!newChunk, "Chunk request should always work");
+ MOZ_RELEASE_ASSERT(newChunk->BufferBytes() == chunkActualBufferBytes,
+ "Unexpected chunk size");
+ MOZ_RELEASE_ASSERT(!newChunk->GetNext(), "There should only be one chunk");
+
+ MOZ_RELEASE_ASSERT(updateCount == 1,
+ "FulfillChunkRequests() after a request should have "
+ "triggered an update");
+ MOZ_RELEASE_ASSERT(!update.IsFinal());
+ MOZ_RELEASE_ASSERT(!update.IsNotUpdate());
+ MOZ_RELEASE_ASSERT(update.UnreleasedBytes() ==
+ previousUnreleasedBytes + newChunk->BufferBytes());
+ previousUnreleasedBytes = update.UnreleasedBytes();
+ MOZ_RELEASE_ASSERT(update.ReleasedBytes() <= previousReleasedBytes);
+ previousReleasedBytes = update.ReleasedBytes();
+ MOZ_RELEASE_ASSERT(previousOldestDoneTimeStamp.IsNull() ||
+ update.OldestDoneTimeStamp() >=
+ previousOldestDoneTimeStamp);
+ previousOldestDoneTimeStamp = update.OldestDoneTimeStamp();
+ MOZ_RELEASE_ASSERT(update.NewlyReleasedChunksRef().empty());
+ updateCount = 0;
+ update.Clear();
+
+ // Make sure the "Done" timestamp below cannot be the same as from the
+ // previous loop.
+ const TimeStamp now = TimeStamp::Now();
+ while (TimeStamp::Now() == now) {
+ ::SleepMilli(1);
+ }
+
+ // Mark previous chunk done and release it.
+ WaitUntilTimeStampChanges(); // Force "done" timestamp to change.
+ chunk->MarkDone();
+ const auto doneTimeStamp = chunk->ChunkHeader().mDoneTimeStamp;
+ const auto bufferBytes = chunk->BufferBytes();
+ cm.ReleaseChunk(std::move(chunk));
+
+ MOZ_RELEASE_ASSERT(updateCount == 1,
+ "ReleaseChunk() should have triggered an update");
+ MOZ_RELEASE_ASSERT(!update.IsFinal());
+ MOZ_RELEASE_ASSERT(!update.IsNotUpdate());
+ MOZ_RELEASE_ASSERT(update.UnreleasedBytes() ==
+ previousUnreleasedBytes - bufferBytes);
+ previousUnreleasedBytes = update.UnreleasedBytes();
+ MOZ_RELEASE_ASSERT(update.ReleasedBytes() ==
+ previousReleasedBytes + bufferBytes);
+ previousReleasedBytes = update.ReleasedBytes();
+ MOZ_RELEASE_ASSERT(previousOldestDoneTimeStamp.IsNull() ||
+ update.OldestDoneTimeStamp() >=
+ previousOldestDoneTimeStamp);
+ previousOldestDoneTimeStamp = update.OldestDoneTimeStamp();
+ MOZ_RELEASE_ASSERT(update.OldestDoneTimeStamp() <= doneTimeStamp);
+ MOZ_RELEASE_ASSERT(update.NewlyReleasedChunksRef().size() == 1);
+ MOZ_RELEASE_ASSERT(update.NewlyReleasedChunksRef()[0].mDoneTimeStamp ==
+ doneTimeStamp);
+ MOZ_RELEASE_ASSERT(update.NewlyReleasedChunksRef()[0].mBufferBytes ==
+ bufferBytes);
+ updateCount = 0;
+ update.Clear();
+
+ // And cycle to the new chunk.
+ chunk = std::move(newChunk);
+ }
+
+ // Enough testing! Clean-up.
+ Unused << chunk->ReserveInitialBlockAsTail(0);
+ chunk->MarkDone();
+ cm.ForgetUnreleasedChunks();
+ MOZ_RELEASE_ASSERT(
+ updateCount == 1,
+ "ForgetUnreleasedChunks() should have triggered an update");
+ MOZ_RELEASE_ASSERT(!update.IsFinal());
+ MOZ_RELEASE_ASSERT(!update.IsNotUpdate());
+ MOZ_RELEASE_ASSERT(update.UnreleasedBytes() == 0);
+ MOZ_RELEASE_ASSERT(update.ReleasedBytes() == previousReleasedBytes);
+ MOZ_RELEASE_ASSERT(update.NewlyReleasedChunksRef().empty() == 1);
+ updateCount = 0;
+ update.Clear();
+
+ ccm.SetUpdateCallback({});
+ MOZ_RELEASE_ASSERT(updateCount == 1,
+ "SetUpdateCallback({}) should have triggered an update");
+ MOZ_RELEASE_ASSERT(update.IsFinal());
+
+# ifdef DEBUG
+ cm.DeregisteredFrom(chunkManagerRegisterer);
+# endif // DEBUG
+
+ printf("TestControlledChunkManagerWithLocalLimit done\n");
+}
+
+# define VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED( \
+ aProfileChunkedBuffer, aStart, aEnd, aPushed, aCleared, aFailed) \
+ { \
+ ProfileChunkedBuffer::State state = (aProfileChunkedBuffer).GetState(); \
+ MOZ_RELEASE_ASSERT(state.mRangeStart == (aStart)); \
+ MOZ_RELEASE_ASSERT(state.mRangeEnd == (aEnd)); \
+ MOZ_RELEASE_ASSERT(state.mPushedBlockCount == (aPushed)); \
+ MOZ_RELEASE_ASSERT(state.mClearedBlockCount == (aCleared)); \
+ MOZ_RELEASE_ASSERT(state.mFailedPutBytes == (aFailed)); \
+ }
+
+static void TestChunkedBuffer() {
+ printf("TestChunkedBuffer...\n");
+
+ ProfileBufferBlockIndex blockIndex;
+ MOZ_RELEASE_ASSERT(!blockIndex);
+ MOZ_RELEASE_ASSERT(blockIndex == nullptr);
+
+ // Create an out-of-session ProfileChunkedBuffer.
+ ProfileChunkedBuffer cb(ProfileChunkedBuffer::ThreadSafety::WithMutex);
+
+ MOZ_RELEASE_ASSERT(cb.BufferLength().isNothing());
+
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1, 1, 0, 0, 0);
+
+ int result = 0;
+ result = cb.ReserveAndPut(
+ []() {
+ MOZ_RELEASE_ASSERT(false);
+ return 1;
+ },
+ [](Maybe<ProfileBufferEntryWriter>& aEW) { return aEW ? 2 : 3; });
+ MOZ_RELEASE_ASSERT(result == 3);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1, 1, 0, 0, 0);
+
+ result = 0;
+ result = cb.Put(
+ 1, [](Maybe<ProfileBufferEntryWriter>& aEW) { return aEW ? 1 : 2; });
+ MOZ_RELEASE_ASSERT(result == 2);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1, 1, 0, 0, 0);
+
+ blockIndex = cb.PutFrom(&result, 1);
+ MOZ_RELEASE_ASSERT(!blockIndex);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1, 1, 0, 0, 0);
+
+ blockIndex = cb.PutObjects(123, result, "hello");
+ MOZ_RELEASE_ASSERT(!blockIndex);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1, 1, 0, 0, 0);
+
+ blockIndex = cb.PutObject(123);
+ MOZ_RELEASE_ASSERT(!blockIndex);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1, 1, 0, 0, 0);
+
+ auto chunks = cb.GetAllChunks();
+ static_assert(std::is_same_v<decltype(chunks), UniquePtr<ProfileBufferChunk>>,
+ "ProfileChunkedBuffer::GetAllChunks() should return a "
+ "UniquePtr<ProfileBufferChunk>");
+ MOZ_RELEASE_ASSERT(!chunks, "Expected no chunks when out-of-session");
+
+ bool ran = false;
+ result = 0;
+ result = cb.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ ran = true;
+ MOZ_RELEASE_ASSERT(!aReader);
+ return 3;
+ });
+ MOZ_RELEASE_ASSERT(ran);
+ MOZ_RELEASE_ASSERT(result == 3);
+
+ cb.ReadEach([](ProfileBufferEntryReader&) { MOZ_RELEASE_ASSERT(false); });
+
+ result = 0;
+ result = cb.ReadAt(nullptr, [](Maybe<ProfileBufferEntryReader>&& er) {
+ MOZ_RELEASE_ASSERT(er.isNothing());
+ return 4;
+ });
+ MOZ_RELEASE_ASSERT(result == 4);
+
+ // Use ProfileBufferChunkManagerWithLocalLimit, which will give away
+ // ProfileBufferChunks that can contain 128 bytes, using up to 1KB of memory
+ // (including usable 128 bytes and headers).
+ constexpr size_t bufferMaxSize = 1024;
+ constexpr ProfileChunkedBuffer::Length chunkMinSize = 128;
+ ProfileBufferChunkManagerWithLocalLimit cm(bufferMaxSize, chunkMinSize);
+ cb.SetChunkManager(cm);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1, 1, 0, 0, 0);
+
+ // Let the chunk manager fulfill the initial request for an extra chunk.
+ cm.FulfillChunkRequests();
+
+ MOZ_RELEASE_ASSERT(cm.MaxTotalSize() == bufferMaxSize);
+ MOZ_RELEASE_ASSERT(cb.BufferLength().isSome());
+ MOZ_RELEASE_ASSERT(*cb.BufferLength() == bufferMaxSize);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1, 1, 0, 0, 0);
+
+ // Write an int with the main `ReserveAndPut` function.
+ const int test = 123;
+ ran = false;
+ blockIndex = nullptr;
+ bool success = cb.ReserveAndPut(
+ []() { return sizeof(test); },
+ [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ ran = true;
+ if (!aEW) {
+ return false;
+ }
+ blockIndex = aEW->CurrentBlockIndex();
+ MOZ_RELEASE_ASSERT(aEW->RemainingBytes() == sizeof(test));
+ aEW->WriteObject(test);
+ MOZ_RELEASE_ASSERT(aEW->RemainingBytes() == 0);
+ return true;
+ });
+ MOZ_RELEASE_ASSERT(ran);
+ MOZ_RELEASE_ASSERT(success);
+ MOZ_RELEASE_ASSERT(blockIndex.ConvertToProfileBufferIndex() == 1);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cb, 1, 1 + ULEB128Size(sizeof(test)) + sizeof(test), 1, 0, 0);
+
+ ran = false;
+ result = 0;
+ result = cb.Read([&](ProfileChunkedBuffer::Reader* aReader) {
+ ran = true;
+ MOZ_RELEASE_ASSERT(!!aReader);
+ // begin() and end() should be at the range edges (verified above).
+ MOZ_RELEASE_ASSERT(
+ aReader->begin().CurrentBlockIndex().ConvertToProfileBufferIndex() ==
+ 1);
+ MOZ_RELEASE_ASSERT(
+ aReader->end().CurrentBlockIndex().ConvertToProfileBufferIndex() == 0);
+ // Null ProfileBufferBlockIndex clamped to the beginning.
+ MOZ_RELEASE_ASSERT(aReader->At(nullptr) == aReader->begin());
+ MOZ_RELEASE_ASSERT(aReader->At(blockIndex) == aReader->begin());
+ // At(begin) same as begin().
+ MOZ_RELEASE_ASSERT(aReader->At(aReader->begin().CurrentBlockIndex()) ==
+ aReader->begin());
+ // At(past block) same as end().
+ MOZ_RELEASE_ASSERT(
+ aReader->At(ProfileBufferBlockIndex::CreateFromProfileBufferIndex(
+ 1 + 1 + sizeof(test))) == aReader->end());
+
+ size_t read = 0;
+ aReader->ForEach([&](ProfileBufferEntryReader& er) {
+ ++read;
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == sizeof(test));
+ const auto value = er.ReadObject<decltype(test)>();
+ MOZ_RELEASE_ASSERT(value == test);
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == 0);
+ });
+ MOZ_RELEASE_ASSERT(read == 1);
+
+ read = 0;
+ for (auto er : *aReader) {
+ static_assert(std::is_same_v<decltype(er), ProfileBufferEntryReader>,
+ "ProfileChunkedBuffer::Reader range-for should produce "
+ "ProfileBufferEntryReader objects");
+ ++read;
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == sizeof(test));
+ const auto value = er.ReadObject<decltype(test)>();
+ MOZ_RELEASE_ASSERT(value == test);
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == 0);
+ };
+ MOZ_RELEASE_ASSERT(read == 1);
+ return 5;
+ });
+ MOZ_RELEASE_ASSERT(ran);
+ MOZ_RELEASE_ASSERT(result == 5);
+
+ // Read the int directly from the ProfileChunkedBuffer, without block index.
+ size_t read = 0;
+ cb.ReadEach([&](ProfileBufferEntryReader& er) {
+ ++read;
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == sizeof(test));
+ const auto value = er.ReadObject<decltype(test)>();
+ MOZ_RELEASE_ASSERT(value == test);
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == 0);
+ });
+ MOZ_RELEASE_ASSERT(read == 1);
+
+ // Read the int directly from the ProfileChunkedBuffer, with block index.
+ read = 0;
+ blockIndex = nullptr;
+ cb.ReadEach(
+ [&](ProfileBufferEntryReader& er, ProfileBufferBlockIndex aBlockIndex) {
+ ++read;
+ MOZ_RELEASE_ASSERT(!!aBlockIndex);
+ MOZ_RELEASE_ASSERT(!blockIndex);
+ blockIndex = aBlockIndex;
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == sizeof(test));
+ const auto value = er.ReadObject<decltype(test)>();
+ MOZ_RELEASE_ASSERT(value == test);
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == 0);
+ });
+ MOZ_RELEASE_ASSERT(read == 1);
+ MOZ_RELEASE_ASSERT(!!blockIndex);
+ MOZ_RELEASE_ASSERT(blockIndex != nullptr);
+
+ // Read the int from its block index.
+ read = 0;
+ result = 0;
+ result = cb.ReadAt(blockIndex, [&](Maybe<ProfileBufferEntryReader>&& er) {
+ ++read;
+ MOZ_RELEASE_ASSERT(er.isSome());
+ MOZ_RELEASE_ASSERT(er->CurrentBlockIndex() == blockIndex);
+ MOZ_RELEASE_ASSERT(!er->NextBlockIndex());
+ MOZ_RELEASE_ASSERT(er->RemainingBytes() == sizeof(test));
+ const auto value = er->ReadObject<decltype(test)>();
+ MOZ_RELEASE_ASSERT(value == test);
+ MOZ_RELEASE_ASSERT(er->RemainingBytes() == 0);
+ return 6;
+ });
+ MOZ_RELEASE_ASSERT(result == 6);
+ MOZ_RELEASE_ASSERT(read == 1);
+
+ MOZ_RELEASE_ASSERT(!cb.IsIndexInCurrentChunk(ProfileBufferIndex{}));
+ MOZ_RELEASE_ASSERT(
+ cb.IsIndexInCurrentChunk(blockIndex.ConvertToProfileBufferIndex()));
+ MOZ_RELEASE_ASSERT(cb.IsIndexInCurrentChunk(cb.GetState().mRangeEnd - 1));
+ MOZ_RELEASE_ASSERT(!cb.IsIndexInCurrentChunk(cb.GetState().mRangeEnd));
+
+ // No changes after reads.
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cb, 1, 1 + ULEB128Size(sizeof(test)) + sizeof(test), 1, 0, 0);
+
+ // Steal the underlying ProfileBufferChunks from the ProfileChunkedBuffer.
+ chunks = cb.GetAllChunks();
+ MOZ_RELEASE_ASSERT(!!chunks, "Expected at least one chunk");
+ MOZ_RELEASE_ASSERT(!!chunks->GetNext(), "Expected two chunks");
+ MOZ_RELEASE_ASSERT(!chunks->GetNext()->GetNext(), "Expected only two chunks");
+ const ProfileChunkedBuffer::Length chunkActualSize = chunks->BufferBytes();
+ MOZ_RELEASE_ASSERT(chunkActualSize >= chunkMinSize);
+ MOZ_RELEASE_ASSERT(chunks->RangeStart() == 1);
+ MOZ_RELEASE_ASSERT(chunks->OffsetFirstBlock() == 0);
+ MOZ_RELEASE_ASSERT(chunks->OffsetPastLastBlock() == 1 + sizeof(test));
+
+ // GetAllChunks() should have advanced the index one full chunk forward.
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1 + chunkActualSize,
+ 1 + chunkActualSize, 1, 0, 0);
+
+ // Nothing more to read from the now-empty ProfileChunkedBuffer.
+ cb.ReadEach([](ProfileBufferEntryReader&) { MOZ_RELEASE_ASSERT(false); });
+ cb.ReadEach([](ProfileBufferEntryReader&, ProfileBufferBlockIndex) {
+ MOZ_RELEASE_ASSERT(false);
+ });
+ result = 0;
+ result = cb.ReadAt(nullptr, [](Maybe<ProfileBufferEntryReader>&& er) {
+ MOZ_RELEASE_ASSERT(er.isNothing());
+ return 7;
+ });
+ MOZ_RELEASE_ASSERT(result == 7);
+
+ // Read the int from the stolen chunks.
+ read = 0;
+ ProfileChunkedBuffer::ReadEach(
+ chunks.get(), nullptr,
+ [&](ProfileBufferEntryReader& er, ProfileBufferBlockIndex aBlockIndex) {
+ ++read;
+ MOZ_RELEASE_ASSERT(aBlockIndex == blockIndex);
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == sizeof(test));
+ const auto value = er.ReadObject<decltype(test)>();
+ MOZ_RELEASE_ASSERT(value == test);
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == 0);
+ });
+ MOZ_RELEASE_ASSERT(read == 1);
+
+ // No changes after reads.
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, 1 + chunkActualSize,
+ 1 + chunkActualSize, 1, 0, 0);
+
+ // Write lots of numbers (by memcpy), which should trigger Chunk destructions.
+ ProfileBufferBlockIndex firstBlockIndex;
+ MOZ_RELEASE_ASSERT(!firstBlockIndex);
+ ProfileBufferBlockIndex lastBlockIndex;
+ MOZ_RELEASE_ASSERT(!lastBlockIndex);
+ const size_t lots = 2 * bufferMaxSize / (1 + sizeof(int));
+ for (size_t i = 1; i < lots; ++i) {
+ ProfileBufferBlockIndex blockIndex = cb.PutFrom(&i, sizeof(i));
+ MOZ_RELEASE_ASSERT(!!blockIndex);
+ MOZ_RELEASE_ASSERT(blockIndex > firstBlockIndex);
+ if (!firstBlockIndex) {
+ firstBlockIndex = blockIndex;
+ }
+ MOZ_RELEASE_ASSERT(blockIndex > lastBlockIndex);
+ lastBlockIndex = blockIndex;
+ }
+
+ ProfileChunkedBuffer::State stateAfterPuts = cb.GetState();
+ ProfileBufferIndex startAfterPuts = stateAfterPuts.mRangeStart;
+ MOZ_RELEASE_ASSERT(startAfterPuts > 1 + chunkActualSize);
+ ProfileBufferIndex endAfterPuts = stateAfterPuts.mRangeEnd;
+ MOZ_RELEASE_ASSERT(endAfterPuts > startAfterPuts);
+ uint64_t pushedAfterPuts = stateAfterPuts.mPushedBlockCount;
+ MOZ_RELEASE_ASSERT(pushedAfterPuts > 0);
+ uint64_t clearedAfterPuts = stateAfterPuts.mClearedBlockCount;
+ MOZ_RELEASE_ASSERT(clearedAfterPuts > 0);
+ MOZ_RELEASE_ASSERT(stateAfterPuts.mFailedPutBytes == 0);
+ MOZ_RELEASE_ASSERT(!cb.IsIndexInCurrentChunk(ProfileBufferIndex{}));
+ MOZ_RELEASE_ASSERT(
+ !cb.IsIndexInCurrentChunk(blockIndex.ConvertToProfileBufferIndex()));
+ MOZ_RELEASE_ASSERT(
+ !cb.IsIndexInCurrentChunk(firstBlockIndex.ConvertToProfileBufferIndex()));
+
+ // Read extant numbers, which should at least follow each other.
+ read = 0;
+ size_t i = 0;
+ cb.ReadEach(
+ [&](ProfileBufferEntryReader& er, ProfileBufferBlockIndex aBlockIndex) {
+ ++read;
+ MOZ_RELEASE_ASSERT(!!aBlockIndex);
+ MOZ_RELEASE_ASSERT(aBlockIndex > firstBlockIndex);
+ MOZ_RELEASE_ASSERT(aBlockIndex <= lastBlockIndex);
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == sizeof(size_t));
+ const auto value = er.ReadObject<size_t>();
+ if (i == 0) {
+ i = value;
+ } else {
+ MOZ_RELEASE_ASSERT(value == ++i);
+ }
+ MOZ_RELEASE_ASSERT(er.RemainingBytes() == 0);
+ });
+ MOZ_RELEASE_ASSERT(read != 0);
+ MOZ_RELEASE_ASSERT(read < lots);
+
+ // Read first extant number.
+ read = 0;
+ i = 0;
+ blockIndex = nullptr;
+ success =
+ cb.ReadAt(firstBlockIndex, [&](Maybe<ProfileBufferEntryReader>&& er) {
+ MOZ_ASSERT(er.isSome());
+ ++read;
+ MOZ_RELEASE_ASSERT(er->CurrentBlockIndex() > firstBlockIndex);
+ MOZ_RELEASE_ASSERT(!!er->NextBlockIndex());
+ MOZ_RELEASE_ASSERT(er->NextBlockIndex() > firstBlockIndex);
+ MOZ_RELEASE_ASSERT(er->NextBlockIndex() < lastBlockIndex);
+ blockIndex = er->NextBlockIndex();
+ MOZ_RELEASE_ASSERT(er->RemainingBytes() == sizeof(size_t));
+ const auto value = er->ReadObject<size_t>();
+ MOZ_RELEASE_ASSERT(i == 0);
+ i = value;
+ MOZ_RELEASE_ASSERT(er->RemainingBytes() == 0);
+ return 7;
+ });
+ MOZ_RELEASE_ASSERT(success);
+ MOZ_RELEASE_ASSERT(read == 1);
+ // Read other extant numbers one by one.
+ do {
+ bool success =
+ cb.ReadAt(blockIndex, [&](Maybe<ProfileBufferEntryReader>&& er) {
+ MOZ_ASSERT(er.isSome());
+ ++read;
+ MOZ_RELEASE_ASSERT(er->CurrentBlockIndex() == blockIndex);
+ MOZ_RELEASE_ASSERT(!er->NextBlockIndex() ||
+ er->NextBlockIndex() > blockIndex);
+ MOZ_RELEASE_ASSERT(!er->NextBlockIndex() ||
+ er->NextBlockIndex() > firstBlockIndex);
+ MOZ_RELEASE_ASSERT(!er->NextBlockIndex() ||
+ er->NextBlockIndex() <= lastBlockIndex);
+ MOZ_RELEASE_ASSERT(er->NextBlockIndex()
+ ? blockIndex < lastBlockIndex
+ : blockIndex == lastBlockIndex,
+ "er->NextBlockIndex() should only be null when "
+ "blockIndex is at the last block");
+ blockIndex = er->NextBlockIndex();
+ MOZ_RELEASE_ASSERT(er->RemainingBytes() == sizeof(size_t));
+ const auto value = er->ReadObject<size_t>();
+ MOZ_RELEASE_ASSERT(value == ++i);
+ MOZ_RELEASE_ASSERT(er->RemainingBytes() == 0);
+ return true;
+ });
+ MOZ_RELEASE_ASSERT(success);
+ } while (blockIndex);
+ MOZ_RELEASE_ASSERT(read > 1);
+
+ // No changes after reads.
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cb, startAfterPuts, endAfterPuts, pushedAfterPuts, clearedAfterPuts, 0);
+
+# ifdef DEBUG
+ // cb.Dump();
+# endif
+
+ cb.Clear();
+
+# ifdef DEBUG
+ // cb.Dump();
+# endif
+
+ ProfileChunkedBuffer::State stateAfterClear = cb.GetState();
+ ProfileBufferIndex startAfterClear = stateAfterClear.mRangeStart;
+ MOZ_RELEASE_ASSERT(startAfterClear > startAfterPuts);
+ ProfileBufferIndex endAfterClear = stateAfterClear.mRangeEnd;
+ MOZ_RELEASE_ASSERT(endAfterClear == startAfterClear);
+ MOZ_RELEASE_ASSERT(stateAfterClear.mPushedBlockCount == 0);
+ MOZ_RELEASE_ASSERT(stateAfterClear.mClearedBlockCount == 0);
+ MOZ_RELEASE_ASSERT(stateAfterClear.mFailedPutBytes == 0);
+ MOZ_RELEASE_ASSERT(!cb.IsIndexInCurrentChunk(ProfileBufferIndex{}));
+ MOZ_RELEASE_ASSERT(
+ !cb.IsIndexInCurrentChunk(blockIndex.ConvertToProfileBufferIndex()));
+ MOZ_RELEASE_ASSERT(!cb.IsIndexInCurrentChunk(stateAfterClear.mRangeEnd - 1));
+ MOZ_RELEASE_ASSERT(!cb.IsIndexInCurrentChunk(stateAfterClear.mRangeEnd));
+
+ // Start writer threads.
+ constexpr int ThreadCount = 32;
+ std::thread threads[ThreadCount];
+ for (int threadNo = 0; threadNo < ThreadCount; ++threadNo) {
+ threads[threadNo] = std::thread(
+ [&](int aThreadNo) {
+ ::SleepMilli(1);
+ constexpr int pushCount = 1024;
+ for (int push = 0; push < pushCount; ++push) {
+ // Reserve as many bytes as the thread number (but at least enough
+ // to store an int), and write an increasing int.
+ const bool success =
+ cb.Put(std::max(aThreadNo, int(sizeof(push))),
+ [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ if (!aEW) {
+ return false;
+ }
+ aEW->WriteObject(aThreadNo * 1000000 + push);
+ // Advance writer to the end.
+ for (size_t r = aEW->RemainingBytes(); r != 0; --r) {
+ aEW->WriteObject<char>('_');
+ }
+ return true;
+ });
+ MOZ_RELEASE_ASSERT(success);
+ }
+ },
+ threadNo);
+ }
+
+ // Wait for all writer threads to die.
+ for (auto&& thread : threads) {
+ thread.join();
+ }
+
+# ifdef DEBUG
+ // cb.Dump();
+# endif
+
+ ProfileChunkedBuffer::State stateAfterMTPuts = cb.GetState();
+ ProfileBufferIndex startAfterMTPuts = stateAfterMTPuts.mRangeStart;
+ MOZ_RELEASE_ASSERT(startAfterMTPuts > startAfterClear);
+ ProfileBufferIndex endAfterMTPuts = stateAfterMTPuts.mRangeEnd;
+ MOZ_RELEASE_ASSERT(endAfterMTPuts > startAfterMTPuts);
+ MOZ_RELEASE_ASSERT(stateAfterMTPuts.mPushedBlockCount > 0);
+ MOZ_RELEASE_ASSERT(stateAfterMTPuts.mClearedBlockCount > 0);
+ MOZ_RELEASE_ASSERT(stateAfterMTPuts.mFailedPutBytes == 0);
+
+ // Reset to out-of-session.
+ cb.ResetChunkManager();
+
+ ProfileChunkedBuffer::State stateAfterReset = cb.GetState();
+ ProfileBufferIndex startAfterReset = stateAfterReset.mRangeStart;
+ MOZ_RELEASE_ASSERT(startAfterReset == endAfterMTPuts);
+ ProfileBufferIndex endAfterReset = stateAfterReset.mRangeEnd;
+ MOZ_RELEASE_ASSERT(endAfterReset == startAfterReset);
+ MOZ_RELEASE_ASSERT(stateAfterReset.mPushedBlockCount == 0);
+ MOZ_RELEASE_ASSERT(stateAfterReset.mClearedBlockCount == 0);
+ MOZ_RELEASE_ASSERT(stateAfterReset.mFailedPutBytes == 0);
+
+ success = cb.ReserveAndPut(
+ []() {
+ MOZ_RELEASE_ASSERT(false);
+ return 1;
+ },
+ [](Maybe<ProfileBufferEntryWriter>& aEW) { return !!aEW; });
+ MOZ_RELEASE_ASSERT(!success);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, startAfterReset, endAfterReset,
+ 0, 0, 0);
+
+ success =
+ cb.Put(1, [](Maybe<ProfileBufferEntryWriter>& aEW) { return !!aEW; });
+ MOZ_RELEASE_ASSERT(!success);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, startAfterReset, endAfterReset,
+ 0, 0, 0);
+
+ blockIndex = cb.PutFrom(&success, 1);
+ MOZ_RELEASE_ASSERT(!blockIndex);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, startAfterReset, endAfterReset,
+ 0, 0, 0);
+
+ blockIndex = cb.PutObjects(123, success, "hello");
+ MOZ_RELEASE_ASSERT(!blockIndex);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, startAfterReset, endAfterReset,
+ 0, 0, 0);
+
+ blockIndex = cb.PutObject(123);
+ MOZ_RELEASE_ASSERT(!blockIndex);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, startAfterReset, endAfterReset,
+ 0, 0, 0);
+
+ chunks = cb.GetAllChunks();
+ MOZ_RELEASE_ASSERT(!chunks, "Expected no chunks when out-of-session");
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, startAfterReset, endAfterReset,
+ 0, 0, 0);
+
+ cb.ReadEach([](ProfileBufferEntryReader&) { MOZ_RELEASE_ASSERT(false); });
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, startAfterReset, endAfterReset,
+ 0, 0, 0);
+
+ success = cb.ReadAt(nullptr, [](Maybe<ProfileBufferEntryReader>&& er) {
+ MOZ_RELEASE_ASSERT(er.isNothing());
+ return true;
+ });
+ MOZ_RELEASE_ASSERT(success);
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cb, startAfterReset, endAfterReset,
+ 0, 0, 0);
+
+ printf("TestChunkedBuffer done\n");
+}
+
+static void TestChunkedBufferSingle() {
+ printf("TestChunkedBufferSingle...\n");
+
+ constexpr ProfileChunkedBuffer::Length chunkMinSize = 128;
+
+ // Create a ProfileChunkedBuffer that will own&use a
+ // ProfileBufferChunkManagerSingle, which will give away one
+ // ProfileBufferChunk that can contain 128 bytes.
+ ProfileChunkedBuffer cbSingle(
+ ProfileChunkedBuffer::ThreadSafety::WithoutMutex,
+ MakeUnique<ProfileBufferChunkManagerSingle>(chunkMinSize));
+
+ MOZ_RELEASE_ASSERT(cbSingle.BufferLength().isSome());
+ const ProfileChunkedBuffer::Length bufferBytes = *cbSingle.BufferLength();
+ MOZ_RELEASE_ASSERT(bufferBytes >= chunkMinSize);
+
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cbSingle, 1, 1, 0, 0, 0);
+
+ // We will write this many blocks to fill the chunk.
+ constexpr size_t testBlocks = 4;
+ const ProfileChunkedBuffer::Length blockBytes = bufferBytes / testBlocks;
+ MOZ_RELEASE_ASSERT(ULEB128Size(blockBytes) == 1,
+ "This test assumes block sizes are small enough so that "
+ "their ULEB128-encoded size is 1 byte");
+ const ProfileChunkedBuffer::Length entryBytes =
+ blockBytes - ULEB128Size(blockBytes);
+
+ // First buffer-filling test: Try to write a too-big entry at the end of the
+ // chunk.
+
+ // Write all but one block.
+ for (size_t i = 0; i < testBlocks - 1; ++i) {
+ cbSingle.Put(entryBytes, [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ while (aEW->RemainingBytes() > 0) {
+ **aEW = '0' + i;
+ ++(*aEW);
+ }
+ });
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cbSingle, 1, 1 + blockBytes * (i + 1), i + 1, 0, 0);
+ }
+
+ // Write the last block so that it's too big (by 1 byte) to fit in the chunk,
+ // this should fail.
+ const ProfileChunkedBuffer::Length remainingBytesForLastBlock =
+ bufferBytes - blockBytes * (testBlocks - 1);
+ MOZ_RELEASE_ASSERT(ULEB128Size(remainingBytesForLastBlock) == 1,
+ "This test assumes block sizes are small enough so that "
+ "their ULEB128-encoded size is 1 byte");
+ const ProfileChunkedBuffer::Length entryToFitRemainingBytes =
+ remainingBytesForLastBlock - ULEB128Size(remainingBytesForLastBlock);
+ cbSingle.Put(entryToFitRemainingBytes + 1,
+ [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isNothing());
+ });
+ // The buffer state should not have changed, apart from the failed bytes.
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cbSingle, 1, 1 + blockBytes * (testBlocks - 1), testBlocks - 1, 0,
+ remainingBytesForLastBlock + 1);
+
+ size_t read = 0;
+ cbSingle.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(aER.RemainingBytes() == entryBytes);
+ while (aER.RemainingBytes() > 0) {
+ MOZ_RELEASE_ASSERT(*aER == '0' + read);
+ ++aER;
+ }
+ ++read;
+ });
+ MOZ_RELEASE_ASSERT(read == testBlocks - 1);
+
+ // ~Interlude~ Test AppendContent:
+ // Create another ProfileChunkedBuffer that will use a
+ // ProfileBufferChunkManagerWithLocalLimit, which will give away
+ // ProfileBufferChunks that can contain 128 bytes, using up to 1KB of memory
+ // (including usable 128 bytes and headers).
+ constexpr size_t bufferMaxSize = 1024;
+ ProfileBufferChunkManagerWithLocalLimit cmTarget(bufferMaxSize, chunkMinSize);
+ ProfileChunkedBuffer cbTarget(ProfileChunkedBuffer::ThreadSafety::WithMutex,
+ cmTarget);
+
+ // It should start empty.
+ cbTarget.ReadEach(
+ [](ProfileBufferEntryReader&) { MOZ_RELEASE_ASSERT(false); });
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cbTarget, 1, 1, 0, 0, 0);
+
+ // Copy the contents from cbSingle to cbTarget.
+ cbTarget.AppendContents(cbSingle);
+
+ // And verify that we now have the same contents in cbTarget.
+ read = 0;
+ cbTarget.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(aER.RemainingBytes() == entryBytes);
+ while (aER.RemainingBytes() > 0) {
+ MOZ_RELEASE_ASSERT(*aER == '0' + read);
+ ++aER;
+ }
+ ++read;
+ });
+ MOZ_RELEASE_ASSERT(read == testBlocks - 1);
+ // The state should be the same as the source.
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cbTarget, 1, 1 + blockBytes * (testBlocks - 1), testBlocks - 1, 0, 0);
+
+# ifdef DEBUG
+ // cbSingle.Dump();
+ // cbTarget.Dump();
+# endif
+
+ // Because we failed to write a too-big chunk above, the chunk was marked
+ // full, so that entries should be consistently rejected from now on.
+ cbSingle.Put(1, [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isNothing());
+ });
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cbSingle, 1, 1 + blockBytes * ((testBlocks - 1)), testBlocks - 1, 0,
+ remainingBytesForLastBlock + 1 + ULEB128Size(1u) + 1);
+
+ // Clear the buffer before the next test.
+
+ cbSingle.Clear();
+ // Clear() should move the index to the next chunk range -- even if it's
+ // really reusing the same chunk.
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cbSingle, 1 + bufferBytes,
+ 1 + bufferBytes, 0, 0, 0);
+ cbSingle.ReadEach(
+ [&](ProfileBufferEntryReader& aER) { MOZ_RELEASE_ASSERT(false); });
+
+ // Second buffer-filling test: Try to write a final entry that just fits at
+ // the end of the chunk.
+
+ // Write all but one block.
+ for (size_t i = 0; i < testBlocks - 1; ++i) {
+ cbSingle.Put(entryBytes, [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ while (aEW->RemainingBytes() > 0) {
+ **aEW = 'a' + i;
+ ++(*aEW);
+ }
+ });
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cbSingle, 1 + bufferBytes, 1 + bufferBytes + blockBytes * (i + 1),
+ i + 1, 0, 0);
+ }
+
+ read = 0;
+ cbSingle.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(aER.RemainingBytes() == entryBytes);
+ while (aER.RemainingBytes() > 0) {
+ MOZ_RELEASE_ASSERT(*aER == 'a' + read);
+ ++aER;
+ }
+ ++read;
+ });
+ MOZ_RELEASE_ASSERT(read == testBlocks - 1);
+
+ // Write the last block so that it fits exactly in the chunk.
+ cbSingle.Put(entryToFitRemainingBytes,
+ [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ while (aEW->RemainingBytes() > 0) {
+ **aEW = 'a' + (testBlocks - 1);
+ ++(*aEW);
+ }
+ });
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cbSingle, 1 + bufferBytes, 1 + bufferBytes + blockBytes * testBlocks,
+ testBlocks, 0, 0);
+
+ read = 0;
+ cbSingle.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(
+ aER.RemainingBytes() ==
+ ((read < testBlocks) ? entryBytes : entryToFitRemainingBytes));
+ while (aER.RemainingBytes() > 0) {
+ MOZ_RELEASE_ASSERT(*aER == 'a' + read);
+ ++aER;
+ }
+ ++read;
+ });
+ MOZ_RELEASE_ASSERT(read == testBlocks);
+
+ // Because the single chunk has been filled, it shouldn't be possible to write
+ // more entries.
+ cbSingle.Put(1, [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isNothing());
+ });
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cbSingle, 1 + bufferBytes, 1 + bufferBytes + blockBytes * testBlocks,
+ testBlocks, 0, ULEB128Size(1u) + 1);
+
+ cbSingle.Clear();
+ // Clear() should move the index to the next chunk range -- even if it's
+ // really reusing the same chunk.
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(cbSingle, 1 + bufferBytes * 2,
+ 1 + bufferBytes * 2, 0, 0, 0);
+ cbSingle.ReadEach(
+ [&](ProfileBufferEntryReader& aER) { MOZ_RELEASE_ASSERT(false); });
+
+ // Clear() recycles the released chunk, so we should be able to record new
+ // entries.
+ cbSingle.Put(entryBytes, [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ while (aEW->RemainingBytes() > 0) {
+ **aEW = 'x';
+ ++(*aEW);
+ }
+ });
+ VERIFY_PCB_START_END_PUSHED_CLEARED_FAILED(
+ cbSingle, 1 + bufferBytes * 2,
+ 1 + bufferBytes * 2 + ULEB128Size(entryBytes) + entryBytes, 1, 0, 0);
+ read = 0;
+ cbSingle.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(read == 0);
+ MOZ_RELEASE_ASSERT(aER.RemainingBytes() == entryBytes);
+ while (aER.RemainingBytes() > 0) {
+ MOZ_RELEASE_ASSERT(*aER == 'x');
+ ++aER;
+ }
+ ++read;
+ });
+ MOZ_RELEASE_ASSERT(read == 1);
+
+ printf("TestChunkedBufferSingle done\n");
+}
+
+static void TestModuloBuffer(ModuloBuffer<>& mb, uint32_t MBSize) {
+ using MB = ModuloBuffer<>;
+
+ MOZ_RELEASE_ASSERT(mb.BufferLength().Value() == MBSize);
+
+ // Iterator comparisons.
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(2) == mb.ReaderAt(2));
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(2) != mb.ReaderAt(3));
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(2) < mb.ReaderAt(3));
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(2) <= mb.ReaderAt(2));
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(2) <= mb.ReaderAt(3));
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(3) > mb.ReaderAt(2));
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(2) >= mb.ReaderAt(2));
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(3) >= mb.ReaderAt(2));
+
+ // Iterators indices don't wrap around (even though they may be pointing at
+ // the same location).
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(2) != mb.ReaderAt(MBSize + 2));
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(MBSize + 2) != mb.ReaderAt(2));
+
+ // Dereference.
+ static_assert(std::is_same<decltype(*mb.ReaderAt(0)), const MB::Byte&>::value,
+ "Dereferencing from a reader should return const Byte*");
+ static_assert(std::is_same<decltype(*mb.WriterAt(0)), MB::Byte&>::value,
+ "Dereferencing from a writer should return Byte*");
+ // Contiguous between 0 and MBSize-1.
+ MOZ_RELEASE_ASSERT(&*mb.ReaderAt(MBSize - 1) ==
+ &*mb.ReaderAt(0) + (MBSize - 1));
+ // Wraps around.
+ MOZ_RELEASE_ASSERT(&*mb.ReaderAt(MBSize) == &*mb.ReaderAt(0));
+ MOZ_RELEASE_ASSERT(&*mb.ReaderAt(MBSize + MBSize - 1) ==
+ &*mb.ReaderAt(MBSize - 1));
+ MOZ_RELEASE_ASSERT(&*mb.ReaderAt(MBSize + MBSize) == &*mb.ReaderAt(0));
+ // Power of 2 modulo wrapping.
+ MOZ_RELEASE_ASSERT(&*mb.ReaderAt(uint32_t(-1)) == &*mb.ReaderAt(MBSize - 1));
+ MOZ_RELEASE_ASSERT(&*mb.ReaderAt(static_cast<MB::Index>(-1)) ==
+ &*mb.ReaderAt(MBSize - 1));
+
+ // Arithmetic.
+ MB::Reader arit = mb.ReaderAt(0);
+ MOZ_RELEASE_ASSERT(++arit == mb.ReaderAt(1));
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(1));
+
+ MOZ_RELEASE_ASSERT(--arit == mb.ReaderAt(0));
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(0));
+
+ MOZ_RELEASE_ASSERT(arit++ == mb.ReaderAt(0));
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(1));
+
+ MOZ_RELEASE_ASSERT(arit-- == mb.ReaderAt(1));
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(0));
+
+ MOZ_RELEASE_ASSERT(arit + 3 == mb.ReaderAt(3));
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(0));
+
+ MOZ_RELEASE_ASSERT(4 + arit == mb.ReaderAt(4));
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(0));
+
+ // (Can't have assignments inside asserts, hence the split.)
+ const bool checkPlusEq = ((arit += 3) == mb.ReaderAt(3));
+ MOZ_RELEASE_ASSERT(checkPlusEq);
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(3));
+
+ MOZ_RELEASE_ASSERT((arit - 2) == mb.ReaderAt(1));
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(3));
+
+ const bool checkMinusEq = ((arit -= 2) == mb.ReaderAt(1));
+ MOZ_RELEASE_ASSERT(checkMinusEq);
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(1));
+
+ // Random access.
+ MOZ_RELEASE_ASSERT(&arit[3] == &*(arit + 3));
+ MOZ_RELEASE_ASSERT(arit == mb.ReaderAt(1));
+
+ // Iterator difference.
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(3) - mb.ReaderAt(1) == 2);
+ MOZ_RELEASE_ASSERT(mb.ReaderAt(1) - mb.ReaderAt(3) == MB::Index(-2));
+
+ // Only testing Writer, as Reader is just a subset with no code differences.
+ MB::Writer it = mb.WriterAt(0);
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == 0);
+
+ // Write two characters at the start.
+ it.WriteObject('x');
+ it.WriteObject('y');
+
+ // Backtrack to read them.
+ it -= 2;
+ // PeekObject should read without moving.
+ MOZ_RELEASE_ASSERT(it.PeekObject<char>() == 'x');
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == 0);
+ // ReadObject should read and move past the character.
+ MOZ_RELEASE_ASSERT(it.ReadObject<char>() == 'x');
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == 1);
+ MOZ_RELEASE_ASSERT(it.PeekObject<char>() == 'y');
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == 1);
+ MOZ_RELEASE_ASSERT(it.ReadObject<char>() == 'y');
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == 2);
+
+ // Checking that a reader can be created from a writer.
+ MB::Reader it2(it);
+ MOZ_RELEASE_ASSERT(it2.CurrentIndex() == 2);
+ // Or assigned.
+ it2 = it;
+ MOZ_RELEASE_ASSERT(it2.CurrentIndex() == 2);
+
+ // Iterator traits.
+ static_assert(std::is_same<std::iterator_traits<MB::Reader>::difference_type,
+ MB::Index>::value,
+ "ModuloBuffer::Reader::difference_type should be Index");
+ static_assert(std::is_same<std::iterator_traits<MB::Reader>::value_type,
+ MB::Byte>::value,
+ "ModuloBuffer::Reader::value_type should be Byte");
+ static_assert(std::is_same<std::iterator_traits<MB::Reader>::pointer,
+ const MB::Byte*>::value,
+ "ModuloBuffer::Reader::pointer should be const Byte*");
+ static_assert(std::is_same<std::iterator_traits<MB::Reader>::reference,
+ const MB::Byte&>::value,
+ "ModuloBuffer::Reader::reference should be const Byte&");
+ static_assert(std::is_base_of<
+ std::input_iterator_tag,
+ std::iterator_traits<MB::Reader>::iterator_category>::value,
+ "ModuloBuffer::Reader::iterator_category should be derived "
+ "from input_iterator_tag");
+ static_assert(std::is_base_of<
+ std::forward_iterator_tag,
+ std::iterator_traits<MB::Reader>::iterator_category>::value,
+ "ModuloBuffer::Reader::iterator_category should be derived "
+ "from forward_iterator_tag");
+ static_assert(std::is_base_of<
+ std::bidirectional_iterator_tag,
+ std::iterator_traits<MB::Reader>::iterator_category>::value,
+ "ModuloBuffer::Reader::iterator_category should be derived "
+ "from bidirectional_iterator_tag");
+ static_assert(
+ std::is_same<std::iterator_traits<MB::Reader>::iterator_category,
+ std::random_access_iterator_tag>::value,
+ "ModuloBuffer::Reader::iterator_category should be "
+ "random_access_iterator_tag");
+
+ // Use as input iterator by std::string constructor (which is only considered
+ // with proper input iterators.)
+ std::string s(mb.ReaderAt(0), mb.ReaderAt(2));
+ MOZ_RELEASE_ASSERT(s == "xy");
+
+ // Write 4-byte number at index 2.
+ it.WriteObject(int32_t(123));
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == 6);
+ // And another, which should now wrap around (but index continues on.)
+ it.WriteObject(int32_t(456));
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == MBSize + 2);
+ // Even though index==MBSize+2, we can read the object we wrote at 2.
+ MOZ_RELEASE_ASSERT(it.ReadObject<int32_t>() == 123);
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == MBSize + 6);
+ // And similarly, index MBSize+6 points at the same location as index 6.
+ MOZ_RELEASE_ASSERT(it.ReadObject<int32_t>() == 456);
+ MOZ_RELEASE_ASSERT(it.CurrentIndex() == MBSize + MBSize + 2);
+}
+
+void TestModuloBuffer() {
+ printf("TestModuloBuffer...\n");
+
+ // Testing ModuloBuffer with default template arguments.
+ using MB = ModuloBuffer<>;
+
+ // Only 8-byte buffers, to easily test wrap-around.
+ constexpr uint32_t MBSize = 8;
+
+ // MB with self-allocated heap buffer.
+ MB mbByLength(MakePowerOfTwo32<MBSize>());
+ TestModuloBuffer(mbByLength, MBSize);
+
+ // MB taking ownership of a provided UniquePtr to a buffer.
+ auto uniqueBuffer = MakeUnique<uint8_t[]>(MBSize);
+ MB mbByUniquePtr(MakeUnique<uint8_t[]>(MBSize), MakePowerOfTwo32<MBSize>());
+ TestModuloBuffer(mbByUniquePtr, MBSize);
+
+ // MB using part of a buffer on the stack. The buffer is three times the
+ // required size: The middle third is where ModuloBuffer will work, the first
+ // and last thirds are only used to later verify that ModuloBuffer didn't go
+ // out of its bounds.
+ uint8_t buffer[MBSize * 3];
+ // Pre-fill the buffer with a known pattern, so we can later see what changed.
+ for (size_t i = 0; i < MBSize * 3; ++i) {
+ buffer[i] = uint8_t('A' + i);
+ }
+ MB mbByBuffer(&buffer[MBSize], MakePowerOfTwo32<MBSize>());
+ TestModuloBuffer(mbByBuffer, MBSize);
+
+ // Check that only the provided stack-based sub-buffer was modified.
+ uint32_t changed = 0;
+ for (size_t i = MBSize; i < MBSize * 2; ++i) {
+ changed += (buffer[i] == uint8_t('A' + i)) ? 0 : 1;
+ }
+ // Expect at least 75% changes.
+ MOZ_RELEASE_ASSERT(changed >= MBSize * 6 / 8);
+
+ // Everything around the sub-buffer should be unchanged.
+ for (size_t i = 0; i < MBSize; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+ for (size_t i = MBSize * 2; i < MBSize * 3; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+
+ // Check that move-construction is allowed. This verifies that we do not
+ // crash from a double free, when `mbByBuffer` and `mbByStolenBuffer` are both
+ // destroyed at the end of this function.
+ MB mbByStolenBuffer = std::move(mbByBuffer);
+ TestModuloBuffer(mbByStolenBuffer, MBSize);
+
+ // Check that only the provided stack-based sub-buffer was modified.
+ changed = 0;
+ for (size_t i = MBSize; i < MBSize * 2; ++i) {
+ changed += (buffer[i] == uint8_t('A' + i)) ? 0 : 1;
+ }
+ // Expect at least 75% changes.
+ MOZ_RELEASE_ASSERT(changed >= MBSize * 6 / 8);
+
+ // Everything around the sub-buffer should be unchanged.
+ for (size_t i = 0; i < MBSize; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+ for (size_t i = MBSize * 2; i < MBSize * 3; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+
+ // This test function does a `ReadInto` as directed, and checks that the
+ // result is the same as if the copy had been done manually byte-by-byte.
+ // `TestReadInto(3, 7, 2)` copies from index 3 to index 7, 2 bytes long.
+ // Return the output string (from `ReadInto`) for external checks.
+ auto TestReadInto = [](MB::Index aReadFrom, MB::Index aWriteTo,
+ MB::Length aBytes) {
+ constexpr uint32_t TRISize = 16;
+
+ // Prepare an input buffer, all different elements.
+ uint8_t input[TRISize + 1] = "ABCDEFGHIJKLMNOP";
+ const MB mbInput(input, MakePowerOfTwo32<TRISize>());
+
+ // Prepare an output buffer, different from input.
+ uint8_t output[TRISize + 1] = "abcdefghijklmnop";
+ MB mbOutput(output, MakePowerOfTwo32<TRISize>());
+
+ // Run ReadInto.
+ auto writer = mbOutput.WriterAt(aWriteTo);
+ mbInput.ReaderAt(aReadFrom).ReadInto(writer, aBytes);
+
+ // Do the same operation manually.
+ uint8_t outputCheck[TRISize + 1] = "abcdefghijklmnop";
+ MB mbOutputCheck(outputCheck, MakePowerOfTwo32<TRISize>());
+ auto readerCheck = mbInput.ReaderAt(aReadFrom);
+ auto writerCheck = mbOutputCheck.WriterAt(aWriteTo);
+ for (MB::Length i = 0; i < aBytes; ++i) {
+ *writerCheck++ = *readerCheck++;
+ }
+
+ // Compare the two outputs.
+ for (uint32_t i = 0; i < TRISize; ++i) {
+# ifdef TEST_MODULOBUFFER_FAILURE_DEBUG
+ // Only used when debugging failures.
+ if (output[i] != outputCheck[i]) {
+ printf(
+ "*** from=%u to=%u bytes=%u i=%u\ninput: '%s'\noutput: "
+ "'%s'\ncheck: '%s'\n",
+ unsigned(aReadFrom), unsigned(aWriteTo), unsigned(aBytes),
+ unsigned(i), input, output, outputCheck);
+ }
+# endif
+ MOZ_RELEASE_ASSERT(output[i] == outputCheck[i]);
+ }
+
+# ifdef TEST_MODULOBUFFER_HELPER
+ // Only used when adding more tests.
+ printf("*** from=%u to=%u bytes=%u output: %s\n", unsigned(aReadFrom),
+ unsigned(aWriteTo), unsigned(aBytes), output);
+# endif
+
+ return std::string(reinterpret_cast<const char*>(output));
+ };
+
+ // A few manual checks:
+ constexpr uint32_t TRISize = 16;
+ MOZ_RELEASE_ASSERT(TestReadInto(0, 0, 0) == "abcdefghijklmnop");
+ MOZ_RELEASE_ASSERT(TestReadInto(0, 0, TRISize) == "ABCDEFGHIJKLMNOP");
+ MOZ_RELEASE_ASSERT(TestReadInto(0, 5, TRISize) == "LMNOPABCDEFGHIJK");
+ MOZ_RELEASE_ASSERT(TestReadInto(5, 0, TRISize) == "FGHIJKLMNOPABCDE");
+
+ // Test everything! (16^3 = 4096, not too much.)
+ for (MB::Index r = 0; r < TRISize; ++r) {
+ for (MB::Index w = 0; w < TRISize; ++w) {
+ for (MB::Length len = 0; len < TRISize; ++len) {
+ TestReadInto(r, w, len);
+ }
+ }
+ }
+
+ printf("TestModuloBuffer done\n");
+}
+
+void TestBlocksRingBufferAPI() {
+ printf("TestBlocksRingBufferAPI...\n");
+
+ // Create a 16-byte buffer, enough to store up to 3 entries (1 byte size + 4
+ // bytes uint64_t).
+ constexpr uint32_t MBSize = 16;
+ uint8_t buffer[MBSize * 3];
+ for (size_t i = 0; i < MBSize * 3; ++i) {
+ buffer[i] = uint8_t('A' + i);
+ }
+
+ // Start a temporary block to constrain buffer lifetime.
+ {
+ BlocksRingBuffer rb(BlocksRingBuffer::ThreadSafety::WithMutex,
+ &buffer[MBSize], MakePowerOfTwo32<MBSize>());
+
+# define VERIFY_START_END_PUSHED_CLEARED(aStart, aEnd, aPushed, aCleared) \
+ { \
+ BlocksRingBuffer::State state = rb.GetState(); \
+ MOZ_RELEASE_ASSERT(state.mRangeStart.ConvertToProfileBufferIndex() == \
+ (aStart)); \
+ MOZ_RELEASE_ASSERT(state.mRangeEnd.ConvertToProfileBufferIndex() == \
+ (aEnd)); \
+ MOZ_RELEASE_ASSERT(state.mPushedBlockCount == (aPushed)); \
+ MOZ_RELEASE_ASSERT(state.mClearedBlockCount == (aCleared)); \
+ }
+
+ // All entries will contain one 32-bit number. The resulting blocks will
+ // have the following structure:
+ // - 1 byte for the LEB128 size of 4
+ // - 4 bytes for the number.
+ // E.g., if we have entries with `123` and `456`:
+ // .-- Index 0 reserved for empty ProfileBufferBlockIndex, nothing there.
+ // | .-- first readable block at index 1
+ // | |.-- first block at index 1
+ // | ||.-- 1 byte for the entry size, which is `4` (32 bits)
+ // | ||| .-- entry starts at index 2, contains 32-bit int
+ // | ||| | .-- entry and block finish *after* index 5 (so 6)
+ // | ||| | | .-- second block starts at index 6
+ // | ||| | | | etc.
+ // | ||| | | | .-- End readable blocks: 11
+ // v vvv v v V v
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+ // - S[4 | int(123) ] [4 | int(456) ]E
+
+ // Empty buffer to start with.
+ // Start&end indices still at 1 (0 is reserved for the default
+ // ProfileBufferBlockIndex{} that cannot point at a valid entry), nothing
+ // cleared.
+ VERIFY_START_END_PUSHED_CLEARED(1, 1, 0, 0);
+
+ // Default ProfileBufferBlockIndex.
+ ProfileBufferBlockIndex bi0;
+ if (bi0) {
+ MOZ_RELEASE_ASSERT(false,
+ "if (ProfileBufferBlockIndex{}) should fail test");
+ }
+ if (!bi0) {
+ } else {
+ MOZ_RELEASE_ASSERT(false,
+ "if (!ProfileBufferBlockIndex{}) should succeed test");
+ }
+ MOZ_RELEASE_ASSERT(!bi0);
+ MOZ_RELEASE_ASSERT(bi0 == bi0);
+ MOZ_RELEASE_ASSERT(bi0 <= bi0);
+ MOZ_RELEASE_ASSERT(bi0 >= bi0);
+ MOZ_RELEASE_ASSERT(!(bi0 != bi0));
+ MOZ_RELEASE_ASSERT(!(bi0 < bi0));
+ MOZ_RELEASE_ASSERT(!(bi0 > bi0));
+
+ // Default ProfileBufferBlockIndex can be used, but returns no valid entry.
+ rb.ReadAt(bi0, [](Maybe<ProfileBufferEntryReader>&& aMaybeReader) {
+ MOZ_RELEASE_ASSERT(aMaybeReader.isNothing());
+ });
+
+ // Push `1` directly.
+ MOZ_RELEASE_ASSERT(
+ rb.PutObject(uint32_t(1)).ConvertToProfileBufferIndex() == 1);
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+ // - S[4 | int(1) ]E
+ VERIFY_START_END_PUSHED_CLEARED(1, 6, 1, 0);
+
+ // Push `2` through ReserveAndPut, check output ProfileBufferBlockIndex.
+ auto bi2 = rb.ReserveAndPut([]() { return sizeof(uint32_t); },
+ [](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ aEW->WriteObject(uint32_t(2));
+ return aEW->CurrentBlockIndex();
+ });
+ static_assert(std::is_same<decltype(bi2), ProfileBufferBlockIndex>::value,
+ "All index-returning functions should return a "
+ "ProfileBufferBlockIndex");
+ MOZ_RELEASE_ASSERT(bi2.ConvertToProfileBufferIndex() == 6);
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+ // - S[4 | int(1) ] [4 | int(2) ]E
+ VERIFY_START_END_PUSHED_CLEARED(1, 11, 2, 0);
+
+ // Check single entry at bi2, store next block index.
+ auto i2Next =
+ rb.ReadAt(bi2, [bi2](Maybe<ProfileBufferEntryReader>&& aMaybeReader) {
+ MOZ_RELEASE_ASSERT(aMaybeReader.isSome());
+ MOZ_RELEASE_ASSERT(aMaybeReader->CurrentBlockIndex() == bi2);
+ MOZ_RELEASE_ASSERT(aMaybeReader->NextBlockIndex() == nullptr);
+ size_t entrySize = aMaybeReader->RemainingBytes();
+ MOZ_RELEASE_ASSERT(aMaybeReader->ReadObject<uint32_t>() == 2);
+ // The next block index is after this block, which is made of the
+ // entry size (coded as ULEB128) followed by the entry itself.
+ return bi2.ConvertToProfileBufferIndex() + ULEB128Size(entrySize) +
+ entrySize;
+ });
+ auto bi2Next = rb.GetState().mRangeEnd;
+ MOZ_RELEASE_ASSERT(bi2Next.ConvertToProfileBufferIndex() == i2Next);
+ // bi2Next is at the end, nothing to read.
+ rb.ReadAt(bi2Next, [](Maybe<ProfileBufferEntryReader>&& aMaybeReader) {
+ MOZ_RELEASE_ASSERT(aMaybeReader.isNothing());
+ });
+
+ // ProfileBufferBlockIndex tests.
+ if (bi2) {
+ } else {
+ MOZ_RELEASE_ASSERT(
+ false,
+ "if (non-default-ProfileBufferBlockIndex) should succeed test");
+ }
+ if (!bi2) {
+ MOZ_RELEASE_ASSERT(
+ false, "if (!non-default-ProfileBufferBlockIndex) should fail test");
+ }
+
+ MOZ_RELEASE_ASSERT(!!bi2);
+ MOZ_RELEASE_ASSERT(bi2 == bi2);
+ MOZ_RELEASE_ASSERT(bi2 <= bi2);
+ MOZ_RELEASE_ASSERT(bi2 >= bi2);
+ MOZ_RELEASE_ASSERT(!(bi2 != bi2));
+ MOZ_RELEASE_ASSERT(!(bi2 < bi2));
+ MOZ_RELEASE_ASSERT(!(bi2 > bi2));
+
+ MOZ_RELEASE_ASSERT(bi0 != bi2);
+ MOZ_RELEASE_ASSERT(bi0 < bi2);
+ MOZ_RELEASE_ASSERT(bi0 <= bi2);
+ MOZ_RELEASE_ASSERT(!(bi0 == bi2));
+ MOZ_RELEASE_ASSERT(!(bi0 > bi2));
+ MOZ_RELEASE_ASSERT(!(bi0 >= bi2));
+
+ MOZ_RELEASE_ASSERT(bi2 != bi0);
+ MOZ_RELEASE_ASSERT(bi2 > bi0);
+ MOZ_RELEASE_ASSERT(bi2 >= bi0);
+ MOZ_RELEASE_ASSERT(!(bi2 == bi0));
+ MOZ_RELEASE_ASSERT(!(bi2 < bi0));
+ MOZ_RELEASE_ASSERT(!(bi2 <= bi0));
+
+ MOZ_RELEASE_ASSERT(bi2 != bi2Next);
+ MOZ_RELEASE_ASSERT(bi2 < bi2Next);
+ MOZ_RELEASE_ASSERT(bi2 <= bi2Next);
+ MOZ_RELEASE_ASSERT(!(bi2 == bi2Next));
+ MOZ_RELEASE_ASSERT(!(bi2 > bi2Next));
+ MOZ_RELEASE_ASSERT(!(bi2 >= bi2Next));
+
+ MOZ_RELEASE_ASSERT(bi2Next != bi2);
+ MOZ_RELEASE_ASSERT(bi2Next > bi2);
+ MOZ_RELEASE_ASSERT(bi2Next >= bi2);
+ MOZ_RELEASE_ASSERT(!(bi2Next == bi2));
+ MOZ_RELEASE_ASSERT(!(bi2Next < bi2));
+ MOZ_RELEASE_ASSERT(!(bi2Next <= bi2));
+
+ // Push `3` through Put, check writer output
+ // is returned to the initial caller.
+ auto put3 =
+ rb.Put(sizeof(uint32_t), [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ aEW->WriteObject(uint32_t(3));
+ MOZ_RELEASE_ASSERT(aEW->CurrentBlockIndex() == bi2Next);
+ return float(aEW->CurrentBlockIndex().ConvertToProfileBufferIndex());
+ });
+ static_assert(std::is_same<decltype(put3), float>::value,
+ "Expect float as returned by callback.");
+ MOZ_RELEASE_ASSERT(put3 == 11.0);
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (16)
+ // - S[4 | int(1) ] [4 | int(2) ] [4 | int(3) ]E
+ VERIFY_START_END_PUSHED_CLEARED(1, 16, 3, 0);
+
+ // Re-Read single entry at bi2, it should now have a next entry.
+ rb.ReadAt(bi2, [&](Maybe<ProfileBufferEntryReader>&& aMaybeReader) {
+ MOZ_RELEASE_ASSERT(aMaybeReader.isSome());
+ MOZ_RELEASE_ASSERT(aMaybeReader->CurrentBlockIndex() == bi2);
+ MOZ_RELEASE_ASSERT(aMaybeReader->ReadObject<uint32_t>() == 2);
+ MOZ_RELEASE_ASSERT(aMaybeReader->NextBlockIndex() == bi2Next);
+ });
+
+ // Check that we have `1` to `3`.
+ uint32_t count = 0;
+ rb.ReadEach([&](ProfileBufferEntryReader& aReader) {
+ MOZ_RELEASE_ASSERT(aReader.ReadObject<uint32_t>() == ++count);
+ });
+ MOZ_RELEASE_ASSERT(count == 3);
+
+ // Push `4`, store its ProfileBufferBlockIndex for later.
+ // This will wrap around, and clear the first entry.
+ ProfileBufferBlockIndex bi4 = rb.PutObject(uint32_t(4));
+ // Before:
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (16)
+ // - S[4 | int(1) ] [4 | int(2) ] [4 | int(3) ]E
+ // 1. First entry cleared:
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (16)
+ // - ? ? ? ? ? S[4 | int(2) ] [4 | int(3) ]E
+ // 2. New entry starts at 15 and wraps around: (shown on separate line)
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (16)
+ // - ? ? ? ? ? S[4 | int(2) ] [4 | int(3) ]
+ // 16 17 18 19 20 21 ...
+ // [4 | int(4) ]E
+ // (collapsed)
+ // 16 17 18 19 20 21 6 7 8 9 10 11 12 13 14 15 (16)
+ // [4 | int(4) ]E ? S[4 | int(2) ] [4 | int(3) ]
+ VERIFY_START_END_PUSHED_CLEARED(6, 21, 4, 1);
+
+ // Check that we have `2` to `4`.
+ count = 1;
+ rb.ReadEach([&](ProfileBufferEntryReader& aReader) {
+ MOZ_RELEASE_ASSERT(aReader.ReadObject<uint32_t>() == ++count);
+ });
+ MOZ_RELEASE_ASSERT(count == 4);
+
+ // Push 5 through Put, no returns.
+ // This will clear the second entry.
+ // Check that the EntryWriter can access bi4 but not bi2.
+ auto bi5 =
+ rb.Put(sizeof(uint32_t), [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ aEW->WriteObject(uint32_t(5));
+ return aEW->CurrentBlockIndex();
+ });
+ auto bi6 = rb.GetState().mRangeEnd;
+ // 16 17 18 19 20 21 22 23 24 25 26 11 12 13 14 15 (16)
+ // [4 | int(4) ] [4 | int(5) ]E ? S[4 | int(3) ]
+ VERIFY_START_END_PUSHED_CLEARED(11, 26, 5, 2);
+
+ // Read single entry at bi2, should now gracefully fail.
+ rb.ReadAt(bi2, [](Maybe<ProfileBufferEntryReader>&& aMaybeReader) {
+ MOZ_RELEASE_ASSERT(aMaybeReader.isNothing());
+ });
+
+ // Read single entry at bi5.
+ rb.ReadAt(bi5, [](Maybe<ProfileBufferEntryReader>&& aMaybeReader) {
+ MOZ_RELEASE_ASSERT(aMaybeReader.isSome());
+ MOZ_RELEASE_ASSERT(aMaybeReader->ReadObject<uint32_t>() == 5);
+ });
+
+ rb.Read([&](BlocksRingBuffer::Reader* aReader) {
+ MOZ_RELEASE_ASSERT(!!aReader);
+ // begin() and end() should be at the range edges (verified above).
+ MOZ_RELEASE_ASSERT(
+ aReader->begin().CurrentBlockIndex().ConvertToProfileBufferIndex() ==
+ 11);
+ MOZ_RELEASE_ASSERT(
+ aReader->end().CurrentBlockIndex().ConvertToProfileBufferIndex() ==
+ 26);
+ // Null ProfileBufferBlockIndex clamped to the beginning.
+ MOZ_RELEASE_ASSERT(aReader->At(bi0) == aReader->begin());
+ // Cleared block index clamped to the beginning.
+ MOZ_RELEASE_ASSERT(aReader->At(bi2) == aReader->begin());
+ // At(begin) same as begin().
+ MOZ_RELEASE_ASSERT(aReader->At(aReader->begin().CurrentBlockIndex()) ==
+ aReader->begin());
+ // bi5 at expected position.
+ MOZ_RELEASE_ASSERT(
+ aReader->At(bi5).CurrentBlockIndex().ConvertToProfileBufferIndex() ==
+ 21);
+ // bi6 at expected position at the end.
+ MOZ_RELEASE_ASSERT(aReader->At(bi6) == aReader->end());
+ // At(end) same as end().
+ MOZ_RELEASE_ASSERT(aReader->At(aReader->end().CurrentBlockIndex()) ==
+ aReader->end());
+ });
+
+ // Check that we have `3` to `5`.
+ count = 2;
+ rb.ReadEach([&](ProfileBufferEntryReader& aReader) {
+ MOZ_RELEASE_ASSERT(aReader.ReadObject<uint32_t>() == ++count);
+ });
+ MOZ_RELEASE_ASSERT(count == 5);
+
+ // Clear everything before `4`, this should clear `3`.
+ rb.ClearBefore(bi4);
+ // 16 17 18 19 20 21 22 23 24 25 26 11 12 13 14 15
+ // S[4 | int(4) ] [4 | int(5) ]E ? ? ? ? ? ?
+ VERIFY_START_END_PUSHED_CLEARED(16, 26, 5, 3);
+
+ // Check that we have `4` to `5`.
+ count = 3;
+ rb.ReadEach([&](ProfileBufferEntryReader& aReader) {
+ MOZ_RELEASE_ASSERT(aReader.ReadObject<uint32_t>() == ++count);
+ });
+ MOZ_RELEASE_ASSERT(count == 5);
+
+ // Clear everything before `4` again, nothing to clear.
+ rb.ClearBefore(bi4);
+ VERIFY_START_END_PUSHED_CLEARED(16, 26, 5, 3);
+
+ // Clear everything, this should clear `4` and `5`, and bring the start
+ // index where the end index currently is.
+ rb.ClearBefore(bi6);
+ // 16 17 18 19 20 21 22 23 24 25 26 11 12 13 14 15
+ // ? ? ? ? ? ? ? ? ? ? SE? ? ? ? ? ?
+ VERIFY_START_END_PUSHED_CLEARED(26, 26, 5, 5);
+
+ // Check that we have nothing to read.
+ rb.ReadEach([&](auto&&) { MOZ_RELEASE_ASSERT(false); });
+
+ // Read single entry at bi5, should now gracefully fail.
+ rb.ReadAt(bi5, [](Maybe<ProfileBufferEntryReader>&& aMaybeReader) {
+ MOZ_RELEASE_ASSERT(aMaybeReader.isNothing());
+ });
+
+ // Clear everything before now-cleared `4`, nothing to clear.
+ rb.ClearBefore(bi4);
+ VERIFY_START_END_PUSHED_CLEARED(26, 26, 5, 5);
+
+ // Push `6` directly.
+ MOZ_RELEASE_ASSERT(rb.PutObject(uint32_t(6)) == bi6);
+ // 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+ // ? ? ? ? ? ? ? ? ? ? S[4 | int(6) ]E ?
+ VERIFY_START_END_PUSHED_CLEARED(26, 31, 6, 5);
+
+ {
+ // Create a 2nd buffer and fill it with `7` and `8`.
+ uint8_t buffer2[MBSize];
+ BlocksRingBuffer rb2(BlocksRingBuffer::ThreadSafety::WithoutMutex,
+ buffer2, MakePowerOfTwo32<MBSize>());
+ rb2.PutObject(uint32_t(7));
+ rb2.PutObject(uint32_t(8));
+ // Main buffer shouldn't have changed.
+ VERIFY_START_END_PUSHED_CLEARED(26, 31, 6, 5);
+
+ // Append contents of rb2 to rb, this should end up being the same as
+ // pushing the two numbers.
+ rb.AppendContents(rb2);
+ // 32 33 34 35 36 37 38 39 40 41 26 27 28 29 30 31
+ // int(7) ] [4 | int(8) ]E ? S[4 | int(6) ] [4 |
+ VERIFY_START_END_PUSHED_CLEARED(26, 41, 8, 5);
+
+ // Append contents of rb2 to rb again, to verify that rb2 was not modified
+ // above. This should clear `6` and the first `7`.
+ rb.AppendContents(rb2);
+ // 48 49 50 51 36 37 38 39 40 41 42 43 44 45 46 47
+ // int(8) ]E ? S[4 | int(8) ] [4 | int(7) ] [4 |
+ VERIFY_START_END_PUSHED_CLEARED(36, 51, 10, 7);
+
+ // End of block where rb2 lives, to verify that it is not needed anymore
+ // for its copied values to survive in rb.
+ }
+ VERIFY_START_END_PUSHED_CLEARED(36, 51, 10, 7);
+
+ // bi6 should now have been cleared.
+ rb.ReadAt(bi6, [](Maybe<ProfileBufferEntryReader>&& aMaybeReader) {
+ MOZ_RELEASE_ASSERT(aMaybeReader.isNothing());
+ });
+
+ // Check that we have `8`, `7`, `8`.
+ count = 0;
+ uint32_t expected[3] = {8, 7, 8};
+ rb.ReadEach([&](ProfileBufferEntryReader& aReader) {
+ MOZ_RELEASE_ASSERT(count < 3);
+ MOZ_RELEASE_ASSERT(aReader.ReadObject<uint32_t>() == expected[count++]);
+ });
+ MOZ_RELEASE_ASSERT(count == 3);
+
+ // End of block where rb lives, BlocksRingBuffer destructor should call
+ // entry destructor for remaining entries.
+ }
+
+ // Check that only the provided stack-based sub-buffer was modified.
+ uint32_t changed = 0;
+ for (size_t i = MBSize; i < MBSize * 2; ++i) {
+ changed += (buffer[i] == uint8_t('A' + i)) ? 0 : 1;
+ }
+ // Expect at least 75% changes.
+ MOZ_RELEASE_ASSERT(changed >= MBSize * 6 / 8);
+
+ // Everything around the sub-buffer should be unchanged.
+ for (size_t i = 0; i < MBSize; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+ for (size_t i = MBSize * 2; i < MBSize * 3; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+
+ printf("TestBlocksRingBufferAPI done\n");
+}
+
+void TestBlocksRingBufferUnderlyingBufferChanges() {
+ printf("TestBlocksRingBufferUnderlyingBufferChanges...\n");
+
+ // Out-of-session BlocksRingBuffer to start with.
+ BlocksRingBuffer rb(BlocksRingBuffer::ThreadSafety::WithMutex);
+
+ // Block index to read at. Initially "null", but may be changed below.
+ ProfileBufferBlockIndex bi;
+
+ // Test all rb APIs when rb is out-of-session and therefore doesn't have an
+ // underlying buffer.
+ auto testOutOfSession = [&]() {
+ MOZ_RELEASE_ASSERT(rb.BufferLength().isNothing());
+ BlocksRingBuffer::State state = rb.GetState();
+ // When out-of-session, range start and ends are the same, and there are no
+ // pushed&cleared blocks.
+ MOZ_RELEASE_ASSERT(state.mRangeStart == state.mRangeEnd);
+ MOZ_RELEASE_ASSERT(state.mPushedBlockCount == 0);
+ MOZ_RELEASE_ASSERT(state.mClearedBlockCount == 0);
+ // `Put()` functions run the callback with `Nothing`.
+ int32_t ran = 0;
+ rb.Put(1, [&](Maybe<ProfileBufferEntryWriter>& aMaybeEntryWriter) {
+ MOZ_RELEASE_ASSERT(aMaybeEntryWriter.isNothing());
+ ++ran;
+ });
+ MOZ_RELEASE_ASSERT(ran == 1);
+ // `PutFrom` won't do anything, and returns the null
+ // ProfileBufferBlockIndex.
+ MOZ_RELEASE_ASSERT(rb.PutFrom(&ran, sizeof(ran)) ==
+ ProfileBufferBlockIndex{});
+ MOZ_RELEASE_ASSERT(rb.PutObject(ran) == ProfileBufferBlockIndex{});
+ // `Read()` functions run the callback with `Nothing`.
+ ran = 0;
+ rb.Read([&](BlocksRingBuffer::Reader* aReader) {
+ MOZ_RELEASE_ASSERT(!aReader);
+ ++ran;
+ });
+ MOZ_RELEASE_ASSERT(ran == 1);
+ ran = 0;
+ rb.ReadAt(ProfileBufferBlockIndex{},
+ [&](Maybe<ProfileBufferEntryReader>&& aMaybeEntryReader) {
+ MOZ_RELEASE_ASSERT(aMaybeEntryReader.isNothing());
+ ++ran;
+ });
+ MOZ_RELEASE_ASSERT(ran == 1);
+ ran = 0;
+ rb.ReadAt(bi, [&](Maybe<ProfileBufferEntryReader>&& aMaybeEntryReader) {
+ MOZ_RELEASE_ASSERT(aMaybeEntryReader.isNothing());
+ ++ran;
+ });
+ MOZ_RELEASE_ASSERT(ran == 1);
+ // `ReadEach` shouldn't run the callback (nothing to read).
+ rb.ReadEach([](auto&&) { MOZ_RELEASE_ASSERT(false); });
+ };
+
+ // As `testOutOfSession()` attempts to modify the buffer, we run it twice to
+ // make sure one run doesn't influence the next one.
+ testOutOfSession();
+ testOutOfSession();
+
+ rb.ClearBefore(bi);
+ testOutOfSession();
+ testOutOfSession();
+
+ rb.Clear();
+ testOutOfSession();
+ testOutOfSession();
+
+ rb.Reset();
+ testOutOfSession();
+ testOutOfSession();
+
+ constexpr uint32_t MBSize = 32;
+
+ rb.Set(MakePowerOfTwo<BlocksRingBuffer::Length, MBSize>());
+
+ constexpr bool EMPTY = true;
+ constexpr bool NOT_EMPTY = false;
+ // Test all rb APIs when rb has an underlying buffer.
+ auto testInSession = [&](bool aExpectEmpty) {
+ MOZ_RELEASE_ASSERT(rb.BufferLength().isSome());
+ BlocksRingBuffer::State state = rb.GetState();
+ if (aExpectEmpty) {
+ MOZ_RELEASE_ASSERT(state.mRangeStart == state.mRangeEnd);
+ MOZ_RELEASE_ASSERT(state.mPushedBlockCount == 0);
+ MOZ_RELEASE_ASSERT(state.mClearedBlockCount == 0);
+ } else {
+ MOZ_RELEASE_ASSERT(state.mRangeStart < state.mRangeEnd);
+ MOZ_RELEASE_ASSERT(state.mPushedBlockCount > 0);
+ MOZ_RELEASE_ASSERT(state.mClearedBlockCount <= state.mPushedBlockCount);
+ }
+ int32_t ran = 0;
+ // The following three `Put...` will write three int32_t of value 1.
+ bi = rb.Put(sizeof(ran),
+ [&](Maybe<ProfileBufferEntryWriter>& aMaybeEntryWriter) {
+ MOZ_RELEASE_ASSERT(aMaybeEntryWriter.isSome());
+ ++ran;
+ aMaybeEntryWriter->WriteObject(ran);
+ return aMaybeEntryWriter->CurrentBlockIndex();
+ });
+ MOZ_RELEASE_ASSERT(ran == 1);
+ MOZ_RELEASE_ASSERT(rb.PutFrom(&ran, sizeof(ran)) !=
+ ProfileBufferBlockIndex{});
+ MOZ_RELEASE_ASSERT(rb.PutObject(ran) != ProfileBufferBlockIndex{});
+ ran = 0;
+ rb.Read([&](BlocksRingBuffer::Reader* aReader) {
+ MOZ_RELEASE_ASSERT(!!aReader);
+ ++ran;
+ });
+ MOZ_RELEASE_ASSERT(ran == 1);
+ ran = 0;
+ rb.ReadEach([&](ProfileBufferEntryReader& aEntryReader) {
+ MOZ_RELEASE_ASSERT(aEntryReader.RemainingBytes() == sizeof(ran));
+ MOZ_RELEASE_ASSERT(aEntryReader.ReadObject<decltype(ran)>() == 1);
+ ++ran;
+ });
+ MOZ_RELEASE_ASSERT(ran >= 3);
+ ran = 0;
+ rb.ReadAt(ProfileBufferBlockIndex{},
+ [&](Maybe<ProfileBufferEntryReader>&& aMaybeEntryReader) {
+ MOZ_RELEASE_ASSERT(aMaybeEntryReader.isNothing());
+ ++ran;
+ });
+ MOZ_RELEASE_ASSERT(ran == 1);
+ ran = 0;
+ rb.ReadAt(bi, [&](Maybe<ProfileBufferEntryReader>&& aMaybeEntryReader) {
+ MOZ_RELEASE_ASSERT(aMaybeEntryReader.isNothing() == !bi);
+ ++ran;
+ });
+ MOZ_RELEASE_ASSERT(ran == 1);
+ };
+
+ testInSession(EMPTY);
+ testInSession(NOT_EMPTY);
+
+ rb.Set(MakePowerOfTwo<BlocksRingBuffer::Length, 32>());
+ MOZ_RELEASE_ASSERT(rb.BufferLength().isSome());
+ rb.ReadEach([](auto&&) { MOZ_RELEASE_ASSERT(false); });
+
+ testInSession(EMPTY);
+ testInSession(NOT_EMPTY);
+
+ rb.Reset();
+ testOutOfSession();
+ testOutOfSession();
+
+ uint8_t buffer[MBSize * 3];
+ for (size_t i = 0; i < MBSize * 3; ++i) {
+ buffer[i] = uint8_t('A' + i);
+ }
+
+ rb.Set(&buffer[MBSize], MakePowerOfTwo<BlocksRingBuffer::Length, MBSize>());
+ MOZ_RELEASE_ASSERT(rb.BufferLength().isSome());
+ rb.ReadEach([](auto&&) { MOZ_RELEASE_ASSERT(false); });
+
+ testInSession(EMPTY);
+ testInSession(NOT_EMPTY);
+
+ rb.Reset();
+ testOutOfSession();
+ testOutOfSession();
+
+ rb.Set(&buffer[MBSize], MakePowerOfTwo<BlocksRingBuffer::Length, MBSize>());
+ MOZ_RELEASE_ASSERT(rb.BufferLength().isSome());
+ rb.ReadEach([](auto&&) { MOZ_RELEASE_ASSERT(false); });
+
+ testInSession(EMPTY);
+ testInSession(NOT_EMPTY);
+
+ // Remove the current underlying buffer, this should clear all entries.
+ rb.Reset();
+
+ // Check that only the provided stack-based sub-buffer was modified.
+ uint32_t changed = 0;
+ for (size_t i = MBSize; i < MBSize * 2; ++i) {
+ changed += (buffer[i] == uint8_t('A' + i)) ? 0 : 1;
+ }
+ // Expect at least 75% changes.
+ MOZ_RELEASE_ASSERT(changed >= MBSize * 6 / 8);
+
+ // Everything around the sub-buffer should be unchanged.
+ for (size_t i = 0; i < MBSize; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+ for (size_t i = MBSize * 2; i < MBSize * 3; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+
+ testOutOfSession();
+ testOutOfSession();
+
+ printf("TestBlocksRingBufferUnderlyingBufferChanges done\n");
+}
+
+void TestBlocksRingBufferThreading() {
+ printf("TestBlocksRingBufferThreading...\n");
+
+ constexpr uint32_t MBSize = 8192;
+ uint8_t buffer[MBSize * 3];
+ for (size_t i = 0; i < MBSize * 3; ++i) {
+ buffer[i] = uint8_t('A' + i);
+ }
+ BlocksRingBuffer rb(BlocksRingBuffer::ThreadSafety::WithMutex,
+ &buffer[MBSize], MakePowerOfTwo32<MBSize>());
+
+ // Start reader thread.
+ std::atomic<bool> stopReader{false};
+ std::thread reader([&]() {
+ for (;;) {
+ BlocksRingBuffer::State state = rb.GetState();
+ printf(
+ "Reader: range=%llu..%llu (%llu bytes) pushed=%llu cleared=%llu "
+ "(alive=%llu)\n",
+ static_cast<unsigned long long>(
+ state.mRangeStart.ConvertToProfileBufferIndex()),
+ static_cast<unsigned long long>(
+ state.mRangeEnd.ConvertToProfileBufferIndex()),
+ static_cast<unsigned long long>(
+ state.mRangeEnd.ConvertToProfileBufferIndex()) -
+ static_cast<unsigned long long>(
+ state.mRangeStart.ConvertToProfileBufferIndex()),
+ static_cast<unsigned long long>(state.mPushedBlockCount),
+ static_cast<unsigned long long>(state.mClearedBlockCount),
+ static_cast<unsigned long long>(state.mPushedBlockCount -
+ state.mClearedBlockCount));
+ if (stopReader) {
+ break;
+ }
+ ::SleepMilli(1);
+ }
+ });
+
+ // Start writer threads.
+ constexpr int ThreadCount = 32;
+ std::thread threads[ThreadCount];
+ for (int threadNo = 0; threadNo < ThreadCount; ++threadNo) {
+ threads[threadNo] = std::thread(
+ [&](int aThreadNo) {
+ ::SleepMilli(1);
+ constexpr int pushCount = 1024;
+ for (int push = 0; push < pushCount; ++push) {
+ // Reserve as many bytes as the thread number (but at least enough
+ // to store an int), and write an increasing int.
+ rb.Put(std::max(aThreadNo, int(sizeof(push))),
+ [&](Maybe<ProfileBufferEntryWriter>& aEW) {
+ MOZ_RELEASE_ASSERT(aEW.isSome());
+ aEW->WriteObject(aThreadNo * 1000000 + push);
+ *aEW += aEW->RemainingBytes();
+ });
+ }
+ },
+ threadNo);
+ }
+
+ // Wait for all writer threads to die.
+ for (auto&& thread : threads) {
+ thread.join();
+ }
+
+ // Stop reader thread.
+ stopReader = true;
+ reader.join();
+
+ // Check that only the provided stack-based sub-buffer was modified.
+ uint32_t changed = 0;
+ for (size_t i = MBSize; i < MBSize * 2; ++i) {
+ changed += (buffer[i] == uint8_t('A' + i)) ? 0 : 1;
+ }
+ // Expect at least 75% changes.
+ MOZ_RELEASE_ASSERT(changed >= MBSize * 6 / 8);
+
+ // Everything around the sub-buffer should be unchanged.
+ for (size_t i = 0; i < MBSize; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+ for (size_t i = MBSize * 2; i < MBSize * 3; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+
+ printf("TestBlocksRingBufferThreading done\n");
+}
+
+void TestBlocksRingBufferSerialization() {
+ printf("TestBlocksRingBufferSerialization...\n");
+
+ constexpr uint32_t MBSize = 64;
+ uint8_t buffer[MBSize * 3];
+ for (size_t i = 0; i < MBSize * 3; ++i) {
+ buffer[i] = uint8_t('A' + i);
+ }
+ BlocksRingBuffer rb(BlocksRingBuffer::ThreadSafety::WithMutex,
+ &buffer[MBSize], MakePowerOfTwo32<MBSize>());
+
+ // Will expect literal string to always have the same address.
+# define THE_ANSWER "The answer is "
+ const char* theAnswer = THE_ANSWER;
+
+ rb.PutObjects('0', WrapProfileBufferLiteralCStringPointer(THE_ANSWER), 42,
+ std::string(" but pi="), 3.14);
+ rb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ char c0;
+ const char* answer;
+ int integer;
+ std::string str;
+ double pi;
+ aER.ReadIntoObjects(c0, answer, integer, str, pi);
+ MOZ_RELEASE_ASSERT(c0 == '0');
+ MOZ_RELEASE_ASSERT(answer == theAnswer);
+ MOZ_RELEASE_ASSERT(integer == 42);
+ MOZ_RELEASE_ASSERT(str == " but pi=");
+ MOZ_RELEASE_ASSERT(pi == 3.14);
+ });
+ rb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ char c0 = aER.ReadObject<char>();
+ MOZ_RELEASE_ASSERT(c0 == '0');
+ const char* answer = aER.ReadObject<const char*>();
+ MOZ_RELEASE_ASSERT(answer == theAnswer);
+ int integer = aER.ReadObject<int>();
+ MOZ_RELEASE_ASSERT(integer == 42);
+ std::string str = aER.ReadObject<std::string>();
+ MOZ_RELEASE_ASSERT(str == " but pi=");
+ double pi = aER.ReadObject<double>();
+ MOZ_RELEASE_ASSERT(pi == 3.14);
+ });
+
+ rb.Clear();
+ // Write an int and store its ProfileBufferBlockIndex.
+ ProfileBufferBlockIndex blockIndex = rb.PutObject(123);
+ // It should be non-0.
+ MOZ_RELEASE_ASSERT(blockIndex != ProfileBufferBlockIndex{});
+ // Write that ProfileBufferBlockIndex.
+ rb.PutObject(blockIndex);
+ rb.Read([&](BlocksRingBuffer::Reader* aR) {
+ BlocksRingBuffer::BlockIterator it = aR->begin();
+ const BlocksRingBuffer::BlockIterator itEnd = aR->end();
+ MOZ_RELEASE_ASSERT(it != itEnd);
+ MOZ_RELEASE_ASSERT((*it).ReadObject<int>() == 123);
+ ++it;
+ MOZ_RELEASE_ASSERT(it != itEnd);
+ MOZ_RELEASE_ASSERT((*it).ReadObject<ProfileBufferBlockIndex>() ==
+ blockIndex);
+ ++it;
+ MOZ_RELEASE_ASSERT(it == itEnd);
+ });
+
+ rb.Clear();
+ rb.PutObjects(
+ std::make_tuple('0', WrapProfileBufferLiteralCStringPointer(THE_ANSWER),
+ 42, std::string(" but pi="), 3.14));
+ rb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(aER.ReadObject<char>() == '0');
+ MOZ_RELEASE_ASSERT(aER.ReadObject<const char*>() == theAnswer);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<int>() == 42);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<std::string>() == " but pi=");
+ MOZ_RELEASE_ASSERT(aER.ReadObject<double>() == 3.14);
+ });
+
+ rb.Clear();
+ rb.PutObjects(
+ std::make_tuple('0', WrapProfileBufferLiteralCStringPointer(THE_ANSWER),
+ 42, std::string(" but pi="), 3.14));
+ rb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(aER.ReadObject<char>() == '0');
+ MOZ_RELEASE_ASSERT(aER.ReadObject<const char*>() == theAnswer);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<int>() == 42);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<std::string>() == " but pi=");
+ MOZ_RELEASE_ASSERT(aER.ReadObject<double>() == 3.14);
+ });
+
+ rb.Clear();
+ {
+ UniqueFreePtr<char> ufps(strdup(THE_ANSWER));
+ rb.PutObjects(ufps);
+ }
+ rb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ auto ufps = aER.ReadObject<UniqueFreePtr<char>>();
+ MOZ_RELEASE_ASSERT(!!ufps);
+ MOZ_RELEASE_ASSERT(std::string(THE_ANSWER) == ufps.get());
+ });
+
+ rb.Clear();
+ int intArray[] = {1, 2, 3, 4, 5};
+ rb.PutObjects(Span(intArray));
+ rb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ int intArrayOut[sizeof(intArray) / sizeof(intArray[0])] = {0};
+ auto outSpan = Span(intArrayOut);
+ aER.ReadIntoObject(outSpan);
+ for (size_t i = 0; i < sizeof(intArray) / sizeof(intArray[0]); ++i) {
+ MOZ_RELEASE_ASSERT(intArrayOut[i] == intArray[i]);
+ }
+ });
+
+ rb.Clear();
+ rb.PutObjects(Maybe<int>(Nothing{}), Maybe<int>(Some(123)));
+ rb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ Maybe<int> mi0, mi1;
+ aER.ReadIntoObjects(mi0, mi1);
+ MOZ_RELEASE_ASSERT(mi0.isNothing());
+ MOZ_RELEASE_ASSERT(mi1.isSome());
+ MOZ_RELEASE_ASSERT(*mi1 == 123);
+ });
+
+ rb.Clear();
+ using V = Variant<int, double, int>;
+ V v0(VariantIndex<0>{}, 123);
+ V v1(3.14);
+ V v2(VariantIndex<2>{}, 456);
+ rb.PutObjects(v0, v1, v2);
+ rb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v0);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v1);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v2);
+ });
+
+ // 2nd BlocksRingBuffer to contain the 1st one. It has be be more than twice
+ // the size.
+ constexpr uint32_t MBSize2 = MBSize * 4;
+ uint8_t buffer2[MBSize2 * 3];
+ for (size_t i = 0; i < MBSize2 * 3; ++i) {
+ buffer2[i] = uint8_t('B' + i);
+ }
+ BlocksRingBuffer rb2(BlocksRingBuffer::ThreadSafety::WithoutMutex,
+ &buffer2[MBSize2], MakePowerOfTwo32<MBSize2>());
+ rb2.PutObject(rb);
+
+ // 3rd BlocksRingBuffer deserialized from the 2nd one.
+ uint8_t buffer3[MBSize * 3];
+ for (size_t i = 0; i < MBSize * 3; ++i) {
+ buffer3[i] = uint8_t('C' + i);
+ }
+ BlocksRingBuffer rb3(BlocksRingBuffer::ThreadSafety::WithoutMutex,
+ &buffer3[MBSize], MakePowerOfTwo32<MBSize>());
+ rb2.ReadEach([&](ProfileBufferEntryReader& aER) { aER.ReadIntoObject(rb3); });
+
+ // And a 4th heap-allocated one.
+ UniquePtr<BlocksRingBuffer> rb4up;
+ rb2.ReadEach([&](ProfileBufferEntryReader& aER) {
+ rb4up = aER.ReadObject<UniquePtr<BlocksRingBuffer>>();
+ });
+ MOZ_RELEASE_ASSERT(!!rb4up);
+
+ // Clear 1st and 2nd BlocksRingBuffers, to ensure we have made a deep copy
+ // into the 3rd&4th ones.
+ rb.Clear();
+ rb2.Clear();
+
+ // And now the 3rd one should have the same contents as the 1st one had.
+ rb3.ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v0);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v1);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v2);
+ });
+
+ // And 4th.
+ rb4up->ReadEach([&](ProfileBufferEntryReader& aER) {
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v0);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v1);
+ MOZ_RELEASE_ASSERT(aER.ReadObject<V>() == v2);
+ });
+
+ // In fact, the 3rd and 4th ones should have the same state, because they were
+ // created the same way.
+ MOZ_RELEASE_ASSERT(rb3.GetState().mRangeStart ==
+ rb4up->GetState().mRangeStart);
+ MOZ_RELEASE_ASSERT(rb3.GetState().mRangeEnd == rb4up->GetState().mRangeEnd);
+ MOZ_RELEASE_ASSERT(rb3.GetState().mPushedBlockCount ==
+ rb4up->GetState().mPushedBlockCount);
+ MOZ_RELEASE_ASSERT(rb3.GetState().mClearedBlockCount ==
+ rb4up->GetState().mClearedBlockCount);
+
+ // Check that only the provided stack-based sub-buffer was modified.
+ uint32_t changed = 0;
+ for (size_t i = MBSize; i < MBSize * 2; ++i) {
+ changed += (buffer[i] == uint8_t('A' + i)) ? 0 : 1;
+ }
+ // Expect at least 75% changes.
+ MOZ_RELEASE_ASSERT(changed >= MBSize * 6 / 8);
+
+ // Everything around the sub-buffers should be unchanged.
+ for (size_t i = 0; i < MBSize; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+ for (size_t i = MBSize * 2; i < MBSize * 3; ++i) {
+ MOZ_RELEASE_ASSERT(buffer[i] == uint8_t('A' + i));
+ }
+
+ for (size_t i = 0; i < MBSize2; ++i) {
+ MOZ_RELEASE_ASSERT(buffer2[i] == uint8_t('B' + i));
+ }
+ for (size_t i = MBSize2 * 2; i < MBSize2 * 3; ++i) {
+ MOZ_RELEASE_ASSERT(buffer2[i] == uint8_t('B' + i));
+ }
+
+ for (size_t i = 0; i < MBSize; ++i) {
+ MOZ_RELEASE_ASSERT(buffer3[i] == uint8_t('C' + i));
+ }
+ for (size_t i = MBSize * 2; i < MBSize * 3; ++i) {
+ MOZ_RELEASE_ASSERT(buffer3[i] == uint8_t('C' + i));
+ }
+
+ printf("TestBlocksRingBufferSerialization done\n");
+}
+
+void TestLiteralEmptyStringView() {
+ printf("TestLiteralEmptyStringView...\n");
+
+ static_assert(mozilla::LiteralEmptyStringView<char>() ==
+ std::string_view(""));
+ static_assert(!!mozilla::LiteralEmptyStringView<char>().data());
+ static_assert(mozilla::LiteralEmptyStringView<char>().length() == 0);
+
+ static_assert(mozilla::LiteralEmptyStringView<char16_t>() ==
+ std::basic_string_view<char16_t>(u""));
+ static_assert(!!mozilla::LiteralEmptyStringView<char16_t>().data());
+ static_assert(mozilla::LiteralEmptyStringView<char16_t>().length() == 0);
+
+ printf("TestLiteralEmptyStringView done\n");
+}
+
+template <typename CHAR>
+void TestProfilerStringView() {
+ if constexpr (std::is_same_v<CHAR, char>) {
+ printf("TestProfilerStringView<char>...\n");
+ } else if constexpr (std::is_same_v<CHAR, char16_t>) {
+ printf("TestProfilerStringView<char16_t>...\n");
+ } else {
+ MOZ_RELEASE_ASSERT(false,
+ "TestProfilerStringView only handles char and char16_t");
+ }
+
+ // Used to verify implicit constructions, as this will normally be used in
+ // function parameters.
+ auto BSV = [](mozilla::ProfilerStringView<CHAR>&& aBSV) {
+ return std::move(aBSV);
+ };
+
+ // These look like string literals, as expected by some string constructors.
+ const CHAR empty[0 + 1] = {CHAR('\0')};
+ const CHAR hi[2 + 1] = {
+ CHAR('h'),
+ CHAR('i'),
+ CHAR('\0'),
+ };
+
+ // Literal empty string.
+ MOZ_RELEASE_ASSERT(BSV(empty).Length() == 0);
+ MOZ_RELEASE_ASSERT(BSV(empty).AsSpan().IsEmpty());
+ MOZ_RELEASE_ASSERT(BSV(empty).IsLiteral());
+ MOZ_RELEASE_ASSERT(!BSV(empty).IsReference());
+
+ // Literal non-empty string.
+ MOZ_RELEASE_ASSERT(BSV(hi).Length() == 2);
+ MOZ_RELEASE_ASSERT(BSV(hi).AsSpan().Elements());
+ MOZ_RELEASE_ASSERT(BSV(hi).AsSpan().Elements()[0] == CHAR('h'));
+ MOZ_RELEASE_ASSERT(BSV(hi).AsSpan().Elements()[1] == CHAR('i'));
+ MOZ_RELEASE_ASSERT(BSV(hi).IsLiteral());
+ MOZ_RELEASE_ASSERT(!BSV(hi).IsReference());
+
+ // std::string_view to a literal empty string.
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string_view<CHAR>(empty)).Length() == 0);
+ MOZ_RELEASE_ASSERT(
+ BSV(std::basic_string_view<CHAR>(empty)).AsSpan().IsEmpty());
+ MOZ_RELEASE_ASSERT(!BSV(std::basic_string_view<CHAR>(empty)).IsLiteral());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string_view<CHAR>(empty)).IsReference());
+
+ // std::string_view to a literal non-empty string.
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string_view<CHAR>(hi)).Length() == 2);
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string_view<CHAR>(hi)).AsSpan().Elements());
+ MOZ_RELEASE_ASSERT(
+ BSV(std::basic_string_view<CHAR>(hi)).AsSpan().Elements()[0] ==
+ CHAR('h'));
+ MOZ_RELEASE_ASSERT(
+ BSV(std::basic_string_view<CHAR>(hi)).AsSpan().Elements()[1] ==
+ CHAR('i'));
+ MOZ_RELEASE_ASSERT(!BSV(std::basic_string_view<CHAR>(hi)).IsLiteral());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string_view<CHAR>(hi)).IsReference());
+
+ // Default std::string_view points at nullptr, ProfilerStringView converts it
+ // to the literal empty string.
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string_view<CHAR>()).Length() == 0);
+ MOZ_RELEASE_ASSERT(!std::basic_string_view<CHAR>().data());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string_view<CHAR>()).AsSpan().IsEmpty());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string_view<CHAR>()).IsLiteral());
+ MOZ_RELEASE_ASSERT(!BSV(std::basic_string_view<CHAR>()).IsReference());
+
+ // std::string to a literal empty string.
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>(empty)).Length() == 0);
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>(empty)).AsSpan().IsEmpty());
+ MOZ_RELEASE_ASSERT(!BSV(std::basic_string<CHAR>(empty)).IsLiteral());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>(empty)).IsReference());
+
+ // std::string to a literal non-empty string.
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>(hi)).Length() == 2);
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>(hi)).AsSpan().Elements());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>(hi)).AsSpan().Elements()[0] ==
+ CHAR('h'));
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>(hi)).AsSpan().Elements()[1] ==
+ CHAR('i'));
+ MOZ_RELEASE_ASSERT(!BSV(std::basic_string<CHAR>(hi)).IsLiteral());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>(hi)).IsReference());
+
+ // Default std::string contains an empty null-terminated string.
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>()).Length() == 0);
+ MOZ_RELEASE_ASSERT(std::basic_string<CHAR>().data());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>()).AsSpan().IsEmpty());
+ MOZ_RELEASE_ASSERT(!BSV(std::basic_string<CHAR>()).IsLiteral());
+ MOZ_RELEASE_ASSERT(BSV(std::basic_string<CHAR>()).IsReference());
+
+ // Class that quacks like nsTString (with Data(), Length(), IsLiteral()), to
+ // check that ProfilerStringView can read from them.
+ class FakeNsTString {
+ public:
+ FakeNsTString(const CHAR* aData, size_t aLength, bool aIsLiteral)
+ : mData(aData), mLength(aLength), mIsLiteral(aIsLiteral) {}
+
+ const CHAR* Data() const { return mData; }
+ size_t Length() const { return mLength; }
+ bool IsLiteral() const { return mIsLiteral; }
+
+ private:
+ const CHAR* mData;
+ size_t mLength;
+ bool mIsLiteral;
+ };
+
+ // FakeNsTString to nullptr.
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(nullptr, 0, true)).Length() == 0);
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(nullptr, 0, true)).AsSpan().IsEmpty());
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(nullptr, 0, true)).IsLiteral());
+ MOZ_RELEASE_ASSERT(!BSV(FakeNsTString(nullptr, 0, true)).IsReference());
+
+ // FakeNsTString to a literal empty string.
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(empty, 0, true)).Length() == 0);
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(empty, 0, true)).AsSpan().IsEmpty());
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(empty, 0, true)).IsLiteral());
+ MOZ_RELEASE_ASSERT(!BSV(FakeNsTString(empty, 0, true)).IsReference());
+
+ // FakeNsTString to a literal non-empty string.
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, true)).Length() == 2);
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, true)).AsSpan().Elements());
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, true)).AsSpan().Elements()[0] ==
+ CHAR('h'));
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, true)).AsSpan().Elements()[1] ==
+ CHAR('i'));
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, true)).IsLiteral());
+ MOZ_RELEASE_ASSERT(!BSV(FakeNsTString(hi, 2, true)).IsReference());
+
+ // FakeNsTString to a non-literal non-empty string.
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, false)).Length() == 2);
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, false)).AsSpan().Elements());
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, false)).AsSpan().Elements()[0] ==
+ CHAR('h'));
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, false)).AsSpan().Elements()[1] ==
+ CHAR('i'));
+ MOZ_RELEASE_ASSERT(!BSV(FakeNsTString(hi, 2, false)).IsLiteral());
+ MOZ_RELEASE_ASSERT(BSV(FakeNsTString(hi, 2, false)).IsReference());
+
+ // Serialization and deserialization (with ownership).
+ constexpr size_t bufferMaxSize = 1024;
+ constexpr ProfileChunkedBuffer::Length chunkMinSize = 128;
+ ProfileBufferChunkManagerWithLocalLimit cm(bufferMaxSize, chunkMinSize);
+ ProfileChunkedBuffer cb(ProfileChunkedBuffer::ThreadSafety::WithMutex, cm);
+
+ // Literal string, serialized as raw pointer.
+ MOZ_RELEASE_ASSERT(cb.PutObject(BSV(hi)));
+ {
+ unsigned read = 0;
+ ProfilerStringView<CHAR> outerBSV;
+ cb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ ++read;
+ auto bsv = aER.ReadObject<ProfilerStringView<CHAR>>();
+ MOZ_RELEASE_ASSERT(bsv.Length() == 2);
+ MOZ_RELEASE_ASSERT(bsv.AsSpan().Elements());
+ MOZ_RELEASE_ASSERT(bsv.AsSpan().Elements()[0] == CHAR('h'));
+ MOZ_RELEASE_ASSERT(bsv.AsSpan().Elements()[1] == CHAR('i'));
+ MOZ_RELEASE_ASSERT(bsv.IsLiteral());
+ MOZ_RELEASE_ASSERT(!bsv.IsReference());
+ outerBSV = std::move(bsv);
+ });
+ MOZ_RELEASE_ASSERT(read == 1);
+ MOZ_RELEASE_ASSERT(outerBSV.Length() == 2);
+ MOZ_RELEASE_ASSERT(outerBSV.AsSpan().Elements());
+ MOZ_RELEASE_ASSERT(outerBSV.AsSpan().Elements()[0] == CHAR('h'));
+ MOZ_RELEASE_ASSERT(outerBSV.AsSpan().Elements()[1] == CHAR('i'));
+ MOZ_RELEASE_ASSERT(outerBSV.IsLiteral());
+ MOZ_RELEASE_ASSERT(!outerBSV.IsReference());
+ }
+
+ MOZ_RELEASE_ASSERT(cb.GetState().mRangeStart == 1u);
+
+ cb.Clear();
+
+ // Non-literal string, content is serialized.
+
+ // We'll try to write 4 strings, such that the 4th one will cross into the
+ // next chunk.
+ unsigned guessedChunkBytes = unsigned(cb.GetState().mRangeStart) - 1u;
+ static constexpr unsigned stringCount = 4u;
+ const unsigned stringSize =
+ guessedChunkBytes / stringCount / sizeof(CHAR) + 3u;
+
+ std::basic_string<CHAR> longString;
+ longString.reserve(stringSize);
+ for (unsigned i = 0; i < stringSize; ++i) {
+ longString += CHAR('0' + i);
+ }
+
+ for (unsigned i = 0; i < stringCount; ++i) {
+ MOZ_RELEASE_ASSERT(cb.PutObject(BSV(longString)));
+ }
+
+ {
+ unsigned read = 0;
+ ProfilerStringView<CHAR> outerBSV;
+ cb.ReadEach([&](ProfileBufferEntryReader& aER) {
+ ++read;
+ {
+ auto bsv = aER.ReadObject<ProfilerStringView<CHAR>>();
+ MOZ_RELEASE_ASSERT(bsv.Length() == stringSize);
+ MOZ_RELEASE_ASSERT(bsv.AsSpan().Elements());
+ for (unsigned i = 0; i < stringSize; ++i) {
+ MOZ_RELEASE_ASSERT(bsv.AsSpan().Elements()[i] == CHAR('0' + i));
+ longString += '0' + i;
+ }
+ MOZ_RELEASE_ASSERT(!bsv.IsLiteral());
+ // The first 3 should be references (because they fit in one chunk, so
+ // they can be referenced directly), which the 4th one have to be copied
+ // out of two chunks and stitched back together.
+ MOZ_RELEASE_ASSERT(bsv.IsReference() == (read != 4));
+
+ // Test move of ownership.
+ outerBSV = std::move(bsv);
+ // After a move, references stay complete, while a non-reference had a
+ // buffer that has been moved out.
+ // NOLINTNEXTLINE(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
+ MOZ_RELEASE_ASSERT(bsv.Length() == ((read != 4) ? stringSize : 0));
+ }
+
+ MOZ_RELEASE_ASSERT(outerBSV.Length() == stringSize);
+ MOZ_RELEASE_ASSERT(outerBSV.AsSpan().Elements());
+ for (unsigned i = 0; i < stringSize; ++i) {
+ MOZ_RELEASE_ASSERT(outerBSV.AsSpan().Elements()[i] == CHAR('0' + i));
+ longString += '0' + i;
+ }
+ MOZ_RELEASE_ASSERT(!outerBSV.IsLiteral());
+ MOZ_RELEASE_ASSERT(outerBSV.IsReference() == (read != 4));
+ });
+ MOZ_RELEASE_ASSERT(read == 4);
+ }
+
+ if constexpr (std::is_same_v<CHAR, char>) {
+ printf("TestProfilerStringView<char> done\n");
+ } else if constexpr (std::is_same_v<CHAR, char16_t>) {
+ printf("TestProfilerStringView<char16_t> done\n");
+ }
+}
+
+void TestProfilerDependencies() {
+ TestPowerOfTwoMask();
+ TestPowerOfTwo();
+ TestLEB128();
+ TestJSONTimeOutput();
+ TestChunk();
+ TestChunkManagerSingle();
+ TestChunkManagerWithLocalLimit();
+ TestControlledChunkManagerUpdate();
+ TestControlledChunkManagerWithLocalLimit();
+ TestChunkedBuffer();
+ TestChunkedBufferSingle();
+ TestModuloBuffer();
+ TestBlocksRingBufferAPI();
+ TestBlocksRingBufferUnderlyingBufferChanges();
+ TestBlocksRingBufferThreading();
+ TestBlocksRingBufferSerialization();
+ TestLiteralEmptyStringView();
+ TestProfilerStringView<char>();
+ TestProfilerStringView<char16_t>();
+}
+
+// Increase the depth, to a maximum (to avoid too-deep recursion).
+static constexpr size_t NextDepth(size_t aDepth) {
+ constexpr size_t MAX_DEPTH = 128;
+ return (aDepth < MAX_DEPTH) ? (aDepth + 1) : aDepth;
+}
+
+Atomic<bool, Relaxed> sStopFibonacci;
+
+// Compute fibonacci the hard way (recursively: `f(n)=f(n-1)+f(n-2)`), and
+// prevent inlining.
+// The template parameter makes each depth be a separate function, to better
+// distinguish them in the profiler output.
+template <size_t DEPTH = 0>
+MOZ_NEVER_INLINE unsigned long long Fibonacci(unsigned long long n) {
+ AUTO_BASE_PROFILER_LABEL_DYNAMIC_STRING("fib", OTHER, std::to_string(DEPTH));
+ if (n == 0) {
+ return 0;
+ }
+ if (n == 1) {
+ return 1;
+ }
+ if (DEPTH < 5 && sStopFibonacci) {
+ return 1'000'000'000;
+ }
+ TimeStamp start = TimeStamp::Now();
+ static constexpr size_t MAX_MARKER_DEPTH = 10;
+ unsigned long long f2 = Fibonacci<NextDepth(DEPTH)>(n - 2);
+ if (DEPTH == 0) {
+ BASE_PROFILER_MARKER_UNTYPED("Half-way through Fibonacci", OTHER);
+ }
+ unsigned long long f1 = Fibonacci<NextDepth(DEPTH)>(n - 1);
+ if (DEPTH < MAX_MARKER_DEPTH) {
+ BASE_PROFILER_MARKER_TEXT("fib", OTHER,
+ MarkerTiming::IntervalUntilNowFrom(start),
+ std::to_string(DEPTH));
+ }
+ return f2 + f1;
+}
+
+void TestProfiler() {
+ printf("TestProfiler starting -- pid: %" PRIu64 ", tid: %" PRIu64 "\n",
+ uint64_t(baseprofiler::profiler_current_process_id().ToNumber()),
+ uint64_t(baseprofiler::profiler_current_thread_id().ToNumber()));
+ // ::SleepMilli(10000);
+
+ TestProfilerDependencies();
+
+ {
+ MOZ_RELEASE_ASSERT(!baseprofiler::profiler_is_active());
+ MOZ_RELEASE_ASSERT(!baseprofiler::profiler_thread_is_being_profiled());
+ MOZ_RELEASE_ASSERT(!baseprofiler::profiler_thread_is_sleeping());
+
+ const baseprofiler::BaseProfilerThreadId mainThreadId =
+ mozilla::baseprofiler::profiler_current_thread_id();
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::profiler_main_thread_id() ==
+ mainThreadId);
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::profiler_is_main_thread());
+
+ std::thread testThread([&]() {
+ const baseprofiler::BaseProfilerThreadId testThreadId =
+ mozilla::baseprofiler::profiler_current_thread_id();
+ MOZ_RELEASE_ASSERT(testThreadId != mainThreadId);
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::profiler_main_thread_id() !=
+ testThreadId);
+ MOZ_RELEASE_ASSERT(!mozilla::baseprofiler::profiler_is_main_thread());
+ });
+ testThread.join();
+
+ printf("profiler_start()...\n");
+ Vector<const char*> filters;
+ // Profile all registered threads.
+ MOZ_RELEASE_ASSERT(filters.append(""));
+ const uint32_t features = baseprofiler::ProfilerFeature::StackWalk;
+ baseprofiler::profiler_start(baseprofiler::BASE_PROFILER_DEFAULT_ENTRIES,
+ BASE_PROFILER_DEFAULT_INTERVAL, features,
+ filters.begin(), filters.length());
+
+ MOZ_RELEASE_ASSERT(baseprofiler::profiler_is_active());
+ MOZ_RELEASE_ASSERT(baseprofiler::profiler_thread_is_being_profiled());
+ MOZ_RELEASE_ASSERT(!baseprofiler::profiler_thread_is_sleeping());
+
+ sStopFibonacci = false;
+
+ std::thread threadFib([]() {
+ AUTO_BASE_PROFILER_REGISTER_THREAD("fibonacci");
+ SleepMilli(5);
+ auto cause = baseprofiler::profiler_capture_backtrace();
+ AUTO_BASE_PROFILER_MARKER_TEXT(
+ "fibonacci", OTHER, MarkerStack::TakeBacktrace(std::move(cause)),
+ "First leaf call");
+ static const unsigned long long fibStart = 37;
+ printf("Fibonacci(%llu)...\n", fibStart);
+ AUTO_BASE_PROFILER_LABEL("Label around Fibonacci", OTHER);
+
+ unsigned long long f = Fibonacci(fibStart);
+ printf("Fibonacci(%llu) = %llu\n", fibStart, f);
+ });
+
+ std::thread threadCancelFib([]() {
+ AUTO_BASE_PROFILER_REGISTER_THREAD("fibonacci canceller");
+ SleepMilli(5);
+ AUTO_BASE_PROFILER_MARKER_TEXT("fibonacci", OTHER, {}, "Canceller");
+ static const int waitMaxSeconds = 10;
+ for (int i = 0; i < waitMaxSeconds; ++i) {
+ if (sStopFibonacci) {
+ AUTO_BASE_PROFILER_LABEL_DYNAMIC_STRING("fibCancel", OTHER,
+ std::to_string(i));
+ return;
+ }
+ AUTO_BASE_PROFILER_THREAD_SLEEP;
+ SleepMilli(1000);
+ }
+ AUTO_BASE_PROFILER_LABEL_DYNAMIC_STRING("fibCancel", OTHER,
+ "Cancelling!");
+ sStopFibonacci = true;
+ });
+
+ {
+ AUTO_BASE_PROFILER_MARKER_TEXT("main thread", OTHER, {},
+ "joining fibonacci thread");
+ AUTO_BASE_PROFILER_THREAD_SLEEP;
+ threadFib.join();
+ }
+
+ {
+ AUTO_BASE_PROFILER_MARKER_TEXT("main thread", OTHER, {},
+ "joining fibonacci-canceller thread");
+ sStopFibonacci = true;
+ AUTO_BASE_PROFILER_THREAD_SLEEP;
+ threadCancelFib.join();
+ }
+
+ // Just making sure all payloads know how to (de)serialize and stream.
+
+ MOZ_RELEASE_ASSERT(
+ baseprofiler::AddMarker("markers 2.0 without options (omitted)",
+ mozilla::baseprofiler::category::OTHER));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 without options (implicit brace-init)",
+ mozilla::baseprofiler::category::OTHER, {}));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 without options (explicit init)",
+ mozilla::baseprofiler::category::OTHER, MarkerOptions()));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 without options (explicit brace-init)",
+ mozilla::baseprofiler::category::OTHER, MarkerOptions{}));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 with one option (implicit)",
+ mozilla::baseprofiler::category::OTHER, MarkerInnerWindowId(123)));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 with one option (implicit brace-init)",
+ mozilla::baseprofiler::category::OTHER, {MarkerInnerWindowId(123)}));
+
+ MOZ_RELEASE_ASSERT(
+ baseprofiler::AddMarker("markers 2.0 with one option (explicit init)",
+ mozilla::baseprofiler::category::OTHER,
+ MarkerOptions(MarkerInnerWindowId(123))));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 with one option (explicit brace-init)",
+ mozilla::baseprofiler::category::OTHER,
+ MarkerOptions{MarkerInnerWindowId(123)}));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 with two options (implicit brace-init)",
+ mozilla::baseprofiler::category::OTHER,
+ {MarkerInnerWindowId(123), MarkerStack::Capture()}));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 with two options (explicit init)",
+ mozilla::baseprofiler::category::OTHER,
+ MarkerOptions(MarkerInnerWindowId(123), MarkerStack::Capture())));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "markers 2.0 with two options (explicit brace-init)",
+ mozilla::baseprofiler::category::OTHER,
+ MarkerOptions{MarkerInnerWindowId(123), MarkerStack::Capture()}));
+
+ MOZ_RELEASE_ASSERT(
+ baseprofiler::AddMarker("default-templated markers 2.0 without options",
+ mozilla::baseprofiler::category::OTHER));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "default-templated markers 2.0 with option",
+ mozilla::baseprofiler::category::OTHER, MarkerInnerWindowId(123)));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "explicitly-default-templated markers 2.0 without options",
+ mozilla::baseprofiler::category::OTHER, {},
+ ::mozilla::baseprofiler::markers::NoPayload{}));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "explicitly-default-templated markers 2.0 with option",
+ mozilla::baseprofiler::category::OTHER, MarkerInnerWindowId(123),
+ ::mozilla::baseprofiler::markers::NoPayload{}));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "tracing", mozilla::baseprofiler::category::OTHER, {},
+ mozilla::baseprofiler::markers::Tracing{}, "category"));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "text", mozilla::baseprofiler::category::OTHER, {},
+ mozilla::baseprofiler::markers::TextMarker{}, "text text"));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "media sample", mozilla::baseprofiler::category::OTHER, {},
+ mozilla::baseprofiler::markers::MediaSampleMarker{}, 123, 456, 789));
+
+ MOZ_RELEASE_ASSERT(baseprofiler::AddMarker(
+ "video falling behind", mozilla::baseprofiler::category::OTHER, {},
+ mozilla::baseprofiler::markers::VideoFallingBehindMarker{}, 123, 456));
+
+ printf("Sleep 1s...\n");
+ {
+ AUTO_BASE_PROFILER_THREAD_SLEEP;
+ SleepMilli(1000);
+ }
+
+ printf("baseprofiler_pause()...\n");
+ baseprofiler::profiler_pause();
+
+ MOZ_RELEASE_ASSERT(!baseprofiler::profiler_thread_is_being_profiled());
+
+ Maybe<baseprofiler::ProfilerBufferInfo> info =
+ baseprofiler::profiler_get_buffer_info();
+ MOZ_RELEASE_ASSERT(info.isSome());
+ printf("Profiler buffer range: %llu .. %llu (%llu bytes)\n",
+ static_cast<unsigned long long>(info->mRangeStart),
+ static_cast<unsigned long long>(info->mRangeEnd),
+ // sizeof(ProfileBufferEntry) == 9
+ (static_cast<unsigned long long>(info->mRangeEnd) -
+ static_cast<unsigned long long>(info->mRangeStart)) *
+ 9);
+ printf("Stats: min(us) .. mean(us) .. max(us) [count]\n");
+ printf("- Intervals: %7.1f .. %7.1f .. %7.1f [%u]\n",
+ info->mIntervalsUs.min,
+ info->mIntervalsUs.sum / info->mIntervalsUs.n,
+ info->mIntervalsUs.max, info->mIntervalsUs.n);
+ printf("- Overheads: %7.1f .. %7.1f .. %7.1f [%u]\n",
+ info->mOverheadsUs.min,
+ info->mOverheadsUs.sum / info->mOverheadsUs.n,
+ info->mOverheadsUs.max, info->mOverheadsUs.n);
+ printf(" - Locking: %7.1f .. %7.1f .. %7.1f [%u]\n",
+ info->mLockingsUs.min, info->mLockingsUs.sum / info->mLockingsUs.n,
+ info->mLockingsUs.max, info->mLockingsUs.n);
+ printf(" - Clearning: %7.1f .. %7.1f .. %7.1f [%u]\n",
+ info->mCleaningsUs.min,
+ info->mCleaningsUs.sum / info->mCleaningsUs.n,
+ info->mCleaningsUs.max, info->mCleaningsUs.n);
+ printf(" - Counters: %7.1f .. %7.1f .. %7.1f [%u]\n",
+ info->mCountersUs.min, info->mCountersUs.sum / info->mCountersUs.n,
+ info->mCountersUs.max, info->mCountersUs.n);
+ printf(" - Threads: %7.1f .. %7.1f .. %7.1f [%u]\n",
+ info->mThreadsUs.min, info->mThreadsUs.sum / info->mThreadsUs.n,
+ info->mThreadsUs.max, info->mThreadsUs.n);
+
+ printf("baseprofiler_get_profile()...\n");
+ UniquePtr<char[]> profile = baseprofiler::profiler_get_profile();
+
+ // Use a string view over the profile contents, for easier testing.
+ std::string_view profileSV = profile.get();
+
+ constexpr const auto svnpos = std::string_view::npos;
+ // TODO: Properly parse profile and check fields.
+ // Check for some expected marker schema JSON output.
+ MOZ_RELEASE_ASSERT(profileSV.find("\"markerSchema\":[") != svnpos);
+ MOZ_RELEASE_ASSERT(profileSV.find("\"name\":\"Text\",") != svnpos);
+ MOZ_RELEASE_ASSERT(profileSV.find("\"name\":\"tracing\",") != svnpos);
+ MOZ_RELEASE_ASSERT(profileSV.find("\"name\":\"MediaSample\",") != svnpos);
+ MOZ_RELEASE_ASSERT(profileSV.find("\"display\":[") != svnpos);
+ MOZ_RELEASE_ASSERT(profileSV.find("\"marker-chart\"") != svnpos);
+ MOZ_RELEASE_ASSERT(profileSV.find("\"marker-table\"") != svnpos);
+ MOZ_RELEASE_ASSERT(profileSV.find("\"format\":\"string\"") != svnpos);
+ // TODO: Add more checks for what's expected in the profile. Some of them
+ // are done in gtest's.
+
+ printf("baseprofiler_save_profile_to_file()...\n");
+ baseprofiler::baseprofiler_save_profile_to_file(
+ "TestProfiler_profile.json");
+
+ printf("profiler_stop()...\n");
+ baseprofiler::profiler_stop();
+
+ MOZ_RELEASE_ASSERT(!baseprofiler::profiler_is_active());
+ MOZ_RELEASE_ASSERT(!baseprofiler::profiler_thread_is_being_profiled());
+ MOZ_RELEASE_ASSERT(!baseprofiler::profiler_thread_is_sleeping());
+
+ printf("profiler_shutdown()...\n");
+ }
+
+ printf("TestProfiler done\n");
+}
+
+// Minimal string escaping, similar to how C++ stringliterals should be entered,
+// to help update comparison strings in tests below.
+void printEscaped(std::string_view aString) {
+ for (const char c : aString) {
+ switch (c) {
+ case '\n':
+ fprintf(stderr, "\\n\n");
+ break;
+ case '"':
+ fprintf(stderr, "\\\"");
+ break;
+ case '\\':
+ fprintf(stderr, "\\\\");
+ break;
+ default:
+ if (c >= ' ' && c <= '~') {
+ fprintf(stderr, "%c", c);
+ } else {
+ fprintf(stderr, "\\x%02x", unsigned(c));
+ }
+ break;
+ }
+ }
+}
+
+// Run aF(SpliceableChunkedJSONWriter&, UniqueJSONStrings&) from inside a JSON
+// array, then output the string table, and compare the full output to
+// aExpected.
+template <typename F>
+static void VerifyUniqueStringContents(
+ F&& aF, std::string_view aExpectedData,
+ std::string_view aExpectedUniqueStrings,
+ mozilla::baseprofiler::UniqueJSONStrings* aUniqueStringsOrNull = nullptr) {
+ mozilla::baseprofiler::SpliceableChunkedJSONWriter writer{
+ FailureLatchInfallibleSource::Singleton()};
+
+ MOZ_RELEASE_ASSERT(!writer.ChunkedWriteFunc().Fallible());
+ MOZ_RELEASE_ASSERT(!writer.ChunkedWriteFunc().Failed());
+ MOZ_RELEASE_ASSERT(!writer.ChunkedWriteFunc().GetFailure());
+ MOZ_RELEASE_ASSERT(&writer.ChunkedWriteFunc().SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ MOZ_RELEASE_ASSERT(
+ &std::as_const(writer.ChunkedWriteFunc()).SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+
+ MOZ_RELEASE_ASSERT(!writer.Fallible());
+ MOZ_RELEASE_ASSERT(!writer.Failed());
+ MOZ_RELEASE_ASSERT(!writer.GetFailure());
+ MOZ_RELEASE_ASSERT(&writer.SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ MOZ_RELEASE_ASSERT(&std::as_const(writer).SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+
+ // By default use a local UniqueJSONStrings, otherwise use the one provided.
+ mozilla::baseprofiler::UniqueJSONStrings localUniqueStrings{
+ FailureLatchInfallibleSource::Singleton()};
+ MOZ_RELEASE_ASSERT(!localUniqueStrings.Fallible());
+ MOZ_RELEASE_ASSERT(!localUniqueStrings.Failed());
+ MOZ_RELEASE_ASSERT(!localUniqueStrings.GetFailure());
+ MOZ_RELEASE_ASSERT(&localUniqueStrings.SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+ MOZ_RELEASE_ASSERT(&std::as_const(localUniqueStrings).SourceFailureLatch() ==
+ &mozilla::FailureLatchInfallibleSource::Singleton());
+
+ mozilla::baseprofiler::UniqueJSONStrings& uniqueStrings =
+ aUniqueStringsOrNull ? *aUniqueStringsOrNull : localUniqueStrings;
+ MOZ_RELEASE_ASSERT(!uniqueStrings.Failed());
+ MOZ_RELEASE_ASSERT(!uniqueStrings.GetFailure());
+
+ writer.Start();
+ {
+ writer.StartArrayProperty("data");
+ { std::forward<F>(aF)(writer, uniqueStrings); }
+ writer.EndArray();
+
+ writer.StartArrayProperty("stringTable");
+ { uniqueStrings.SpliceStringTableElements(writer); }
+ writer.EndArray();
+ }
+ writer.End();
+
+ MOZ_RELEASE_ASSERT(!uniqueStrings.Failed());
+ MOZ_RELEASE_ASSERT(!uniqueStrings.GetFailure());
+
+ MOZ_RELEASE_ASSERT(!writer.ChunkedWriteFunc().Failed());
+ MOZ_RELEASE_ASSERT(!writer.ChunkedWriteFunc().GetFailure());
+
+ MOZ_RELEASE_ASSERT(!writer.Failed());
+ MOZ_RELEASE_ASSERT(!writer.GetFailure());
+
+ UniquePtr<char[]> jsonString = writer.ChunkedWriteFunc().CopyData();
+ MOZ_RELEASE_ASSERT(jsonString);
+ std::string_view jsonStringView(jsonString.get());
+ const size_t length = writer.ChunkedWriteFunc().Length();
+ MOZ_RELEASE_ASSERT(length == jsonStringView.length());
+ std::string expected = "{\"data\":[";
+ expected += aExpectedData;
+ expected += "],\"stringTable\":[";
+ expected += aExpectedUniqueStrings;
+ expected += "]}";
+ if (jsonStringView != expected) {
+ fprintf(stderr,
+ "Expected:\n"
+ "------\n");
+ printEscaped(expected);
+ fprintf(stderr,
+ "\n"
+ "------\n"
+ "Actual:\n"
+ "------\n");
+ printEscaped(jsonStringView);
+ fprintf(stderr,
+ "\n"
+ "------\n");
+ }
+ MOZ_RELEASE_ASSERT(jsonStringView == expected);
+}
+
+void TestUniqueJSONStrings() {
+ printf("TestUniqueJSONStrings...\n");
+
+ using SCJW = mozilla::baseprofiler::SpliceableChunkedJSONWriter;
+ using UJS = mozilla::baseprofiler::UniqueJSONStrings;
+
+ // Empty everything.
+ VerifyUniqueStringContents([](SCJW& aWriter, UJS& aUniqueStrings) {}, "", "");
+
+ // Empty unique strings.
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aWriter.StringElement("string");
+ },
+ R"("string")", "");
+
+ // One unique string.
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aUniqueStrings.WriteElement(aWriter, "string");
+ },
+ "0", R"("string")");
+
+ // One unique string twice.
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aUniqueStrings.WriteElement(aWriter, "string");
+ aUniqueStrings.WriteElement(aWriter, "string");
+ },
+ "0,0", R"("string")");
+
+ // Two single unique strings.
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ aUniqueStrings.WriteElement(aWriter, "string1");
+ },
+ "0,1", R"("string0","string1")");
+
+ // Two unique strings with repetition.
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ aUniqueStrings.WriteElement(aWriter, "string1");
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ },
+ "0,1,0", R"("string0","string1")");
+
+ // Mix some object properties, for coverage.
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ aWriter.StartObjectElement();
+ {
+ aUniqueStrings.WriteProperty(aWriter, "p0", "prop");
+ aUniqueStrings.WriteProperty(aWriter, "p1", "string0");
+ aUniqueStrings.WriteProperty(aWriter, "p2", "prop");
+ }
+ aWriter.EndObject();
+ aUniqueStrings.WriteElement(aWriter, "string1");
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ aUniqueStrings.WriteElement(aWriter, "prop");
+ },
+ R"(0,{"p0":1,"p1":0,"p2":1},2,0,1)", R"("string0","prop","string1")");
+
+ // Unique string table with pre-existing data.
+ {
+ UJS ujs{FailureLatchInfallibleSource::Singleton()};
+ {
+ SCJW writer{FailureLatchInfallibleSource::Singleton()};
+ ujs.WriteElement(writer, "external0");
+ ujs.WriteElement(writer, "external1");
+ ujs.WriteElement(writer, "external0");
+ }
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ aUniqueStrings.WriteElement(aWriter, "string1");
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ },
+ "2,3,2", R"("external0","external1","string0","string1")", &ujs);
+ }
+
+ // Unique string table with pre-existing data from another table.
+ {
+ UJS ujs{FailureLatchInfallibleSource::Singleton()};
+ {
+ SCJW writer{FailureLatchInfallibleSource::Singleton()};
+ ujs.WriteElement(writer, "external0");
+ ujs.WriteElement(writer, "external1");
+ ujs.WriteElement(writer, "external0");
+ }
+ UJS ujsCopy(FailureLatchInfallibleSource::Singleton(), ujs,
+ mozilla::ProgressLogger{});
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ aUniqueStrings.WriteElement(aWriter, "string1");
+ aUniqueStrings.WriteElement(aWriter, "string0");
+ },
+ "2,3,2", R"("external0","external1","string0","string1")", &ujs);
+ }
+
+ // Unique string table through SpliceableJSONWriter.
+ VerifyUniqueStringContents(
+ [](SCJW& aWriter, UJS& aUniqueStrings) {
+ aWriter.SetUniqueStrings(aUniqueStrings);
+ aWriter.UniqueStringElement("string0");
+ aWriter.StartObjectElement();
+ {
+ aWriter.UniqueStringProperty("p0", "prop");
+ aWriter.UniqueStringProperty("p1", "string0");
+ aWriter.UniqueStringProperty("p2", "prop");
+ }
+ aWriter.EndObject();
+ aWriter.UniqueStringElement("string1");
+ aWriter.UniqueStringElement("string0");
+ aWriter.UniqueStringElement("prop");
+ aWriter.ResetUniqueStrings();
+ },
+ R"(0,{"p0":1,"p1":0,"p2":1},2,0,1)", R"("string0","prop","string1")");
+
+ printf("TestUniqueJSONStrings done\n");
+}
+
+void StreamMarkers(const mozilla::ProfileChunkedBuffer& aBuffer,
+ mozilla::baseprofiler::SpliceableJSONWriter& aWriter) {
+ aWriter.StartArrayProperty("data");
+ {
+ aBuffer.ReadEach([&](mozilla::ProfileBufferEntryReader& aEntryReader) {
+ mozilla::ProfileBufferEntryKind entryKind =
+ aEntryReader.ReadObject<mozilla::ProfileBufferEntryKind>();
+ MOZ_RELEASE_ASSERT(entryKind == mozilla::ProfileBufferEntryKind::Marker);
+
+ mozilla::base_profiler_markers_detail::DeserializeAfterKindAndStream(
+ aEntryReader,
+ [&](const mozilla::baseprofiler::BaseProfilerThreadId&) {
+ return &aWriter;
+ },
+ [&](mozilla::ProfileChunkedBuffer&) {
+ aWriter.StringElement("Real backtrace would be here");
+ },
+ [&](mozilla::base_profiler_markers_detail::Streaming::
+ DeserializerTag) {});
+ });
+ }
+ aWriter.EndArray();
+}
+
+void PrintMarkers(const mozilla::ProfileChunkedBuffer& aBuffer) {
+ mozilla::baseprofiler::SpliceableJSONWriter writer(
+ mozilla::MakeUnique<mozilla::baseprofiler::OStreamJSONWriteFunc>(
+ std::cout),
+ FailureLatchInfallibleSource::Singleton());
+ mozilla::baseprofiler::UniqueJSONStrings uniqueStrings{
+ FailureLatchInfallibleSource::Singleton()};
+ writer.SetUniqueStrings(uniqueStrings);
+ writer.Start();
+ {
+ StreamMarkers(aBuffer, writer);
+
+ writer.StartArrayProperty("stringTable");
+ { uniqueStrings.SpliceStringTableElements(writer); }
+ writer.EndArray();
+ }
+ writer.End();
+ writer.ResetUniqueStrings();
+}
+
+static void SubTestMarkerCategory(
+ const mozilla::MarkerCategory& aMarkerCategory,
+ const mozilla::baseprofiler::ProfilingCategoryPair& aProfilingCategoryPair,
+ const mozilla::baseprofiler::ProfilingCategory& aProfilingCategory) {
+ MOZ_RELEASE_ASSERT(aMarkerCategory.CategoryPair() == aProfilingCategoryPair,
+ "Unexpected MarkerCategory::CategoryPair()");
+
+ MOZ_RELEASE_ASSERT(
+ mozilla::MarkerCategory(aProfilingCategoryPair).CategoryPair() ==
+ aProfilingCategoryPair,
+ "MarkerCategory(<name>).CategoryPair() should return <name>");
+
+ MOZ_RELEASE_ASSERT(aMarkerCategory.GetCategory() == aProfilingCategory,
+ "Unexpected MarkerCategory::GetCategory()");
+
+ mozilla::ProfileBufferChunkManagerSingle chunkManager(512);
+ mozilla::ProfileChunkedBuffer buffer(
+ mozilla::ProfileChunkedBuffer::ThreadSafety::WithoutMutex, chunkManager);
+ mozilla::ProfileBufferBlockIndex i = buffer.PutObject(aMarkerCategory);
+ MOZ_RELEASE_ASSERT(i != mozilla::ProfileBufferBlockIndex{},
+ "Failed serialization");
+ buffer.ReadEach([&](mozilla::ProfileBufferEntryReader& aER,
+ mozilla::ProfileBufferBlockIndex aIndex) {
+ MOZ_RELEASE_ASSERT(aIndex == i, "Unexpected deserialization index");
+ const auto readCategory = aER.ReadObject<mozilla::MarkerCategory>();
+ MOZ_RELEASE_ASSERT(aER.RemainingBytes() == 0,
+ "Unexpected extra serialized bytes");
+ MOZ_RELEASE_ASSERT(readCategory.CategoryPair() == aProfilingCategoryPair,
+ "Incorrect deserialization value");
+ });
+}
+
+void TestMarkerCategory() {
+ printf("TestMarkerCategory...\n");
+
+ mozilla::ProfileBufferChunkManagerSingle chunkManager(512);
+ mozilla::ProfileChunkedBuffer buffer(
+ mozilla::ProfileChunkedBuffer::ThreadSafety::WithoutMutex, chunkManager);
+
+# define CATEGORY_ENUM_BEGIN_CATEGORY(name, labelAsString, color)
+# define CATEGORY_ENUM_SUBCATEGORY(supercategory, name, labelAsString) \
+ static_assert( \
+ std::is_same_v<decltype(mozilla::baseprofiler::category::name), \
+ const mozilla::MarkerCategory>, \
+ "baseprofiler::category::<name> should be a const MarkerCategory"); \
+ \
+ SubTestMarkerCategory( \
+ mozilla::baseprofiler::category::name, \
+ mozilla::baseprofiler::ProfilingCategoryPair::name, \
+ mozilla::baseprofiler::ProfilingCategory::supercategory);
+# define CATEGORY_ENUM_END_CATEGORY
+ MOZ_PROFILING_CATEGORY_LIST(CATEGORY_ENUM_BEGIN_CATEGORY,
+ CATEGORY_ENUM_SUBCATEGORY,
+ CATEGORY_ENUM_END_CATEGORY)
+# undef CATEGORY_ENUM_BEGIN_CATEGORY
+# undef CATEGORY_ENUM_SUBCATEGORY
+# undef CATEGORY_ENUM_END_CATEGORY
+
+ printf("TestMarkerCategory done\n");
+}
+
+void TestMarkerThreadId() {
+ printf("TestMarkerThreadId...\n");
+
+ MOZ_RELEASE_ASSERT(MarkerThreadId{}.IsUnspecified());
+ MOZ_RELEASE_ASSERT(!MarkerThreadId::MainThread().IsUnspecified());
+ MOZ_RELEASE_ASSERT(!MarkerThreadId::CurrentThread().IsUnspecified());
+
+ MOZ_RELEASE_ASSERT(!MarkerThreadId{
+ mozilla::baseprofiler::BaseProfilerThreadId::FromNumber(42)}
+ .IsUnspecified());
+ MOZ_RELEASE_ASSERT(
+ MarkerThreadId{
+ mozilla::baseprofiler::BaseProfilerThreadId::FromNumber(42)}
+ .ThreadId()
+ .ToNumber() == 42);
+
+ // We'll assume that this test runs in the main thread (which should be true
+ // when called from the `main` function).
+ MOZ_RELEASE_ASSERT(MarkerThreadId::MainThread().ThreadId() ==
+ mozilla::baseprofiler::profiler_main_thread_id());
+
+ MOZ_RELEASE_ASSERT(MarkerThreadId::CurrentThread().ThreadId() ==
+ mozilla::baseprofiler::profiler_current_thread_id());
+
+ MOZ_RELEASE_ASSERT(MarkerThreadId::CurrentThread().ThreadId() ==
+ mozilla::baseprofiler::profiler_main_thread_id());
+
+ std::thread testThread([]() {
+ MOZ_RELEASE_ASSERT(!MarkerThreadId::MainThread().IsUnspecified());
+ MOZ_RELEASE_ASSERT(!MarkerThreadId::CurrentThread().IsUnspecified());
+
+ MOZ_RELEASE_ASSERT(MarkerThreadId::MainThread().ThreadId() ==
+ mozilla::baseprofiler::profiler_main_thread_id());
+
+ MOZ_RELEASE_ASSERT(MarkerThreadId::CurrentThread().ThreadId() ==
+ mozilla::baseprofiler::profiler_current_thread_id());
+
+ MOZ_RELEASE_ASSERT(MarkerThreadId::CurrentThread().ThreadId() !=
+ mozilla::baseprofiler::profiler_main_thread_id());
+ });
+ testThread.join();
+
+ printf("TestMarkerThreadId done\n");
+}
+
+void TestMarkerNoPayload() {
+ printf("TestMarkerNoPayload...\n");
+
+ mozilla::ProfileBufferChunkManagerSingle chunkManager(512);
+ mozilla::ProfileChunkedBuffer buffer(
+ mozilla::ProfileChunkedBuffer::ThreadSafety::WithoutMutex, chunkManager);
+
+ mozilla::ProfileBufferBlockIndex i0 =
+ mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "literal", mozilla::baseprofiler::category::OTHER_Profiling);
+ MOZ_RELEASE_ASSERT(i0);
+
+ const std::string dynamic = "dynamic";
+ mozilla::ProfileBufferBlockIndex i1 =
+ mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, dynamic,
+ mozilla::baseprofiler::category::GRAPHICS_FlushingAsyncPaints, {});
+ MOZ_RELEASE_ASSERT(i1);
+ MOZ_RELEASE_ASSERT(i1 > i0);
+
+ mozilla::ProfileBufferBlockIndex i2 =
+ mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, std::string_view("string_view"),
+ mozilla::baseprofiler::category::GRAPHICS_FlushingAsyncPaints, {});
+ MOZ_RELEASE_ASSERT(i2);
+ MOZ_RELEASE_ASSERT(i2 > i1);
+
+# ifdef DEBUG
+ buffer.Dump();
+# endif
+
+ PrintMarkers(buffer);
+
+ printf("TestMarkerNoPayload done\n");
+}
+
+void TestUserMarker() {
+ printf("TestUserMarker...\n");
+
+ // User-defined marker type with text.
+ // It's fine to define it right in the function where it's used.
+ struct MarkerTypeTestMinimal {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("test-minimal");
+ }
+ static void StreamJSONMarkerData(
+ mozilla::baseprofiler::SpliceableJSONWriter& aWriter,
+ const std::string& aText) {
+ aWriter.StringProperty("text", aText);
+ }
+ static mozilla::MarkerSchema MarkerTypeDisplay() {
+ using MS = mozilla::MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ schema.SetTooltipLabel("tooltip for test-minimal");
+ schema.AddKeyLabelFormatSearchable("text", "Text", MS::Format::String,
+ MS::Searchable::Searchable);
+ return schema;
+ }
+ };
+
+ mozilla::ProfileBufferChunkManagerSingle chunkManager(1024);
+ mozilla::ProfileChunkedBuffer buffer(
+ mozilla::ProfileChunkedBuffer::ThreadSafety::WithoutMutex, chunkManager);
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling, {},
+ MarkerTypeTestMinimal{}, std::string("payload text")));
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling,
+ mozilla::MarkerThreadId(
+ mozilla::baseprofiler::BaseProfilerThreadId::FromNumber(123)),
+ MarkerTypeTestMinimal{}, std::string("ThreadId(123)")));
+
+ auto start = mozilla::TimeStamp::Now();
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling,
+ mozilla::MarkerTiming::InstantAt(start), MarkerTypeTestMinimal{},
+ std::string("InstantAt(start)")));
+
+ auto then = mozilla::TimeStamp::Now();
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling,
+ mozilla::MarkerTiming::IntervalStart(start), MarkerTypeTestMinimal{},
+ std::string("IntervalStart(start)")));
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling,
+ mozilla::MarkerTiming::IntervalEnd(then), MarkerTypeTestMinimal{},
+ std::string("IntervalEnd(then)")));
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling,
+ mozilla::MarkerTiming::Interval(start, then), MarkerTypeTestMinimal{},
+ std::string("Interval(start, then)")));
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling,
+ mozilla::MarkerTiming::IntervalUntilNowFrom(start),
+ MarkerTypeTestMinimal{}, std::string("IntervalUntilNowFrom(start)")));
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling,
+ mozilla::MarkerStack::NoStack(), MarkerTypeTestMinimal{},
+ std::string("NoStack")));
+ // Note: We cannot test stack-capture here, because the profiler is not
+ // initialized.
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, "test2", mozilla::baseprofiler::category::OTHER_Profiling,
+ mozilla::MarkerInnerWindowId(123), MarkerTypeTestMinimal{},
+ std::string("InnerWindowId(123)")));
+
+# ifdef DEBUG
+ buffer.Dump();
+# endif
+
+ PrintMarkers(buffer);
+
+ printf("TestUserMarker done\n");
+}
+
+void TestPredefinedMarkers() {
+ printf("TestPredefinedMarkers...\n");
+
+ mozilla::ProfileBufferChunkManagerSingle chunkManager(1024);
+ mozilla::ProfileChunkedBuffer buffer(
+ mozilla::ProfileChunkedBuffer::ThreadSafety::WithoutMutex, chunkManager);
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, std::string_view("tracing"),
+ mozilla::baseprofiler::category::OTHER, {},
+ mozilla::baseprofiler::markers::Tracing{}, "category"));
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, std::string_view("text"), mozilla::baseprofiler::category::OTHER,
+ {}, mozilla::baseprofiler::markers::TextMarker{}, "text text"));
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, std::string_view("media"), mozilla::baseprofiler::category::OTHER,
+ {}, mozilla::baseprofiler::markers::MediaSampleMarker{}, 123, 456, 789));
+
+ MOZ_RELEASE_ASSERT(mozilla::baseprofiler::AddMarkerToBuffer(
+ buffer, std::string_view("media"), mozilla::baseprofiler::category::OTHER,
+ {}, mozilla::baseprofiler::markers::VideoFallingBehindMarker{}, 123,
+ 456));
+
+# ifdef DEBUG
+ buffer.Dump();
+# endif
+
+ PrintMarkers(buffer);
+
+ printf("TestPredefinedMarkers done\n");
+}
+
+void TestProfilerMarkers() {
+ printf(
+ "TestProfilerMarkers -- pid: %" PRIu64 ", tid: %" PRIu64 "\n",
+ uint64_t(mozilla::baseprofiler::profiler_current_process_id().ToNumber()),
+ uint64_t(mozilla::baseprofiler::profiler_current_thread_id().ToNumber()));
+ // ::SleepMilli(10000);
+
+ TestUniqueJSONStrings();
+ TestMarkerCategory();
+ TestMarkerThreadId();
+ TestMarkerNoPayload();
+ TestUserMarker();
+ TestPredefinedMarkers();
+
+ printf("TestProfilerMarkers done\n");
+}
+
+#else // MOZ_GECKO_PROFILER
+
+// Testing that macros are still #defined (but do nothing) when
+// MOZ_GECKO_PROFILER is disabled.
+void TestProfiler() {
+ // These don't need to make sense, we just want to know that they're defined
+ // and don't do anything.
+
+# ifndef AUTO_BASE_PROFILER_INIT
+# error AUTO_BASE_PROFILER_INIT not #defined
+# endif // AUTO_BASE_PROFILER_INIT
+ AUTO_BASE_PROFILER_INIT;
+
+# ifndef AUTO_BASE_PROFILER_MARKER_TEXT
+# error AUTO_BASE_PROFILER_MARKER_TEXT not #defined
+# endif // AUTO_BASE_PROFILER_MARKER_TEXT
+
+# ifndef AUTO_BASE_PROFILER_LABEL
+# error AUTO_BASE_PROFILER_LABEL not #defined
+# endif // AUTO_BASE_PROFILER_LABEL
+
+# ifndef AUTO_BASE_PROFILER_THREAD_SLEEP
+# error AUTO_BASE_PROFILER_THREAD_SLEEP not #defined
+# endif // AUTO_BASE_PROFILER_THREAD_SLEEP
+ AUTO_BASE_PROFILER_THREAD_SLEEP;
+
+# ifndef BASE_PROFILER_MARKER_UNTYPED
+# error BASE_PROFILER_MARKER_UNTYPED not #defined
+# endif // BASE_PROFILER_MARKER_UNTYPED
+
+# ifndef BASE_PROFILER_MARKER
+# error BASE_PROFILER_MARKER not #defined
+# endif // BASE_PROFILER_MARKER
+
+# ifndef BASE_PROFILER_MARKER_TEXT
+# error BASE_PROFILER_MARKER_TEXT not #defined
+# endif // BASE_PROFILER_MARKER_TEXT
+
+ MOZ_RELEASE_ASSERT(!mozilla::baseprofiler::profiler_get_backtrace(),
+ "profiler_get_backtrace should return nullptr");
+ mozilla::ProfileChunkedBuffer buffer(
+ mozilla::ProfileChunkedBuffer::ThreadSafety::WithoutMutex);
+ MOZ_RELEASE_ASSERT(!mozilla::baseprofiler::profiler_capture_backtrace_into(
+ buffer, mozilla::StackCaptureOptions::Full),
+ "profiler_capture_backtrace_into should return false");
+ MOZ_RELEASE_ASSERT(!mozilla::baseprofiler::profiler_capture_backtrace(),
+ "profiler_capture_backtrace should return nullptr");
+}
+
+// Testing that macros are still #defined (but do nothing) when
+// MOZ_GECKO_PROFILER is disabled.
+void TestProfilerMarkers() {
+ // These don't need to make sense, we just want to know that they're defined
+ // and don't do anything.
+}
+
+#endif // MOZ_GECKO_PROFILER else
+
+#if defined(XP_WIN)
+int wmain()
+#else
+int main()
+#endif // defined(XP_WIN)
+{
+#ifdef MOZ_GECKO_PROFILER
+ printf("BaseTestProfiler -- pid: %" PRIu64 ", tid: %" PRIu64 "\n",
+ uint64_t(baseprofiler::profiler_current_process_id().ToNumber()),
+ uint64_t(baseprofiler::profiler_current_thread_id().ToNumber()));
+ // ::SleepMilli(10000);
+#endif // MOZ_GECKO_PROFILER
+
+ TestFailureLatch();
+ TestProfilerUtils();
+ TestBaseAndProfilerDetail();
+ TestSharedMutex();
+ TestProportionValue();
+ TestProgressLogger();
+ // Note that there are two `TestProfiler{,Markers}` functions above, depending
+ // on whether MOZ_GECKO_PROFILER is #defined.
+ {
+ printf("profiler_init()...\n");
+ AUTO_BASE_PROFILER_INIT;
+
+ TestProfiler();
+ TestProfilerMarkers();
+ }
+
+ return 0;
+}
diff --git a/mozglue/tests/TestIntegerPrintfMacros.cpp b/mozglue/tests/TestIntegerPrintfMacros.cpp
new file mode 100644
index 0000000000..71fb26fc47
--- /dev/null
+++ b/mozglue/tests/TestIntegerPrintfMacros.cpp
@@ -0,0 +1,1128 @@
+/* -*- 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/. */
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Sprintf.h"
+
+#include <string.h>
+#include <inttypes.h>
+
+/* Output array and poisoning method shared by all tests. */
+static char gOutput[32];
+
+static void PoisonOutput() { memset(gOutput, 0xDA, sizeof(gOutput)); }
+
+/*
+ * The fprintf macros for signed integers are:
+ *
+ * PRIdN PRIdLEASTN PRIdFASTN PRIdMAX PRIdPTR
+ * PRIiN PRIiLEASTN PRIiFASTN PRIiMAX PRIiPTR
+ *
+ * In these names N is the width of the type as described in C99 7.18.1.
+ */
+
+static void TestPrintSigned8() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRId8, int8_t(-17));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-17"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIi8, int8_t(42));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
+}
+
+static void TestPrintSigned16() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRId16, int16_t(-289));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-289"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIi16, int16_t(728));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "728"));
+}
+
+static void TestPrintSigned32() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRId32, int32_t(-342178));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-342178"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIi32, int32_t(5719283));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "5719283"));
+}
+
+static void TestPrintSigned64() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRId64, int64_t(-INT64_C(432157943248732)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-432157943248732"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIi64, int64_t(INT64_C(325719232983)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
+}
+
+static void TestPrintSignedN() {
+ TestPrintSigned8();
+ TestPrintSigned16();
+ TestPrintSigned32();
+ TestPrintSigned64();
+}
+
+static void TestPrintSignedLeast8() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdLEAST8, int_least8_t(-17));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-17"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiLEAST8, int_least8_t(42));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
+}
+
+static void TestPrintSignedLeast16() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdLEAST16, int_least16_t(-289));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-289"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiLEAST16, int_least16_t(728));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "728"));
+}
+
+static void TestPrintSignedLeast32() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdLEAST32, int_least32_t(-342178));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-342178"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiLEAST32, int_least32_t(5719283));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "5719283"));
+}
+
+static void TestPrintSignedLeast64() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdLEAST64,
+ int_least64_t(-INT64_C(432157943248732)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-432157943248732"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiLEAST64,
+ int_least64_t(INT64_C(325719232983)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
+}
+
+static void TestPrintSignedLeastN() {
+ TestPrintSignedLeast8();
+ TestPrintSignedLeast16();
+ TestPrintSignedLeast32();
+ TestPrintSignedLeast64();
+}
+
+static void TestPrintSignedFast8() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdFAST8, int_fast8_t(-17));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-17"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiFAST8, int_fast8_t(42));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
+}
+
+static void TestPrintSignedFast16() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdFAST16, int_fast16_t(-289));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-289"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiFAST16, int_fast16_t(728));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "728"));
+}
+
+static void TestPrintSignedFast32() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdFAST32, int_fast32_t(-342178));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-342178"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiFAST32, int_fast32_t(5719283));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "5719283"));
+}
+
+static void TestPrintSignedFast64() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdFAST64,
+ int_fast64_t(-INT64_C(432157943248732)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-432157943248732"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiFAST64, int_fast64_t(INT64_C(325719232983)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
+}
+
+static void TestPrintSignedFastN() {
+ TestPrintSignedFast8();
+ TestPrintSignedFast16();
+ TestPrintSignedFast32();
+ TestPrintSignedFast64();
+}
+
+static void TestPrintSignedMax() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdMAX, intmax_t(-INTMAX_C(432157943248732)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-432157943248732"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiMAX, intmax_t(INTMAX_C(325719232983)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
+}
+
+static void TestPrintSignedPtr() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIdPTR,
+ intptr_t(reinterpret_cast<void*>(12345678)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "12345678"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIiPTR,
+ intptr_t(reinterpret_cast<void*>(87654321)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "87654321"));
+}
+
+static void TestPrintSigned() {
+ TestPrintSignedN();
+ TestPrintSignedLeastN();
+ TestPrintSignedFastN();
+ TestPrintSignedMax();
+ TestPrintSignedPtr();
+}
+
+/*
+ * The fprintf macros for unsigned integers are:
+ *
+ * PRIoN PRIoLEASTN PRIoFASTN PRIoMAX PRIoPTR
+ * PRIuN PRIuLEASTN PRIuFASTN PRIuMAX PRIuPTR
+ * PRIxN PRIxLEASTN PRIxFASTN PRIxMAX PRIxPTR
+ * PRIXN PRIXLEASTN PRIXFASTN PRIXMAX PRIXPTR
+ *
+ * In these names N is the width of the type as described in C99 7.18.1.
+ */
+
+static void TestPrintUnsigned8() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIo8, uint8_t(042));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIu8, uint8_t(17));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIx8, uint8_t(0x2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIX8, uint8_t(0xCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CD"));
+}
+
+static void TestPrintUnsigned16() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIo16, uint16_t(04242));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIu16, uint16_t(1717));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "1717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIx16, uint16_t(0x2a2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIX16, uint16_t(0xCDCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCD"));
+}
+
+static void TestPrintUnsigned32() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIo32, uint32_t(0424242));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIu32, uint32_t(171717));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "171717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIx32, uint32_t(0x2a2a2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIX32, uint32_t(0xCDCDCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCD"));
+}
+
+static void TestPrintUnsigned64() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIo64, uint64_t(UINT64_C(0424242424242)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242424242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIu64, uint64_t(UINT64_C(17171717171717171717)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17171717171717171717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIx64, uint64_t(UINT64_C(0x2a2a2a2a2a2a2a)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a2a2a2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIX64, uint64_t(UINT64_C(0xCDCDCDCDCDCD)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCDCDCDCD"));
+}
+
+static void TestPrintUnsignedN() {
+ TestPrintUnsigned8();
+ TestPrintUnsigned16();
+ TestPrintUnsigned32();
+ TestPrintUnsigned64();
+}
+
+static void TestPrintUnsignedLeast8() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoLEAST8, uint_least8_t(042));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuLEAST8, uint_least8_t(17));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxLEAST8, uint_least8_t(0x2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXLEAST8, uint_least8_t(0xCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CD"));
+}
+
+static void TestPrintUnsignedLeast16() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoLEAST16, uint_least16_t(04242));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuLEAST16, uint_least16_t(1717));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "1717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxLEAST16, uint_least16_t(0x2a2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXLEAST16, uint_least16_t(0xCDCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCD"));
+}
+
+static void TestPrintUnsignedLeast32() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoLEAST32, uint_least32_t(0424242));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuLEAST32, uint_least32_t(171717));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "171717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxLEAST32, uint_least32_t(0x2a2a2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXLEAST32, uint_least32_t(0xCDCDCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCD"));
+}
+
+static void TestPrintUnsignedLeast64() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoLEAST64,
+ uint_least64_t(UINT64_C(0424242424242)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242424242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuLEAST64,
+ uint_least64_t(UINT64_C(17171717171717171717)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17171717171717171717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxLEAST64,
+ uint_least64_t(UINT64_C(0x2a2a2a2a2a2a2a)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a2a2a2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXLEAST64,
+ uint_least64_t(UINT64_C(0xCDCDCDCDCDCD)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCDCDCDCD"));
+}
+
+static void TestPrintUnsignedLeastN() {
+ TestPrintUnsignedLeast8();
+ TestPrintUnsignedLeast16();
+ TestPrintUnsignedLeast32();
+ TestPrintUnsignedLeast64();
+}
+
+static void TestPrintUnsignedFast8() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoFAST8, uint_fast8_t(042));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuFAST8, uint_fast8_t(17));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxFAST8, uint_fast8_t(0x2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXFAST8, uint_fast8_t(0xCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CD"));
+}
+
+static void TestPrintUnsignedFast16() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoFAST16, uint_fast16_t(04242));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuFAST16, uint_fast16_t(1717));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "1717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxFAST16, uint_fast16_t(0x2a2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXFAST16, uint_fast16_t(0xCDCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCD"));
+}
+
+static void TestPrintUnsignedFast32() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoFAST32, uint_fast32_t(0424242));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuFAST32, uint_fast32_t(171717));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "171717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxFAST32, uint_fast32_t(0x2a2a2a));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXFAST32, uint_fast32_t(0xCDCDCD));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCD"));
+}
+
+static void TestPrintUnsignedFast64() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoFAST64,
+ uint_fast64_t(UINT64_C(0424242424242)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242424242"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuFAST64,
+ uint_fast64_t(UINT64_C(17171717171717171717)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17171717171717171717"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxFAST64,
+ uint_fast64_t(UINT64_C(0x2a2a2a2a2a2a2a)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a2a2a2a2a"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXFAST64,
+ uint_fast64_t(UINT64_C(0xCDCDCDCDCDCD)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCDCDCDCD"));
+}
+
+static void TestPrintUnsignedFastN() {
+ TestPrintUnsignedFast8();
+ TestPrintUnsignedFast16();
+ TestPrintUnsignedFast32();
+ TestPrintUnsignedFast64();
+}
+
+static void TestPrintUnsignedMax() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoMAX, uintmax_t(UINTMAX_C(432157943248732)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "14220563454333534"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuMAX, uintmax_t(UINTMAX_C(325719232983)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxMAX, uintmax_t(UINTMAX_C(327281321873)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4c337ca791"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXMAX, uintmax_t(UINTMAX_C(912389523743523)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "33DD03D75A323"));
+}
+
+static void TestPrintUnsignedPtr() {
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIoPTR,
+ uintptr_t(reinterpret_cast<void*>(12345678)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "57060516"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIuPTR,
+ uintptr_t(reinterpret_cast<void*>(87654321)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "87654321"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIxPTR,
+ uintptr_t(reinterpret_cast<void*>(0x4c3a791)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4c3a791"));
+
+ PoisonOutput();
+ SprintfLiteral(gOutput, "%" PRIXPTR,
+ uintptr_t(reinterpret_cast<void*>(0xF328DB)));
+ MOZ_RELEASE_ASSERT(!strcmp(gOutput, "F328DB"));
+}
+
+static void TestPrintUnsigned() {
+ TestPrintUnsignedN();
+ TestPrintUnsignedLeastN();
+ TestPrintUnsignedFastN();
+ TestPrintUnsignedMax();
+ TestPrintUnsignedPtr();
+}
+
+static void TestPrint() {
+ TestPrintSigned();
+ TestPrintUnsigned();
+}
+
+/*
+ * The fscanf macros for signed integers are:
+ *
+ * SCNdN SCNdLEASTN SCNdFASTN SCNdMAX SCNdPTR
+ * SCNiN SCNiLEASTN SCNiFASTN SCNiMAX SCNiPTR
+ *
+ * In these names N is the width of the type as described in C99 7.18.1.
+ */
+
+/*
+ * MSVC's scanf is insufficiently powerful to implement all the SCN* macros.
+ * Rather than support some subset of them, we instead support none of them.
+ * See the comment at the top of IntegerPrintfMacros.h. But in case we ever do
+ * support them, the following tests should adequately test implementation
+ * correctness. (Indeed, these tests *revealed* MSVC's limitations.)
+ *
+ * That said, even if MSVC ever picks up complete support, we still probably
+ * don't want to support these, because of the undefined-behavior issue noted
+ * further down in the comment atop IntegerPrintfMacros.h.
+ */
+#define SHOULD_TEST_SCANF_MACROS 0
+
+#if SHOULD_TEST_SCANF_MACROS
+
+/*
+ * glibc header definitions for SCN{d,i,o,u,x}{,LEAST,FAST}8 use the "hh" length
+ * modifier, which is new in C99 (and C++11, by reference). We compile this
+ * file as C++11, so if "hh" is used in these macros, it's standard. But some
+ * versions of gcc wrongly think it isn't and warn about a "non-standard"
+ * modifier. And since these tests mostly exist to verify format-macro/type
+ * consistency (particularly through compiler warnings about incorrect formats),
+ * these warnings are unacceptable. So for now, compile tests for those macros
+ * only if we aren't compiling with gcc.
+ */
+# define SHOULD_TEST_8BIT_FORMAT_MACROS (!(MOZ_IS_GCC))
+
+template <typename T>
+union Input {
+ T mI;
+ unsigned char mPun[16];
+};
+
+template <typename T>
+static void PoisonInput(Input<T>& aInput) {
+ memset(aInput.mPun, 0xDA, sizeof(aInput.mPun));
+}
+
+template <typename T>
+static bool ExtraBitsUntouched(const Input<T>& aInput) {
+ for (size_t i = sizeof(aInput.mI); i < sizeof(aInput); i++) {
+ if (aInput.mPun[i] != 0xDA) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static void TestScanSigned8() {
+# if SHOULD_TEST_8BIT_FORMAT_MACROS
+ Input<int8_t> u;
+
+ PoisonInput(u);
+ sscanf("-17", "%" SCNd8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -17);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("042", "%" SCNi8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 042);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+# endif
+}
+
+static void TestScanSigned16() {
+ Input<int16_t> u;
+
+ PoisonInput(u);
+ sscanf("-1742", "%" SCNd16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -1742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("04217", "%" SCNi16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 04217);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSigned32() {
+ Input<int32_t> u;
+
+ PoisonInput(u);
+ sscanf("-174257", "%" SCNd32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -174257);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("0423571", "%" SCNi32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0423571);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSigned64() {
+ Input<int64_t> u;
+
+ PoisonInput(u);
+ sscanf("-17425238927232", "%" SCNd64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -INT64_C(17425238927232));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("042333576571", "%" SCNi64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == INT64_C(042333576571));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSignedN() {
+ TestScanSigned8();
+ TestScanSigned16();
+ TestScanSigned32();
+ TestScanSigned64();
+}
+
+static void TestScanSignedLeast8() {
+# if SHOULD_TEST_8BIT_FORMAT_MACROS
+ Input<int_least8_t> u;
+
+ PoisonInput(u);
+ sscanf("-17", "%" SCNdLEAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -17);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("042", "%" SCNiLEAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 042);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+# endif
+}
+
+static void TestScanSignedLeast16() {
+ Input<int_least16_t> u;
+
+ PoisonInput(u);
+ sscanf("-1742", "%" SCNdLEAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -1742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("04217", "%" SCNiLEAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 04217);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSignedLeast32() {
+ Input<int_least32_t> u;
+
+ PoisonInput(u);
+ sscanf("-174257", "%" SCNdLEAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -174257);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("0423571", "%" SCNiLEAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0423571);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSignedLeast64() {
+ Input<int_least64_t> u;
+
+ PoisonInput(u);
+ sscanf("-17425238927232", "%" SCNdLEAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -INT64_C(17425238927232));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("042333576571", "%" SCNiLEAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == INT64_C(042333576571));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSignedLeastN() {
+ TestScanSignedLeast8();
+ TestScanSignedLeast16();
+ TestScanSignedLeast32();
+ TestScanSignedLeast64();
+}
+
+static void TestScanSignedFast8() {
+# if SHOULD_TEST_8BIT_FORMAT_MACROS
+ Input<int_fast8_t> u;
+
+ PoisonInput(u);
+ sscanf("-17", "%" SCNdFAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -17);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("042", "%" SCNiFAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 042);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+# endif
+}
+
+static void TestScanSignedFast16() {
+ Input<int_fast16_t> u;
+
+ PoisonInput(u);
+ sscanf("-1742", "%" SCNdFAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -1742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("04217", "%" SCNiFAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 04217);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSignedFast32() {
+ Input<int_fast32_t> u;
+
+ PoisonInput(u);
+ sscanf("-174257", "%" SCNdFAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -174257);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("0423571", "%" SCNiFAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0423571);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSignedFast64() {
+ Input<int_fast64_t> u;
+
+ PoisonInput(u);
+ sscanf("-17425238927232", "%" SCNdFAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -INT64_C(17425238927232));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("042333576571", "%" SCNiFAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == INT64_C(042333576571));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSignedFastN() {
+ TestScanSignedFast8();
+ TestScanSignedFast16();
+ TestScanSignedFast32();
+ TestScanSignedFast64();
+}
+
+static void TestScanSignedMax() {
+ Input<intmax_t> u;
+
+ PoisonInput(u);
+ sscanf("-432157943248732", "%" SCNdMAX, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == -INTMAX_C(432157943248732));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("04233357236571", "%" SCNiMAX, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == INTMAX_C(04233357236571));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSignedPtr() {
+ Input<intptr_t> u;
+
+ PoisonInput(u);
+ sscanf("12345678", "%" SCNdPTR, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == intptr_t(reinterpret_cast<void*>(12345678)));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("04233357236", "%" SCNiPTR, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == intptr_t(reinterpret_cast<void*>(04233357236)));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanSigned() {
+ TestScanSignedN();
+ TestScanSignedLeastN();
+ TestScanSignedFastN();
+ TestScanSignedMax();
+ TestScanSignedPtr();
+}
+
+/*
+ * The fscanf macros for unsigned integers are:
+ *
+ * SCNoN SCNoLEASTN SCNoFASTN SCNoMAX SCNoPTR
+ * SCNuN SCNuLEASTN SCNuFASTN SCNuMAX SCNuPTR
+ * SCNxN SCNxLEASTN SCNxFASTN SCNxMAX SCNxPTR
+ *
+ * In these names N is the width of the type as described in C99 7.18.1.
+ */
+
+static void TestScanUnsigned8() {
+# if SHOULD_TEST_8BIT_FORMAT_MACROS
+ Input<uint8_t> u;
+
+ PoisonInput(u);
+ sscanf("17", "%" SCNo8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 017);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("42", "%" SCNu8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 42);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2A", "%" SCNx8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2A);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+# endif
+}
+
+static void TestScanUnsigned16() {
+ Input<uint16_t> u;
+
+ PoisonInput(u);
+ sscanf("1742", "%" SCNo16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 01742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("4217", "%" SCNu16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 4217);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2ABC", "%" SCNx16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2ABC);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsigned32() {
+ Input<uint32_t> u;
+
+ PoisonInput(u);
+ sscanf("17421742", "%" SCNo32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 017421742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("4217867", "%" SCNu32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 4217867);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2ABCBEEF", "%" SCNx32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2ABCBEEF);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsigned64() {
+ Input<uint64_t> u;
+
+ PoisonInput(u);
+ sscanf("17421742173", "%" SCNo64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(017421742173));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("421786713579", "%" SCNu64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(421786713579));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("DEADBEEF7457E", "%" SCNx64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(0xDEADBEEF7457E));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsignedN() {
+ TestScanUnsigned8();
+ TestScanUnsigned16();
+ TestScanUnsigned32();
+ TestScanUnsigned64();
+}
+
+static void TestScanUnsignedLeast8() {
+# if SHOULD_TEST_8BIT_FORMAT_MACROS
+ Input<uint_least8_t> u;
+
+ PoisonInput(u);
+ sscanf("17", "%" SCNoLEAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 017);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("42", "%" SCNuLEAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 42);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2A", "%" SCNxLEAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2A);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+# endif
+}
+
+static void TestScanUnsignedLeast16() {
+ Input<uint_least16_t> u;
+
+ PoisonInput(u);
+ sscanf("1742", "%" SCNoLEAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 01742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("4217", "%" SCNuLEAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 4217);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2ABC", "%" SCNxLEAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2ABC);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsignedLeast32() {
+ Input<uint_least32_t> u;
+
+ PoisonInput(u);
+ sscanf("17421742", "%" SCNoLEAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 017421742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("4217867", "%" SCNuLEAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 4217867);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2ABCBEEF", "%" SCNxLEAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2ABCBEEF);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsignedLeast64() {
+ Input<uint_least64_t> u;
+
+ PoisonInput(u);
+ sscanf("17421742173", "%" SCNoLEAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(017421742173));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("421786713579", "%" SCNuLEAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(421786713579));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("DEADBEEF7457E", "%" SCNxLEAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(0xDEADBEEF7457E));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsignedLeastN() {
+ TestScanUnsignedLeast8();
+ TestScanUnsignedLeast16();
+ TestScanUnsignedLeast32();
+ TestScanUnsignedLeast64();
+}
+
+static void TestScanUnsignedFast8() {
+# if SHOULD_TEST_8BIT_FORMAT_MACROS
+ Input<uint_fast8_t> u;
+
+ PoisonInput(u);
+ sscanf("17", "%" SCNoFAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 017);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("42", "%" SCNuFAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 42);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2A", "%" SCNxFAST8, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2A);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+# endif
+}
+
+static void TestScanUnsignedFast16() {
+ Input<uint_fast16_t> u;
+
+ PoisonInput(u);
+ sscanf("1742", "%" SCNoFAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 01742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("4217", "%" SCNuFAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 4217);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2ABC", "%" SCNxFAST16, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2ABC);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsignedFast32() {
+ Input<uint_fast32_t> u;
+
+ PoisonInput(u);
+ sscanf("17421742", "%" SCNoFAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 017421742);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("4217867", "%" SCNuFAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 4217867);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("2ABCBEEF", "%" SCNxFAST32, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == 0x2ABCBEEF);
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsignedFast64() {
+ Input<uint_fast64_t> u;
+
+ PoisonInput(u);
+ sscanf("17421742173", "%" SCNoFAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(017421742173));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("421786713579", "%" SCNuFAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(421786713579));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("DEADBEEF7457E", "%" SCNxFAST64, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINT64_C(0xDEADBEEF7457E));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsignedFastN() {
+ TestScanUnsignedFast8();
+ TestScanUnsignedFast16();
+ TestScanUnsignedFast32();
+ TestScanUnsignedFast64();
+}
+
+static void TestScanUnsignedMax() {
+ Input<uintmax_t> u;
+
+ PoisonInput(u);
+ sscanf("14220563454333534", "%" SCNoMAX, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINTMAX_C(432157943248732));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("432157943248732", "%" SCNuMAX, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINTMAX_C(432157943248732));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("4c337ca791", "%" SCNxMAX, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == UINTMAX_C(327281321873));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsignedPtr() {
+ Input<uintptr_t> u;
+
+ PoisonInput(u);
+ sscanf("57060516", "%" SCNoPTR, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == uintptr_t(reinterpret_cast<void*>(12345678)));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("87654321", "%" SCNuPTR, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == uintptr_t(reinterpret_cast<void*>(87654321)));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+
+ PoisonInput(u);
+ sscanf("4c3a791", "%" SCNxPTR, &u.mI);
+ MOZ_RELEASE_ASSERT(u.mI == uintptr_t(reinterpret_cast<void*>(0x4c3a791)));
+ MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
+}
+
+static void TestScanUnsigned() {
+ TestScanUnsignedN();
+ TestScanUnsignedLeastN();
+ TestScanUnsignedFastN();
+ TestScanUnsignedMax();
+ TestScanUnsignedPtr();
+}
+
+static void TestScan() {
+ TestScanSigned();
+ TestScanUnsigned();
+}
+
+#endif /* SHOULD_TEST_SCANF_MACROS */
+
+#if defined(XP_WIN)
+int wmain()
+#else
+int main()
+#endif // defined(XP_WIN)
+{
+ TestPrint();
+#if SHOULD_TEST_SCANF_MACROS
+ TestScan();
+#endif
+ return 0;
+}
diff --git a/mozglue/tests/TestNativeNt.cpp b/mozglue/tests/TestNativeNt.cpp
new file mode 100644
index 0000000000..d4f671e33c
--- /dev/null
+++ b/mozglue/tests/TestNativeNt.cpp
@@ -0,0 +1,606 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#include "nscore.h"
+#include "mozilla/NativeNt.h"
+#include "mozilla/ThreadLocal.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/WindowsEnumProcessModules.h"
+
+#include <stdio.h>
+#include <windows.h>
+#include <strsafe.h>
+
+const wchar_t kNormal[] = L"Foo.dll";
+const wchar_t kHex12[] = L"Foo.ABCDEF012345.dll";
+const wchar_t kHex15[] = L"ABCDEF012345678.dll";
+const wchar_t kHex16[] = L"ABCDEF0123456789.dll";
+const wchar_t kHex17[] = L"ABCDEF0123456789a.dll";
+const wchar_t kHex24[] = L"ABCDEF0123456789cdabef98.dll";
+const wchar_t kHex8[] = L"01234567.dll";
+const wchar_t kNonHex12[] = L"Foo.ABCDEFG12345.dll";
+const wchar_t kHex13[] = L"Foo.ABCDEF0123456.dll";
+const wchar_t kHex11[] = L"Foo.ABCDEF01234.dll";
+const wchar_t kPrefixedHex16[] = L"Pabcdef0123456789.dll";
+const uint32_t kTlsDataValue = 1234;
+static MOZ_THREAD_LOCAL(uint32_t) sTlsData;
+
+// Need non-inline functions to bypass compiler optimization that the thread
+// local storage pointer is cached in a register before accessing a thread-local
+// variable. See bug 1803322 for a motivating example.
+MOZ_NEVER_INLINE uint32_t getTlsData() { return sTlsData.get(); }
+MOZ_NEVER_INLINE void setTlsData(uint32_t x) { sTlsData.set(x); }
+
+const char kFailFmt[] =
+ "TEST-FAILED | NativeNt | %s(%s) should have returned %s but did not\n";
+
+#define RUN_TEST(fn, varName, expected) \
+ if (fn(varName) == !expected) { \
+ printf(kFailFmt, #fn, #varName, #expected); \
+ return 1; \
+ }
+
+#define EXPECT_FAIL(fn, varName) RUN_TEST(fn, varName, false)
+
+#define EXPECT_SUCCESS(fn, varName) RUN_TEST(fn, varName, true)
+
+using namespace mozilla;
+using namespace mozilla::nt;
+
+bool TestVirtualQuery(HANDLE aProcess, LPCVOID aAddress) {
+ MEMORY_BASIC_INFORMATION info1 = {}, info2 = {};
+ SIZE_T result1 = ::VirtualQueryEx(aProcess, aAddress, &info1, sizeof(info1)),
+ result2 = mozilla::nt::VirtualQueryEx(aProcess, aAddress, &info2,
+ sizeof(info2));
+ if (result1 != result2) {
+ printf("TEST-FAILED | NativeNt | The returned values mismatch\n");
+ return false;
+ }
+
+ if (!result1) {
+ // Both APIs failed.
+ return true;
+ }
+
+ if (memcmp(&info1, &info2, result1) != 0) {
+ printf("TEST-FAILED | NativeNt | The returned structures mismatch\n");
+ return false;
+ }
+
+ return true;
+}
+
+// This class copies the self executable file to the %temp%\<outer>\<inner>
+// folder. The length of its path is longer than MAX_PATH.
+class LongNameModule {
+ wchar_t mOuterDirBuffer[MAX_PATH];
+ wchar_t mInnerDirBuffer[MAX_PATH * 2];
+ wchar_t mTargetFileBuffer[MAX_PATH * 2];
+
+ const wchar_t* mOuterDir;
+ const wchar_t* mInnerDir;
+ const wchar_t* mTargetFile;
+
+ public:
+ explicit LongNameModule(const wchar_t* aNewLeafNameAfterCopy)
+ : mOuterDir(nullptr), mInnerDir(nullptr), mTargetFile(nullptr) {
+ const wchar_t kFolderName160Chars[] =
+ L"0123456789ABCDEF0123456789ABCDEF"
+ L"0123456789ABCDEF0123456789ABCDEF"
+ L"0123456789ABCDEF0123456789ABCDEF"
+ L"0123456789ABCDEF0123456789ABCDEF"
+ L"0123456789ABCDEF0123456789ABCDEF";
+ UniquePtr<wchar_t[]> thisExe = GetFullBinaryPath();
+ if (!thisExe) {
+ return;
+ }
+
+ // If the buffer is too small, GetTempPathW returns the required
+ // length including a null character, while on a successful case
+ // it returns the number of copied characters which does not include
+ // a null character. This means len == MAX_PATH should never happen
+ // and len > MAX_PATH means GetTempPathW failed.
+ wchar_t tempDir[MAX_PATH];
+ DWORD len = ::GetTempPathW(MAX_PATH, tempDir);
+ if (!len || len >= MAX_PATH) {
+ return;
+ }
+
+ if (FAILED(::StringCbPrintfW(mOuterDirBuffer, sizeof(mOuterDirBuffer),
+ L"\\\\?\\%s%s", tempDir,
+ kFolderName160Chars)) ||
+ !::CreateDirectoryW(mOuterDirBuffer, nullptr)) {
+ return;
+ }
+ mOuterDir = mOuterDirBuffer;
+
+ if (FAILED(::StringCbPrintfW(mInnerDirBuffer, sizeof(mInnerDirBuffer),
+ L"\\\\?\\%s%s\\%s", tempDir,
+ kFolderName160Chars, kFolderName160Chars)) ||
+ !::CreateDirectoryW(mInnerDirBuffer, nullptr)) {
+ return;
+ }
+ mInnerDir = mInnerDirBuffer;
+
+ if (FAILED(::StringCbPrintfW(mTargetFileBuffer, sizeof(mTargetFileBuffer),
+ L"\\\\?\\%s%s\\%s\\%s", tempDir,
+ kFolderName160Chars, kFolderName160Chars,
+ aNewLeafNameAfterCopy)) ||
+ !::CopyFileW(thisExe.get(), mTargetFileBuffer,
+ /*bFailIfExists*/ TRUE)) {
+ return;
+ }
+ mTargetFile = mTargetFileBuffer;
+ }
+
+ ~LongNameModule() {
+ if (mTargetFile) {
+ ::DeleteFileW(mTargetFile);
+ }
+ if (mInnerDir) {
+ ::RemoveDirectoryW(mInnerDir);
+ }
+ if (mOuterDir) {
+ ::RemoveDirectoryW(mOuterDir);
+ }
+ }
+
+ operator const wchar_t*() const { return mTargetFile; }
+};
+
+// Make sure module info retrieved from nt::PEHeaders is the same as one
+// retrieved from GetModuleInformation API.
+bool CompareModuleInfo(HMODULE aModuleForApi, HMODULE aModuleForPEHeader) {
+ MODULEINFO moduleInfo;
+ if (!::GetModuleInformation(::GetCurrentProcess(), aModuleForApi, &moduleInfo,
+ sizeof(moduleInfo))) {
+ printf("TEST-FAILED | NativeNt | GetModuleInformation failed - %08lx\n",
+ ::GetLastError());
+ return false;
+ }
+
+ PEHeaders headers(aModuleForPEHeader);
+ if (!headers) {
+ printf("TEST-FAILED | NativeNt | Failed to instantiate PEHeaders\n");
+ return false;
+ }
+
+ Maybe<Range<const uint8_t>> bounds = headers.GetBounds();
+ if (!bounds) {
+ printf("TEST-FAILED | NativeNt | PEHeaders::GetBounds failed\n");
+ return false;
+ }
+
+ if (bounds->length() != moduleInfo.SizeOfImage) {
+ printf("TEST-FAILED | NativeNt | SizeOfImage does not match\n");
+ return false;
+ }
+
+ // GetModuleInformation sets EntryPoint to 0 for executables
+ // except the running self.
+ static const HMODULE sSelf = ::GetModuleHandleW(nullptr);
+ if (aModuleForApi != sSelf &&
+ !(headers.GetFileCharacteristics() & IMAGE_FILE_DLL)) {
+ if (moduleInfo.EntryPoint) {
+ printf(
+ "TEST-FAIL | NativeNt | "
+ "GetModuleInformation returned a non-zero entrypoint "
+ "for an executable\n");
+ return false;
+ }
+
+ // Cannot verify PEHeaders::GetEntryPoint.
+ return true;
+ }
+
+ // For a module whose entrypoint is 0 (e.g. ntdll.dll or win32u.dll),
+ // MODULEINFO::EntryPoint is set to 0, while PEHeaders::GetEntryPoint
+ // returns the imagebase (RVA=0).
+ intptr_t rvaEntryPoint =
+ moduleInfo.EntryPoint
+ ? reinterpret_cast<uintptr_t>(moduleInfo.EntryPoint) -
+ reinterpret_cast<uintptr_t>(moduleInfo.lpBaseOfDll)
+ : 0;
+ if (rvaEntryPoint < 0) {
+ printf("TEST-FAILED | NativeNt | MODULEINFO is invalid\n");
+ return false;
+ }
+
+ if (headers.RVAToPtr<FARPROC>(rvaEntryPoint) != headers.GetEntryPoint()) {
+ printf("TEST-FAILED | NativeNt | Entrypoint does not match\n");
+ return false;
+ }
+
+ return true;
+}
+
+bool TestModuleInfo() {
+ UNICODE_STRING newLeafName;
+ ::RtlInitUnicodeString(&newLeafName,
+ L"\u672D\u5E4C\u5473\u564C.\u30E9\u30FC\u30E1\u30F3");
+
+ LongNameModule longNameModule(newLeafName.Buffer);
+ if (!longNameModule) {
+ printf(
+ "TEST-FAILED | NativeNt | "
+ "Failed to copy the executable to a long directory path\n");
+ return 1;
+ }
+
+ {
+ nsModuleHandle module(::LoadLibraryW(longNameModule));
+
+ bool detectedTarget = false;
+ bool passedAllModules = true;
+ auto moduleCallback = [&](const wchar_t* aModulePath, HMODULE aModule) {
+ UNICODE_STRING modulePath, moduleName;
+ ::RtlInitUnicodeString(&modulePath, aModulePath);
+ GetLeafName(&moduleName, &modulePath);
+ if (::RtlEqualUnicodeString(&moduleName, &newLeafName,
+ /*aCaseInsensitive*/ TRUE)) {
+ detectedTarget = true;
+ }
+
+ if (!CompareModuleInfo(aModule, aModule)) {
+ passedAllModules = false;
+ }
+ };
+
+ if (!mozilla::EnumerateProcessModules(moduleCallback)) {
+ printf("TEST-FAILED | NativeNt | EnumerateProcessModules failed\n");
+ return false;
+ }
+
+ if (!detectedTarget) {
+ printf(
+ "TEST-FAILED | NativeNt | "
+ "EnumerateProcessModules missed the target file\n");
+ return false;
+ }
+
+ if (!passedAllModules) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Make sure PEHeaders works for a module loaded with LOAD_LIBRARY_AS_DATAFILE
+// as well as a module loaded normally.
+bool TestModuleLoadedAsData() {
+ const wchar_t kNewLeafName[] = L"\u03BC\u0061\u9EBA.txt";
+
+ LongNameModule longNameModule(kNewLeafName);
+ if (!longNameModule) {
+ printf(
+ "TEST-FAILED | NativeNt | "
+ "Failed to copy the executable to a long directory path\n");
+ return 1;
+ }
+
+ const wchar_t* kManualLoadModules[] = {
+ L"mshtml.dll",
+ L"shell32.dll",
+ longNameModule,
+ };
+
+ for (const auto moduleName : kManualLoadModules) {
+ // Must load a module as data first,
+ nsModuleHandle moduleAsData(::LoadLibraryExW(
+ moduleName, nullptr,
+ LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE));
+
+ // then load a module normally to map it on a different address.
+ nsModuleHandle module(::LoadLibraryW(moduleName));
+
+ if (!CompareModuleInfo(module.get(), moduleAsData.get())) {
+ return false;
+ }
+
+ PEHeaders peAsData(moduleAsData.get());
+ PEHeaders pe(module.get());
+ if (!peAsData || !pe) {
+ printf("TEST-FAIL | NativeNt | Failed to load the module\n");
+ return false;
+ }
+
+ if (peAsData.RVAToPtr<HMODULE>(0) == pe.RVAToPtr<HMODULE>(0)) {
+ printf(
+ "TEST-FAIL | NativeNt | "
+ "The module should have been mapped onto two different places\n");
+ return false;
+ }
+
+ const auto* pdb1 = peAsData.GetPdbInfo();
+ const auto* pdb2 = pe.GetPdbInfo();
+ if (pdb1 && pdb2) {
+ if (pdb1->pdbSignature != pdb2->pdbSignature ||
+ pdb1->pdbAge != pdb2->pdbAge ||
+ strcmp(pdb1->pdbFileName, pdb2->pdbFileName)) {
+ printf(
+ "TEST-FAIL | NativeNt | "
+ "PDB info from the same module did not match.\n");
+ return false;
+ }
+ } else if (pdb1 || pdb2) {
+ printf(
+ "TEST-FAIL | NativeNt | Failed to get PDB info from the module.\n");
+ return false;
+ }
+
+ uint64_t version1, version2;
+ bool result1 = peAsData.GetVersionInfo(version1);
+ bool result2 = pe.GetVersionInfo(version2);
+ if (result1 && result2) {
+ if (version1 != version2) {
+ printf("TEST-FAIL | NativeNt | Version mismatch\n");
+ return false;
+ }
+ } else if (result1 || result2) {
+ printf(
+ "TEST-FAIL | NativeNt | Failed to get PDB info from the module.\n");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+LauncherResult<HMODULE> GetModuleHandleFromLeafName(const wchar_t* aName) {
+ UNICODE_STRING name;
+ ::RtlInitUnicodeString(&name, aName);
+ return nt::GetModuleHandleFromLeafName(name);
+}
+
+// Need a non-inline function to bypass compiler optimization that the thread
+// local storage pointer is cached in a register before accessing a thread-local
+// variable.
+MOZ_NEVER_INLINE PVOID SwapThreadLocalStoragePointer(PVOID aNewValue) {
+ auto oldValue = RtlGetThreadLocalStoragePointer();
+ RtlSetThreadLocalStoragePointerForTestingOnly(aNewValue);
+ return oldValue;
+}
+
+int wmain(int argc, wchar_t* argv[]) {
+ UNICODE_STRING normal;
+ ::RtlInitUnicodeString(&normal, kNormal);
+
+ UNICODE_STRING hex12;
+ ::RtlInitUnicodeString(&hex12, kHex12);
+
+ UNICODE_STRING hex16;
+ ::RtlInitUnicodeString(&hex16, kHex16);
+
+ UNICODE_STRING hex24;
+ ::RtlInitUnicodeString(&hex24, kHex24);
+
+ UNICODE_STRING hex8;
+ ::RtlInitUnicodeString(&hex8, kHex8);
+
+ UNICODE_STRING nonHex12;
+ ::RtlInitUnicodeString(&nonHex12, kNonHex12);
+
+ UNICODE_STRING hex13;
+ ::RtlInitUnicodeString(&hex13, kHex13);
+
+ UNICODE_STRING hex11;
+ ::RtlInitUnicodeString(&hex11, kHex11);
+
+ UNICODE_STRING hex15;
+ ::RtlInitUnicodeString(&hex15, kHex15);
+
+ UNICODE_STRING hex17;
+ ::RtlInitUnicodeString(&hex17, kHex17);
+
+ UNICODE_STRING prefixedHex16;
+ ::RtlInitUnicodeString(&prefixedHex16, kPrefixedHex16);
+
+ EXPECT_FAIL(Contains12DigitHexString, normal);
+ EXPECT_SUCCESS(Contains12DigitHexString, hex12);
+ EXPECT_FAIL(Contains12DigitHexString, hex13);
+ EXPECT_FAIL(Contains12DigitHexString, hex11);
+ EXPECT_FAIL(Contains12DigitHexString, hex16);
+ EXPECT_FAIL(Contains12DigitHexString, nonHex12);
+
+ EXPECT_FAIL(IsFileNameAtLeast16HexDigits, normal);
+ EXPECT_FAIL(IsFileNameAtLeast16HexDigits, hex12);
+ EXPECT_SUCCESS(IsFileNameAtLeast16HexDigits, hex24);
+ EXPECT_SUCCESS(IsFileNameAtLeast16HexDigits, hex16);
+ EXPECT_SUCCESS(IsFileNameAtLeast16HexDigits, hex17);
+ EXPECT_FAIL(IsFileNameAtLeast16HexDigits, hex8);
+ EXPECT_FAIL(IsFileNameAtLeast16HexDigits, hex15);
+ EXPECT_FAIL(IsFileNameAtLeast16HexDigits, prefixedHex16);
+
+ if (RtlGetProcessHeap() != ::GetProcessHeap()) {
+ printf("TEST-FAILED | NativeNt | RtlGetProcessHeap() is broken\n");
+ return 1;
+ }
+
+#ifdef HAVE_SEH_EXCEPTIONS
+ PVOID origTlsHead = nullptr;
+ bool isExceptionThrown = false;
+ // Touch sTlsData.get() several times to prevent the call to sTlsData.set()
+ // from being optimized out in PGO build.
+ printf("sTlsData#1 = %08x\n", getTlsData());
+ MOZ_SEH_TRY {
+ // Need to call SwapThreadLocalStoragePointer inside __try to make sure
+ // accessing sTlsData is caught by SEH. This is due to clang's design.
+ // https://bugs.llvm.org/show_bug.cgi?id=44174.
+ origTlsHead = SwapThreadLocalStoragePointer(nullptr);
+ setTlsData(~kTlsDataValue);
+ }
+ MOZ_SEH_EXCEPT(GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION
+ ? EXCEPTION_EXECUTE_HANDLER
+ : EXCEPTION_CONTINUE_SEARCH) {
+ isExceptionThrown = true;
+ }
+ SwapThreadLocalStoragePointer(origTlsHead);
+ printf("sTlsData#2 = %08x\n", getTlsData());
+ setTlsData(kTlsDataValue);
+ printf("sTlsData#3 = %08x\n", getTlsData());
+ if (!isExceptionThrown || getTlsData() != kTlsDataValue) {
+ printf(
+ "TEST-FAILED | NativeNt | RtlGetThreadLocalStoragePointer() is "
+ "broken\n");
+ return 1;
+ }
+#endif
+
+ if (RtlGetCurrentThreadId() != ::GetCurrentThreadId()) {
+ printf("TEST-FAILED | NativeNt | RtlGetCurrentThreadId() is broken\n");
+ return 1;
+ }
+
+ const wchar_t kKernel32[] = L"kernel32.dll";
+ DWORD verInfoSize = ::GetFileVersionInfoSizeW(kKernel32, nullptr);
+ if (!verInfoSize) {
+ printf(
+ "TEST-FAILED | NativeNt | Call to GetFileVersionInfoSizeW failed with "
+ "code %lu\n",
+ ::GetLastError());
+ return 1;
+ }
+
+ auto verInfoBuf = MakeUnique<char[]>(verInfoSize);
+
+ if (!::GetFileVersionInfoW(kKernel32, 0, verInfoSize, verInfoBuf.get())) {
+ printf(
+ "TEST-FAILED | NativeNt | Call to GetFileVersionInfoW failed with code "
+ "%lu\n",
+ ::GetLastError());
+ return 1;
+ }
+
+ UINT len;
+ VS_FIXEDFILEINFO* fixedFileInfo = nullptr;
+ if (!::VerQueryValueW(verInfoBuf.get(), L"\\", (LPVOID*)&fixedFileInfo,
+ &len)) {
+ printf(
+ "TEST-FAILED | NativeNt | Call to VerQueryValueW failed with code "
+ "%lu\n",
+ ::GetLastError());
+ return 1;
+ }
+
+ const uint64_t expectedVersion =
+ (static_cast<uint64_t>(fixedFileInfo->dwFileVersionMS) << 32) |
+ static_cast<uint64_t>(fixedFileInfo->dwFileVersionLS);
+
+ PEHeaders k32headers(::GetModuleHandleW(kKernel32));
+ if (!k32headers) {
+ printf(
+ "TEST-FAILED | NativeNt | Failed parsing kernel32.dll's PE headers\n");
+ return 1;
+ }
+
+ uint64_t version;
+ if (!k32headers.GetVersionInfo(version)) {
+ printf(
+ "TEST-FAILED | NativeNt | Unable to obtain version information from "
+ "kernel32.dll\n");
+ return 1;
+ }
+
+ if (version != expectedVersion) {
+ printf(
+ "TEST-FAILED | NativeNt | kernel32.dll's detected version "
+ "(0x%016llX) does not match expected version (0x%016llX)\n",
+ version, expectedVersion);
+ return 1;
+ }
+
+ Maybe<Span<IMAGE_THUNK_DATA>> iatThunks =
+ k32headers.GetIATThunksForModule("kernel32.dll");
+ if (iatThunks) {
+ printf(
+ "TEST-FAILED | NativeNt | Detected the IAT thunk for kernel32 "
+ "in kernel32.dll\n");
+ return 1;
+ }
+
+ const mozilla::nt::CodeViewRecord70* debugInfo = k32headers.GetPdbInfo();
+ if (!debugInfo) {
+ printf(
+ "TEST-FAILED | NativeNt | Unable to obtain debug information from "
+ "kernel32.dll\n");
+ return 1;
+ }
+
+#ifndef WIN32 // failure on windows10x32
+ if (stricmp(debugInfo->pdbFileName, "kernel32.pdb")) {
+ printf(
+ "TEST-FAILED | NativeNt | Unexpected PDB filename "
+ "in kernel32.dll: %s\n",
+ debugInfo->pdbFileName);
+ return 1;
+ }
+#endif
+
+ PEHeaders ntdllheaders(::GetModuleHandleW(L"ntdll.dll"));
+
+ auto ntdllBoundaries = ntdllheaders.GetBounds();
+ if (!ntdllBoundaries) {
+ printf(
+ "TEST-FAILED | NativeNt | "
+ "Unable to obtain the boundaries of ntdll.dll\n");
+ return 1;
+ }
+
+ iatThunks =
+ k32headers.GetIATThunksForModule("ntdll.dll", ntdllBoundaries.ptr());
+ if (!iatThunks) {
+ printf(
+ "TEST-FAILED | NativeNt | Unable to find the IAT thunk for "
+ "ntdll.dll in kernel32.dll\n");
+ return 1;
+ }
+
+ // To test the Ex version of API, we purposely get a real handle
+ // instead of a pseudo handle.
+ nsAutoHandle process(
+ ::OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId()));
+ if (!process) {
+ printf("TEST-FAILED | NativeNt | OpenProcess() failed - %08lx\n",
+ ::GetLastError());
+ return 1;
+ }
+
+ // Test Null page, Heap, Mapped image, and Invalid handle
+ if (!TestVirtualQuery(process, nullptr) || !TestVirtualQuery(process, argv) ||
+ !TestVirtualQuery(process, kNormal) ||
+ !TestVirtualQuery(nullptr, kNormal)) {
+ return 1;
+ }
+
+ auto moduleResult = GetModuleHandleFromLeafName(kKernel32);
+ if (moduleResult.isErr() ||
+ moduleResult.inspect() != k32headers.template RVAToPtr<HMODULE>(0)) {
+ printf(
+ "TEST-FAILED | NativeNt | "
+ "GetModuleHandleFromLeafName returns a wrong value.\n");
+ return 1;
+ }
+
+ moduleResult = GetModuleHandleFromLeafName(L"invalid");
+ if (moduleResult.isOk()) {
+ printf(
+ "TEST-FAILED | NativeNt | "
+ "GetModuleHandleFromLeafName unexpectedly returns a value.\n");
+ return 1;
+ }
+
+ if (!TestModuleInfo()) {
+ return 1;
+ }
+
+ if (!TestModuleLoadedAsData()) {
+ return 1;
+ }
+
+ printf("TEST-PASS | NativeNt | All tests ran successfully\n");
+ return 0;
+}
diff --git a/mozglue/tests/TestPEExportSection.cpp b/mozglue/tests/TestPEExportSection.cpp
new file mode 100644
index 0000000000..cf160368d3
--- /dev/null
+++ b/mozglue/tests/TestPEExportSection.cpp
@@ -0,0 +1,706 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+// This test makes sure mozilla::nt::PEExportSection can parse the export
+// section of a local process, and a remote process even though it's
+// modified by an external code.
+
+#include "mozilla/CmdLineAndEnvUtils.h"
+#include "mozilla/NativeNt.h"
+#include "nsWindowsDllInterceptor.h"
+
+#include <stdio.h>
+#include <windows.h>
+
+#define EXPORT_FUNCTION_EQ(name, func) \
+ (GetProcAddress(imageBase, name) == reinterpret_cast<void*>(func))
+
+#define VERIFY_EXPORT_FUNCTION(tables, name, expected, errorMessage) \
+ do { \
+ if (tables.GetProcAddress(name) != reinterpret_cast<void*>(expected)) { \
+ printf("TEST-FAILED | TestPEExportSection | %s", errorMessage); \
+ return kTestFail; \
+ } \
+ } while (0)
+
+using namespace mozilla::nt;
+using mozilla::interceptor::MMPolicyInProcess;
+using mozilla::interceptor::MMPolicyOutOfProcess;
+using LocalPEExportSection = PEExportSection<MMPolicyInProcess>;
+using RemotePEExportSection = PEExportSection<MMPolicyOutOfProcess>;
+
+constexpr DWORD kEventTimeoutinMs = 5000;
+const wchar_t kProcessControlEventName[] =
+ L"TestPEExportSection.Process.Control.Event";
+
+enum TestResult : int {
+ kTestSuccess = 0,
+ kTestFail,
+ kTestSkip,
+};
+
+// These strings start with the same keyword to make sure we don't do substring
+// match. Moreover, kSecretFunctionInvalid is purposely longer than the
+// combination of the other two strings and located in between the other two
+// strings to effectively test binary search.
+const char kSecretFunction[] = "Secret";
+const char kSecretFunctionInvalid[] = "Secret invalid long name";
+const char kSecretFunctionWithSuffix[] = "Secret2";
+
+const wchar_t* kNoModification = L"--NoModification";
+const wchar_t* kNoExport = L"--NoExport";
+const wchar_t* kModifyTableEntry = L"--ModifyTableEntry";
+const wchar_t* kModifyTable = L"--ModifyTable";
+const wchar_t* kModifyDirectoryEntry = L"--ModifyDirectoryEntry";
+const wchar_t* kExportByOrdinal = L"--ExportByOrdinal";
+
+// Use the global variable to pass the child process's error status to the
+// parent process. We don't use a process's exit code to keep the test simple.
+int gChildProcessStatus = 0;
+
+// These functions are exported by linker or export section tampering at
+// runtime. Each of function bodies needs to be different to avoid ICF.
+extern "C" __declspec(dllexport) int Export1() { return 0; }
+extern "C" __declspec(dllexport) int Export2() { return 1; }
+int SecretFunction1() { return 100; }
+int SecretFunction2() { return 101; }
+
+// This class allocates a writable region downstream of the mapped image
+// and prepares it as a valid export section.
+class ExportDirectoryPatcher final {
+ static constexpr int kRegionAllocationTryLimit = 100;
+ static constexpr int kNumOfTableEntries = 2;
+ // VirtualAlloc sometimes fails if a desired base address is too small.
+ // Define a minimum desired base to reduce the number of allocation tries.
+ static constexpr uintptr_t kMinimumAllocationPoint = 0x8000000;
+
+ struct ExportDirectory {
+ IMAGE_EXPORT_DIRECTORY mDirectoryHeader;
+ DWORD mExportAddressTable[kNumOfTableEntries];
+ DWORD mExportNameTable[kNumOfTableEntries];
+ WORD mExportOrdinalTable[kNumOfTableEntries];
+ char mNameBuffer1[sizeof(kSecretFunction)];
+ char mNameBuffer2[sizeof(kSecretFunctionWithSuffix)];
+
+ template <typename T>
+ static DWORD PtrToRVA(T aPtr, uintptr_t aBase) {
+ return reinterpret_cast<uintptr_t>(aPtr) - aBase;
+ }
+
+ explicit ExportDirectory(uintptr_t aImageBase) : mDirectoryHeader{} {
+ mDirectoryHeader.Base = 1;
+ mExportAddressTable[0] = PtrToRVA(SecretFunction1, aImageBase);
+ mExportAddressTable[1] = PtrToRVA(SecretFunction2, aImageBase);
+ mExportNameTable[0] = PtrToRVA(mNameBuffer1, aImageBase);
+ mExportNameTable[1] = PtrToRVA(mNameBuffer2, aImageBase);
+ mExportOrdinalTable[0] = 0;
+ mExportOrdinalTable[1] = 1;
+ strcpy(mNameBuffer1, kSecretFunction);
+ strcpy(mNameBuffer2, kSecretFunctionWithSuffix);
+ }
+ };
+
+ uintptr_t mImageBase;
+ ExportDirectory* mNewExportDirectory;
+
+ DWORD PtrToRVA(const void* aPtr) const {
+ return reinterpret_cast<uintptr_t>(aPtr) - mImageBase;
+ }
+
+ public:
+ explicit ExportDirectoryPatcher(HMODULE aModule)
+ : mImageBase(PEHeaders::HModuleToBaseAddr<uintptr_t>(aModule)),
+ mNewExportDirectory(nullptr) {
+ SYSTEM_INFO si = {};
+ ::GetSystemInfo(&si);
+
+ int numPagesRequired = ((sizeof(ExportDirectory) - 1) / si.dwPageSize) + 1;
+
+ uintptr_t desiredBase = mImageBase + si.dwAllocationGranularity;
+ desiredBase = std::max(desiredBase, kMinimumAllocationPoint);
+
+ for (int i = 0; i < kRegionAllocationTryLimit; ++i) {
+ void* allocated =
+ ::VirtualAlloc(reinterpret_cast<void*>(desiredBase),
+ numPagesRequired * si.dwPageSize,
+ MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+ if (allocated) {
+ // Use the end of a allocated page as ExportDirectory in order to test
+ // the boundary between a commit page and a non-commited page.
+ allocated = reinterpret_cast<uint8_t*>(allocated) +
+ (numPagesRequired * si.dwPageSize) -
+ sizeof(ExportDirectory);
+ mNewExportDirectory = new (allocated) ExportDirectory(mImageBase);
+ return;
+ }
+
+ desiredBase += si.dwAllocationGranularity;
+ }
+
+ gChildProcessStatus = kTestSkip;
+ printf(
+ "TEST-SKIP | TestPEExportSection | "
+ "Giving up finding an allocatable space following the mapped image.\n");
+ }
+
+ ~ExportDirectoryPatcher() {
+ // Intentionally leave mNewExportDirectory leaked to keep a patched data
+ // available until the process is terminated.
+ }
+
+ explicit operator bool() const { return !!mNewExportDirectory; }
+
+ void PopulateDirectory(IMAGE_EXPORT_DIRECTORY& aOutput) const {
+ aOutput.NumberOfFunctions = aOutput.NumberOfNames = kNumOfTableEntries;
+ aOutput.AddressOfFunctions =
+ PtrToRVA(mNewExportDirectory->mExportAddressTable);
+ aOutput.AddressOfNames = PtrToRVA(mNewExportDirectory->mExportNameTable);
+ aOutput.AddressOfNameOrdinals =
+ PtrToRVA(mNewExportDirectory->mExportOrdinalTable);
+ }
+
+ void PopulateDirectoryEntry(IMAGE_DATA_DIRECTORY& aOutput) const {
+ PopulateDirectory(mNewExportDirectory->mDirectoryHeader);
+ aOutput.VirtualAddress = PtrToRVA(&mNewExportDirectory->mDirectoryHeader);
+ aOutput.Size = sizeof(ExportDirectory);
+ }
+};
+
+// This exports SecretFunction1 as "Export1" by replacing an entry of the
+// export address table.
+void ModifyExportAddressTableEntry() {
+ MMPolicyInProcess policy;
+ HMODULE imageBase = ::GetModuleHandleW(nullptr);
+ auto ourExe = LocalPEExportSection::Get(imageBase, policy);
+
+ auto addressTableEntry =
+ const_cast<DWORD*>(ourExe.FindExportAddressTableEntry("Export1"));
+ if (!addressTableEntry) {
+ gChildProcessStatus = kTestFail;
+ return;
+ }
+
+ mozilla::AutoVirtualProtect protection(
+ addressTableEntry, sizeof(*addressTableEntry), PAGE_READWRITE);
+ if (!protection) {
+ gChildProcessStatus = kTestFail;
+ return;
+ }
+
+ *addressTableEntry = reinterpret_cast<uintptr_t>(SecretFunction1) -
+ PEHeaders::HModuleToBaseAddr<uintptr_t>(imageBase);
+
+ if (!EXPORT_FUNCTION_EQ("Export1", SecretFunction1) ||
+ !EXPORT_FUNCTION_EQ("Export2", Export2)) {
+ gChildProcessStatus = kTestFail;
+ }
+}
+
+// This switches the entire address table into one exporting SecretFunction1
+// and SecretFunction2.
+void ModifyExportAddressTable() {
+ MMPolicyInProcess policy;
+ HMODULE imageBase = ::GetModuleHandleW(nullptr);
+ auto ourExe = LocalPEExportSection::Get(imageBase, policy);
+
+ auto exportDirectory = ourExe.GetExportDirectory();
+ if (!exportDirectory) {
+ gChildProcessStatus = kTestFail;
+ return;
+ }
+
+ mozilla::AutoVirtualProtect protection(
+ exportDirectory, sizeof(*exportDirectory), PAGE_READWRITE);
+ if (!protection) {
+ gChildProcessStatus = kTestFail;
+ return;
+ }
+
+ ExportDirectoryPatcher patcher(imageBase);
+ if (!patcher) {
+ return;
+ }
+
+ patcher.PopulateDirectory(*exportDirectory);
+
+ if (GetProcAddress(imageBase, "Export1") ||
+ GetProcAddress(imageBase, "Export2") ||
+ !EXPORT_FUNCTION_EQ(kSecretFunction, SecretFunction1) ||
+ !EXPORT_FUNCTION_EQ(kSecretFunctionWithSuffix, SecretFunction2)) {
+ gChildProcessStatus = kTestFail;
+ }
+}
+
+// This hides all export functions by setting the table size to 0.
+void HideExportSection() {
+ HMODULE imageBase = ::GetModuleHandleW(nullptr);
+ PEHeaders ourExe(imageBase);
+
+ auto sectionTable =
+ ourExe.GetImageDirectoryEntryPtr(IMAGE_DIRECTORY_ENTRY_EXPORT);
+
+ mozilla::AutoVirtualProtect protection(sectionTable, sizeof(*sectionTable),
+ PAGE_READWRITE);
+ if (!protection) {
+ gChildProcessStatus = kTestFail;
+ return;
+ }
+
+ sectionTable->VirtualAddress = sectionTable->Size = 0;
+
+ if (GetProcAddress(imageBase, "Export1") ||
+ GetProcAddress(imageBase, "Export2")) {
+ gChildProcessStatus = kTestFail;
+ }
+}
+
+// This makes the export directory entry point to a new export section
+// which exports SecretFunction1 and SecretFunction2.
+void ModifyExportDirectoryEntry() {
+ HMODULE imageBase = ::GetModuleHandleW(nullptr);
+ PEHeaders ourExe(imageBase);
+
+ auto sectionTable =
+ ourExe.GetImageDirectoryEntryPtr(IMAGE_DIRECTORY_ENTRY_EXPORT);
+
+ mozilla::AutoVirtualProtect protection(sectionTable, sizeof(*sectionTable),
+ PAGE_READWRITE);
+ if (!protection) {
+ gChildProcessStatus = kTestFail;
+ return;
+ }
+
+ ExportDirectoryPatcher patcher(imageBase);
+ if (!patcher) {
+ return;
+ }
+
+ patcher.PopulateDirectoryEntry(*sectionTable);
+
+ if (GetProcAddress(imageBase, "Export1") ||
+ GetProcAddress(imageBase, "Export2") ||
+ !EXPORT_FUNCTION_EQ(kSecretFunction, SecretFunction1) ||
+ !EXPORT_FUNCTION_EQ(kSecretFunctionWithSuffix, SecretFunction2)) {
+ gChildProcessStatus = kTestFail;
+ }
+}
+
+// This exports functions only by Ordinal by hiding the export name table.
+void ExportByOrdinal() {
+ ModifyExportDirectoryEntry();
+ if (gChildProcessStatus != kTestSuccess) {
+ return;
+ }
+
+ MMPolicyInProcess policy;
+ HMODULE imageBase = ::GetModuleHandleW(nullptr);
+ auto ourExe = LocalPEExportSection::Get(imageBase, policy);
+
+ auto exportDirectory = ourExe.GetExportDirectory();
+ if (!exportDirectory) {
+ gChildProcessStatus = kTestFail;
+ return;
+ }
+
+ exportDirectory->NumberOfNames = 0;
+
+ if (GetProcAddress(imageBase, "Export1") ||
+ GetProcAddress(imageBase, "Export2") ||
+ GetProcAddress(imageBase, kSecretFunction) ||
+ GetProcAddress(imageBase, kSecretFunctionWithSuffix) ||
+ !EXPORT_FUNCTION_EQ(MAKEINTRESOURCE(1), SecretFunction1) ||
+ !EXPORT_FUNCTION_EQ(MAKEINTRESOURCE(2), SecretFunction2)) {
+ gChildProcessStatus = kTestFail;
+ }
+}
+
+class ChildProcess final {
+ nsAutoHandle mChildProcess;
+ nsAutoHandle mChildMainThread;
+
+ public:
+ static int Main(const nsAutoHandle& aEvent, const wchar_t* aOption) {
+ if (wcscmp(aOption, kNoModification) == 0) {
+ ;
+ } else if (wcscmp(aOption, kNoExport) == 0) {
+ HideExportSection();
+ } else if (wcscmp(aOption, kModifyTableEntry) == 0) {
+ ModifyExportAddressTableEntry();
+ } else if (wcscmp(aOption, kModifyTable) == 0) {
+ ModifyExportAddressTable();
+ } else if (wcscmp(aOption, kModifyDirectoryEntry) == 0) {
+ ModifyExportDirectoryEntry();
+ } else if (wcscmp(aOption, kExportByOrdinal) == 0) {
+ ExportByOrdinal();
+ }
+
+ // Letting the parent process know the child process is ready.
+ ::SetEvent(aEvent);
+
+ // The child process does not exit itself. It's force terminated by
+ // the parent process when all tests are done.
+ for (;;) {
+ ::Sleep(100);
+ }
+ }
+
+ ChildProcess(const wchar_t* aExecutable, const wchar_t* aOption,
+ const nsAutoHandle& aEvent, const nsAutoHandle& aJob) {
+ const wchar_t* childArgv[] = {aExecutable, aOption};
+ auto cmdLine(
+ mozilla::MakeCommandLine(mozilla::ArrayLength(childArgv), childArgv));
+
+ STARTUPINFOW si = {sizeof(si)};
+ PROCESS_INFORMATION pi;
+ BOOL ok = ::CreateProcessW(aExecutable, cmdLine.get(), nullptr, nullptr,
+ FALSE, 0, nullptr, nullptr, &si, &pi);
+ if (!ok) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "CreateProcessW falied - %08lx.\n",
+ GetLastError());
+ return;
+ }
+
+ if (aJob && !::AssignProcessToJobObject(aJob, pi.hProcess)) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "AssignProcessToJobObject falied - %08lx.\n",
+ GetLastError());
+ ::TerminateProcess(pi.hProcess, 1);
+ return;
+ }
+
+ // Wait until requested modification is done in the child process.
+ if (::WaitForSingleObject(aEvent, kEventTimeoutinMs) != WAIT_OBJECT_0) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "Child process was not ready in time.\n");
+ return;
+ }
+
+ mChildProcess.own(pi.hProcess);
+ mChildMainThread.own(pi.hThread);
+ }
+
+ ~ChildProcess() { ::TerminateProcess(mChildProcess, 0); }
+
+ operator HANDLE() const { return mChildProcess; }
+
+ TestResult GetStatus() const {
+ TestResult status = kTestSuccess;
+ if (!::ReadProcessMemory(mChildProcess, &gChildProcessStatus, &status,
+ sizeof(status), nullptr)) {
+ status = kTestFail;
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "ReadProcessMemory failed - %08lx\n",
+ GetLastError());
+ }
+ return status;
+ }
+};
+
+template <typename MMPolicy>
+TestResult BasicTest(const MMPolicy& aMMPolicy) {
+ const bool isAppHelpLoaded = ::GetModuleHandleW(L"apphelp.dll");
+
+ // Use ntdll.dll because it does not have any forwarder RVA.
+ HMODULE ntdllImageBase = ::GetModuleHandleW(L"ntdll.dll");
+ auto ntdllExports = PEExportSection<MMPolicy>::Get(ntdllImageBase, aMMPolicy);
+
+ auto exportDir = ntdllExports.GetExportDirectory();
+ auto tableOfNames =
+ ntdllExports.template RVAToPtr<const PDWORD>(exportDir->AddressOfNames);
+ for (DWORD i = 0; i < exportDir->NumberOfNames; ++i) {
+ const auto name =
+ ntdllExports.template RVAToPtr<const char*>(tableOfNames[i]);
+
+ if (isAppHelpLoaded && strcmp(name, "NtdllDefWindowProc_W") == 0) {
+ // In this case, GetProcAddress will return
+ // apphelp!DWM8AND16BitHook_DefWindowProcW.
+ continue;
+ }
+
+ auto funcEntry = ntdllExports.FindExportAddressTableEntry(name);
+ if (ntdllExports.template RVAToPtr<const void*>(*funcEntry) !=
+ ::GetProcAddress(ntdllImageBase, name)) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "FindExportAddressTableEntry did not resolve ntdll!%s.\n",
+ name);
+ return kTestFail;
+ }
+ }
+
+ for (DWORD i = 0; i < 0x10000; i += 0x10) {
+ if (ntdllExports.GetProcAddress(MAKEINTRESOURCE(i)) !=
+ ::GetProcAddress(ntdllImageBase, MAKEINTRESOURCE(i))) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "GetProcAddress did not resolve ntdll!Ordinal#%lu.\n",
+ i);
+ return kTestFail;
+ }
+ }
+
+ // Test a known forwarder RVA.
+ auto k32Exports = PEExportSection<MMPolicy>::Get(
+ ::GetModuleHandleW(L"kernel32.dll"), aMMPolicy);
+ if (k32Exports.FindExportAddressTableEntry("HeapAlloc")) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "kernel32!HeapAlloc should be forwarded to ntdll!RtlAllocateHeap.\n");
+ return kTestFail;
+ }
+
+ // Test invalid names.
+ if (k32Exports.FindExportAddressTableEntry("Invalid name") ||
+ k32Exports.FindExportAddressTableEntry("")) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "FindExportAddressTableEntry should return "
+ "nullptr for a non-existent name.\n");
+ return kTestFail;
+ }
+
+ return kTestSuccess;
+}
+
+TestResult RunChildProcessTest(
+ const wchar_t* aExecutable, const wchar_t* aOption,
+ const nsAutoHandle& aEvent, const nsAutoHandle& aJob,
+ TestResult (*aTestCallback)(const RemotePEExportSection&)) {
+ ChildProcess childProcess(aExecutable, aOption, aEvent, aJob);
+ if (!childProcess) {
+ return kTestFail;
+ }
+
+ auto result = childProcess.GetStatus();
+ if (result != kTestSuccess) {
+ return result;
+ }
+
+ MMPolicyOutOfProcess policy(childProcess);
+
+ // One time is enough to run BasicTest in the child process.
+ static TestResult oneTimeResult = BasicTest<MMPolicyOutOfProcess>(policy);
+ if (oneTimeResult != kTestSuccess) {
+ return oneTimeResult;
+ }
+
+ auto exportTableChild =
+ RemotePEExportSection::Get(::GetModuleHandleW(nullptr), policy);
+ return aTestCallback(exportTableChild);
+}
+
+mozilla::LauncherResult<nsReturnRef<HANDLE>> CreateJobToLimitProcessLifetime() {
+ uint64_t version;
+ PEHeaders ntdllHeaders(::GetModuleHandleW(L"ntdll.dll"));
+ if (!ntdllHeaders.GetVersionInfo(version)) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "Unable to obtain version information from ntdll.dll\n");
+ return LAUNCHER_ERROR_FROM_LAST();
+ }
+
+ constexpr uint64_t kWin8 = 0x60002ull << 32;
+ nsAutoHandle job;
+
+ if (version < kWin8) {
+ // Since a process can be associated only with a single job in Win7 or
+ // older and this test program is already assigned with a job by
+ // infrastructure, we cannot use a job.
+ return job.out();
+ }
+
+ job.own(::CreateJobObject(nullptr, nullptr));
+ if (!job) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "CreateJobObject falied - %08lx.\n",
+ GetLastError());
+ return LAUNCHER_ERROR_FROM_LAST();
+ }
+
+ JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobInfo = {};
+ jobInfo.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+
+ if (!::SetInformationJobObject(job, JobObjectExtendedLimitInformation,
+ &jobInfo, sizeof(jobInfo))) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "SetInformationJobObject falied - %08lx.\n",
+ GetLastError());
+ return LAUNCHER_ERROR_FROM_LAST();
+ }
+
+ return job.out();
+}
+
+extern "C" int wmain(int argc, wchar_t* argv[]) {
+ nsAutoHandle controlEvent(
+ ::CreateEventW(nullptr, FALSE, FALSE, kProcessControlEventName));
+
+ if (argc == 2) {
+ return ChildProcess::Main(controlEvent, argv[1]);
+ }
+
+ if (argc != 1) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "Invalid arguments.\n");
+ return kTestFail;
+ }
+
+ MMPolicyInProcess policy;
+ if (BasicTest<MMPolicyInProcess>(policy)) {
+ return kTestFail;
+ }
+
+ auto exportTableSelf =
+ LocalPEExportSection::Get(::GetModuleHandleW(nullptr), policy);
+ if (!exportTableSelf) {
+ printf(
+ "TEST-FAILED | TestPEExportSection | "
+ "LocalPEExportSection::Get failed.\n");
+ return kTestFail;
+ }
+
+ VERIFY_EXPORT_FUNCTION(exportTableSelf, "Export1", Export1,
+ "Local | Export1 was not exported.\n");
+ VERIFY_EXPORT_FUNCTION(exportTableSelf, "Export2", Export2,
+ "Local | Export2 was not exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ exportTableSelf, "Invalid name", 0,
+ "Local | GetProcAddress should return nullptr for an invalid name.\n");
+
+ // We'll add the child process to a job so that, in the event of a failure in
+ // this parent process, the child process will be automatically terminated.
+ auto probablyJob = CreateJobToLimitProcessLifetime();
+ if (probablyJob.isErr()) {
+ return kTestFail;
+ }
+
+ nsAutoHandle job(probablyJob.unwrap());
+
+ auto result = RunChildProcessTest(
+ argv[0], kNoModification, controlEvent, job,
+ [](const RemotePEExportSection& aTables) {
+ VERIFY_EXPORT_FUNCTION(aTables, "Export1", Export1,
+ "NoModification | Export1 was not exported.\n");
+ VERIFY_EXPORT_FUNCTION(aTables, "Export2", Export2,
+ "NoModification | Export2 was not exported.\n");
+ return kTestSuccess;
+ });
+ if (result == kTestFail) {
+ return result;
+ }
+
+ result = RunChildProcessTest(
+ argv[0], kNoExport, controlEvent, job,
+ [](const RemotePEExportSection& aTables) {
+ VERIFY_EXPORT_FUNCTION(aTables, "Export1", 0,
+ "NoExport | Export1 was exported.\n");
+ VERIFY_EXPORT_FUNCTION(aTables, "Export2", 0,
+ "NoExport | Export2 was exported.\n");
+ return kTestSuccess;
+ });
+ if (result == kTestFail) {
+ return result;
+ }
+
+ result = RunChildProcessTest(
+ argv[0], kModifyTableEntry, controlEvent, job,
+ [](const RemotePEExportSection& aTables) {
+ VERIFY_EXPORT_FUNCTION(
+ aTables, "Export1", SecretFunction1,
+ "ModifyTableEntry | SecretFunction1 was not exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, "Export2", Export2,
+ "ModifyTableEntry | Export2 was not exported.\n");
+ return kTestSuccess;
+ });
+ if (result == kTestFail) {
+ return result;
+ }
+
+ result = RunChildProcessTest(
+ argv[0], kModifyTable, controlEvent, job,
+ [](const RemotePEExportSection& aTables) {
+ VERIFY_EXPORT_FUNCTION(aTables, "Export1", 0,
+ "ModifyTable | Export1 was exported.\n");
+ VERIFY_EXPORT_FUNCTION(aTables, "Export2", 0,
+ "ModifyTable | Export2 was exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, kSecretFunction, SecretFunction1,
+ "ModifyTable | SecretFunction1 was not exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, kSecretFunctionWithSuffix, SecretFunction2,
+ "ModifyTable | SecretFunction2 was not exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, kSecretFunctionInvalid, 0,
+ "ModifyTable | kSecretFunctionInvalid was exported.\n");
+ return kTestSuccess;
+ });
+ if (result == kTestFail) {
+ return result;
+ }
+
+ result = RunChildProcessTest(
+ argv[0], kModifyDirectoryEntry, controlEvent, job,
+ [](const RemotePEExportSection& aTables) {
+ VERIFY_EXPORT_FUNCTION(
+ aTables, "Export1", 0,
+ "ModifyDirectoryEntry | Export1 was exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, "Export2", 0,
+ "ModifyDirectoryEntry | Export2 was exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, kSecretFunction, SecretFunction1,
+ "ModifyDirectoryEntry | SecretFunction1 was not exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, kSecretFunctionWithSuffix, SecretFunction2,
+ "ModifyDirectoryEntry | SecretFunction2 was not exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, kSecretFunctionInvalid, 0,
+ "ModifyDirectoryEntry | kSecretFunctionInvalid was exported.\n");
+ return kTestSuccess;
+ });
+ if (result == kTestFail) {
+ return result;
+ }
+
+ result = RunChildProcessTest(
+ argv[0], kExportByOrdinal, controlEvent, job,
+ [](const RemotePEExportSection& aTables) {
+ VERIFY_EXPORT_FUNCTION(aTables, "Export1", 0,
+ "ExportByOrdinal | Export1 was exported.\n");
+ VERIFY_EXPORT_FUNCTION(aTables, "Export2", 0,
+ "ExportByOrdinal | Export2 was exported.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, kSecretFunction, 0,
+ "ModifyDirectoryEntry | kSecretFunction was exported by name.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, kSecretFunctionWithSuffix, 0,
+ "ModifyDirectoryEntry | "
+ "kSecretFunctionWithSuffix was exported by name.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, MAKEINTRESOURCE(1), SecretFunction1,
+ "ModifyDirectoryEntry | "
+ "kSecretFunction was not exported by ordinal.\n");
+ VERIFY_EXPORT_FUNCTION(
+ aTables, MAKEINTRESOURCE(2), SecretFunction2,
+ "ModifyDirectoryEntry | "
+ "kSecretFunctionWithSuffix was not exported by ordinal.\n");
+ return kTestSuccess;
+ });
+ if (result == kTestFail) {
+ return result;
+ }
+
+ return kTestSuccess;
+}
diff --git a/mozglue/tests/TestPrintf.cpp b/mozglue/tests/TestPrintf.cpp
new file mode 100644
index 0000000000..5f6f9e2005
--- /dev/null
+++ b/mozglue/tests/TestPrintf.cpp
@@ -0,0 +1,264 @@
+/* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
+/* 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 "mozilla/Printf.h"
+
+#include <cfloat>
+#include <cmath>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stddef.h>
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wc++11-narrowing"
+#elif defined(__GNUC__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wnarrowing"
+#endif
+namespace tiformat {
+#include "glibc_printf_tests/tiformat.c"
+}
+namespace tllformat {
+#include "glibc_printf_tests/tllformat.c"
+}
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#elif defined(__GNUC__)
+# pragma GCC diagnostic pop
+#endif
+namespace tfformat {
+#include "glibc_printf_tests/tfformat.c"
+}
+
+// A simple implementation of PrintfTarget, just for testing
+// PrintfTarget::print.
+class TestPrintfTarget : public mozilla::PrintfTarget {
+ public:
+ static const char* test_string;
+
+ TestPrintfTarget() : mOut(0) { memset(mBuffer, '\0', sizeof(mBuffer)); }
+
+ ~TestPrintfTarget() {
+ MOZ_RELEASE_ASSERT(mOut == strlen(test_string));
+ MOZ_RELEASE_ASSERT(strncmp(mBuffer, test_string, strlen(test_string)) == 0);
+ }
+
+ bool append(const char* sp, size_t len) override {
+ if (mOut + len < sizeof(mBuffer)) {
+ memcpy(&mBuffer[mOut], sp, len);
+ }
+ mOut += len;
+ return true;
+ }
+
+ private:
+ char mBuffer[100];
+ size_t mOut;
+};
+
+const char* TestPrintfTarget::test_string = "test string";
+
+static void TestPrintfTargetPrint() {
+ TestPrintfTarget checker;
+ checker.print("test string");
+}
+
+// As of clang 14, __attribute__((printf)) doesn't allow %n on Android targets,
+// which is used in this test.
+static bool
+#ifndef __ANDROID__
+MOZ_FORMAT_PRINTF(5, 6)
+#endif
+ check_print(const char* file, int line,
+ bool (*cmp)(const char* a, const char* b), const char* expect,
+ const char* fmt, ...) {
+ va_list ap;
+
+ va_start(ap, fmt);
+ mozilla::SmprintfPointer output = mozilla::Vsmprintf(fmt, ap);
+ va_end(ap);
+
+ bool ret = output && cmp(output.get(), expect);
+ if (!ret && strcmp(expect, "ignore") != 0) {
+ fprintf(stderr, "(actual) \"%s\" != (expected) \"%s\" (%s:%d)\n",
+ output.get() ? output.get() : "null", expect, file, line);
+ }
+ return ret;
+}
+
+bool str_match(const char* a, const char* b) { return !strcmp(a, b); }
+
+bool approx_match(const char* a, const char* b) {
+ return tfformat::matches(const_cast<char*>(a), b);
+}
+
+#define print_one(...) check_print(__FILE__, __LINE__, str_match, __VA_ARGS__)
+
+static const char* zero() { return nullptr; }
+
+static void TestPrintfFormats() {
+ MOZ_RELEASE_ASSERT(print_one("0", "%d", 0));
+ MOZ_RELEASE_ASSERT(print_one("23", "%d", 23));
+ MOZ_RELEASE_ASSERT(print_one("+23", "%+d", 23));
+ MOZ_RELEASE_ASSERT(print_one("-23", "%+d", -23));
+ MOZ_RELEASE_ASSERT(print_one("0023", "%04d", 23));
+ MOZ_RELEASE_ASSERT(print_one("777777", "%04d", 777777));
+ MOZ_RELEASE_ASSERT(print_one(" 23", "% 4d", 23));
+ MOZ_RELEASE_ASSERT(print_one("23 ", "%-4d", 23));
+ MOZ_RELEASE_ASSERT(print_one(" 23", "%*d", 4, 23));
+ MOZ_RELEASE_ASSERT(print_one("-23 ", "%*d", -7, -23));
+ MOZ_RELEASE_ASSERT(print_one(" 077", "%5.3d", 77));
+ MOZ_RELEASE_ASSERT(print_one(" 077", "%5.*d", 3, 77));
+ MOZ_RELEASE_ASSERT(print_one(" 077", "%*.*d", 5, 3, 77));
+ MOZ_RELEASE_ASSERT(print_one("077 ", "%*.*d", -5, 3, 77));
+ MOZ_RELEASE_ASSERT(print_one("77 ", "%*.*d", -5, -3, 77));
+ MOZ_RELEASE_ASSERT(print_one("-1", "%d", -1));
+ MOZ_RELEASE_ASSERT(print_one("23", "%u", 23u));
+ MOZ_RELEASE_ASSERT(print_one("0x17", "0x%x", 23u));
+ MOZ_RELEASE_ASSERT(print_one("0xFF", "0x%X", 255u));
+ MOZ_RELEASE_ASSERT(print_one("027", "0%o", 23u));
+ MOZ_RELEASE_ASSERT(print_one("-1", "%hd", (short)-1));
+ // A funny special case.
+ MOZ_RELEASE_ASSERT(print_one("", "%.*d", 0, 0));
+ // This could be expanded if need be, it's just convenient to do
+ // it this way.
+ if (sizeof(short) == 2) {
+ MOZ_RELEASE_ASSERT(print_one("8000", "%hx", (unsigned short)0x8000));
+ }
+ MOZ_RELEASE_ASSERT(print_one("2305", "%ld", 2305l));
+ MOZ_RELEASE_ASSERT(print_one("-2305", "%ld", -2305l));
+ MOZ_RELEASE_ASSERT(print_one("0xf0f0", "0x%lx", 0xf0f0ul));
+ MOZ_RELEASE_ASSERT(print_one("0", "%lld", 0ll));
+ MOZ_RELEASE_ASSERT(print_one("2305", "%lld", 2305ll));
+ MOZ_RELEASE_ASSERT(print_one("-2305", "%lld", -2305ll));
+ // A funny special case.
+ MOZ_RELEASE_ASSERT(print_one("", "%.*lld", 0, 0ll));
+ MOZ_RELEASE_ASSERT(print_one("0xF0F0", "0x%llX", 0xf0f0ull));
+ MOZ_RELEASE_ASSERT(print_one("27270", "%zu", (size_t)27270));
+ MOZ_RELEASE_ASSERT(print_one("27270", "%tu", (ptrdiff_t)27270));
+ MOZ_RELEASE_ASSERT(print_one("27270", "%ju", (intmax_t)27270));
+ MOZ_RELEASE_ASSERT(print_one("hello", "he%so", "ll"));
+ MOZ_RELEASE_ASSERT(print_one("hello ", "%-8s", "hello"));
+ MOZ_RELEASE_ASSERT(print_one(" hello", "%8s", "hello"));
+ MOZ_RELEASE_ASSERT(print_one("hello ", "%*s", -8, "hello"));
+ MOZ_RELEASE_ASSERT(print_one("hello", "%.*s", 5, "hello there"));
+ MOZ_RELEASE_ASSERT(print_one("", "%.*s", 0, "hello there"));
+ MOZ_RELEASE_ASSERT(print_one("%%", "%%%%"));
+ MOZ_RELEASE_ASSERT(print_one("0", "%p", (char*)0));
+ MOZ_RELEASE_ASSERT(print_one("h", "%c", 'h'));
+ MOZ_RELEASE_ASSERT(print_one("1.500000", "%f", 1.5f));
+ MOZ_RELEASE_ASSERT(print_one("1.5", "%g", 1.5));
+ MOZ_RELEASE_ASSERT(print_one("1.50000", "%.5f", 1.5));
+
+ MOZ_RELEASE_ASSERT(print_one("z ", "%-7s", "z"));
+ MOZ_RELEASE_ASSERT(print_one("z ", "%*s", -7, "z"));
+ MOZ_RELEASE_ASSERT(print_one("hello", "%*s", -3, "hello"));
+
+ MOZ_RELEASE_ASSERT(print_one(" q", "%3c", 'q'));
+ MOZ_RELEASE_ASSERT(print_one("q ", "%-3c", 'q'));
+ MOZ_RELEASE_ASSERT(print_one(" q", "%*c", 3, 'q'));
+ MOZ_RELEASE_ASSERT(print_one("q ", "%*c", -3, 'q'));
+
+ // Regression test for bug#1350097. The bug was an assertion
+ // failure caused by printing a very long floating point value.
+ print_one("ignore", "%lf", DBL_MAX);
+
+ // Regression test for bug#1517433. The bug was an assertion
+ // failure caused by printing a floating point value with a large
+ // precision and/or width.
+ print_one("ignore", "%500.500lf", DBL_MAX);
+
+ MOZ_RELEASE_ASSERT(print_one("2727", "%" PRIu32, (uint32_t)2727));
+ MOZ_RELEASE_ASSERT(print_one("aa7", "%" PRIx32, (uint32_t)2727));
+ MOZ_RELEASE_ASSERT(print_one("2727", "%" PRIu64, (uint64_t)2727));
+ MOZ_RELEASE_ASSERT(print_one("aa7", "%" PRIx64, (uint64_t)2727));
+
+ int n1, n2;
+ MOZ_RELEASE_ASSERT(print_one(" hi ", "%n hi %n", &n1, &n2));
+ MOZ_RELEASE_ASSERT(n1 == 0);
+ MOZ_RELEASE_ASSERT(n2 == 4);
+
+ MOZ_RELEASE_ASSERT(print_one("23 % 24", "%2$ld %% %1$d", 24, 23l));
+ MOZ_RELEASE_ASSERT(
+ print_one("7 8 9 10", "%4$lld %3$ld %2$d %1$hd", (short)10, 9, 8l, 7ll));
+
+ MOZ_RELEASE_ASSERT(print_one("0 ", "%2$p %1$n", &n1, zero()));
+ MOZ_RELEASE_ASSERT(n1 == 2);
+
+ MOZ_RELEASE_ASSERT(print_one("23 % 024", "%2$-3ld%%%1$4.3d", 24, 23l));
+ MOZ_RELEASE_ASSERT(print_one("23 1.5", "%2$d %1$g", 1.5, 23));
+ MOZ_RELEASE_ASSERT(
+ print_one("ff number FF", "%3$llx %1$s %2$lX", "number", 255ul, 255ull));
+ MOZ_RELEASE_ASSERT(
+ print_one("7799 9977", "%2$zu %1$zu", (size_t)9977, (size_t)7799));
+}
+
+template <typename T, size_t N>
+static void TestGlibcPrintf(T (&test_cases)[N], const char* file,
+ bool (*cmp)(const char* a, const char* b)) {
+ bool ok = true;
+ char fmt2[40];
+ for (auto& line : test_cases) {
+ // mozilla::PrintfTarget doesn't support the `#` flag character or the
+ // `a` conversion specifier.
+ if (!line.line || strchr(line.format_string, '#') ||
+ strchr(line.format_string, 'a')) {
+ continue;
+ }
+
+ // Derive the format string in the test case to add "2$" in the specifier
+ // (transforming e.g. "%f" into "%2$f"), and append "%1$.0d".
+ // The former will make the format string take the `line.value` as the
+ // second argument, and the latter will make the first argument formatted
+ // with no precision. We'll pass 0 as the first argument, such that the
+ // formatted value for it is "", which means the expected result string
+ // is still the same.
+ MOZ_RELEASE_ASSERT(sizeof(fmt2) > strlen(line.format_string) + 8);
+ const char* percent = strchr(line.format_string, '%');
+ MOZ_RELEASE_ASSERT(percent);
+ size_t percent_off = percent - line.format_string;
+ memcpy(fmt2, line.format_string, percent_off + 1);
+ memcpy(fmt2 + percent_off + 1, "2$", 2);
+ strcpy(fmt2 + percent_off + 3, percent + 1);
+ strcat(fmt2, "%1$.0d");
+
+ int l = line.line;
+ const char* res = line.result;
+ const char* fmt = line.format_string;
+ if (strchr(line.format_string, 'I')) {
+ ok = check_print(file, l, cmp, res, fmt, (size_t)line.value) && ok;
+ ok = check_print(file, l, cmp, res, fmt2, 0, (size_t)line.value) && ok;
+ } else {
+ ok = check_print(file, l, cmp, res, fmt, line.value) && ok;
+ ok = check_print(file, l, cmp, res, fmt2, 0, line.value) && ok;
+ }
+ }
+ MOZ_RELEASE_ASSERT(ok);
+}
+
+#if defined(XP_WIN)
+int wmain()
+#else
+int main()
+#endif // defined(XP_WIN)
+{
+ TestPrintfFormats();
+ TestPrintfTargetPrint();
+ TestGlibcPrintf(tiformat::sprint_ints, "tiformat.c", str_match);
+ TestGlibcPrintf(tllformat::sprint_ints, "tllformat.c", str_match);
+ TestGlibcPrintf(tfformat::sprint_doubles, "tfformat.c", approx_match);
+
+ // %f is actually a not very useful formatting specifier, and if you give
+ // large numbers, it will print... large amounts of characters. Ensure
+ // that it does (which requires a patch to double-conversion).
+ mozilla::SmprintfPointer dbl_max = mozilla::Smprintf("%f", -DBL_MAX);
+ MOZ_RELEASE_ASSERT(dbl_max);
+ // Its length should be 309 digits before the dot, 6 after, plus the dot
+ // and the negative sign.
+ MOZ_RELEASE_ASSERT(strlen(dbl_max.get()) == 317);
+
+ return 0;
+}
diff --git a/mozglue/tests/TestStackCookie.cpp b/mozglue/tests/TestStackCookie.cpp
new file mode 100644
index 0000000000..6970fbc240
--- /dev/null
+++ b/mozglue/tests/TestStackCookie.cpp
@@ -0,0 +1,89 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#include <stdio.h>
+#include <windows.h>
+
+#include <array>
+#include <utility>
+
+#include "mozilla/WindowsStackCookie.h"
+
+#if defined(DEBUG) && defined(_M_X64) && !defined(__MINGW64__)
+
+uint64_t NoStackCookie(const uint64_t* aArray, size_t aSize) {
+ uint64_t result = 0;
+ for (size_t i = 0; i < aSize; ++i) {
+ result += aArray[i];
+ }
+ result /= aSize;
+ return result;
+}
+
+// We expect the following instructions to be generated:
+//
+// 48 8b 05 XX XX XX XX mov rax,qword ptr [__security_cookie]
+// 48 31 e0 xor rax,rsp 48
+// 89 44 24 38 mov qword ptr [rsp+38h],rax
+uint64_t StackCookieWithSmallStackSpace(const uint64_t* aArray, size_t aSize) {
+ uint64_t array[0x2]{};
+ for (size_t i = 0; i < aSize; ++i) {
+ array[aArray[i]] += aArray[i];
+ }
+ return array[0] + array[1];
+}
+
+// We expect the following instructions to be generated:
+//
+// 48 8b 05 XX XX XX XX mov rax,qword ptr [__security_cookie]
+// 48 31 e0 xor rax,rsp
+// 48 89 84 24 28 40 00 00 mov qword ptr [rsp+4028h],rax
+uint64_t StackCookieWithLargeStackSpace(const uint64_t* aArray, size_t aSize) {
+ uint64_t array[0x800]{};
+ for (size_t i = 0; i < aSize; ++i) {
+ array[aArray[i]] += aArray[i];
+ }
+ return array[0] + array[0x7FF];
+}
+
+bool TestStackCookieCheck() {
+ std::array<std::pair<uintptr_t, bool>, 3> testCases{
+ std::make_pair<uintptr_t, bool>(
+ reinterpret_cast<uintptr_t>(NoStackCookie), false),
+ std::make_pair<uintptr_t, bool>(
+ reinterpret_cast<uintptr_t>(StackCookieWithSmallStackSpace), true),
+ std::make_pair<uintptr_t, bool>(
+ reinterpret_cast<uintptr_t>(StackCookieWithLargeStackSpace), true),
+ };
+ for (auto [functionAddress, expectStackCookieCheck] : testCases) {
+ if (mozilla::HasStackCookieCheck(functionAddress) !=
+ expectStackCookieCheck) {
+ printf(
+ "TEST-FAILED | StackCookie | Wrong output from HasStackCookieCheck "
+ "for function at %p (expected %d).\n",
+ reinterpret_cast<void*>(functionAddress), expectStackCookieCheck);
+ return false;
+ }
+ printf(
+ "TEST-PASS | StackCookie | Correct output from HasStackCookieCheck for "
+ "function at %p (expected %d).\n",
+ reinterpret_cast<void*>(functionAddress), expectStackCookieCheck);
+ }
+ return true;
+}
+
+#endif // defined(DEBUG) && defined(_M_X64) && !defined(__MINGW64__)
+
+int wmain(int argc, wchar_t* argv[]) {
+#if defined(DEBUG) && defined(_M_X64) && !defined(__MINGW64__)
+ if (!TestStackCookieCheck()) {
+ return 1;
+ }
+#endif // defined(DEBUG) && defined(_M_X64) && !defined(__MINGW64__)
+
+ printf("TEST-PASS | StackCookie | All tests ran successfully\n");
+ return 0;
+}
diff --git a/mozglue/tests/TestTimeStampWin.cpp b/mozglue/tests/TestTimeStampWin.cpp
new file mode 100644
index 0000000000..a69e2be59f
--- /dev/null
+++ b/mozglue/tests/TestTimeStampWin.cpp
@@ -0,0 +1,96 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/CmdLineAndEnvUtils.h"
+#include "mozilla/TimeStamp.h"
+
+#include "nsWindowsHelpers.h"
+
+#include <stdio.h>
+#include <windows.h>
+
+static wchar_t kChildArg[] = L"--child";
+
+static nsReturnRef<HANDLE> CreateProcessWrapper(const wchar_t* aPath) {
+ nsAutoHandle empty;
+
+ const wchar_t* childArgv[] = {aPath, kChildArg};
+ mozilla::UniquePtr<wchar_t[]> cmdLine(
+ mozilla::MakeCommandLine(mozilla::ArrayLength(childArgv), childArgv));
+
+ STARTUPINFOW si = {sizeof(si)};
+ PROCESS_INFORMATION pi;
+ BOOL ok = ::CreateProcessW(aPath, cmdLine.get(), nullptr, nullptr, FALSE, 0,
+ nullptr, nullptr, &si, &pi);
+ if (!ok) {
+ printf(
+ "TEST-FAILED | TimeStampWin | "
+ "CreateProcess failed - %08lx\n",
+ GetLastError());
+ return empty.out();
+ }
+
+ nsAutoHandle proc(pi.hProcess);
+ nsAutoHandle thd(pi.hThread);
+
+ return proc.out();
+}
+
+int ChildMain() {
+ // Make sure a process creation timestamp is always not bigger than
+ // the current timestamp.
+ auto t0 = mozilla::TimeStamp::ProcessCreation();
+ auto t1 = mozilla::TimeStamp::Now();
+ if (t0 > t1) {
+ printf(
+ "TEST-FAILED | TimeStampWin | "
+ "Process creation timestamp is bigger than the current "
+ "timestamp!\n");
+ return 1;
+ }
+ return 0;
+}
+
+int wmain(int argc, wchar_t* argv[]) {
+ if (argc == 2 && wcscmp(argv[1], kChildArg) == 0) {
+ return ChildMain();
+ }
+
+ if (argc != 1) {
+ printf(
+ "TEST-FAILED | TimeStampWin | "
+ "Unexpected argc\n");
+ return 1;
+ }
+
+ // Start a child process successively, checking any of them terminates with
+ // a non-zero value which means an error.
+ for (int i = 0; i < 20; ++i) {
+ nsAutoHandle childProc(CreateProcessWrapper(argv[0]));
+
+ if (::WaitForSingleObject(childProc, 60000) != WAIT_OBJECT_0) {
+ printf(
+ "TEST-FAILED | TimeStampWin | "
+ "Unexpected result from WaitForSingleObject\n");
+ return 1;
+ }
+
+ DWORD childExitCode;
+ if (!::GetExitCodeProcess(childProc.get(), &childExitCode)) {
+ printf(
+ "TEST-FAILED | TimeStampWin | "
+ "GetExitCodeProcess failed - %08lx\n",
+ GetLastError());
+ return 1;
+ }
+
+ if (childExitCode != 0) {
+ return childExitCode;
+ }
+ }
+
+ return 0;
+}
diff --git a/mozglue/tests/glibc_printf_tests/COPYING b/mozglue/tests/glibc_printf_tests/COPYING
new file mode 100644
index 0000000000..d159169d10
--- /dev/null
+++ b/mozglue/tests/glibc_printf_tests/COPYING
@@ -0,0 +1,339 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/mozglue/tests/glibc_printf_tests/COPYING.LIB b/mozglue/tests/glibc_printf_tests/COPYING.LIB
new file mode 100644
index 0000000000..4362b49151
--- /dev/null
+++ b/mozglue/tests/glibc_printf_tests/COPYING.LIB
@@ -0,0 +1,502 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/mozglue/tests/glibc_printf_tests/README.MOZILLA b/mozglue/tests/glibc_printf_tests/README.MOZILLA
new file mode 100644
index 0000000000..0016c66f70
--- /dev/null
+++ b/mozglue/tests/glibc_printf_tests/README.MOZILLA
@@ -0,0 +1,2 @@
+The files in this directory were copied from the stdio-common subdirectory
+in glibc (https://sourceware.org/git/glibc.git).
diff --git a/mozglue/tests/glibc_printf_tests/tfformat.c b/mozglue/tests/glibc_printf_tests/tfformat.c
new file mode 100644
index 0000000000..97151cb876
--- /dev/null
+++ b/mozglue/tests/glibc_printf_tests/tfformat.c
@@ -0,0 +1,4164 @@
+#include <math.h>
+#include <stdio.h>
+
+/* Tests taken from Cygnus C library. */
+
+typedef struct
+{
+ int line;
+ double value;
+ const char *result;
+ const char *format_string;
+} sprint_double_type;
+
+sprint_double_type sprint_doubles[] =
+{
+ {__LINE__, 30.3, "< +30.3>", "<%+15.10g>"},
+ {__LINE__, 10.0, "<10.00>", "<%5.2f>"},
+
+ {__LINE__, 1.002121970718271e+05, "100212.19707 ", "%0-15.5f"},
+ {__LINE__, -1.002121970718271e+05, "-100212.19707 ", "%0-15.5f"},
+ {__LINE__, 1.002121970718271e+05, "000100212.19707", "%015.5f"},
+ {__LINE__, -1.002121970718271e+05, "-00100212.19707", "%015.5f"},
+ {__LINE__, 1.002121970718271e+05, "+00100212.19707", "%+015.5f"},
+ {__LINE__, -1.002121970718271e+05, "-00100212.19707", "%+015.5f"},
+ {__LINE__, 1.002121970718271e+05, " 00100212.19707", "% 015.5f"},
+ {__LINE__, -1.002121970718271e+05, "-00100212.19707", "% 015.5f"},
+ {__LINE__, 1.002121970718271e+05, "+100212.19707 ", "%+-15.5f"},
+ {__LINE__, -1.002121970718271e+05, "-100212.19707 ", "%+-15.5f"},
+
+ {__LINE__, -1.002121970718271e+29, "-1.0E+29", "%.1E"},
+ {__LINE__, -1.002126048612756e-02, "-1.002126E-02", "%+#E"},
+ {__LINE__, -1.002653755271637e+00, "-1.00265", "%G"},
+ {__LINE__, -1.003238744365917e-23, "-0.00", "%4.2f"},
+ {__LINE__, -1.005084840877781e-29, " -0", "%4.f"},
+ {__LINE__, -1.005362549674427e+01, "-10.0536", "%#g"},
+ {__LINE__, -1.005915042991691e-17, "-1.00592E-17", "%G"},
+ {__LINE__, -1.007829874228503e-18, "-1.00783e-18", "%.7g"},
+ {__LINE__, -1.007829874228503e-18, "-1.007830e-18", "%#.7g"},
+ {__LINE__, -1.009390937771849e+15, "-1009390937771848.628657", "%+f"},
+ {__LINE__, -1.010679382726182e-29, "-0.0000000", "%.7f"},
+ {__LINE__, -1.010691853346650e+13, "-10106918533466.497934", "%+f"},
+ {__LINE__, -1.013412912122286e-22, "-1.01E-22", "%.2E"},
+ {__LINE__, -1.019269582113858e-25, " -0", "%4.0f"},
+ {__LINE__, -1.019886033368556e+24, "-1.019886E+24", "%+.7G"},
+ {__LINE__, -1.021037413548719e+02, "-102.103741", "%f"},
+ {__LINE__, -1.023833576089065e+26, "-1.023834E+26", "%+E"},
+ {__LINE__, -1.024736652408627e+10, "-10247366524.086265", "%+f"},
+ {__LINE__, -1.025439198495476e+09, "-1.02544e+09", "%+g"},
+ {__LINE__, -1.027080247585776e-04, "-0.0001027", "%6.7f"},
+ {__LINE__, -1.028096307262016e+18, "-1.0281E+18", "%3G"},
+ {__LINE__, -1.029604290697901e-02, "-0.010296", "%g"},
+ {__LINE__, -1.034347730570491e+16, "-10343477305704908.975059", "%+f"},
+ {__LINE__, -1.034663325049286e+22, "-1.0E+22", "%#.1E"},
+ {__LINE__, -1.034843152721857e-14, " -0", "%6.f"},
+ {__LINE__, -1.036082122299529e-29, "-1.04e-29", "%4.3g"},
+ {__LINE__, -1.037213662365954e-09, "-1e-09", "%3.e"},
+ {__LINE__, -1.038563976775690e-12, "-0.000000", "%f"},
+ {__LINE__, -1.040910158681323e-02, "-0.0104091", "%+G"},
+ {__LINE__, -1.044680094714482e-20, "-1.04468E-20", "%G"},
+ {__LINE__, -1.044990054091126e+24, "-1.044990E+24", "%+E"},
+ {__LINE__, -1.045693871096982e+11, "-1.045694e+11", "%+e"},
+ {__LINE__, -1.045714133591312e-04, "-0.000104571", "%+#3g"},
+ {__LINE__, -1.046215079103016e-15, "-1.04622e-15", "%g"},
+ {__LINE__, -1.046285293993789e-18, "-1.04629E-18", "%+4G"},
+ {__LINE__, -1.046306092899333e-06, "-0.00", "%0.2f"},
+ {__LINE__, -1.047308973649206e-22, "-1.05E-22", "%+1.3G"},
+ {__LINE__, -1.047369032507755e+01, "-1.047369E+01", "%E"},
+ {__LINE__, -1.048986365562919e-21, "-1.05E-21", "%+.2E"},
+ {__LINE__, -1.049530193156793e-17, "-1.04953E-17", "%+G"},
+ {__LINE__, -1.050073419263768e+25, "-1.05007e+25", "%g"},
+ {__LINE__, -1.051739652002504e-28, "-0.000000", "%+f"},
+ {__LINE__, -1.054493420082636e+21, "-1.0545e+21", "%#5.4e"},
+ {__LINE__, -1.055867291029098e+18, "-1.05587e+18", "%g"},
+ {__LINE__, -1.056514389757866e-16, "-1.05651E-16", "%5.6G"},
+ {__LINE__, -1.057180924868704e+15, "-1057180924868704", "%4.f"},
+ {__LINE__, -1.058455468395683e-23, "-1.05846e-23", "%g"},
+ {__LINE__, -1.062560982393212e+08, "-1.06256e+08", "%g"},
+ {__LINE__, -1.063365829241138e-10, "-1.063366e-10", "%+e"},
+ {__LINE__, -1.063568908667280e-19, "-1.06357E-19", "%+G"},
+ {__LINE__, -1.063734263253492e-13, "-0.000000", "%0f"},
+ {__LINE__, -1.064472689765495e-13, "-1E-13", "%4.0G"},
+ {__LINE__, -1.067192610000129e-25, "-1.06719E-25", "%G"},
+ {__LINE__, -1.068401334996592e-12, "-0.0000000", "%+.7f"},
+ {__LINE__, -1.069012628653724e-13, "-1.069013E-13", "%+.7G"},
+ {__LINE__, -1.069451976810790e+16, "-10694519768107904.056365", "%f"},
+ {__LINE__, -1.069568935323556e+17, "-1.06957e+17", "%g"},
+ {__LINE__, -1.071351044854107e-29, "-1.07135e-29", "%g"},
+ {__LINE__, -1.072274197526185e-21, "-1E-21", "%1.G"},
+ {__LINE__, -1.073875921752995e+23, "-1E+23", "%5.E"},
+ {__LINE__, -1.074835151152265e-12, "-1.0748e-12", "%1.5g"},
+ {__LINE__, -1.075171047088241e-19, "-1.07517E-19", "%#G"},
+ {__LINE__, -1.076258826412760e+22, "-1.076259e+22", "%+e"},
+ {__LINE__, -1.076365103160401e+06, "-1.07637E+06", "%+4.6G"},
+ {__LINE__, -1.076817750454633e+08, "-1e+08", "%4.g"},
+ {__LINE__, -1.078615405755685e-30, "-1e-30", "%4.g"},
+ {__LINE__, -1.078629622917468e-25, "-1.078630e-25", "%e"},
+ {__LINE__, -1.079352432833170e+11, "-107935243283", "%+2.f"},
+ {__LINE__, -1.081431147440215e+16, "-10814311474402147.439378", "%+f"},
+ {__LINE__, -1.083042116905339e-16, "-1.083e-16", "%.5g"},
+ {__LINE__, -1.085351710708553e-10, "-1.085e-10", "%1.4g"},
+ {__LINE__, -1.085796045618276e+07, "-1.085796e+07", "%e"},
+ {__LINE__, -1.087398259981007e+22, "-1.0874e+22", "%g"},
+ {__LINE__, -1.087986044402224e-11, "-1.087986e-11", "%e"},
+ {__LINE__, -1.090451848762709e-02, "-1.090452e-02", "%e"},
+ {__LINE__, -1.091463236899737e+11, "-1.091463E+11", "%#E"},
+ {__LINE__, -1.091617921737384e-29, "-1.09162e-29", "%3g"},
+ {__LINE__, -1.092049328579047e-17, "-1.092049E-17", "%E"},
+ {__LINE__, -1.093647615472090e+06, "-1093647.61547", "%6.5f"},
+ {__LINE__, -1.094133175602384e-08, "-1.1E-08", "%0.1E"},
+ {__LINE__, -1.095397916728214e-23, "-1e-23", "%6.e"},
+ {__LINE__, -1.098958790437321e+02, "-109.895879", "%+#f"},
+ {__LINE__, -1.100194638181594e-20, "-1.100195e-20", "%e"},
+ {__LINE__, -1.102174253534260e+05, "-1.1e+05", "%2.3g"},
+ {__LINE__, -1.102890180316350e-12, "-1.10289e-12", "%+g"},
+ {__LINE__, -1.105582337418378e+00, "-1.11", "%3.3g"},
+ {__LINE__, -1.110515122647056e+04, "-1.E+04", "%#0.G"},
+ {__LINE__, -1.111365895262625e-18, "-1e-18", "%0.g"},
+ {__LINE__, -1.112010622677495e+04, "-11120.1", "%g"},
+ {__LINE__, -1.112580043156699e-23, "-1.11258e-23", "%1g"},
+ {__LINE__, -1.112829057091303e+08, "-1.11283e+08", "%+2g"},
+ {__LINE__, -1.115019046200472e+18, "-1.1150190e+18", "%+#.7e"},
+ {__LINE__, -1.118078332268016e-13, "-1.12E-13", "%1.3G"},
+ {__LINE__, -1.119113571963886e+08, "-1.119114e+08", "%e"},
+ {__LINE__, -1.120102397563448e-15, "-1.12e-15", "%.4g"},
+ {__LINE__, -1.120707480791434e-19, "-1.12071e-19", "%g"},
+ {__LINE__, -1.124243676139007e-07, "-0.000000", "%f"},
+ {__LINE__, -1.125025214608798e+15, "-1.12503E+15", "%0G"},
+ {__LINE__, -1.126074395136447e+06, "-1E+06", "%+.0G"},
+ {__LINE__, -1.127203019940870e-06, "-0.000001", "%+#7f"},
+ {__LINE__, -1.130577648480677e+01, "-1.130578e+01", "%e"},
+ {__LINE__, -1.131469694425240e-11, "-1.13147e-11", "%#0.6g"},
+ {__LINE__, -1.132225023239752e+02, "-113.223", "%G"},
+ {__LINE__, -1.133702113050128e+20, "-1E+20", "%+3.E"},
+ {__LINE__, -1.135529466224404e-13, "-1.13553e-13", "%#g"},
+ {__LINE__, -1.137587210063004e+21, "-1e+21", "%.1g"},
+ {__LINE__, -1.140765637106361e-21, "-1.1e-21", "%+.1e"},
+ {__LINE__, -1.141182595083699e-18, "-0.000000", "%f"},
+ {__LINE__, -1.141695709120972e+00, "-1.1417", "%3G"},
+ {__LINE__, -1.143199141708028e+18, "-1143199141708027833", "%2.f"},
+ {__LINE__, -1.146712902056139e+21, "-1146712902056139071760.298975", "%f"},
+ {__LINE__, -1.146837903839073e-02, " -0.0", "%+5.1f"},
+ {__LINE__, -1.147363016107446e+10, "-1.14736e+10", "%+7g"},
+ {__LINE__, -1.149575523465052e+20, "-114957552346505220697.28140", "%+.5f"},
+ {__LINE__, -1.152748955392589e+13, "-1.15275E+13", "%G"},
+ {__LINE__, -1.152751106015483e-17, "-1E-17", "%+3.E"},
+ {__LINE__, -1.155539139258226e-18, "-1.2e-18", "%+.2g"},
+ {__LINE__, -1.157089280563492e+20, "-1.15709e+20", "%g"},
+ {__LINE__, -1.161217745859779e+19, "-1.161218E+19", "%E"},
+ {__LINE__, -1.162293536734798e+10, "-11622935367.347980", "%f"},
+ {__LINE__, -1.162629909468603e+20, "-1.16E+20", "%.3G"},
+ {__LINE__, -1.164979155838631e+24, "-1.16498E+24", "%G"},
+ {__LINE__, -1.165103052644816e-20, " -1e-20", "%+7.g"},
+ {__LINE__, -1.166448459023264e-08, "-0.000000", "%f"},
+ {__LINE__, -1.167694506705309e+28, "-1e+28", "%.1g"},
+ {__LINE__, -1.169901754818745e-28, "-0.000000", "%+f"},
+ {__LINE__, -1.170330336216446e+08, " -1e+08", "%7.g"},
+ {__LINE__, -1.170946623214213e-17, "-1.17095E-17", "%G"},
+ {__LINE__, -1.174581596799302e+27, "-1.174582e+27", "%+e"},
+ {__LINE__, -1.174763473995155e-28, "-1E-28", "%.1G"},
+ {__LINE__, -1.175885640508038e-23, "-1E-23", "%+.0E"},
+ {__LINE__, -1.177268411775439e-05, "-0.000012", "%#2.6f"},
+ {__LINE__, -1.177739669428001e-30, "-1.17774E-30", "%G"},
+ {__LINE__, -1.178059639880544e-02, "-0.0117806", "%+.7G"},
+ {__LINE__, -1.178793300854446e-13, "-1.2E-13", "%+#0.2G"},
+ {__LINE__, -1.179629345138058e-04, "-0.000118", "%0.3g"},
+ {__LINE__, -1.180730292213358e-25, "-1.18073e-25", "%g"},
+ {__LINE__, -1.180766261654697e+02, "-118.077", "%3g"},
+ {__LINE__, -1.181880261069391e-29, "-1.181880e-29", "%+#e"},
+ {__LINE__, -1.183752810063514e-09, "-1.18375e-09", "%#g"},
+ {__LINE__, -1.184191742443406e-21, "-1.184192e-21", "%e"},
+ {__LINE__, -1.184859760488406e-26, "-1.18486E-26", "%G"},
+ {__LINE__, -1.187276828720072e-29, "-1.18728E-29", "%G"},
+ {__LINE__, -1.187992907205195e-04, "-1.187993E-04", "%E"},
+ {__LINE__, -1.190586192763405e-28, "-1.E-28", "%#1.E"},
+ {__LINE__, -1.192104053032086e+02, "-119.21", "%G"},
+ {__LINE__, -1.192917884333569e+26, "-1.192918E+26", "%E"},
+ {__LINE__, -1.195900753509801e+22, "-1.1959e+22", "%g"},
+ {__LINE__, -1.196559413116537e-28, "-0.000000", "%6.6f"},
+ {__LINE__, -1.197534588732952e+12, "-1.19753e+12", "%#g"},
+ {__LINE__, -1.200279514790649e-25, "-0.0000", "%0.4f"},
+ {__LINE__, -1.203806667944635e+10, "-1.2038067E+10", "%5.7E"},
+ {__LINE__, -1.204344885974736e+07, "-1.204E+07", "%#2.4G"},
+ {__LINE__, -1.205668007693083e+00, "-1.20567", "%g"},
+ {__LINE__, -1.205898515218947e-11, "-1.2059e-11", "%+g"},
+ {__LINE__, -1.206787414909373e-05, "-1.2e-05", "%2.2g"},
+ {__LINE__, -1.207905830366447e+15, "-1.207906e+15", "%6.7g"},
+ {__LINE__, -1.208067010597729e-17, "-1.208067e-17", "%5e"},
+ {__LINE__, -1.210189135822574e+01, "-12", "%+2.0f"},
+ {__LINE__, -1.211560695948122e+10, "-1.21156e+10", "%+g"},
+ {__LINE__, -1.214003025273234e-18, "-1.214e-18", "%+g"},
+ {__LINE__, -1.214096815259005e+17, "-121409681525900459.142520", "%f"},
+ {__LINE__, -1.214699041716797e-14, "-1.2147E-14", "%G"},
+ {__LINE__, -1.215061611919443e+14, "-121506161191944.306310", "%+#f"},
+ {__LINE__, -1.217491221065185e+27, "-1.21749e+27", "%g"},
+ {__LINE__, -1.218538401534388e-11, "-1.218538e-11", "%#e"},
+ {__LINE__, -1.218810085883466e+16, "-1e+16", "%+.1g"},
+ {__LINE__, -1.219422688169801e+08, "-1.219423e+08", "%e"},
+ {__LINE__, -1.220473194407651e-14, "-1.2205E-14", "%1.5G"},
+ {__LINE__, -1.220824440193375e-02, "-0.012208", "%4f"},
+ {__LINE__, -1.221520240637007e+13, "-1.221520E+13", "%1E"},
+ {__LINE__, -1.221894719843486e+29, "-1.22189E+29", "%G"},
+ {__LINE__, -1.223020108610281e+25, "-1.22302E+25", "%G"},
+ {__LINE__, -1.223203206227728e-02, "-0.012232", "%G"},
+ {__LINE__, -1.225661737076919e-15, "-1.22566E-15", "%G"},
+ {__LINE__, -1.228147221003795e-08, "-1.22815E-08", "%G"},
+ {__LINE__, -1.228298534591771e+20, "-1.22830E+20", "%#G"},
+ {__LINE__, -1.228469080229780e-02, "-0.012285", "%0f"},
+ {__LINE__, -1.229161950699222e-09, "-1e-09", "%0.e"},
+ {__LINE__, -1.231294820136559e-17, "-1.231295E-17", "%1.7G"},
+ {__LINE__, -1.232588663406698e-21, "-1E-21", "%+0.G"},
+ {__LINE__, -1.233381256982191e-26, "-0.000000", "%f"},
+ {__LINE__, -1.233435864835578e+14, "-1.23344e+14", "%#g"},
+ {__LINE__, -1.237409567806099e-25, "-1.23741E-25", "%#G"},
+ {__LINE__, -1.238244697758558e-02, "-1.238245e-02", "%7e"},
+ {__LINE__, -1.239393163123284e+26, "-1.23939e+26", "%+g"},
+ {__LINE__, -1.240484781756132e-18, "-1E-18", "%4.E"},
+ {__LINE__, -1.241420286838750e+23, "-1E+23", "%2.E"},
+ {__LINE__, -1.243781122052343e-18, "-1.243781e-18", "%+e"},
+ {__LINE__, -1.244421506844779e+07, "-1.244422E+07", "%+6E"},
+ {__LINE__, -1.245754054764741e-21, "-1e-21", "%5.0g"},
+ {__LINE__, -1.245992228426733e-24, "-0.000000", "%f"},
+ {__LINE__, -1.246498277739883e-12, "-0.0000000", "%5.7f"},
+ {__LINE__, -1.247130891343776e-18, "-1.24713E-18", "%G"},
+ {__LINE__, -1.247309461703025e-03, "-0.0012473", "%#5.5G"},
+ {__LINE__, -1.248139162966407e-29, "-1.e-29", "%+#6.g"},
+ {__LINE__, -1.249756153623776e+08, "-1.249756e+08", "%e"},
+ {__LINE__, -1.250899983565585e-10, "-1.2509e-10", "%5g"},
+ {__LINE__, -1.250957368798327e+19, "-1.25096E+19", "%0G"},
+ {__LINE__, -1.252630814464822e-02, "-0.012526", "%+f"},
+ {__LINE__, -1.253076368257011e-28, "-0.000000", "%f"},
+ {__LINE__, -1.254243507039370e+01, "-1.254244e+01", "%e"},
+ {__LINE__, -1.257605614492298e-12, "-1.257606E-12", "%6.7G"},
+ {__LINE__, -1.258041911573120e+06, "-1258041.911573", "%+f"},
+ {__LINE__, -1.261670983426507e-25, "-0.00", "%.2f"},
+ {__LINE__, -1.263216883336562e-14, "-1.26322e-14", "%g"},
+ {__LINE__, -1.266846944498751e-15, "-1e-15", "%0.g"},
+ {__LINE__, -1.266977908502326e+06, "-1266978", "%+1.f"},
+ {__LINE__, -1.267006162870084e-23, "-1.267006e-23", "%e"},
+ {__LINE__, -1.269144609375931e+01, "-1.269145e+01", "%+e"},
+ {__LINE__, -1.269458714257904e+25, "-1.26946E+25", "%G"},
+ {__LINE__, -1.276697325772662e-02, "-0.0128", "%7.3G"},
+ {__LINE__, -1.278855081807602e+15, "-1278855081807601.87891", "%#0.5f"},
+ {__LINE__, -1.278966821639612e+20, "-1.278967E+20", "%3E"},
+ {__LINE__, -1.281942705258106e+03, "-1281.94", "%+G"},
+ {__LINE__, -1.282331291499203e+14, "-128233129149920.266343", "%+f"},
+ {__LINE__, -1.285125739341808e-28, "-1.28513e-28", "%g"},
+ {__LINE__, -1.285700693704978e+11, "-1.285701E+11", "%E"},
+ {__LINE__, -1.286574096459251e+28, "-1.287E+28", "%6.4G"},
+ {__LINE__, -1.287967889247240e+03, "-1287.97", "%G"},
+ {__LINE__, -1.288913808801319e-27, "-1.3e-27", "%7.1e"},
+ {__LINE__, -1.289147517760377e-18, "-1.289148E-18", "%E"},
+ {__LINE__, -1.289355006600107e+23, "-1.28936E+23", "%+G"},
+ {__LINE__, -1.291232014623979e+01, "-1.29123E+01", "%+.5E"},
+ {__LINE__, -1.293658562875966e-18, "-1.29366e-18", "%+g"},
+ {__LINE__, -1.294982911983638e-19, "-1.29498E-19", "%#G"},
+ {__LINE__, -1.296123363481695e-13, "-1.296123E-13", "%E"},
+ {__LINE__, -1.296632862070602e-20, "-1.29663e-20", "%+g"},
+ {__LINE__, -1.297801639022777e+23, "-129780163902277735132884.11777", "%#0.5f"},
+ {__LINE__, -1.297886574534611e+16, "-1.297887e+16", "%+e"},
+ {__LINE__, -1.300588216308401e+11, "-1.30e+11", "%.2e"},
+ {__LINE__, -1.301296100909062e-10, "-1.3013e-10", "%+g"},
+ {__LINE__, -1.303144244306468e-07, "-1.303144E-07", "%E"},
+ {__LINE__, -1.304096315024042e-20, "-1.3041E-20", "%+G"},
+ {__LINE__, -1.304817970675085e+16, "-1.304818E+16", "%+E"},
+ {__LINE__, -1.304870304632683e-15, " -1e-15", "%7.g"},
+ {__LINE__, -1.305213586757638e-18, "-1.30521e-18", "%g"},
+ {__LINE__, -1.306880734910465e-22, "-1.306881E-22", "%E"},
+ {__LINE__, -1.308964092631446e-23, "-1.30896e-23", "%g"},
+ {__LINE__, -1.312070555198201e+26, "-131207055519820126043839537", "%+7.f"},
+ {__LINE__, -1.312511609151056e-30, "-1.312512E-30", "%#E"},
+ {__LINE__, -1.313087359008389e-23, "-0.000000", "%+f"},
+ {__LINE__, -1.316948423042059e-02, "-1.316948E-02", "%+E"},
+ {__LINE__, -1.317080882577385e+29, "-1.317E+29", "%+.4G"},
+ {__LINE__, -1.317514598984346e+24, "-1.317515e+24", "%e"},
+ {__LINE__, -1.317817551125923e-21, "-1.31782E-21", "%+G"},
+ {__LINE__, -1.319603985988120e+29, "-131960398598811989856471882376.354188", "%f"},
+ {__LINE__, -1.328850458671907e+06, "-1e+06", "%.0e"},
+ {__LINE__, -1.328945346449817e-23, "-1.328945e-23", "%+e"},
+ {__LINE__, -1.330146584094221e-08, "-1e-08", "%+5.g"},
+ {__LINE__, -1.332609617892115e+00, "-1.33261", "%2.7G"},
+#ifndef __PCCNECV70__
+ {__LINE__, -1.332751724965715e+22, "-13327517249657150344432.920974", "%f"},
+ {__LINE__, -1.333194379353273e-19, "-0.000000", "%f"},
+ {__LINE__, -1.334304387932777e-06, "-1.334304e-06", "%e"},
+ {__LINE__, -1.334306581172082e-05, "-1.3e-05", "%+1.2g"},
+ {__LINE__, -1.335283510893438e-05, " -1E-05", "%7.G"},
+ {__LINE__, -1.337939692108373e+11, "-1.33794e+11", "%+4g"},
+ {__LINE__, -1.339117288874809e-03, "-0.001", "%1.3f"},
+ {__LINE__, -1.340100588141492e+27, "-1.340101E+27", "%E"},
+ {__LINE__, -1.341953272572953e-19, "-0.000000", "%+f"},
+ {__LINE__, -1.343058354301620e-02, "-1.343058e-02", "%e"},
+ {__LINE__, -1.346662720871543e+22, "-1.34666E+22", "%#G"},
+ {__LINE__, -1.354010578652210e-02, "-0.0135401", "%#g"},
+ {__LINE__, -1.354066549307666e-12, " -0", "%+6.f"},
+ {__LINE__, -1.355284719365947e+21, "-1.35528e+21", "%g"},
+ {__LINE__, -1.356326532145087e+29, "-1E+29", "%4.G"},
+ {__LINE__, -1.357278618897291e+19, "-13572786188972911780.581398", "%f"},
+ {__LINE__, -1.357537331348202e-10, "-0.000", "%+.3f"},
+ {__LINE__, -1.360011287595868e-10, "-0.000000", "%f"},
+ {__LINE__, -1.360506902899232e+16, "-13605069028992320.", "%#5.f"},
+ {__LINE__, -1.361102570277000e+10, "-1.3611E+10", "%G"},
+ {__LINE__, -1.362601255900219e+07, "-1.363E+07", "%.4G"},
+ {__LINE__, -1.366078182354771e+10, "-1.36608E+10", "%0G"},
+ {__LINE__, -1.366667926615127e+08, "-136666792.661513", "%f"},
+ {__LINE__, -1.367162823743231e-12, "-0.000000", "%#f"},
+ {__LINE__, -1.371523037550709e+09, "-1.37152e+09", "%+g"},
+ {__LINE__, -1.374328925986197e-17, "-1.37e-17", "%.2e"},
+ {__LINE__, -1.374995603898421e-26, "-1.375e-26", "%+g"},
+ {__LINE__, -1.376726539375688e+09, "-1.376727E+09", "%+E"},
+ {__LINE__, -1.378351117694958e-13, "-0.000000", "%f"},
+ {__LINE__, -1.378514699313619e-14, "-1.378515e-14", "%e"},
+ {__LINE__, -1.379347588942324e-23, "-1.4e-23", "%+.1e"},
+ {__LINE__, -1.380380583822272e-17, "-0.000000", "%+f"},
+ {__LINE__, -1.381658659947406e+19, "-1.38166e+19", "%g"},
+ {__LINE__, -1.382775316390237e+29, "-138277531639023653298181670834.3104", "%+#7.4f"},
+ {__LINE__, -1.383541138922400e+00, "-1.383541E+00", "%E"},
+ {__LINE__, -1.384625301445090e+01, "-13.8", "%+.3g"},
+ {__LINE__, -1.386844086284027e-13, "-1.38684E-13", "%+G"},
+ {__LINE__, -1.386930516448650e-28, "-1.386931E-28", "%E"},
+ {__LINE__, -1.387444896054260e-07, "-1.38744E-07", "%G"},
+ {__LINE__, -1.389685107980798e+22, "-1.38969E+22", "%G"},
+ {__LINE__, -1.390880300369347e+03, "-1390.880300", "%f"},
+ {__LINE__, -1.391423370198150e-17, "-1E-17", "%+2.G"},
+ {__LINE__, -1.394441767471218e-09, "-1.394442e-09", "%e"},
+ {__LINE__, -1.396275525062527e-20, "-1.39628E-20", "%G"},
+ {__LINE__, -1.397045957455157e+24, "-1E+24", "%.0E"},
+ {__LINE__, -1.397458546930799e+21, "-1397458546930798526375.383517", "%f"},
+ {__LINE__, -1.397584578988941e-14, "-1.39758e-14", "%5g"},
+ {__LINE__, -1.397789397300823e+09, "-1.398e+09", "%.4g"},
+ {__LINE__, -1.398167472294874e+21, "-1.398167E+21", "%+7E"},
+ {__LINE__, -1.398809636136688e-16, "-0.000000", "%+f"},
+ {__LINE__, -1.399545335304119e+26, "-139954533530411872277454676.805064", "%#5f"},
+ {__LINE__, -1.400102603335755e+20, "-140010260333575509150.705329", "%2f"},
+ {__LINE__, -1.401212746235235e+04, "-1.401213e+04", "%e"},
+ {__LINE__, -1.404409427681801e+07, "-1E+07", "%4.E"},
+ {__LINE__, -1.406018114263948e-25, "-1e-25", "%3.e"},
+ {__LINE__, -1.406245608096877e-06, "-1.4e-06", "%+.1e"},
+ {__LINE__, -1.410697254683835e-10, "-1.410697e-10", "%e"},
+ {__LINE__, -1.410739097553846e+25, "-1.410739E+25", "%+E"},
+ {__LINE__, -1.410850631189577e+04, "-14108.5", "%.6g"},
+ {__LINE__, -1.411680434455781e+28, "-14116804344557807304738616949.180141", "%f"},
+ {__LINE__, -1.413309465660099e-27, "-1.413309E-27", "%+#E"},
+ {__LINE__, -1.418468741386300e+09, "-1418468741.386300", "%f"},
+ {__LINE__, -1.420277110892909e+06, "-1.42028e+06", "%1g"},
+ {__LINE__, -1.420417889565590e-17, "-1.42E-17", "%.2E"},
+ {__LINE__, -1.421098212056305e+08, "-1.421098e+08", "%4e"},
+ {__LINE__, -1.421792812798986e-20, " -1E-20", "%7.G"},
+ {__LINE__, -1.423675488122461e+18, "-1423675488122461363.360571", "%f"},
+ {__LINE__, -1.423810545840653e+15, "-1E+15", "%3.E"},
+ {__LINE__, -1.424242673476368e-15, "-1.424243e-15", "%e"},
+ {__LINE__, -1.427847435688733e-01, "-1.427847E-01", "%E"},
+ {__LINE__, -1.433897734612555e-04, "-0.0001", "%3.g"},
+ {__LINE__, -1.434537754075696e-24, "-1.435E-24", "%+0.3E"},
+ {__LINE__, -1.434774864809324e-24, "-1E-24", "%2.E"},
+ {__LINE__, -1.435583851565142e-11, "-1E-11", "%.0E"},
+ {__LINE__, -1.438791024010112e+11, "-1.43879e+11", "%#.6g"},
+ {__LINE__, -1.439267565343777e+27, "-1.4e+27", "%2.1e"},
+ {__LINE__, -1.439440602670449e+02, "-143.944", "%G"},
+ {__LINE__, -1.439494412124925e+13, "-14394944121249.251268", "%f"},
+ {__LINE__, -1.440032823245152e+10, "-14400328232.451516", "%f"},
+ {__LINE__, -1.440174494009562e-08, "-0.000000", "%7f"},
+ {__LINE__, -1.440827804010568e+07, "-1.E+07", "%#6.1G"},
+ {__LINE__, -1.442760907195336e+09, "-1.44276E+09", "%+5G"},
+ {__LINE__, -1.444655304181403e+10, "-14446553041.814035", "%7f"},
+ {__LINE__, -1.444995766787036e+04, "-14450", "%5G"},
+ {__LINE__, -1.445078682874535e-13, "-1E-13", "%3.E"},
+ {__LINE__, -1.446781469662328e+01, "-14.4678", "%G"},
+ {__LINE__, -1.447795251395321e-04, "-0.000145", "%+f"},
+ {__LINE__, -1.448193079247108e-02, "-0.014", "%4.2G"},
+ {__LINE__, -1.449552967961345e+14, "-1E+14", "%1.E"},
+ {__LINE__, -1.451269763513571e+10, "-14512697635.135705", "%6f"},
+ {__LINE__, -1.451843176990292e+12, "-1e+12", "%1.g"},
+ {__LINE__, -1.452631405935931e+06, "-1.452631e+06", "%e"},
+ {__LINE__, -1.452753650285897e+21, "-1452753650285897091265.496783", "%5f"},
+ {__LINE__, -1.453811512433860e-05, "-1e-05", "%+6.g"},
+ {__LINE__, -1.454071430557372e+13, "-1.4541E+13", "%.4E"},
+ {__LINE__, -1.455956079562999e+03, "-1455.96", "%G"},
+ {__LINE__, -1.459712196146602e-17, "-1.45971e-17", "%g"},
+ {__LINE__, -1.461857733495947e-02, "-1.4619E-02", "%.4E"},
+ {__LINE__, -1.465257069090911e-11, "-1.465257E-11", "%+E"},
+ {__LINE__, -1.465306607257042e+05, "-146531", "%g"},
+ {__LINE__, -1.465857076315921e+20, "-1.46586E+20", "%+G"},
+ {__LINE__, -1.467919792051489e+16, "-1.46792e+16", "%2g"},
+ {__LINE__, -1.469271519834567e+20, "-146927151983456720785", "%+.0f"},
+ {__LINE__, -1.472961447442697e-28, "-1.47296e-28", "%#g"},
+ {__LINE__, -1.473385695190456e-12, "-1.473386E-12", "%E"},
+ {__LINE__, -1.485003089033267e-10, "-1.485E-10", "%2G"},
+ {__LINE__, -1.490541379072390e-18, "-1.490541E-18", "%4E"},
+ {__LINE__, -1.490683434793125e+22, "-14906834347931249951102.472551", "%#f"},
+ {__LINE__, -1.498356837215425e+20, "-1.49836E+20", "%#G"},
+ {__LINE__, -1.498677007818122e+14, "-1.49868E+14", "%+4G"},
+ {__LINE__, -1.502143197677119e+23, "-150214319767711934616727.", "%#7.f"},
+ {__LINE__, -1.503563770470753e-24, "-1.50356e-24", "%.6g"},
+ {__LINE__, -1.504643092793197e-18, "-1.504643e-18", "%+4e"},
+ {__LINE__, -1.507017706254022e-13, "-1.50702e-13", "%+g"},
+ {__LINE__, -1.507054033750081e-22, "-0.000000", "%f"},
+ {__LINE__, -1.508662346022339e+16, "-1.508662E+16", "%#E"},
+ {__LINE__, -1.509366882438902e+08, "-2e+08", "%4.g"},
+ {__LINE__, -1.511086567087967e+20, "-1.51109e+20", "%g"},
+ {__LINE__, -1.514959134622707e-18, "-0.000000", "%+f"},
+ {__LINE__, -1.515730120364204e+06, "-2E+06", "%0.G"},
+ {__LINE__, -1.516372763118606e-09, "-1.51637e-09", "%g"},
+ {__LINE__, -1.520610443546204e+27, "-1.52061e+27", "%g"},
+ {__LINE__, -1.522040655642012e+11, "-1.52204E+11", "%+2G"},
+ {__LINE__, -1.523772495014966e-24, "-2E-24", "%2.G"},
+ {__LINE__, -1.523980825983892e-05, "-0.000", "%2.3f"},
+ {__LINE__, -1.526696214603152e-03, "-0.0015267", "%+6.5G"},
+ {__LINE__, -1.528680540769583e+00, "-1.5287", "%0.5G"},
+ {__LINE__, -1.529951830525433e+08, "-1.529952e+08", "%+e"},
+ {__LINE__, -1.533052896559935e+05, "-153305", "%4.0f"},
+ {__LINE__, -1.533829640475152e-03, "-0.00153383", "%+#g"},
+ {__LINE__, -1.535617804643105e-30, "-1.535618e-30", "%e"},
+ {__LINE__, -1.537623698361821e+16, "-15376236983618207.7875719", "%4.7f"},
+ {__LINE__, -1.544994895330616e+24, "-1.54499e+24", "%g"},
+ {__LINE__, -1.545083356728403e+17, "-1.545083e+17", "%e"},
+ {__LINE__, -1.545684535393879e+12, "-1.55E+12", "%3.3G"},
+ {__LINE__, -1.545878334099427e+13, "-15458783340994.268762", "%1f"},
+ {__LINE__, -1.547697185980564e-18, "-1.5477e-18", "%.6g"},
+ {__LINE__, -1.548576527172579e-29, "-1.5E-29", "%2.2G"},
+ {__LINE__, -1.549712227835891e+08, "-1.549712e+08", "%#6.7g"},
+ {__LINE__, -1.550010819435335e-21, "-1.55001E-21", "%G"},
+ {__LINE__, -1.551412476164257e+14, "-1.551412E+14", "%E"},
+ {__LINE__, -1.553156638090030e+01, " -2E+01", "%7.G"},
+ {__LINE__, -1.553733233064355e-01, "-0.2", "%3.g"},
+ {__LINE__, -1.558391111609365e+00, "-1.558391", "%+f"},
+ {__LINE__, -1.562004019284766e+15, "-1.562E+15", "%6.5G"},
+ {__LINE__, -1.562195733239758e-16, "-0.000000", "%f"},
+ {__LINE__, -1.563953339012525e-14, "-1.56395E-14", "%1G"},
+ {__LINE__, -1.568317638534983e+18, "-1.56832E+18", "%1G"},
+ {__LINE__, -1.568546851135348e+04, "-15685.5", "%+#G"},
+ {__LINE__, -1.574297872228857e+18, "-1.574298e+18", "%e"},
+ {__LINE__, -1.575696460196291e-21, "-1.5757E-21", "%G"},
+ {__LINE__, -1.576324848379791e+25, "-1.57632E+25", "%+G"},
+ {__LINE__, -1.577524395140843e+06, "-1.5775E+06", "%.5G"},
+ {__LINE__, -1.585122856675091e+12, "-1585122856675.091452", "%f"},
+ {__LINE__, -1.586734674395556e-02, "-1.586735E-02", "%E"},
+ {__LINE__, -1.592602264315192e+22, "-1.5926E+22", "%G"},
+ {__LINE__, -1.594121556700562e+05, "-2E+05", "%+.0G"},
+ {__LINE__, -1.598538116193430e+22, "-1.59854e+22", "%+g"},
+ {__LINE__, -1.605647463222382e+18, "-1.6056E+18", "%.5G"},
+ {__LINE__, -1.610891449201191e+06, "-1.6109E+06", "%#6.4E"},
+ {__LINE__, -1.614593168166818e-05, "-1.61459E-05", "%G"},
+ {__LINE__, -1.615597722557325e-03, "-0.001616", "%f"},
+ {__LINE__, -1.616038022182124e-29, "-1.61604E-29", "%1G"},
+ {__LINE__, -1.618380771451625e-28, "-2e-28", "%+1.g"},
+ {__LINE__, -1.620287456872150e+10, "-1.620e+10", "%#7.3e"},
+ {__LINE__, -1.620469955611903e-29, "-0.000000", "%f"},
+ {__LINE__, -1.622580720690927e+20, "-1.622581E+20", "%+#E"},
+ {__LINE__, -1.622752500991079e-12, "-1.622753E-12", "%E"},
+ {__LINE__, -1.622771933776459e+08, "-1.6228E+08", "%+4.4E"},
+ {__LINE__, -1.623894567037391e+09, "-1.623895e+09", "%#e"},
+ {__LINE__, -1.624021408185354e-25, "-1.624E-25", "%.5G"},
+ {__LINE__, -1.624405320939366e-06, "-1.62441e-06", "%+#g"},
+ {__LINE__, -1.631236208958857e-25, "-1.631236e-25", "%#e"},
+ {__LINE__, -1.632165969536046e+20, "-1.63217E+20", "%G"},
+ {__LINE__, -1.632859596256475e+06, "-1.63286E+06", "%G"},
+ {__LINE__, -1.634371961703112e+06, "-1.634372E+06", "%+E"},
+ {__LINE__, -1.637230383641845e+24, "-1.63723e+24", "%#g"},
+ {__LINE__, -1.638081480475853e+17, "-1.63808e+17", "%+g"},
+ {__LINE__, -1.638279690467673e+14, "-163827969046767.325523", "%#f"},
+ {__LINE__, -1.640360249548215e-29, "-1.64036e-29", "%+6.6g"},
+ {__LINE__, -1.645691728060833e-30, "-1.64569e-30", "%g"},
+ {__LINE__, -1.648548965852592e-03, " -0", "%5.f"},
+ {__LINE__, -1.650100957771182e+21, "-1650100957771182308420.065965", "%+f"},
+ {__LINE__, -1.650957176011913e-02, "-0.016510", "%#4.5G"},
+ {__LINE__, -1.651165108095301e+29, "-165116510809530137038336761179.380119", "%f"},
+ {__LINE__, -1.657132845094847e-06, "-0.000002", "%f"},
+ {__LINE__, -1.657152146172541e+12, "-1.657152E+12", "%.7G"},
+ {__LINE__, -1.658377345516132e-06, "-0.00", "%.2f"},
+ {__LINE__, -1.658850468902324e+20, "-1.659e+20", "%.4g"},
+ {__LINE__, -1.661723557149830e+18, "-1.66172E+18", "%G"},
+ {__LINE__, -1.663570885140273e+14, "-166357088514027", "%2.f"},
+ {__LINE__, -1.665186944896906e+25, "-1.66519E+25", "%G"},
+ {__LINE__, -1.675910137717036e+22, "-2e+22", "%5.g"},
+ {__LINE__, -1.677447987675587e-15, "-1.67745E-15", "%G"},
+ {__LINE__, -1.677510590697220e+06, "-1677510.590697", "%5f"},
+ {__LINE__, -1.677658141289510e-18, "-2E-18", "%+5.G"},
+ {__LINE__, -1.678316848066192e-03, "-1.678317E-03", "%E"},
+ {__LINE__, -1.681506404024821e+24, "-1.68151E+24", "%G"},
+ {__LINE__, -1.688584243722160e+12, "-1.68858E+12", "%+#G"},
+ {__LINE__, -1.689468295411408e+28, "-1.68947E+28", "%+G"},
+ {__LINE__, -1.690746767470207e-11, "-1.69075E-11", "%G"},
+ {__LINE__, -1.692773960755248e-14, "-2E-14", "%4.E"},
+ {__LINE__, -1.693349092740995e-18, "-1.69335e-18", "%g"},
+ {__LINE__, -1.693642321808920e-26, "-1.69364E-26", "%G"},
+ {__LINE__, -1.694579128700042e-12, "-0.000000", "%f"},
+ {__LINE__, -1.695454897264717e-08, "-1.7E-08", "%+4.3G"},
+ {__LINE__, -1.695733278397589e+19, "-1.695733e+19", "%4e"},
+ {__LINE__, -1.699522534409388e-05, "-1.69952E-05", "%G"},
+ {__LINE__, -1.701752039544919e+00, "-2", "%.0f"},
+ {__LINE__, -1.702304998615036e+16, "-1.7023E+16", "%1G"},
+ {__LINE__, -1.703113580904556e-25, "-1.703114e-25", "%+e"},
+ {__LINE__, -1.705165515454546e+29, "-1.705166e+29", "%+e"},
+ {__LINE__, -1.707392568277288e-05, "-1.70739E-05", "%G"},
+ {__LINE__, -1.707477319256742e+09, "-1707477319.26", "%7.2f"},
+ {__LINE__, -1.709669107513969e-03, " -0.002", "%7.g"},
+ {__LINE__, -1.713284011412432e-24, "-1.713e-24", "%3.3e"},
+ {__LINE__, -1.715512203951086e-28, "-1.715512E-28", "%E"},
+ {__LINE__, -1.716880832248879e+13, "-1.71688e+13", "%+g"},
+ {__LINE__, -1.720722835740680e-15, "-1.7E-15", "%.1E"},
+ {__LINE__, -1.721855769574895e+07, "-17218557.695749", "%3f"},
+ {__LINE__, -1.722449437415368e+01, "-1.722449e+01", "%e"},
+ {__LINE__, -1.723218805116591e-29, "-2e-29", "%.0g"},
+ {__LINE__, -1.726129004920195e-05, "-1.72613E-05", "%0G"},
+ {__LINE__, -1.727400228037571e-28, "-0.0000000", "%2.7f"},
+ {__LINE__, -1.730008745782339e-23, "-1.73e-23", "%.4g"},
+ {__LINE__, -1.731875670201859e+09, "-1.73188E+09", "%G"},
+ {__LINE__, -1.732142976428085e+10, "-2E+10", "%+6.0E"},
+ {__LINE__, -1.732699651229194e-02, "-0.017327", "%5g"},
+ {__LINE__, -1.734772870736446e-12, "-0.000000", "%+f"},
+ {__LINE__, -1.738576887938331e+09, "-1.73858e+09", "%g"},
+ {__LINE__, -1.738759937912438e-08, "-1.73876e-08", "%+2g"},
+ {__LINE__, -1.739320154069143e-18, "-0.0000", "%1.4f"},
+ {__LINE__, -1.739870415800800e+16, "-1.73987e+16", "%g"},
+ {__LINE__, -1.741290506928618e+04, "-17412.9", "%G"},
+ {__LINE__, -1.742520800031913e+29, "-1.742521e+29", "%7e"},
+ {__LINE__, -1.747620095195231e+01, "-2e+01", "%+2.g"},
+ {__LINE__, -1.749860675924882e-21, "-1.74986E-21", "%G"},
+ {__LINE__, -1.752675363661431e-06, "-1.7527E-06", "%.5G"},
+ {__LINE__, -1.752871508059699e-06, " -0", "%7.f"},
+ {__LINE__, -1.755178530989839e+25, "-1.7551785e+25", "%1.7e"},
+ {__LINE__, -1.755566213249512e-07, "-1.755566e-07", "%.6e"},
+ {__LINE__, -1.756193485005071e-24, "-1.75619E-24", "%+2.6G"},
+ {__LINE__, -1.758501410496218e+03, "-1758.501", "%.7G"},
+ {__LINE__, -1.758795617219102e+20, "-1.75880E+20", "%#6G"},
+ {__LINE__, -1.760538679276709e+03, "-2e+03", "%+1.e"},
+ {__LINE__, -1.762660914833003e+27, "-1.76266E+27", "%G"},
+ {__LINE__, -1.765122691141907e+19, "-17651226911419071186.1", "%5.1f"},
+ {__LINE__, -1.765313277389086e-18, "-2E-18", "%+1.E"},
+ {__LINE__, -1.765821717148734e+19, "-1.76582E+19", "%G"},
+ {__LINE__, -1.767048687863149e-17, "-1.77E-17", "%+.3G"},
+ {__LINE__, -1.768661645451962e+18, "-1.77E+18", "%+.3G"},
+ {__LINE__, -1.769753257452233e+01, "-17.6975", "%G"},
+ {__LINE__, -1.770945665065531e+28, "-1.770946E+28", "%0.7G"},
+ {__LINE__, -1.776713865753894e-09, "-2e-09", "%1.g"},
+ {__LINE__, -1.778424845787448e+03, "-1.7784E+03", "%.4E"},
+ {__LINE__, -1.779060610701250e+06, "-1.779061E+06", "%E"},
+ {__LINE__, -1.781447182110762e-27, "-1.781447E-27", "%E"},
+ {__LINE__, -1.782655842123784e-13, "-2.E-13", "%#2.1G"},
+ {__LINE__, -1.783071018169166e+16, "-17830710181691664.217851", "%+f"},
+ {__LINE__, -1.784665985294415e+25, "-2E+25", "%3.G"},
+ {__LINE__, -1.787297600658096e+25, "-2E+25", "%+5.E"},
+ {__LINE__, -1.788200250255718e+12, "-1.7882E+12", "%2.4E"},
+ {__LINE__, -1.792860730579114e-09, "-1.79286E-09", "%G"},
+ {__LINE__, -1.793122797100936e+24, "-1.793123e+24", "%e"},
+ {__LINE__, -1.793761706915029e-25, "-0.000000", "%f"},
+ {__LINE__, -1.793947567431932e+22, "-1.79395e+22", "%g"},
+ {__LINE__, -1.796428035404303e-18, "-1.79643e-18", "%g"},
+ {__LINE__, -1.797113144273918e-16, "-1.79711E-16", "%.6G"},
+ {__LINE__, -1.798796767828424e-29, "-1.7988E-29", "%G"},
+ {__LINE__, -1.805004010633763e-11, "-1.805e-11", "%2.5g"},
+ {__LINE__, -1.806936269752338e-26, "-1.80694e-26", "%g"},
+ {__LINE__, -1.807122541760172e-10, "-1.80712e-10", "%g"},
+ {__LINE__, -1.808295407815630e-06, "-1.8083E-06", "%+G"},
+ {__LINE__, -1.813893236685959e+15, "-1813893236685959", "%0.f"},
+ {__LINE__, -1.816201530145367e+06, "-1816202", "%+2.f"},
+ {__LINE__, -1.822811219123512e+13, "-1.82281e+13", "%g"},
+ {__LINE__, -1.826276499170243e-25, "-2E-25", "%+3.G"},
+ {__LINE__, -1.832399287433839e-26, "-1.832399E-26", "%#4E"},
+ {__LINE__, -1.833597815584463e-18, "-0.000000", "%+3f"},
+ {__LINE__, -1.834165532712233e+28, "-1.834166E+28", "%.7G"},
+ {__LINE__, -1.837633147831083e+28, "-1.8376331e+28", "%.7e"},
+ {__LINE__, -1.839756716742518e-01, "-0.2", "%+0.G"},
+ {__LINE__, -1.840101206950368e-14, "-1.840101E-14", "%+E"},
+ {__LINE__, -1.842043645474877e+17, "-1.84204e+17", "%+g"},
+ {__LINE__, -1.842155892969934e+17, "-1.84216e+17", "%+g"},
+ {__LINE__, -1.843566073012842e-25, "-1.84357E-25", "%G"},
+ {__LINE__, -1.843976321320497e-02, "-0.02", "%+4.2f"},
+ {__LINE__, -1.845299931651554e+11, "-1.8453E+11", "%0.4E"},
+ {__LINE__, -1.846199038659889e-06, "-1.8462e-06", "%0.5g"},
+ {__LINE__, -1.847062180184169e-30, "-1.847062E-30", "%5E"},
+ {__LINE__, -1.847962158722201e-16, "-0.000000", "%f"},
+ {__LINE__, -1.849446376756582e+15, "-1.8E+15", "%2.2G"},
+ {__LINE__, -1.853168465523878e-24, "-2E-24", "%1.E"},
+ {__LINE__, -1.853601367230139e+10, "-1.853601e+10", "%e"},
+ {__LINE__, -1.857367903775364e+18, "-1.86E+18", "%1.3G"},
+ {__LINE__, -1.858332820633906e-05, "-0.000019", "%7f"},
+ {__LINE__, -1.860243811657223e-23, "-1.860244e-23", "%e"},
+ {__LINE__, -1.860660612539794e+08, "-1.86066e+08", "%+6.5e"},
+ {__LINE__, -1.861160816251124e-09, "-2E-09", "%1.G"},
+ {__LINE__, -1.862380636974688e-25, "-1.9E-25", "%.2G"},
+ {__LINE__, -1.864168808453004e+15, "-1.86417E+15", "%G"},
+ {__LINE__, -1.864273144411246e+07, "-1.86427e+07", "%g"},
+ {__LINE__, -1.864929236615802e-02, "-2e-02", "%+3.e"},
+ {__LINE__, -1.865010503480847e+19, "-2E+19", "%4.G"},
+ {__LINE__, -1.866276374553144e+22, "-1.866276e+22", "%e"},
+ {__LINE__, -1.870809567910649e+09, "-1.870810e+09", "%e"},
+ {__LINE__, -1.872555495839008e-13, "-1.872555E-13", "%3E"},
+ {__LINE__, -1.874465717110388e-22, "-1.874466E-22", "%E"},
+ {__LINE__, -1.874916306627632e+21, "-1874916306627632422987.517202", "%f"},
+ {__LINE__, -1.875804322194491e-23, "-0.000000", "%+f"},
+ {__LINE__, -1.876662099198587e-04, "-0.000187666", "%G"},
+ {__LINE__, -1.876775504795760e-25, "-1.87678e-25", "%0g"},
+ {__LINE__, -1.879343051002554e-20, " -0.", "%#6.f"},
+ {__LINE__, -1.881535445774717e-15, "-1.881535e-15", "%e"},
+ {__LINE__, -1.887515901404300e+00, "-1.888", "%2.4G"},
+ {__LINE__, -1.887730637149009e+17, "-1.887731E+17", "%E"},
+ {__LINE__, -1.889920303480086e+17, "-1.889920e+17", "%+e"},
+ {__LINE__, -1.891903478784091e+04, "-1.891903e+04", "%e"},
+ {__LINE__, -1.893550084305833e+16, "-1.89355e+16", "%g"},
+ {__LINE__, -1.894675230197676e+05, "-1.894675e+05", "%#e"},
+ {__LINE__, -1.898389624953187e-27, "-1.898390e-27", "%+e"},
+ {__LINE__, -1.899250044644046e+21, "-1899250044644046120367.875119", "%+4.6f"},
+ {__LINE__, -1.904187609804679e-02, "-1.90419E-02", "%0.5E"},
+ {__LINE__, -1.904452538421193e-04, "-2e-04", "%4.0e"},
+ {__LINE__, -1.904615326969061e-16, "-1.904615e-16", "%1.7g"},
+ {__LINE__, -1.907761255064750e+02, "-190.776126", "%f"},
+ {__LINE__, -1.910727641826707e-10, " -2e-10", "%7.g"},
+ {__LINE__, -1.913149279262051e+15, "-1.913149e+15", "%.7g"},
+ {__LINE__, -1.913235739298009e+28, "-1.913236e+28", "%e"},
+ {__LINE__, -1.913526822735271e+18, "-1.914e+18", "%.4g"},
+ {__LINE__, -1.913780977515583e+17, "-191378097751558335.9150", "%5.4f"},
+ {__LINE__, -1.917095456962182e-10, "-2E-10", "%4.G"},
+ {__LINE__, -1.918803033972851e+23, "-191880303397285132405158.947222", "%f"},
+ {__LINE__, -1.926420984801848e+16, "-19264209848018483.128840", "%+f"},
+ {__LINE__, -1.931905465942639e-10, "-1.93191e-10", "%g"},
+ {__LINE__, -1.932907105840252e+06, "-1.932907e+06", "%+#e"},
+ {__LINE__, -1.933091601918916e+15, "-1.933092E+15", "%#E"},
+ {__LINE__, -1.934296184983361e+09, "-1.9343e+09", "%1.6g"},
+ {__LINE__, -1.934637311832448e+11, "-1.93464e+11", "%+g"},
+ {__LINE__, -1.936201483262186e+12, "-2e+12", "%+6.g"},
+ {__LINE__, -1.939114661603911e+19, "-1.93911E+19", "%G"},
+ {__LINE__, -1.940478182124347e-13, "-0.000000", "%f"},
+ {__LINE__, -1.943218220654923e+08, "-2E+08", "%+5.0G"},
+ {__LINE__, -1.943526872455779e-30, "-1.9E-30", "%.1E"},
+ {__LINE__, -1.949869164681357e+19, "-1.949869e+19", "%#3e"},
+ {__LINE__, -1.954181060535402e+23, "-1.954181e+23", "%e"},
+ {__LINE__, -1.961581555579142e+14, "-1.962E+14", "%.3E"},
+ {__LINE__, -1.964535562036915e+07, "-1.96454E+07", "%G"},
+ {__LINE__, -1.969749653575926e+04, "-19697.5", "%.6g"},
+ {__LINE__, -1.973475369169053e+15, "-1.97348e+15", "%g"},
+ {__LINE__, -1.975658532866600e-21, "-2e-21", "%+1.2g"},
+ {__LINE__, -1.984050343831260e+09, "-1.984050E+09", "%E"},
+ {__LINE__, -1.984422410018571e+12, "-1.984422e+12", "%+4.7g"},
+ {__LINE__, -1.984878687667223e-22, "-0.000000", "%f"},
+ {__LINE__, -1.986116930967811e-28, "-1.98612e-28", "%g"},
+ {__LINE__, -1.986774457812683e+02, "-1.986774e+02", "%e"},
+ {__LINE__, -1.987274814938726e-04, "-0.000198727", "%g"},
+ {__LINE__, -1.987319200580415e+10, "-1.987319E+10", "%E"},
+ {__LINE__, -1.987980768698114e-19, "-0.000000", "%3f"},
+ {__LINE__, -1.994698965044602e-29, "-2E-29", "%+4.0G"},
+ {__LINE__, -1.997833122667050e+26, "-1.99783E+26", "%G"},
+ {__LINE__, -1.999453681184129e-10, "-0.00000", "%.5f"},
+ {__LINE__, -1.999897345839745e-16, "-1.9999e-16", "%g"},
+ {__LINE__, -2.003703825123989e-22, "-0.000000", "%f"},
+ {__LINE__, -2.004569188274957e-23, "-2.00457E-23", "%G"},
+ {__LINE__, -2.005911883189058e+07, "-2.00591E+07", "%G"},
+ {__LINE__, -2.006438312005722e-25, "-2.006e-25", "%0.4g"},
+ {__LINE__, -2.017322171210280e+18, "-2.01732E+18", "%+0G"},
+ {__LINE__, -2.017718635819594e-06, "-2.01772e-06", "%5g"},
+ {__LINE__, -2.019187445568160e-12, "-0.00", "%.2f"},
+ {__LINE__, -2.021022665608503e+25, "-20210226656085028551501636.684", "%2.3f"},
+ {__LINE__, -2.022720393474145e+07, "-2.02272E+07", "%#G"},
+ {__LINE__, -2.024506694471065e+23, "-2.02451E+23", "%G"},
+ {__LINE__, -2.024884686553821e-15, " -2e-15", "%7.g"},
+ {__LINE__, -2.027484636128966e-23, "-2.0275E-23", "%.5G"},
+ {__LINE__, -2.028185530467237e+21, "-2028185530467237374097.067", "%+4.3f"},
+ {__LINE__, -2.028388905566873e-09, "-0.000000", "%f"},
+ {__LINE__, -2.029856507431584e-17, "-2.02986E-17", "%G"},
+ {__LINE__, -2.029891733449167e+27, "-2029891733449166846270372843.7190875", "%3.7f"},
+ {__LINE__, -2.031933616694469e+14, "-2.031934E+14", "%#E"},
+ {__LINE__, -2.034011738471413e-10, "-2.03401E-10", "%#G"},
+ {__LINE__, -2.036087355975756e+29, "-203608735597575574161055556032.806635", "%+f"},
+ {__LINE__, -2.036355025137273e+09, "-2.036355E+09", "%#.7G"},
+ {__LINE__, -2.038423730536878e+12, "-2E+12", "%4.G"},
+ {__LINE__, -2.045209202278810e+23, "-2.045209e+23", "%+#e"},
+ {__LINE__, -2.046794083517423e-06, "-2.04679e-06", "%g"},
+ {__LINE__, -2.048042459678599e-19, "-0.000000", "%f"},
+ {__LINE__, -2.050526462096153e+18, "-2.05053e+18", "%+g"},
+ {__LINE__, -2.053583900249402e+13, "-2.053584e+13", "%0.7g"},
+ {__LINE__, -2.054342100957522e-23, "-2.05434E-23", "%#G"},
+ {__LINE__, -2.054793400141025e+11, "-205479340014.1", "%+2.1f"},
+ {__LINE__, -2.059200689196498e-11, "-0.000000", "%#f"},
+ {__LINE__, -2.060960692728114e-16, "-0.000000", "%+f"},
+ {__LINE__, -2.061417528654300e-30, "-2.06E-30", "%.3G"},
+ {__LINE__, -2.061513401198340e-29, "-2.06151e-29", "%7g"},
+ {__LINE__, -2.061846698845984e+27, "-2.061847E+27", "%E"},
+ {__LINE__, -2.063922242876789e-19, "-2.06392e-19", "%#g"},
+ {__LINE__, -2.065359431805529e+03, "-2065.359432", "%f"},
+ {__LINE__, -2.065529069992156e-04, "-0.000206553", "%+G"},
+ {__LINE__, -2.066082546490980e-25, "-2.06608e-25", "%5g"},
+ {__LINE__, -2.068394312095200e+17, "-2.068394e+17", "%e"},
+ {__LINE__, -2.071024178556425e-10, "-2.07102E-10", "%G"},
+ {__LINE__, -2.074401605950382e-22, "-2.07e-22", "%1.3g"},
+ {__LINE__, -2.074731895144874e-26, "-2.07473E-26", "%G"},
+ {__LINE__, -2.074895800882730e+18, "-2074895800882730068.082083", "%+f"},
+ {__LINE__, -2.077336220500764e-30, "-0", "%2.f"},
+ {__LINE__, -2.078067878561077e+09, "-2.0781e+09", "%0.5g"},
+ {__LINE__, -2.080497889634533e+15, "-2.080498E+15", "%4E"},
+ {__LINE__, -2.084717279367594e-21, "-2.08472e-21", "%+g"},
+ {__LINE__, -2.087827915301948e+29, "-2E+29", "%6.1G"},
+ {__LINE__, -2.090268686389680e+05, "-2.090269e+05", "%1e"},
+ {__LINE__, -2.092036176589720e+24, "-2.09204e+24", "%+g"},
+ {__LINE__, -2.093546373938615e-21, "-2.093546e-21", "%#e"},
+ {__LINE__, -2.101302069316682e+18, "-2.1013e+18", "%+7g"},
+ {__LINE__, -2.103463622286002e-13, "-2.103464E-13", "%E"},
+ {__LINE__, -2.105622845016732e+06, "-2105622.845017", "%1f"},
+ {__LINE__, -2.109999123037767e+28, "-2.11E+28", "%.2E"},
+ {__LINE__, -2.110317013992166e+04, "-21103.2", "%+g"},
+ {__LINE__, -2.112226142154618e+21, "-2112226142154617569702.", "%#6.f"},
+ {__LINE__, -2.112519484486528e+06, "-2.11252E+06", "%G"},
+ {__LINE__, -2.113439260812000e+23, "-2E+23", "%1.G"},
+ {__LINE__, -2.113465893194608e-15, "-2.1135E-15", "%.5G"},
+ {__LINE__, -2.113547784669409e+20, "-2.1135e+20", "%2.5g"},
+ {__LINE__, -2.114146001321822e+28, "-2.114146e+28", "%e"},
+ {__LINE__, -2.114509425574444e-30, " -0", "%4.f"},
+ {__LINE__, -2.114887421659561e-21, "-0.000000", "%+f"},
+ {__LINE__, -2.121120215127601e+21, "-2121120215127601404958.5683097", "%.7f"},
+ {__LINE__, -2.122555390665796e+06, "-2E+06", "%0.G"},
+ {__LINE__, -2.123468430242052e-27, "-0.000000", "%+f"},
+ {__LINE__, -2.123473598890635e+28, "-2.12347e+28", "%+g"},
+ {__LINE__, -2.124328049748190e-04, "-2.124328E-04", "%E"},
+ {__LINE__, -2.125633890999010e+28, "-2E+28", "%+5.G"},
+ {__LINE__, -2.125697963566045e+21, "-2.1257E+21", "%0G"},
+ {__LINE__, -2.127638109230109e+06, "-2.12764e+06", "%+6g"},
+ {__LINE__, -2.128456114617786e+07, "-2.128456E+07", "%E"},
+ {__LINE__, -2.128732742932824e-04, "-2.128733E-04", "%#E"},
+ {__LINE__, -2.129654381588404e+27, "-2129654381588404365999167566.7697564", "%+.7f"},
+ {__LINE__, -2.129792795009985e+20, "-2.12979e+20", "%g"},
+ {__LINE__, -2.131026925664619e-20, "-2e-20", "%.0e"},
+ {__LINE__, -2.132860730144188e-04, "-0.0002", "%5.g"},
+ {__LINE__, -2.133620979309562e+06, "-2e+06", "%3.e"},
+ {__LINE__, -2.133821423139120e-27, "-2.13382E-27", "%.6G"},
+ {__LINE__, -2.134253401425940e-07, "-0.000000", "%f"},
+ {__LINE__, -2.135469568156964e-29, "-2.135470E-29", "%+7E"},
+ {__LINE__, -2.135723595288365e-25, "-0.0", "%.1f"},
+ {__LINE__, -2.137642458920094e-09, "-2.13764e-09", "%g"},
+ {__LINE__, -2.143412361116583e+12, "-2.14341e+12", "%+g"},
+ {__LINE__, -2.144467087741129e-17, "-2.14447e-17", "%+g"},
+ {__LINE__, -2.145726966596964e-11, "-0.000000", "%2f"},
+ {__LINE__, -2.148318753042597e+08, "-2.14832E+08", "%5G"},
+ {__LINE__, -2.149932310549644e-19, "-2.14993e-19", "%g"},
+ {__LINE__, -2.150050917377646e-21, " -0", "%3.f"},
+ {__LINE__, -2.150854313643430e-16, "-0.000000", "%.6f"},
+ {__LINE__, -2.151071797121845e+00, "-2.15107", "%+g"},
+ {__LINE__, -2.158728406865981e+14, "-215872840686598.088666", "%7f"},
+ {__LINE__, -2.166062878011641e-23, "-2.166063e-23", "%e"},
+ {__LINE__, -2.167045002060684e+12, "-2.167045E+12", "%E"},
+ {__LINE__, -2.173752581051530e+20, "-217375258105153035259.604621", "%f"},
+ {__LINE__, -2.175599129057555e+24, "-2.175599E+24", "%E"},
+ {__LINE__, -2.176564454093042e-02, "-0.0217656", "%+G"},
+ {__LINE__, -2.181270774327071e-12, "-0.000000", "%#1f"},
+ {__LINE__, -2.184404769844158e-09, "-2.2E-09", "%+.2G"},
+ {__LINE__, -2.184881476334310e-07, "-2.18488e-07", "%g"},
+ {__LINE__, -2.189197211449684e-11, "-2E-11", "%.0G"},
+ {__LINE__, -2.189451286805190e+20, "-218945128680519029984", "%3.f"},
+ {__LINE__, -2.190642494146884e-27, " -0.", "%#4.f"},
+ {__LINE__, -2.194727956725854e+06, "-2.19E+06", "%.3G"},
+ {__LINE__, -2.196145868303877e+11, "-219614586830.387726", "%+5f"},
+ {__LINE__, -2.196397972262690e-16, "-0.000000", "%3f"},
+ {__LINE__, -2.202692843474668e-01, "-2.203e-01", "%.3e"},
+ {__LINE__, -2.204528684782451e-21, "-2.20453E-21", "%G"},
+ {__LINE__, -2.214926838821340e-16, "-2e-16", "%+2.g"},
+ {__LINE__, -2.215558986352773e+18, "-2215558986352773374", "%0.f"},
+ {__LINE__, -2.216976693056186e+27, "-2216976693056186498154147557.215765", "%f"},
+ {__LINE__, -2.217348422793322e+13, "-2.21735E+13", "%6G"},
+ {__LINE__, -2.217732695583920e-07, "-0", "%.0f"},
+ {__LINE__, -2.221185494767834e-14, "-2.22119e-14", "%g"},
+ {__LINE__, -2.224557193699609e-16, "-2.224557E-16", "%E"},
+ {__LINE__, -2.227417758704028e-18, "-0.000000", "%0f"},
+ {__LINE__, -2.231261655673006e-30, "-2.231262E-30", "%E"},
+ {__LINE__, -2.233081938836160e+21, "-2233081938836160240668.960", "%+6.3f"},
+ {__LINE__, -2.233158918439853e+05, "-223316", "%2G"},
+ {__LINE__, -2.233802298007898e-30, "-2.2338E-30", "%2G"},
+ {__LINE__, -2.233864858404732e+17, "-223386485840473181.241350", "%f"},
+ {__LINE__, -2.241242805107749e+14, "-2.24124E+14", "%G"},
+ {__LINE__, -2.244555498855249e+25, "-2.24456E+25", "%#G"},
+ {__LINE__, -2.248170665127481e-07, "-2.248171E-07", "%E"},
+ {__LINE__, -2.252558275567388e-13, "-2.25256e-13", "%g"},
+ {__LINE__, -2.256190083496001e+13, "-22561900834960.0136398", "%7.7f"},
+ {__LINE__, -2.259851596715945e+27, "-2.259852e+27", "%e"},
+ {__LINE__, -2.260461480001174e-21, "-0.000000", "%f"},
+ {__LINE__, -2.264128628428577e+22, "-2.26413e+22", "%1g"},
+ {__LINE__, -2.265914518399595e-04, "-0.000226591", "%G"},
+ {__LINE__, -2.266251557092826e+23, "-2.26625e+23", "%g"},
+ {__LINE__, -2.268592252572450e+19, "-2.268592e+19", "%2.6e"},
+ {__LINE__, -2.268597523847349e+11, "-2.2686e+11", "%g"},
+ {__LINE__, -2.268963106935546e+05, "-226896", "%+g"},
+ {__LINE__, -2.272527876808919e-24, "-0.000000", "%#f"},
+ {__LINE__, -2.273366440479073e+02, "-227.337", "%g"},
+ {__LINE__, -2.277858038556191e+25, "-2.28E+25", "%0.3G"},
+ {__LINE__, -2.282019915623415e+25, "-2E+25", "%5.E"},
+ {__LINE__, -2.283333247435650e-27, " -0", "%4.f"},
+ {__LINE__, -2.285230610829355e+23, "-2E+23", "%2.G"},
+ {__LINE__, -2.290900253402985e+23, "-2.2909E+23", "%G"},
+ {__LINE__, -2.293266953268186e+08, "-2.29327e+08", "%g"},
+ {__LINE__, -2.293489603164786e+23, "-229348960316478578391752.3076525", "%4.7f"},
+ {__LINE__, -2.294434667605481e+15, "-2.2944E+15", "%.5G"},
+ {__LINE__, -2.296607768466765e+21, "-2.29661E+21", "%G"},
+ {__LINE__, -2.297449967994012e+14, "-229744996799401.23542", "%+.5f"},
+ {__LINE__, -2.301162556466583e-01, "-0.230116", "%+#2g"},
+ {__LINE__, -2.301676246374004e+05, "-230168.", "%#g"},
+ {__LINE__, -2.301976724487835e-01, "-0.230198", "%5G"},
+ {__LINE__, -2.303269770571222e-15, "-2.303270e-15", "%.6e"},
+ {__LINE__, -2.306451480495636e+23, "-2.30645E+23", "%G"},
+ {__LINE__, -2.307659351219690e-17, "-0.000000", "%+3f"},
+ {__LINE__, -2.309009762339430e+16, "-2.30901E+16", "%G"},
+ {__LINE__, -2.309261751862100e+06, "-2309261.751862", "%+f"},
+ {__LINE__, -2.309504876918634e-26, " -2E-26", "%7.E"},
+ {__LINE__, -2.310910348147804e-26, "-2e-26", "%5.g"},
+ {__LINE__, -2.317173552252235e+05, "-231717.4", "%.7g"},
+ {__LINE__, -2.319517289618469e-23, "-2.31952E-23", "%+G"},
+ {__LINE__, -2.320103195142527e+08, "-2.320103E+08", "%+E"},
+ {__LINE__, -2.323523032125633e+24, "-2323523032125633491773442.07419", "%.5f"},
+ {__LINE__, -2.326279126614399e-16, "-0.000000", "%f"},
+ {__LINE__, -2.331393688620925e-09, "-2.33139e-09", "%#g"},
+ {__LINE__, -2.334233527512469e+01, " -23", "%6.0f"},
+ {__LINE__, -2.337418834112767e+24, " -2E+24", "%7.E"},
+ {__LINE__, -2.339455293612118e+12, "-2339455293612.1", "%+.1f"},
+ {__LINE__, -2.341930318143367e-18, "-2.E-18", "%#4.E"},
+ {__LINE__, -2.346107614950921e-17, "-0.00000", "%+2.5f"},
+ {__LINE__, -2.348356578807972e+23, "-2.34836e+23", "%g"},
+ {__LINE__, -2.351485855138244e+19, "-2.351486e+19", "%+e"},
+ {__LINE__, -2.362101647639198e-15, "-2.36210e-15", "%#g"},
+ {__LINE__, -2.369743873030115e+08, "-2e+08", "%.1g"},
+ {__LINE__, -2.371658164739356e+25, "-23716581647393559784120498.079574", "%f"},
+ {__LINE__, -2.372427847607163e+28, "-2.37243E+28", "%G"},
+ {__LINE__, -2.375465465294647e+11, "-2.375465e+11", "%e"},
+ {__LINE__, -2.377128971572195e-18, "-0.0", "%1.1f"},
+ {__LINE__, -2.380322448568089e-13, "-2.38032E-13", "%+#0G"},
+ {__LINE__, -2.385960728264882e+26, "-2E+26", "%.0E"},
+ {__LINE__, -2.387345744004747e+00, "-2.38735", "%G"},
+ {__LINE__, -2.390480023300201e+25, "-2.39048e+25", "%g"},
+ {__LINE__, -2.395420431930886e+23, "-2E+23", "%2.E"},
+ {__LINE__, -2.401144663870969e-10, "-2.e-10", "%#6.g"},
+ {__LINE__, -2.402787441215039e-08, "-2.40279e-08", "%g"},
+ {__LINE__, -2.402990830425278e+08, "-2.40299E+08", "%G"},
+ {__LINE__, -2.404213682932215e+08, "-2.40421e+08", "%2g"},
+ {__LINE__, -2.409385592298822e+21, "-2409385592298821876511.283335", "%7f"},
+ {__LINE__, -2.410798267658614e+13, "-2.4108e+13", "%+g"},
+ {__LINE__, -2.413180068271811e-24, "-0.000000", "%+f"},
+ {__LINE__, -2.413268457113495e+26, "-2.41327E+26", "%3.6G"},
+ {__LINE__, -2.415341832206007e-13, "-0.000000", "%+f"},
+ {__LINE__, -2.422519577068670e-08, "-0.0000000", "%.7f"},
+ {__LINE__, -2.422533651282808e+20, "-2.42253E+20", "%#G"},
+ {__LINE__, -2.422795006880671e+17, "-2.4228e+17", "%g"},
+ {__LINE__, -2.423483330202008e+20, "-2.42348e+20", "%g"},
+ {__LINE__, -2.431756009640369e-04, "-0.000243176", "%+#3g"},
+ {__LINE__, -2.431878622534173e-05, "-0.000024", "%f"},
+ {__LINE__, -2.432012113077180e+24, "-2.43201e+24", "%g"},
+ {__LINE__, -2.433843704470487e+07, "-24338437", "%4.f"},
+ {__LINE__, -2.435475755031956e+11, "-2.435476E+11", "%1E"},
+ {__LINE__, -2.438081888695437e-13, "-0.000000", "%f"},
+ {__LINE__, -2.438334590462860e+10, "-2.4E+10", "%5.2G"},
+ {__LINE__, -2.440223135334059e+17, "-2.44022e+17", "%g"},
+ {__LINE__, -2.444107281115317e-21, "-2.44411e-21", "%+g"},
+ {__LINE__, -2.444582273206171e-02, " -0.02", "%7.G"},
+ {__LINE__, -2.445234676352794e+23, "-2.44523e+23", "%#g"},
+ {__LINE__, -2.449185020984714e+08, "-2.E+08", "%#2.G"},
+ {__LINE__, -2.450646640466020e+22, "-2.45065E+22", "%5G"},
+ {__LINE__, -2.456840850262473e+13, "-24568408502625", "%0.f"},
+ {__LINE__, -2.464466865714499e-10, "-2e-10", "%6.g"},
+ {__LINE__, -2.466022088999151e+27, "-2.46602E+27", "%G"},
+ {__LINE__, -2.484398113119779e-04, "-2.484398E-04", "%E"},
+ {__LINE__, -2.484591850456328e+23, "-248459185045632846566832.085955", "%+f"},
+ {__LINE__, -2.488166252162446e-11, "-2.5E-11", "%4.2G"},
+ {__LINE__, -2.493507313049390e+24, "-2.49E+24", "%4.3G"},
+ {__LINE__, -2.500280281988428e+28, "-2.5E+28", "%.4G"},
+ {__LINE__, -2.500373956445372e-07, "-2.50037e-07", "%g"},
+ {__LINE__, -2.505566434769299e-12, "-2.5E-12", "%+#0.2G"},
+ {__LINE__, -2.508215917020758e+05, "-2.508216e+05", "%5e"},
+ {__LINE__, -2.519368094680315e-29, "-2.51937e-29", "%#0g"},
+ {__LINE__, -2.522266530587753e-11, "-2.52227e-11", "%+g"},
+ {__LINE__, -2.534492886372514e-06, "-2.53449E-06", "%0G"},
+ {__LINE__, -2.534617610955074e-02, "-0.03", "%0.2f"},
+ {__LINE__, -2.540551642835634e+26, "-3E+26", "%4.G"},
+ {__LINE__, -2.548210731830516e-26, "-0.000", "%2.3f"},
+ {__LINE__, -2.558868082397931e-11, "-3E-11", "%2.E"},
+ {__LINE__, -2.560062512991052e+11, "-2.56006E+11", "%+G"},
+ {__LINE__, -2.561274682814428e-05, "-0.000026", "%f"},
+ {__LINE__, -2.563424949397357e-02, " -0", "%6.f"},
+ {__LINE__, -2.577010939931465e+17, "-2.57701E+17", "%G"},
+ {__LINE__, -2.578224879294822e+10, "-3E+10", "%+4.1G"},
+ {__LINE__, -2.585655636750244e+13, "-2.585656e+13", "%+0.7g"},
+ {__LINE__, -2.585657986834408e+14, "-2.5857e+14", "%3.5g"},
+ {__LINE__, -2.586728929368101e+02, "-258.673", "%+g"},
+ {__LINE__, -2.591293023229468e+06, "-2591293.0232295", "%2.7f"},
+ {__LINE__, -2.592454222603538e-06, "-2.59245E-06", "%G"},
+ {__LINE__, -2.599399905869649e+02, "-259.939991", "%f"},
+ {__LINE__, -2.605382860307596e+12, "-2.60538E+12", "%2G"},
+ {__LINE__, -2.607507689402762e-01, "-0.260751", "%#.6g"},
+ {__LINE__, -2.612933252582967e+15, "-2.61293e+15", "%g"},
+ {__LINE__, -2.614337505491483e-14, "-2.61434E-14", "%.6G"},
+ {__LINE__, -2.618302263333671e+14, "-2.62e+14", "%3.3g"},
+ {__LINE__, -2.622998533972296e+00, "-3.", "%#0.g"},
+ {__LINE__, -2.623348319869643e-15, "-2.62335E-15", "%#G"},
+ {__LINE__, -2.626703132693163e+23, "-3E+23", "%+6.E"},
+ {__LINE__, -2.629610853765779e+25, "-2.62961E+25", "%+#G"},
+ {__LINE__, -2.632993880472784e+26, "-2.63299E+26", "%G"},
+ {__LINE__, -2.635651112327873e-20, "-2.63565E-20", "%1G"},
+ {__LINE__, -2.636003980473492e-23, "-2.636E-23", "%G"},
+ {__LINE__, -2.639316453244009e+10, "-26393164532.440094", "%#f"},
+ {__LINE__, -2.640517223417942e-28, "-2.641e-28", "%.3e"},
+ {__LINE__, -2.640625797147664e-22, "-2.640626E-22", "%E"},
+ {__LINE__, -2.644401262524378e-12, " -0.000", "%7.3f"},
+ {__LINE__, -2.651033203243637e-14, "-2.651033e-14", "%+e"},
+ {__LINE__, -2.652386470126594e-24, "-2.652386E-24", "%E"},
+ {__LINE__, -2.654281018623631e-12, "-0.00000", "%6.5f"},
+ {__LINE__, -2.655529742118827e+02, "-265.552974", "%f"},
+ {__LINE__, -2.658550833241620e+22, "-26585508332416196708436.473273", "%+f"},
+ {__LINE__, -2.660515890519100e+08, "-2.660516E+08", "%E"},
+ {__LINE__, -2.665025749266086e-24, "-2.66503E-24", "%G"},
+ {__LINE__, -2.666117105643095e-20, "-2.66612e-20", "%g"},
+ {__LINE__, -2.667051347741259e+11, "-3e+11", "%6.g"},
+ {__LINE__, -2.667207607243375e+04, "-26672.076072", "%+#f"},
+ {__LINE__, -2.667631877167590e+26, "-2.667632E+26", "%E"},
+ {__LINE__, -2.673817942962878e+13, "-2.673818e+13", "%+2.6e"},
+ {__LINE__, -2.674972907853507e+20, "-2.674973E+20", "%E"},
+ {__LINE__, -2.675830887404867e+14, "-2.675831E+14", "%E"},
+ {__LINE__, -2.682749918168908e+26, "-2.682750E+26", "%E"},
+ {__LINE__, -2.689222801942679e-03, "-0.0027", "%7.2G"},
+ {__LINE__, -2.692245629411156e+25, "-2.69225e+25", "%g"},
+ {__LINE__, -2.692606702464273e+11, "-2.69261e+11", "%g"},
+ {__LINE__, -2.693070822061136e-27, "-2.69307e-27", "%+g"},
+ {__LINE__, -2.694415515655336e-30, "-3E-30", "%+3.0E"},
+ {__LINE__, -2.694770057384739e+15, "-2.69477e+15", "%g"},
+ {__LINE__, -2.699998392329361e+01, "-27", "%+.2g"},
+ {__LINE__, -2.700151952281511e+23, "-270015195228151050343968.", "%+#5.f"},
+ {__LINE__, -2.707398527302841e-08, "-2.70740e-08", "%+#3g"},
+ {__LINE__, -2.711404950850030e-21, "-2.71E-21", "%.2E"},
+ {__LINE__, -2.714057739024281e-10, "-2.714e-10", "%.4g"},
+ {__LINE__, -2.717657632815414e-10, "-2.71766e-10", "%g"},
+ {__LINE__, -2.720875786430592e-09, "-2.7E-09", "%6.2G"},
+ {__LINE__, -2.725886730997891e+19, "-2.72589e+19", "%g"},
+ {__LINE__, -2.726089169748676e-09, "-2.72609E-09", "%+G"},
+ {__LINE__, -2.732907572038661e-30, "-2.73291E-30", "%G"},
+ {__LINE__, -2.737918050958789e+11, "-3e+11", "%1.g"},
+ {__LINE__, -2.739024251198484e-18, "-2.73902e-18", "%+g"},
+ {__LINE__, -2.742646144452305e+13, "-2.74265e+13", "%g"},
+ {__LINE__, -2.742911865386719e+06, "-3E+06", "%+5.G"},
+ {__LINE__, -2.759159275123811e-30, "-0.000000", "%+f"},
+ {__LINE__, -2.759794813930001e-21, "-2.75979e-21", "%+g"},
+ {__LINE__, -2.763243077558348e+20, "-2.7632E+20", "%+0.4E"},
+ {__LINE__, -2.770348477810209e-14, "-0.000000", "%2f"},
+ {__LINE__, -2.776074766292453e+05, "-277607", "%g"},
+ {__LINE__, -2.776610811432007e-07, "-2.77661E-07", "%6G"},
+ {__LINE__, -2.778673793270678e+23, "-3E+23", "%+4.E"},
+ {__LINE__, -2.782405168708350e+08, "-278240516.87084", "%.5f"},
+ {__LINE__, -2.783316149365198e-09, "-3E-09", "%5.0G"},
+ {__LINE__, -2.785436703085409e-27, "-2.78544E-27", "%#G"},
+ {__LINE__, -2.787479051660640e+21, "-2.78748e+21", "%g"},
+ {__LINE__, -2.789445406042450e-03, "-0.002789", "%+f"},
+ {__LINE__, -2.791104581836077e+05, "-279110.4581836", "%+7.7f"},
+ {__LINE__, -2.802078617775784e+04, "-28020.786", "%0.3f"},
+ {__LINE__, -2.804954315579055e+20, "-2.80495E+20", "%G"},
+ {__LINE__, -2.806575341862696e-05, "-2.80658E-05", "%G"},
+ {__LINE__, -2.807769556900402e-06, "-0.000003", "%+#f"},
+ {__LINE__, -2.808882056357941e-12, "-0.0", "%.1f"},
+ {__LINE__, -2.809386677339924e+10, "-2.8094E+10", "%6.5G"},
+ {__LINE__, -2.818404311437694e+19, "-3E+19", "%6.G"},
+ {__LINE__, -2.819463285551660e+01, "-28.1946", "%+G"},
+ {__LINE__, -2.821428853207724e-16, "-3e-16", "%6.g"},
+ {__LINE__, -2.824452750788444e+07, "-3e+07", "%+2.g"},
+ {__LINE__, -2.825430381094971e+28, "-3e+28", "%+.0e"},
+ {__LINE__, -2.830010928384944e-17, "-0", "%.0f"},
+ {__LINE__, -2.832505114479680e-09, "-0.000000", "%f"},
+ {__LINE__, -2.833246604950796e+13, "-2.83325E+13", "%G"},
+ {__LINE__, -2.833274073265017e+13, "-28332740732650.174564", "%f"},
+ {__LINE__, -2.835842581787797e+07, "-2.83584E+07", "%2G"},
+ {__LINE__, -2.839758384681983e-07, "-2.83976E-07", "%.6G"},
+ {__LINE__, -2.841077022753766e-09, "-3E-09", "%0.1G"},
+ {__LINE__, -2.845307294930682e+00, "-2.845307e+00", "%+1e"},
+ {__LINE__, -2.847420163874243e+19, "-2.8e+19", "%1.2g"},
+ {__LINE__, -2.848133715109881e-25, "-2.848134E-25", "%E"},
+ {__LINE__, -2.850208101288058e-06, "-2.8502E-06", "%+5.4E"},
+ {__LINE__, -2.853666525870413e+04, "-28536.665259", "%f"},
+ {__LINE__, -2.855661543202034e+21, "-2.85566e+21", "%g"},
+ {__LINE__, -2.859528889324159e-08, "-2.859529e-08", "%3e"},
+ {__LINE__, -2.860545310690251e+29, "-3e+29", "%.1g"},
+ {__LINE__, -2.863576633666884e-14, "-2.863577e-14", "%+5e"},
+ {__LINE__, -2.864115740396321e-14, "-2.86412e-14", "%g"},
+ {__LINE__, -2.864481979037153e+20, "-2.86E+20", "%3.3G"},
+ {__LINE__, -2.867582970177984e-18, "-0.000000", "%f"},
+ {__LINE__, -2.868237707901564e+25, "-3E+25", "%6.E"},
+ {__LINE__, -2.871741071402520e+13, "-3e+13", "%.1g"},
+ {__LINE__, -2.873724610073364e+18, "-2873724610073364438.278531", "%+#f"},
+ {__LINE__, -2.876433859770866e-25, "-2.87643e-25", "%g"},
+ {__LINE__, -2.877458587075737e-08, "-2.877E-08", "%+.4G"},
+ {__LINE__, -2.883349842927101e+24, "-2.883350E+24", "%2E"},
+ {__LINE__, -2.883749925642885e+09, "-2.883750e+09", "%e"},
+ {__LINE__, -2.883773835633003e-17, "-0.000000", "%+f"},
+ {__LINE__, -2.890389090491409e+24, "-2890389090491409262995148.310438", "%#1f"},
+ {__LINE__, -2.900848552225810e-11, "-0.000000", "%+f"},
+ {__LINE__, -2.911942123176400e+25, "-29119421231764004431852300", "%0.f"},
+ {__LINE__, -2.912904462180751e-18, "-2.9129E-18", "%6G"},
+ {__LINE__, -2.917717875075651e+26, "-3e+26", "%0.e"},
+ {__LINE__, -2.922293201084093e-26, "-2.922293E-26", "%E"},
+ {__LINE__, -2.925070319932451e-30, "-0.000000", "%f"},
+ {__LINE__, -2.926558572870874e+15, "-2.926559E+15", "%E"},
+ {__LINE__, -2.928781435877896e+26, "-2.928781e+26", "%+e"},
+ {__LINE__, -2.930178318110376e+28, "-2.930178E+28", "%E"},
+ {__LINE__, -2.930984661925819e+05, "-293098.5", "%.7G"},
+ {__LINE__, -2.932762424932762e-08, "-0.000000", "%#f"},
+ {__LINE__, -2.933415597492494e+10, "-29334155974.924943", "%+#2f"},
+ {__LINE__, -2.933564314850986e+29, "-2.93356E+29", "%7G"},
+ {__LINE__, -2.943224907893795e+10, "-2.943225E+10", "%+7E"},
+ {__LINE__, -2.945311540471221e+19, "-2.94531E+19", "%#G"},
+ {__LINE__, -2.945812356522847e+15, "-2.94581e+15", "%+g"},
+ {__LINE__, -2.945836999630957e+00, "-2.945837E+00", "%E"},
+ {__LINE__, -2.947798782726622e-01, "-0.29478", "%+g"},
+ {__LINE__, -2.948958405827917e+18, "-2.94896e+18", "%g"},
+ {__LINE__, -2.949790871798059e-11, "-2.94979E-11", "%G"},
+ {__LINE__, -2.950347806125225e-12, "-2.95035e-12", "%g"},
+ {__LINE__, -2.952781884599368e-29, "-2.952782E-29", "%+E"},
+ {__LINE__, -2.956801341442716e+06, "-2.9568E+06", "%G"},
+ {__LINE__, -2.957469310356540e-07, "-0.000", "%1.3f"},
+ {__LINE__, -2.960464869534870e-23, "-2.96046E-23", "%G"},
+ {__LINE__, -2.962339381825446e-07, "-0", "%1.f"},
+ {__LINE__, -2.971013180028710e+22, "-2.971e+22", "%3.5g"},
+ {__LINE__, -2.975167862441254e+07, "-2.97517e+07", "%g"},
+ {__LINE__, -2.976018424339993e+16, "-2.976018e+16", "%3e"},
+ {__LINE__, -2.979173094835454e+29, "-2.97917E+29", "%G"},
+ {__LINE__, -2.983135249987541e-03, "-0.00298314", "%+G"},
+ {__LINE__, -2.985142444917919e-24, "-2.985142E-24", "%+#7E"},
+ {__LINE__, -2.988680953635159e-14, "-0.0000000", "%2.7f"},
+ {__LINE__, -2.989629778079379e+04, "-29896.297781", "%f"},
+ {__LINE__, -2.991274275137276e+19, "-29912742751372762839.423558", "%+4f"},
+ {__LINE__, -2.991286396006024e-06, "-2.99129e-06", "%4g"},
+ {__LINE__, -2.993310397844811e+04, "-2.993310E+04", "%3.6E"},
+ {__LINE__, -2.994669852410861e-29, "-2.99467E-29", "%G"},
+ {__LINE__, -2.996082093034831e+27, "-2.996082e+27", "%1e"},
+ {__LINE__, -2.999783904575110e+16, "-2.999784E+16", "%#E"},
+ {__LINE__, -3.012019221956988e+25, "-3.012019E+25", "%E"},
+ {__LINE__, -3.014211917706622e-25, "-0.000000", "%+f"},
+ {__LINE__, -3.015149723683428e-19, "-3.01515E-19", "%G"},
+ {__LINE__, -3.022158478004638e-19, "-3.02216e-19", "%6g"},
+ {__LINE__, -3.022825518373900e-12, "-3.0228E-12", "%+.4E"},
+ {__LINE__, -3.025108924057340e-19, "-0.000000", "%f"},
+ {__LINE__, -3.026316824631967e+24, "-3026316824631966717618070.106255", "%1f"},
+ {__LINE__, -3.033074643529623e-13, "-3.03307e-13", "%g"},
+ {__LINE__, -3.035292960731141e+24, "-3035292960731141409524980.190326", "%f"},
+ {__LINE__, -3.043291272956732e-13, "-3.04329e-13", "%#g"},
+ {__LINE__, -3.045216723973715e-23, "-3.045e-23", "%.4g"},
+ {__LINE__, -3.047140976048835e+09, "-3.04714E+09", "%3.5E"},
+ {__LINE__, -3.047680278470886e+09, "-3.047680E+09", "%#E"},
+ {__LINE__, -3.048465807963461e+05, "-304847", "%g"},
+ {__LINE__, -3.050904753556756e+22, "-3.0509E+22", "%G"},
+ {__LINE__, -3.052845748999047e-13, "-3.05285e-13", "%g"},
+ {__LINE__, -3.053395231883620e-06, "-3E-06", "%2.G"},
+ {__LINE__, -3.054894203375445e-28, "-3e-28", "%2.g"},
+ {__LINE__, -3.055080347760755e-13, "-0", "%2.f"},
+ {__LINE__, -3.055513037393624e-29, "-3e-29", "%3.g"},
+ {__LINE__, -3.056198778208295e-06, "-3.0562e-06", "%g"},
+ {__LINE__, -3.057813660266980e-21, "-3E-21", "%1.G"},
+ {__LINE__, -3.059687036330998e-11, "-3.1E-11", "%#2.2G"},
+ {__LINE__, -3.061450385559094e-10, "-3.06145E-10", "%G"},
+ {__LINE__, -3.066605713361383e-27, "-0.000000", "%f"},
+ {__LINE__, -3.071590110813156e+22, "-3.07159E+22", "%G"},
+ {__LINE__, -3.073253864426931e+26, "-3.0733E+26", "%.5G"},
+ {__LINE__, -3.078998328596940e+07, "-3.079e+07", "%5.4g"},
+ {__LINE__, -3.082733887951920e+06, "-3.082734e+06", "%+6e"},
+ {__LINE__, -3.084365358064710e+24, "-3.084365E+24", "%#E"},
+ {__LINE__, -3.086948022123716e+25, "-30869480221237162176350921.072299", "%+f"},
+ {__LINE__, -3.088200214218024e-10, "-0", "%0.f"},
+ {__LINE__, -3.093442983942874e+08, "-309344298.394287", "%f"},
+ {__LINE__, -3.103573455403534e-09, "-3.103573E-09", "%#E"},
+ {__LINE__, -3.109178443120997e+07, "-31091784.431210", "%f"},
+ {__LINE__, -3.111494549914917e+28, "-3e+28", "%0.g"},
+ {__LINE__, -3.113384020517480e-17, " -0", "%+6.f"},
+ {__LINE__, -3.121622779718055e+14, "-312162277971805.491", "%+.3f"},
+ {__LINE__, -3.122780443843900e-01, "-0.312278", "%#g"},
+ {__LINE__, -3.122952438335638e-25, "-3.122952E-25", "%E"},
+ {__LINE__, -3.128970339463168e-18, "-3e-18", "%3.g"},
+ {__LINE__, -3.130862507719335e+10, "-3.130863e+10", "%3e"},
+ {__LINE__, -3.145960838955379e+03, "-3145.96", "%g"},
+ {__LINE__, -3.149362645138929e+21, "-3.14936e+21", "%g"},
+ {__LINE__, -3.150697168664913e+26, "-315069716866491322804222363.629378", "%+f"},
+ {__LINE__, -3.157946785041287e+05, "-3.1579e+05", "%.4e"},
+ {__LINE__, -3.158347006986809e-02, "-3.E-02", "%#.0E"},
+ {__LINE__, -3.159542871923388e+07, "-31595429", "%2.f"},
+ {__LINE__, -3.169997512351985e+15, "-3.169998E+15", "%6.7G"},
+ {__LINE__, -3.170971776544746e+07, "-31709717.765447", "%f"},
+ {__LINE__, -3.173246079104466e+19, "-3.173246E+19", "%1E"},
+ {__LINE__, -3.173581228658553e-02, "-0.03", "%+0.G"},
+ {__LINE__, -3.187598864929850e-07, "-3.18760E-07", "%#G"},
+ {__LINE__, -3.190525302270244e+08, "-3.190525e+08", "%+0.7g"},
+ {__LINE__, -3.191879884186422e+19, "-3.19E+19", "%.2E"},
+ {__LINE__, -3.197292604744926e+02, "-3.197293e+02", "%+e"},
+ {__LINE__, -3.203713337688838e-12, "-3.20371E-12", "%6G"},
+ {__LINE__, -3.204416889544914e-18, "-0.000000", "%+f"},
+ {__LINE__, -3.204494471917096e+09, "-3.20449e+09", "%g"},
+ {__LINE__, -3.211933195516720e+11, "-3.21193E+11", "%G"},
+ {__LINE__, -3.214544021431917e-24, "-0.000000", "%1f"},
+ {__LINE__, -3.215501229487004e-07, "-3e-07", "%3.e"},
+ {__LINE__, -3.232157492322707e-13, "-3.E-13", "%+#5.G"},
+ {__LINE__, -3.239074974455177e-05, "-3.239e-05", "%2.4g"},
+ {__LINE__, -3.243083730801156e-24, "-3.243084e-24", "%#e"},
+ {__LINE__, -3.243128583394124e+07, "-32431285.8339", "%6.4f"},
+ {__LINE__, -3.247997999770571e-08, "-3e-08", "%5.e"},
+ {__LINE__, -3.258251054563991e-15, "-3.2583E-15", "%.5G"},
+ {__LINE__, -3.259499053187446e+07, "-3.2595E+07", "%5.6G"},
+ {__LINE__, -3.261907782031174e+20, "-3.3e+20", "%.2g"},
+ {__LINE__, -3.263979380855122e+29, "-3.26398E+29", "%G"},
+ {__LINE__, -3.264166546402073e+06, "-3.26417E+06", "%5G"},
+ {__LINE__, -3.269357648926951e+01, "-3.E+01", "%#5.G"},
+ {__LINE__, -3.273523287028019e-30, "-3.27352e-30", "%g"},
+ {__LINE__, -3.274464331526264e-14, "-3e-14", "%.0g"},
+ {__LINE__, -3.276647049958546e+05, "-327664.7", "%+.1f"},
+ {__LINE__, -3.276853612008326e-04, "-3.276854e-04", "%e"},
+ {__LINE__, -3.288077788905925e+17, "-3.28808e+17", "%g"},
+ {__LINE__, -3.292054327509010e+21, "-3.29205e+21", "%+g"},
+ {__LINE__, -3.292086868337041e-16, " -0", "%7.f"},
+ {__LINE__, -3.299368070005327e-17, "-3E-17", "%5.G"},
+ {__LINE__, -3.307165537474566e-30, "-3e-30", "%+2.g"},
+ {__LINE__, -3.310556325973673e-17, "-3.31056E-17", "%G"},
+ {__LINE__, -3.315407318453138e-09, "-3.315407e-09", "%+#.6e"},
+ {__LINE__, -3.318402800998018e-09, "-3.3184E-09", "%+G"},
+ {__LINE__, -3.324277622889107e-04, "-0.000332428", "%G"},
+ {__LINE__, -3.326372457131185e+14, "-3.326372e+14", "%0e"},
+ {__LINE__, -3.333300611287597e+18, "-3.3E+18", "%4.2G"},
+ {__LINE__, -3.333608976277018e-25, "-3.33361e-25", "%g"},
+ {__LINE__, -3.333613056182724e-24, "-3.33361e-24", "%.5e"},
+ {__LINE__, -3.338505874378410e-26, "-0.00000", "%.5f"},
+ {__LINE__, -3.339838772519661e+24, "-3.3398E+24", "%0.5G"},
+ {__LINE__, -3.354802735583258e-27, "-3.3548E-27", "%G"},
+ {__LINE__, -3.356542080644329e+15, "-3356542080644329.129058", "%#f"},
+ {__LINE__, -3.360027692463026e-29, "-3.36003e-29", "%+g"},
+ {__LINE__, -3.361845657814323e+06, "-3361845.657814", "%f"},
+ {__LINE__, -3.363135493765816e-12, " -0", "%5.f"},
+ {__LINE__, -3.367383112102258e+19, "-33673831121022579360.158034", "%f"},
+ {__LINE__, -3.376798505037497e+03, "-3376.8", "%+3G"},
+ {__LINE__, -3.388170639372559e+09, "-3.388171e+09", "%+e"},
+ {__LINE__, -3.397304185715499e-12, "-3.397304e-12", "%+e"},
+ {__LINE__, -3.401559374016378e-13, "-3.40156e-13", "%g"},
+ {__LINE__, -3.402651870178825e+21, "-3.40265e+21", "%+g"},
+ {__LINE__, -3.410491213537530e+12, "-3.41049E+12", "%G"},
+ {__LINE__, -3.411695570460075e-01, "-3.411696e-01", "%e"},
+ {__LINE__, -3.417311435719220e+29, "-3.4E+29", "%3.1E"},
+ {__LINE__, -3.417581063208165e-23, " -0", "%+4.f"},
+ {__LINE__, -3.424005615113663e-28, "-0.000000", "%f"},
+ {__LINE__, -3.424793585094130e-12, "-0.000000", "%f"},
+ {__LINE__, -3.434733077762304e-05, "-3.43473e-05", "%g"},
+ {__LINE__, -3.436384988494743e+08, "-3.43638E+08", "%G"},
+ {__LINE__, -3.441082995163884e-21, "-0.000000", "%f"},
+ {__LINE__, -3.442868661576827e-23, "-3.442869e-23", "%#.7g"},
+ {__LINE__, -3.444337521046186e+13, "-3.44434E+13", "%#G"},
+ {__LINE__, -3.448230173418967e-28, "-3.44823E-28", "%#G"},
+ {__LINE__, -3.448523828225326e-21, "-3.4485e-21", "%.4e"},
+ {__LINE__, -3.449876796754720e-07, "-3.44988e-07", "%g"},
+ {__LINE__, -3.450163790411588e+25, "-34501637904115876054333966.749255", "%2f"},
+ {__LINE__, -3.450224454406567e-26, "-3.450224E-26", "%#1E"},
+ {__LINE__, -3.459930768422874e-28, "-3.46E-28", "%2.3G"},
+ {__LINE__, -3.460730505022601e-28, "-3.46073e-28", "%#g"},
+ {__LINE__, -3.462894265593946e-10, "-3.46289e-10", "%+#g"},
+ {__LINE__, -3.464808359229496e+05, "-346481", "%6.6G"},
+ {__LINE__, -3.467272303652620e-03, "-0.00346727", "%g"},
+ {__LINE__, -3.468252706910251e+10, "-3.5E+10", "%#7.2G"},
+ {__LINE__, -3.473623965680253e+27, "-3.47362e+27", "%g"},
+ {__LINE__, -3.474527926009729e+11, "-3.475E+11", "%.4G"},
+ {__LINE__, -3.476489048299929e+15, "-3.47649e+15", "%g"},
+ {__LINE__, -3.477809698895344e-09, "-0.000", "%+.3f"},
+ {__LINE__, -3.493008398637667e-28, " -0", "%+4.f"},
+ {__LINE__, -3.497441286691613e+07, "-3.49744e+07", "%g"},
+ {__LINE__, -3.500904660533358e+00, "-3.500905E+00", "%+1E"},
+ {__LINE__, -3.504996054364915e+25, "-3.505e+25", "%+g"},
+ {__LINE__, -3.507738629125434e-24, "-0.00", "%+4.2f"},
+ {__LINE__, -3.508557770253211e-04, "-3.508558e-04", "%#6e"},
+ {__LINE__, -3.516056824437550e+20, "-3.516057e+20", "%#e"},
+ {__LINE__, -3.521102917733367e+02, "-352.11", "%g"},
+ {__LINE__, -3.523948985825251e+10, "-3.52395e+10", "%+g"},
+ {__LINE__, -3.525281835697895e-15, "-3.525282e-15", "%e"},
+ {__LINE__, -3.534088845494570e-26, "-0.000000", "%2f"},
+ {__LINE__, -3.541002442741569e+01, "-35.410", "%3.3f"},
+ {__LINE__, -3.541126630345017e-19, "-3.541127e-19", "%e"},
+ {__LINE__, -3.545277845967514e-17, "-0.000000", "%f"},
+ {__LINE__, -3.560935430637329e-12, "-3.56094E-12", "%G"},
+ {__LINE__, -3.564234584447659e-23, "-3.56423E-23", "%G"},
+ {__LINE__, -3.576040378379921e-11, "-0.000000", "%+6f"},
+ {__LINE__, -3.578133580350674e-05, "-3.578134e-05", "%#e"},
+ {__LINE__, -3.584484015191491e-28, "-0.0", "%+2.1f"},
+ {__LINE__, -3.591961845146752e+27, "-3.59196E+27", "%G"},
+ {__LINE__, -3.602508380305001e+26, "-3.60251e+26", "%g"},
+ {__LINE__, -3.603113449808132e+04, "-36031.134498", "%+3.6f"},
+ {__LINE__, -3.605569849504628e+25, "-4E+25", "%6.G"},
+ {__LINE__, -3.611297754851416e+05, "-361129.775485", "%+f"},
+ {__LINE__, -3.613177909959201e-28, "-0.000000", "%f"},
+ {__LINE__, -3.616261225230595e-01, "-0.361626", "%3g"},
+ {__LINE__, -3.619203521536307e+09, "-3.6192E+09", "%G"},
+ {__LINE__, -3.619316709131723e-27, "-0.0000000", "%.7f"},
+ {__LINE__, -3.623100583082346e+28, "-3.6231E+28", "%+G"},
+ {__LINE__, -3.626582653589919e+21, "-3626582653589918603387.332041", "%f"},
+ {__LINE__, -3.626667540343067e-30, "-4.E-30", "%#.0G"},
+ {__LINE__, -3.633539220625861e-30, "-3.634E-30", "%+.3E"},
+ {__LINE__, -3.641655782149502e-11, "-3.64166E-11", "%G"},
+ {__LINE__, -3.644523594046571e+25, "-3.64452e+25", "%5g"},
+ {__LINE__, -3.645977605394108e+25, "-3.646e+25", "%+0.3e"},
+ {__LINE__, -3.647864582248812e+13, "-4E+13", "%4.G"},
+ {__LINE__, -3.655241667633056e-25, "-3.655242E-25", "%E"},
+ {__LINE__, -3.662603655433297e+23, "-3.662604e+23", "%e"},
+ {__LINE__, -3.668995445134158e+22, " -4E+22", "%7.G"},
+ {__LINE__, -3.670006666569412e-11, "-3.670007e-11", "%e"},
+ {__LINE__, -3.670510381138509e-24, "-3.670510e-24", "%e"},
+ {__LINE__, -3.671283003268254e-20, "-3.67128E-20", "%G"},
+ {__LINE__, -3.687760201176777e-13, "-3.68776E-13", "%G"},
+ {__LINE__, -3.687983982100676e-14, "-0.00", "%.2f"},
+ {__LINE__, -3.694808382827435e-12, "-3.694808E-12", "%#E"},
+ {__LINE__, -3.696158520838821e+28, "-3.69616E+28", "%3G"},
+ {__LINE__, -3.700911860811323e+18, "-3.70091e+18", "%+g"},
+ {__LINE__, -3.701328314738669e+24, "-3.70133e+24", "%g"},
+ {__LINE__, -3.707068461822151e-19, "-3.707068E-19", "%E"},
+ {__LINE__, -3.710679411506914e+25, "-3.71068e+25", "%g"},
+ {__LINE__, -3.713003840923896e-23, "-3.713e-23", "%7g"},
+ {__LINE__, -3.717028397747828e-28, "-3.71703e-28", "%g"},
+ {__LINE__, -3.728159642236442e+14, "-3.72816E+14", "%G"},
+ {__LINE__, -3.731956233637010e+21, "-3.73196E+21", "%G"},
+ {__LINE__, -3.742336623322610e+07, "-3.74234e+07", "%g"},
+ {__LINE__, -3.748328269630045e+04, "-37483.3", "%G"},
+ {__LINE__, -3.750803081283569e-27, "-3.7508E-27", "%+7G"},
+ {__LINE__, -3.752021500826652e-04, "-0.0004", "%.1G"},
+ {__LINE__, -3.755942257004103e-12, "-3.75594E-12", "%G"},
+ {__LINE__, -3.765921235889045e+03, " -4e+03", "%+7.g"},
+ {__LINE__, -3.772453135667801e-28, "-3.77245E-28", "%G"},
+ {__LINE__, -3.776384200230367e+27, "-3.776e+27", "%1.4g"},
+ {__LINE__, -3.787035870684945e-25, "-4E-25", "%+3.G"},
+ {__LINE__, -3.798616350818839e-29, "-3.7986164e-29", "%.7e"},
+ {__LINE__, -3.807178315238428e-15, "-0.000000", "%+#6f"},
+ {__LINE__, -3.822059837967635e+18, "-3822059837967634621.236357", "%6.6f"},
+ {__LINE__, -3.823553096022006e+12, "-3.82355e+12", "%g"},
+ {__LINE__, -3.839198115259428e-23, "-0.000000", "%f"},
+ {__LINE__, -3.846953640321746e+02, "-3.846954E+02", "%E"},
+ {__LINE__, -3.852230696542361e+08, "-3.8522e+08", "%#.5g"},
+ {__LINE__, -3.861139362195314e-25, "-3.86114E-25", "%2G"},
+ {__LINE__, -3.873388618099769e+09, "-3873388618", "%0.0f"},
+ {__LINE__, -3.874161550543817e+15, "-3.874162e+15", "%+e"},
+ {__LINE__, -3.874527935469425e+20, "-3.87E+20", "%3.3G"},
+ {__LINE__, -3.878069577893697e-30, "-3.878070E-30", "%#E"},
+ {__LINE__, -3.878852490397702e-20, "-3.87885e-20", "%g"},
+ {__LINE__, -3.879688342272101e-10, "-0.00", "%#4.2f"},
+ {__LINE__, -3.879797428399897e+03, "-3880", "%1.4g"},
+ {__LINE__, -3.881588804766756e+00, "-3.9", "%+4.2G"},
+ {__LINE__, -3.889377318111182e+01, "-38.8938", "%+.4f"},
+ {__LINE__, -3.893444523430385e-03, "-0.004", "%+2.g"},
+ {__LINE__, -3.894912141515856e+03, "-3894.91", "%+g"},
+ {__LINE__, -3.905279115773667e+04, "-39052.791158", "%f"},
+ {__LINE__, -3.905333955484919e-20, "-3.90533E-20", "%G"},
+ {__LINE__, -3.906559442060730e+27, "-3906559442060730447110472596.250474", "%f"},
+ {__LINE__, -3.909396469655334e-26, "-3.91E-26", "%.3G"},
+ {__LINE__, -3.920132491092364e+11, "-3.92013e+11", "%g"},
+ {__LINE__, -3.935651497471973e+27, "-3935651497471972604103029880", "%5.f"},
+ {__LINE__, -3.939742577853889e-03, "-0.004", "%5.G"},
+ {__LINE__, -3.943284017088198e+19, "-39432840170881981123.3", "%.1f"},
+ {__LINE__, -3.947452186327660e+09, "-3947452186.33", "%0.2f"},
+ {__LINE__, -3.951967237553488e+18, "-3951967237553488132.562052", "%f"},
+ {__LINE__, -3.953673427359789e-28, "-3.954E-28", "%3.4G"},
+ {__LINE__, -3.956044867371602e+23, "-4e+23", "%+6.1g"},
+ {__LINE__, -3.965038994251913e-20, "-3.96504e-20", "%g"},
+ {__LINE__, -3.970527677577937e+05, "-4.e+05", "%#0.1g"},
+ {__LINE__, -3.970717822164395e-20, "-3.970718e-20", "%6e"},
+ {__LINE__, -3.978063834438912e-19, "-3.97806E-19", "%G"},
+ {__LINE__, -3.982705395472599e+27, "-3.9827e+27", "%#.5g"},
+ {__LINE__, -3.983486821352571e-28, "-3.98349e-28", "%g"},
+ {__LINE__, -3.985470630230926e-14, "-4e-14", "%.2g"},
+ {__LINE__, -3.993095662863953e-16, "-3.993096e-16", "%e"},
+ {__LINE__, -4.006984141314271e-22, " -4e-22", "%7.2g"},
+ {__LINE__, -4.006984141314271e-22, "-4.0e-22", "%#7.2g"},
+ {__LINE__, -4.013226099863981e+06, "-4.013226E+06", "%+E"},
+ {__LINE__, -4.013702226581167e+00, "-4.0137022", "%+#3.7f"},
+ {__LINE__, -4.017598274642537e+11, "-4E+11", "%5.G"},
+ {__LINE__, -4.021385792825529e-09, " -4e-09", "%7.2g"},
+ {__LINE__, -4.024099064819937e-20, "-4.0241E-20", "%+G"},
+ {__LINE__, -4.026952473441366e+22, "-4.026952e+22", "%6.7g"},
+ {__LINE__, -4.027636677087866e+12, "-4.02764E+12", "%G"},
+ {__LINE__, -4.036506013049443e+17, "-4.03651e+17", "%0.6g"},
+ {__LINE__, -4.063191953523012e-06, " -0.0", "%6.1f"},
+ {__LINE__, -4.070953223475192e-23, "-4.07095E-23", "%G"},
+ {__LINE__, -4.072425833070524e+09, "-4.072426E+09", "%E"},
+ {__LINE__, -4.086025576759603e+12, "-4.086026e+12", "%e"},
+ {__LINE__, -4.086627783296081e-24, "-4.087E-24", "%.3E"},
+ {__LINE__, -4.086683676772144e+10, "-40866836767.721439", "%f"},
+ {__LINE__, -4.087336043219081e-10, "-0.", "%+#0.f"},
+ {__LINE__, -4.125162973336809e-26, "-4.125163E-26", "%.7G"},
+ {__LINE__, -4.150753797717075e-10, "-4.2e-10", "%.2g"},
+ {__LINE__, -4.152126152181912e+23, "-4.15213e+23", "%g"},
+ {__LINE__, -4.164458223079432e-07, "-4.164458E-07", "%E"},
+ {__LINE__, -4.170624866130099e+03, "-4170.624866", "%4.6f"},
+ {__LINE__, -4.171137277374942e-01, " -4E-01", "%+7.E"},
+ {__LINE__, -4.176067421901769e-25, "-4.17607E-25", "%G"},
+ {__LINE__, -4.179514418604771e+24, "-4.1795e+24", "%3.5g"},
+ {__LINE__, -4.196285183415621e+23, "-4.19629E+23", "%5G"},
+ {__LINE__, -4.198600486581023e+23, "-4E+23", "%+4.G"},
+ {__LINE__, -4.199020494598538e-16, "-0.000000", "%+f"},
+ {__LINE__, -4.207824153501688e-01, "-0.420782", "%G"},
+ {__LINE__, -4.219086441294006e-13, " -0", "%+4.f"},
+ {__LINE__, -4.223689582765525e+12, "-4.22369e+12", "%g"},
+ {__LINE__, -4.230213377391093e+04, "-42302.1", "%+2.6G"},
+ {__LINE__, -4.232495358100605e-02, "-0.042325", "%+f"},
+ {__LINE__, -4.235459662515940e-29, "-0.000000", "%f"},
+ {__LINE__, -4.240807508057296e-07, "-4e-07", "%0.g"},
+ {__LINE__, -4.248376819122346e-13, "-4.248377e-13", "%7e"},
+ {__LINE__, -4.251361939638334e-23, "-4.251362E-23", "%E"},
+ {__LINE__, -4.253044333568077e+24, "-4.253044e+24", "%4e"},
+ {__LINE__, -4.255728039119772e-30, "-4.25573E-30", "%2G"},
+ {__LINE__, -4.256502531648988e+02, "-425.65", "%G"},
+ {__LINE__, -4.260731632612400e-04, "-0", "%2.f"},
+ {__LINE__, -4.262037138254753e-25, "-4e-25", "%5.g"},
+ {__LINE__, -4.270910126379393e+00, "-4.2709", "%#7.4f"},
+ {__LINE__, -4.273844276097008e-09, " -0.", "%#4.f"},
+ {__LINE__, -4.280424136111831e+21, "-4.280E+21", "%.3E"},
+ {__LINE__, -4.284351940366486e-23, "-0.000000", "%+f"},
+ {__LINE__, -4.291747881693517e-29, "-4.3e-29", "%+#.2g"},
+ {__LINE__, -4.298346825232928e+04, "-42983.5", "%G"},
+ {__LINE__, -4.298879924365432e+28, "-42988799243654316484253286034.800112", "%f"},
+ {__LINE__, -4.302192665689887e-25, "-0.000000", "%f"},
+ {__LINE__, -4.303899568112784e+06, "-4E+06", "%1.G"},
+ {__LINE__, -4.307399960278190e-30, "-4.31e-30", "%.3g"},
+ {__LINE__, -4.341161949359232e+01, "-43.411619", "%+f"},
+ {__LINE__, -4.353334435604675e+17, " -4e+17", "%+7.g"},
+ {__LINE__, -4.354760231068195e+08, "-4e+08", "%2.e"},
+ {__LINE__, -4.363535913318519e+08, "-4.363536E+08", "%+7E"},
+ {__LINE__, -4.365389605557404e-29, "-4.365390e-29", "%e"},
+ {__LINE__, -4.369278570829168e-22, "-4.369279E-22", "%5E"},
+ {__LINE__, -4.372187639240662e-11, "-4.37219e-11", "%+g"},
+ {__LINE__, -4.374221079233858e-15, "-4.37422E-15", "%4.6G"},
+ {__LINE__, -4.374840292001664e-13, "-0.000000", "%+f"},
+ {__LINE__, -4.376554800103945e+16, "-43765548001039453.751559", "%f"},
+ {__LINE__, -4.376659235899513e+07, "-4.4E+07", "%0.2G"},
+ {__LINE__, -4.377316129868239e-06, "-4.37732E-06", "%+5G"},
+ {__LINE__, -4.380028480226885e+21, "-4e+21", "%1.0e"},
+ {__LINE__, -4.380434965450223e+16, "-43804349654502230.393405", "%f"},
+ {__LINE__, -4.392477080355168e-15, "-4E-15", "%+2.G"},
+ {__LINE__, -4.396120020536161e+17, "-439612002053616102.159594", "%#f"},
+ {__LINE__, -4.400993154571784e+13, "-44009931545717.844159", "%f"},
+ {__LINE__, -4.402873692051930e-26, "-4.4e-26", "%5.3g"},
+ {__LINE__, -4.405330274903779e+24, "-4405330274903779042006135.568954", "%+5f"},
+ {__LINE__, -4.406272291312090e+06, "-4.40627e+06", "%+g"},
+ {__LINE__, -4.407065949816988e-13, "-0.000000", "%f"},
+ {__LINE__, -4.408295597674563e-10, "-4.4083e-10", "%g"},
+ {__LINE__, -4.417553815178214e-30, "-4.41755E-30", "%G"},
+ {__LINE__, -4.428894120469459e+16, "-4.42889e+16", "%g"},
+ {__LINE__, -4.433747825142046e+04, "-4.433748e+04", "%#e"},
+ {__LINE__, -4.435051082856639e+11, "-4.43505E+11", "%G"},
+ {__LINE__, -4.445045573007259e-27, "-4.445e-27", "%.5g"},
+ {__LINE__, -4.447791368960968e-25, " -4e-25", "%+7.g"},
+ {__LINE__, -4.449691386526521e-11, "-4.44969e-11", "%g"},
+ {__LINE__, -4.451399093849402e+06, "-4.e+06", "%#0.e"},
+ {__LINE__, -4.453753130320864e-22, "-4E-22", "%6.E"},
+ {__LINE__, -4.455910780463539e+00, "-4", "%2.g"},
+ {__LINE__, -4.464935674747308e+25, "-4.46494e+25", "%g"},
+ {__LINE__, -4.469759565657550e-29, "-4.46976e-29", "%g"},
+ {__LINE__, -4.473254139442931e+14, "-4E+14", "%3.1G"},
+ {__LINE__, -4.480844704930373e-04, "-0.000448", "%5.6f"},
+ {__LINE__, -4.484177356024563e+19, "-4.484177E+19", "%E"},
+ {__LINE__, -4.488115678357666e-13, "-4.48812e-13", "%g"},
+ {__LINE__, -4.491545112281561e+12, "-4.491545E+12", "%E"},
+ {__LINE__, -4.492547433553077e-23, "-4.49255e-23", "%g"},
+ {__LINE__, -4.492701755830813e-05, "-0.000045", "%f"},
+ {__LINE__, -4.497405935096372e-02, "-4.497406e-02", "%e"},
+ {__LINE__, -4.502764260212887e+21, "-4.50276E+21", "%G"},
+ {__LINE__, -4.511984199938207e+29, "-451198419993820731832556703011.505306", "%f"},
+ {__LINE__, -4.514517861504637e-13, "-4.51452e-13", "%g"},
+ {__LINE__, -4.525577218881990e+24, "-4.5e+24", "%2.2g"},
+ {__LINE__, -4.549244580903896e-26, "-5E-26", "%2.G"},
+ {__LINE__, -4.569192488002113e-29, "-5E-29", "%3.G"},
+ {__LINE__, -4.572011438847734e+17, "-4.57e+17", "%#.3g"},
+ {__LINE__, -4.573010973514519e-08, "-4.57301e-08", "%+7g"},
+ {__LINE__, -4.584534976177852e-04, "-0.000458453", "%7g"},
+ {__LINE__, -4.584729895132228e-21, "-0.000000", "%4f"},
+ {__LINE__, -4.585259328217483e-30, "-4.58526E-30", "%+#4.6G"},
+ {__LINE__, -4.589603063610410e-04, "-4.589603E-04", "%+E"},
+ {__LINE__, -4.592428795671033e+22, " -5e+22", "%7.g"},
+ {__LINE__, -4.595683678223830e-20, " -0", "%5.f"},
+ {__LINE__, -4.602585606100101e+05, "-4.602586E+05", "%E"},
+ {__LINE__, -4.603375306660027e-08, "-5E-08", "%+6.G"},
+ {__LINE__, -4.611341343728034e-18, "-4.611341e-18", "%5e"},
+ {__LINE__, -4.613608487855863e+05, "-461361", "%6g"},
+ {__LINE__, -4.615997775774194e-24, "-4.61600e-24", "%#g"},
+ {__LINE__, -4.620310950564759e+23, "-462031095056475926696749", "%1.0f"},
+ {__LINE__, -4.620645693595563e-10, "-4.6206457e-10", "%.7e"},
+ {__LINE__, -4.621527706233292e-09, "-4.621528e-09", "%#e"},
+ {__LINE__, -4.625215210297273e-13, "-4.62522E-13", "%G"},
+ {__LINE__, -4.636755152220100e-29, "-0.000000", "%#f"},
+ {__LINE__, -4.641203877508087e+23, "-4.6412e+23", "%0g"},
+ {__LINE__, -4.648627249239175e+23, "-4.65E+23", "%+0.3G"},
+ {__LINE__, -4.662546890623409e-10, "-4.663E-10", "%.3E"},
+ {__LINE__, -4.664488650292317e-27, "-4.66449e-27", "%#g"},
+ {__LINE__, -4.668715685060282e+08, "-466871568.50603", "%.5f"},
+ {__LINE__, -4.673332851657081e-18, "-4.7e-18", "%#5.2g"},
+ {__LINE__, -4.683361436174074e+24, "-4.68e+24", "%#.2e"},
+ {__LINE__, -4.693748680461066e-01, "-0.469375", "%G"},
+ {__LINE__, -4.697110010549124e+23, "-4.69711E+23", "%G"},
+ {__LINE__, -4.710442739966989e+06, "-4.710443e+06", "%2e"},
+ {__LINE__, -4.713427678642280e-09, "-4.71343e-09", "%g"},
+ {__LINE__, -4.721999055940316e-04, "-4.721999e-04", "%#1e"},
+ {__LINE__, -4.724262200578540e+17, "-472426220057853996.081576", "%+f"},
+ {__LINE__, -4.733267644288093e+01, "-4.733268e+01", "%7e"},
+ {__LINE__, -4.742854711396110e-11, "-0.000000", "%f"},
+ {__LINE__, -4.757456106385936e+23, "-4.75746e+23", "%g"},
+ {__LINE__, -4.770895495642298e+27, "-4770895495642298200777986494.358629", "%2f"},
+ {__LINE__, -4.775073456318149e+29, "-4.775073E+29", "%#E"},
+ {__LINE__, -4.779997387204258e+17, "-4.78e+17", "%g"},
+ {__LINE__, -4.799264315770707e-23, "-4.799264E-23", "%+.7G"},
+ {__LINE__, -4.814277930599660e+10, "-5e+10", "%2.1g"},
+ {__LINE__, -4.818413387018612e+05, "-5e+05", "%.0g"},
+ {__LINE__, -4.818827195107612e-16, "-4.818827e-16", "%e"},
+ {__LINE__, -4.841524514024803e+21, "-4.84152E+21", "%G"},
+ {__LINE__, -4.860585077313477e+10, "-4.86059E+10", "%+G"},
+ {__LINE__, -4.870037451948589e+28, "-48700374519485887248038125107.996166", "%f"},
+ {__LINE__, -4.888835952705153e-28, "-4.888836E-28", "%+E"},
+ {__LINE__, -4.893523355754114e-19, "-4.893523e-19", "%.6e"},
+ {__LINE__, -4.906070260482585e+17, "-490607026048258454", "%+.0f"},
+ {__LINE__, -4.907734144101900e+25, "-5E+25", "%+.1G"},
+ {__LINE__, -4.917899547741841e-25, "-4.917900e-25", "%e"},
+ {__LINE__, -4.923348512538722e+25, "-49233485125387215219916470.232420", "%+.6f"},
+ {__LINE__, -4.926052630078460e-26, "-4.926053e-26", "%e"},
+ {__LINE__, -4.926751662051156e+14, "-4.927E+14", "%+5.3E"},
+ {__LINE__, -4.928017952199046e-12, "-0.000000", "%f"},
+ {__LINE__, -4.944296782981195e-21, "-4.9443E-21", "%1.5G"},
+ {__LINE__, -4.947320427183599e-19, "-4.947320e-19", "%.6e"},
+ {__LINE__, -4.968188938972135e+17, "-4.96819E+17", "%G"},
+ {__LINE__, -4.968756725758674e+05, "-496876", "%G"},
+ {__LINE__, -4.968788759793340e-26, "-4.97E-26", "%.3G"},
+ {__LINE__, -4.983904999913364e-24, "-5E-24", "%0.G"},
+ {__LINE__, -4.985209496522767e+23, "-4.985209e+23", "%e"},
+ {__LINE__, -4.987363880732866e+08, "-4.98736E+08", "%G"},
+ {__LINE__, -4.989754940144973e+05, "-498975.494014", "%f"},
+ {__LINE__, -4.998203870733718e-25, "-4.9982e-25", "%g"},
+ {__LINE__, -4.999153445016792e-27, "-5e-27", "%+1.e"},
+ {__LINE__, -5.002693488258108e+06, " -5e+06", "%+7.g"},
+ {__LINE__, -5.017958458603783e+05, "-5.0179585E+05", "%+.7E"},
+ {__LINE__, -5.028902178573363e-12, "-5.0289e-12", "%0g"},
+ {__LINE__, -5.032337536971444e+07, "-50323375.369714", "%f"},
+ {__LINE__, -5.036525516370473e-24, "-5.0365e-24", "%4.5g"},
+ {__LINE__, -5.038642321515756e+18, "-5038642321515755639.893541", "%f"},
+ {__LINE__, -5.051003516976770e-14, "-5.051E-14", "%+G"},
+ {__LINE__, -5.051196143816789e+27, "-5.0512e+27", "%g"},
+ {__LINE__, -5.057372886713786e+28, "-5.057373e+28", "%#e"},
+ {__LINE__, -5.057475029459727e+12, "-5.05748e+12", "%+g"},
+ {__LINE__, -5.068286816124670e-17, "-5.068E-17", "%5.3E"},
+ {__LINE__, -5.070475165759468e-12, "-0.000000", "%4.6f"},
+ {__LINE__, -5.081352543220476e+20, "-5.081E+20", "%.3E"},
+ {__LINE__, -5.084398319179363e+11, "-508439831917.936313", "%#f"},
+ {__LINE__, -5.085781220648484e+05, "-5.E+05", "%+#7.G"},
+ {__LINE__, -5.094941054632498e-24, "-5.09494E-24", "%+G"},
+ {__LINE__, -5.100059596310871e-10, "-5.10006e-10", "%3.6g"},
+ {__LINE__, -5.103072553594136e-01, "-0.5", "%+1.g"},
+ {__LINE__, -5.106319890388412e+08, "-5.106320e+08", "%4e"},
+ {__LINE__, -5.107120687977690e+09, "-5107120687.977690", "%f"},
+ {__LINE__, -5.119910716893161e-13, "-5.11991E-13", "%6G"},
+ {__LINE__, -5.127594569425709e-29, "-5.12759e-29", "%#g"},
+ {__LINE__, -5.130365585632797e+29, "-5.13037e+29", "%#g"},
+ {__LINE__, -5.131415638022112e+08, "-513141563.802211", "%0f"},
+ {__LINE__, -5.144703216335916e-23, "-5.1447e-23", "%g"},
+ {__LINE__, -5.152511923201882e-05, "-5.15251E-05", "%+G"},
+ {__LINE__, -5.165484448280190e-12, " -0.0", "%5.1f"},
+ {__LINE__, -5.179220760465737e-20, "-5e-20", "%+5.g"},
+ {__LINE__, -5.183005119662180e-10, "-5.183005E-10", "%+E"},
+ {__LINE__, -5.199587953258117e+13, "-5.19959e+13", "%6g"},
+ {__LINE__, -5.202041951844580e-25, "-0.000000", "%f"},
+ {__LINE__, -5.202836038621740e+00, "-5.20284", "%G"},
+ {__LINE__, -5.212204099528552e-11, "-5.2122e-11", "%.6g"},
+ {__LINE__, -5.225617726710534e+17, "-522561772671053414.995868", "%+f"},
+ {__LINE__, -5.230162003281426e+25, "-52301620032814257754694153.84578", "%+6.5f"},
+ {__LINE__, -5.251849429321286e-11, "-5.25185e-11", "%g"},
+ {__LINE__, -5.265174939930368e+23, "-5.265175E+23", "%1.6E"},
+ {__LINE__, -5.271218134351422e+21, "-5.27122e+21", "%+1g"},
+ {__LINE__, -5.273823357545750e+17, "-527382335754575048.980541", "%f"},
+ {__LINE__, -5.279848797214957e+11, "-527984879721.495659", "%0f"},
+ {__LINE__, -5.281551888625290e+11, "-5e+11", "%4.g"},
+ {__LINE__, -5.281780377142961e-24, "-5.28178e-24", "%g"},
+ {__LINE__, -5.292125782379512e+03, "-5292.125782", "%f"},
+ {__LINE__, -5.292401691410388e+15, "-5292401691410387.520875", "%f"},
+ {__LINE__, -5.305120752102265e-25, "-5.30512e-25", "%+#.5e"},
+ {__LINE__, -5.317975791704413e+16, "-5.31798e+16", "%+g"},
+ {__LINE__, -5.336522843607233e+27, "-5.33652e+27", "%#6g"},
+ {__LINE__, -5.342016438000917e-05, " -5e-05", "%+7.e"},
+ {__LINE__, -5.351122291549103e+06, "-5351122.291549", "%+0f"},
+ {__LINE__, -5.352043956303597e+00, "-5.35204", "%g"},
+ {__LINE__, -5.353582488767747e+09, "-5.354E+09", "%7.3E"},
+ {__LINE__, -5.383420177718380e+04, "-5e+04", "%1.e"},
+ {__LINE__, -5.384320189791882e-10, "-5.384320e-10", "%e"},
+ {__LINE__, -5.409487543257379e-12, "-5.40949E-12", "%G"},
+ {__LINE__, -5.418395794776773e+23, "-5.4184e+23", "%g"},
+ {__LINE__, -5.419918795921525e-09, "-0.000000", "%+f"},
+ {__LINE__, -5.422374157832442e+11, "-5.42237e+11", "%3g"},
+ {__LINE__, -5.426916951577001e-27, "-5.42692E-27", "%+G"},
+ {__LINE__, -5.430058833461779e+28, "-5.43006E+28", "%G"},
+ {__LINE__, -5.444433348653147e+23, "-5.444433E+23", "%E"},
+ {__LINE__, -5.446560186537024e+09, "-5.446560E+09", "%E"},
+ {__LINE__, -5.464243500152188e+27, "-5.46424E+27", "%G"},
+ {__LINE__, -5.464427517531742e+20, "-546442751753174249529.365625", "%f"},
+ {__LINE__, -5.465783705970954e+05, "-5E+05", "%1.E"},
+ {__LINE__, -5.475138077475789e-11, "-5e-11", "%.0e"},
+ {__LINE__, -5.475302250616576e+10, "-54753022506.1658", "%.4f"},
+ {__LINE__, -5.488964905442472e+09, "-5.48896e+09", "%g"},
+ {__LINE__, -5.492508526846316e-08, "-5.49251e-08", "%.6g"},
+ {__LINE__, -5.520533408804846e-15, "-5.520533e-15", "%e"},
+ {__LINE__, -5.532744688447266e+28, "-55327446884472664123677532188.594341", "%2.6f"},
+ {__LINE__, -5.535834653450131e-14, "-5.5e-14", "%0.1e"},
+ {__LINE__, -5.554344735392882e-02, "-5.554345E-02", "%+#E"},
+ {__LINE__, -5.555497334515501e-17, "-5.5555e-17", "%g"},
+ {__LINE__, -5.558304303221977e+14, "-555830430322197.699411", "%f"},
+ {__LINE__, -5.562210815777694e-05, "-5.562211E-05", "%#1E"},
+ {__LINE__, -5.564800722538402e-09, "-5.56480e-09", "%#.6g"},
+ {__LINE__, -5.567143271590439e-01, "-5.567143e-01", "%#e"},
+ {__LINE__, -5.568606044396186e+01, "-55.6861", "%4g"},
+ {__LINE__, -5.592027856401721e+12, "-5.592028e+12", "%.7g"},
+ {__LINE__, -5.592295342565443e+22, "-6.E+22", "%#3.G"},
+ {__LINE__, -5.600007421926053e+07, "-56000074.219261", "%1f"},
+ {__LINE__, -5.601444553155006e-12, "-5.60144E-12", "%G"},
+ {__LINE__, -5.605128912835080e-03, "-0.005605", "%+f"},
+ {__LINE__, -5.610950285679577e+19, "-5.61095E+19", "%G"},
+ {__LINE__, -5.622074657679467e+11, "-562207465767.946690", "%f"},
+ {__LINE__, -5.627358352391656e-01, "-0.6", "%1.g"},
+ {__LINE__, -5.627974317622488e-02, "-5.627974e-02", "%+e"},
+ {__LINE__, -5.629497696447229e+27, "-5.629E+27", "%+.4G"},
+ {__LINE__, -5.631383567258576e-29, "-5.63138e-29", "%0g"},
+ {__LINE__, -5.635241327177333e-18, "-5.63524E-18", "%G"},
+ {__LINE__, -5.644819783138381e+06, "-5.644820E+06", "%#E"},
+ {__LINE__, -5.648538459114833e+26, "-564853845911483265496144667.849876", "%+f"},
+ {__LINE__, -5.649004865848537e+00, "-5.649", "%g"},
+ {__LINE__, -5.653403316885170e+23, "-6E+23", "%2.0E"},
+ {__LINE__, -5.656109962244926e-18, "-0.000000", "%f"},
+ {__LINE__, -5.674988031695793e+22, "-5.674988E+22", "%+.7G"},
+ {__LINE__, -5.686380226400881e-22, "-0.000000", "%f"},
+ {__LINE__, -5.698840855829442e-14, "-5.69884E-14", "%G"},
+ {__LINE__, -5.707036642649580e+03, "-5707.036643", "%f"},
+ {__LINE__, -5.710344882278847e+11, "-5.71034E+11", "%+G"},
+ {__LINE__, -5.714852196401017e+19, "-5.71485E+19", "%+G"},
+ {__LINE__, -5.720153622156089e-22, "-5.72015E-22", "%G"},
+ {__LINE__, -5.722366011976922e+26, "-5.72237e+26", "%+g"},
+ {__LINE__, -5.722909928097404e+12, "-5.72291E+12", "%2G"},
+ {__LINE__, -5.725325961787777e-25, "-5.72533e-25", "%g"},
+ {__LINE__, -5.727138241052646e+19, "-5.72714e+19", "%+#g"},
+ {__LINE__, -5.734025840446336e+14, "-5.73403e+14", "%+g"},
+ {__LINE__, -5.736469106710259e-05, "-0.000057", "%.6f"},
+ {__LINE__, -5.755099153733116e-14, "-5.7551e-14", "%+g"},
+ {__LINE__, -5.758411844890947e-20, "-6E-20", "%+6.G"},
+ {__LINE__, -5.760350214122813e+03, "-5760.35", "%+g"},
+ {__LINE__, -5.768009192512392e-30, "-0", "%1.f"},
+ {__LINE__, -5.772343286693103e+07, "-5.77234E+07", "%G"},
+ {__LINE__, -5.776693265471852e-27, "-5.776693E-27", "%E"},
+ {__LINE__, -5.779682861172754e-28, "-5.779683e-28", "%e"},
+ {__LINE__, -5.789953490749936e+26, "-578995349074993637117358957.76656", "%5.5f"},
+ {__LINE__, -5.796771264754334e+04, "-57967.7", "%g"},
+ {__LINE__, -5.804788370597286e-02, "-5.80479E-02", "%+#1.5E"},
+ {__LINE__, -5.805343475329215e-13, "-5.80534e-13", "%g"},
+ {__LINE__, -5.809853913830122e+09, "-5809853914", "%+0.f"},
+ {__LINE__, -5.817313814570609e-30, " -0", "%7.0f"},
+ {__LINE__, -5.831708441750138e+00, "-5.83171", "%#g"},
+ {__LINE__, -5.846914550593652e+29, "-5.846915e+29", "%e"},
+ {__LINE__, -5.851455214762288e+04, "-58514.6", "%+G"},
+ {__LINE__, -5.855803663871393e-23, "-6E-23", "%5.E"},
+ {__LINE__, -5.858065129988470e+10, "-5.85807e+10", "%+g"},
+ {__LINE__, -5.863147168075411e-14, "-5.86315e-14", "%+g"},
+ {__LINE__, -5.878936740266680e-04, "-0.000587894", "%g"},
+ {__LINE__, -5.887654893386630e+25, "-58876548933866299506689756.526612", "%#f"},
+ {__LINE__, -5.889416409731902e-02, "-0.06", "%5.g"},
+ {__LINE__, -5.897630195029892e-18, "-5.897630E-18", "%#0.7G"},
+ {__LINE__, -5.898506808456422e-19, "-5.89851E-19", "%G"},
+ {__LINE__, -5.901768645393515e+29, "-5.90177E+29", "%+G"},
+ {__LINE__, -5.907529093570369e+10, "-59075290935.703695", "%f"},
+ {__LINE__, -5.910069365260240e+13, "-59100693652602.39849", "%+#5.5f"},
+ {__LINE__, -5.915678929676435e-07, "-0.000001", "%+f"},
+ {__LINE__, -5.922232380131716e-01, "-0.592223", "%+3f"},
+ {__LINE__, -5.923716473994306e+19, "-5.92372E+19", "%+#.6G"},
+ {__LINE__, -5.929950428920404e-15, "-5.929950e-15", "%+e"},
+ {__LINE__, -5.949552735665802e+26, "-5.94955e+26", "%#g"},
+ {__LINE__, -5.949977081310732e-02, "-0.059500", "%f"},
+ {__LINE__, -5.954520303889356e-07, "-5.954520E-07", "%5E"},
+ {__LINE__, -5.978861337429145e-13, "-6E-13", "%1.G"},
+ {__LINE__, -5.980539445081087e+15, "-5.98054E+15", "%.6G"},
+ {__LINE__, -5.981724990853490e-03, " -0.006", "%#7.g"},
+ {__LINE__, -5.989488907825821e+03, "-6E+03", "%.2G"},
+ {__LINE__, -5.998272294890842e+06, "-6.00E+06", "%4.2E"},
+ {__LINE__, -6.023775731455919e-29, "-6.023776e-29", "%e"},
+ {__LINE__, -6.028153126666870e-05, "-6.e-05", "%+#6.e"},
+ {__LINE__, -6.036200621484690e+25, "-6e+25", "%2.2g"},
+ {__LINE__, -6.036400640928137e-14, "-6.036401e-14", "%e"},
+ {__LINE__, -6.038198451098329e-20, "-6.038198e-20", "%1.7g"},
+ {__LINE__, -6.045778975641123e-15, "-6.04578E-15", "%G"},
+ {__LINE__, -6.046038904252073e+00, "-6.04604", "%g"},
+ {__LINE__, -6.082158462782175e-06, "-0.000006", "%+#f"},
+ {__LINE__, -6.106162726644904e+10, "-6.10616e+10", "%g"},
+ {__LINE__, -6.126345215489182e+10, "-6e+10", "%+1.g"},
+ {__LINE__, -6.131852309620571e+02, "-6e+02", "%4.e"},
+ {__LINE__, -6.134589313243809e-01, "-0.613459", "%+#f"},
+ {__LINE__, -6.142358153783462e-10, "-6.14236E-10", "%4G"},
+ {__LINE__, -6.151524334856263e+27, "-6151524334856262932191839354.345575", "%+6f"},
+ {__LINE__, -6.156818333724550e+04, "-6.e+04", "%#.1g"},
+ {__LINE__, -6.166172551433993e+24, "-6166172551433993120895138.4178", "%5.4f"},
+ {__LINE__, -6.169532428006014e-09, "-6.16953e-09", "%3g"},
+ {__LINE__, -6.172019382601770e-28, "-0.000000", "%+f"},
+ {__LINE__, -6.174496985807155e-09, "-6.1745E-09", "%G"},
+ {__LINE__, -6.186771845105751e+04, "-61867.7", "%G"},
+ {__LINE__, -6.200817973780066e+22, "-6.20082E+22", "%3G"},
+ {__LINE__, -6.218004335456301e-22, "-0.000000", "%+f"},
+ {__LINE__, -6.219009630546262e-18, "-6.22e-18", "%6.3g"},
+ {__LINE__, -6.242532875230618e-06, "-0.000006", "%7f"},
+ {__LINE__, -6.243612261280864e+14, "-6.24361e+14", "%.6g"},
+ {__LINE__, -6.243689597320126e+10, "-6e+10", "%.0e"},
+ {__LINE__, -6.244620667090527e+04, "-6e+04", "%6.e"},
+ {__LINE__, -6.250789625572054e-09, "-0.000000", "%+f"},
+ {__LINE__, -6.253537566219164e+01, "-63.", "%#1.f"},
+ {__LINE__, -6.284420289484166e+21, "-6.2844203e+21", "%7.7e"},
+ {__LINE__, -6.285939888202846e+27, "-6e+27", "%+.0g"},
+ {__LINE__, -6.290025777678105e+13, "-6E+13", "%2.E"},
+ {__LINE__, -6.291364254323924e+10, "-6.3E+10", "%3.2G"},
+ {__LINE__, -6.292428812164449e+15, "-6292428812164448.714839", "%.6f"},
+ {__LINE__, -6.292600606358002e+29, "-6.29260E+29", "%#G"},
+ {__LINE__, -6.292739629144148e-15, "-6.292740E-15", "%E"},
+ {__LINE__, -6.296471626465745e+28, "-6.29647E+28", "%G"},
+ {__LINE__, -6.299575066640315e+27, "-6.300E+27", "%.3E"},
+ {__LINE__, -6.315234679394876e-24, "-6E-24", "%2.G"},
+ {__LINE__, -6.320883246383228e-01, "-0.632088", "%2g"},
+ {__LINE__, -6.324938413548937e-11, "-6e-11", "%.1g"},
+ {__LINE__, -6.336312983176250e+04, "-6.336313e+04", "%e"},
+ {__LINE__, -6.341786787214541e+06, "-6.341787E+06", "%+7.6E"},
+ {__LINE__, -6.360189291106185e-15, "-0.0000000", "%#.7f"},
+ {__LINE__, -6.364818355457748e-15, "-0.0000000", "%1.7f"},
+ {__LINE__, -6.366291103431814e+04, "-63662.9", "%#G"},
+ {__LINE__, -6.366334042923153e-05, "-6.37e-05", "%5.3g"},
+ {__LINE__, -6.370477455143194e-12, "-0.000000", "%f"},
+ {__LINE__, -6.372829256546279e+23, "-6.37283E+23", "%G"},
+ {__LINE__, -6.375208490193110e-23, "-6.37521e-23", "%4.5e"},
+ {__LINE__, -6.382595100891736e-24, "-6.3826E-24", "%5G"},
+ {__LINE__, -6.396882421146790e-22, "-6.39688e-22", "%+g"},
+ {__LINE__, -6.407190354039938e+08, "-6.40719e+08", "%+g"},
+ {__LINE__, -6.408581541430886e-10, "-6.E-10", "%#0.0G"},
+ {__LINE__, -6.409206904981703e-03, "-0.006", "%+.0G"},
+ {__LINE__, -6.416106714707772e+26, "-641610671470777216285341637.558304", "%f"},
+ {__LINE__, -6.417436981761998e-04, "-0.000642", "%+#f"},
+ {__LINE__, -6.429997249673124e+11, "-642999724967.312414", "%#f"},
+ {__LINE__, -6.440827429825250e+16, "-6.44083E+16", "%G"},
+ {__LINE__, -6.444869858444955e+02, "-6e+02", "%6.g"},
+ {__LINE__, -6.471701890976228e-25, " -6e-25", "%7.1g"},
+ {__LINE__, -6.485393161670371e-12, "-6.485393e-12", "%.6e"},
+ {__LINE__, -6.487710907063584e+23, "-6.E+23", "%#3.E"},
+ {__LINE__, -6.492942931343439e-08, "-0.", "%+#2.0f"},
+ {__LINE__, -6.496010652113223e+18, "-6.49601e+18", "%g"},
+ {__LINE__, -6.502856921840228e+22, "-6.50286e+22", "%4g"},
+ {__LINE__, -6.523559906055000e-10, "-6.52356E-10", "%.6G"},
+ {__LINE__, -6.525899074126662e+04, "-6.5e+04", "%+.1e"},
+ {__LINE__, -6.532216801155521e-09, "-6.53222E-09", "%G"},
+ {__LINE__, -6.544601787025684e-27, "-0", "%+.0f"},
+ {__LINE__, -6.558968312132168e-01, " -1", "%+6.f"},
+ {__LINE__, -6.559654261655786e+08, "-6.559654e+08", "%e"},
+ {__LINE__, -6.566562622196495e-21, "-6.56656E-21", "%.6G"},
+ {__LINE__, -6.573486832071960e+04, "-65734.9", "%G"},
+ {__LINE__, -6.573806290918275e+13, "-6.57381E+13", "%G"},
+ {__LINE__, -6.578113771674787e+17, "-6.57811E+17", "%+#G"},
+ {__LINE__, -6.584106931007506e+15, "-6.584107E+15", "%E"},
+ {__LINE__, -6.590538844308877e+07, "-65905388.443089", "%f"},
+ {__LINE__, -6.593708834068371e-07, "-0.000001", "%f"},
+ {__LINE__, -6.597116446195875e+08, "-6.5971164e+08", "%#1.7e"},
+ {__LINE__, -6.605813542127091e-04, "-0.0007", "%+0.g"},
+ {__LINE__, -6.607491403866429e+07, "-7e+07", "%3.g"},
+ {__LINE__, -6.616499847522278e+09, "-6.61650E+09", "%+#G"},
+ {__LINE__, -6.618619768691332e+20, "-7E+20", "%2.G"},
+ {__LINE__, -6.626748168962331e-22, "-7.E-22", "%+#3.E"},
+ {__LINE__, -6.639335450348280e+12, "-6.63934e+12", "%g"},
+ {__LINE__, -6.643910144912576e-03, "-0.006644", "%f"},
+ {__LINE__, -6.650293872031870e-18, "-6.65029e-18", "%+#g"},
+ {__LINE__, -6.654903858656310e-21, "-0.000000", "%f"},
+ {__LINE__, -6.665834666726511e-12, "-6.665835E-12", "%E"},
+ {__LINE__, -6.666428729917570e-19, "-0.000000", "%+#f"},
+ {__LINE__, -6.668415789681128e+27, "-6.66842E+27", "%+G"},
+ {__LINE__, -6.675214676269601e-28, "-6.67521e-28", "%#g"},
+ {__LINE__, -6.679560072732262e+01, "-66.7956", "%#g"},
+ {__LINE__, -6.692325075457020e-19, "-0.000000", "%1f"},
+ {__LINE__, -6.697096655164652e+00, "-6.70", "%#.3g"},
+ {__LINE__, -6.712436135928394e-28, "-7e-28", "%0.g"},
+ {__LINE__, -6.720769486122685e-16, "-7e-16", "%0.e"},
+ {__LINE__, -6.727196898490600e+26, "-672719689849060031860972230.8", "%.1f"},
+ {__LINE__, -6.744132627576416e+02, "-674.413", "%6G"},
+ {__LINE__, -6.757705576425288e+28, "-6.7577056e+28", "%.7e"},
+ {__LINE__, -6.760554929237173e-02, "-0.067606", "%+f"},
+ {__LINE__, -6.763538810629361e+10, "-6.7635E+10", "%.4E"},
+ {__LINE__, -6.764712008860796e-29, "-6.76471E-29", "%+G"},
+ {__LINE__, -6.767299719678443e+04, "-67672.997197", "%f"},
+ {__LINE__, -6.768326491352134e+20, "-676832649135213415547.70", "%+.2f"},
+ {__LINE__, -6.771116968952891e+03, "-7E+03", "%3.1G"},
+ {__LINE__, -6.775218099238350e-30, "-7.e-30", "%+#6.g"},
+ {__LINE__, -6.782142689928918e-18, "-0.00", "%4.2f"},
+ {__LINE__, -6.795409770512149e+08, "-7E+08", "%+5.0G"},
+ {__LINE__, -6.820966157097271e+14, "-6.820966e+14", "%e"},
+ {__LINE__, -6.824972990592273e-22, "-0.00", "%+#1.2f"},
+ {__LINE__, -6.830452914741750e+29, "-6.8E+29", "%+7.2G"},
+ {__LINE__, -6.835797187132348e+10, "-6.8358E+10", "%+5G"},
+ {__LINE__, -6.837040829636343e-03, "-0.00683704", "%+g"},
+ {__LINE__, -6.852956218658224e+23, "-6.85296e+23", "%3g"},
+ {__LINE__, -6.854102607287217e-26, "-7e-26", "%5.e"},
+ {__LINE__, -6.865065870249438e+16, "-6.86507E+16", "%#G"},
+ {__LINE__, -6.884819522625523e-13, "-6.88482E-13", "%5G"},
+ {__LINE__, -6.916316600148513e-12, "-0.000000", "%f"},
+ {__LINE__, -6.925312418761560e-05, "-6.92531E-05", "%#G"},
+ {__LINE__, -6.929518694178331e+09, "-6929518694.178", "%#.3f"},
+ {__LINE__, -6.936008056682024e+02, "-6.936008E+02", "%E"},
+ {__LINE__, -6.944911117352400e+26, "-6.944911E+26", "%1.6E"},
+ {__LINE__, -6.945829492125162e+05, "-6.9e+05", "%+2.2g"},
+ {__LINE__, -6.946603162471856e-13, "-6.94660E-13", "%#G"},
+ {__LINE__, -6.947529440406653e+22, "-6.9475e+22", "%+6.5g"},
+ {__LINE__, -6.950167604854856e-30, "-0.000000", "%7f"},
+ {__LINE__, -6.958122319262799e-26, "-7E-26", "%+1.E"},
+ {__LINE__, -6.958978258390961e+16, "-6.95898E+16", "%+5.6G"},
+ {__LINE__, -6.963780466334008e-06, "-6.96378E-06", "%2G"},
+ {__LINE__, -6.965570896221966e+13, "-6.965571E+13", "%5E"},
+ {__LINE__, -6.967741871945064e-10, "-6.96774E-10", "%+#G"},
+ {__LINE__, -6.973815739524307e+19, "-69738157395243067782.076", "%6.3f"},
+ {__LINE__, -6.982714545008106e+13, "-6.98271e+13", "%g"},
+ {__LINE__, -6.985955885054476e+03, "-6985.96", "%6G"},
+ {__LINE__, -6.986415266835747e+18, "-6.98642e+18", "%#g"},
+ {__LINE__, -6.996461529596512e-08, "-7.0E-08", "%#.1E"},
+ {__LINE__, -7.000144914012241e-05, "-7.00014e-05", "%#g"},
+ {__LINE__, -7.001017894492730e-03, "-0.00700102", "%+#.6G"},
+ {__LINE__, -7.003690685875917e+20, "-7E+20", "%0.G"},
+ {__LINE__, -7.010454163965384e+00, "-7.010454e+00", "%+e"},
+ {__LINE__, -7.011493550018082e-26, " -0", "%7.f"},
+ {__LINE__, -7.018018443394008e+21, "-7.0E+21", "%+#1.1E"},
+ {__LINE__, -7.027253777387243e-05, "-7.02725E-05", "%+G"},
+ {__LINE__, -7.043679213677740e-17, "-0", "%1.f"},
+ {__LINE__, -7.051690489227881e-16, "-7.052e-16", "%0.4g"},
+ {__LINE__, -7.063422475274161e-16, "-7.063422E-16", "%E"},
+ {__LINE__, -7.065069592235558e-30, "-7.06507e-30", "%+#g"},
+ {__LINE__, -7.068265283935834e-29, "-7e-29", "%+5.e"},
+ {__LINE__, -7.068748224536295e-13, "-0.000000", "%f"},
+ {__LINE__, -7.069621910708177e-04, "-0.000707", "%1.3g"},
+ {__LINE__, -7.079725450964823e-12, "-0.000000", "%f"},
+ {__LINE__, -7.087255464668218e+17, "-7.1e+17", "%.1e"},
+ {__LINE__, -7.088715102009605e-09, "-7e-09", "%6.0g"},
+ {__LINE__, -7.090414916270137e-15, "-0.00000", "%.5f"},
+ {__LINE__, -7.091868311008428e-03, " -0.0", "%5.1f"},
+ {__LINE__, -7.094242165237718e+21, "-7.09424e+21", "%+g"},
+ {__LINE__, -7.094324305740325e-05, "-7E-05", "%+3.G"},
+ {__LINE__, -7.104544752289144e+04, "-71045.4", "%#g"},
+ {__LINE__, -7.105164644813694e-29, "-0.000000", "%+f"},
+ {__LINE__, -7.114513164219487e-12, "-7.11451e-12", "%+g"},
+ {__LINE__, -7.115778236604137e-12, "-7.11578E-12", "%G"},
+ {__LINE__, -7.126217683410162e-27, "-7.126218e-27", "%e"},
+ {__LINE__, -7.136214260967733e+28, "-71362142609677334803564008325.338364", "%f"},
+ {__LINE__, -7.143452595522573e+19, "-7.14345e+19", "%g"},
+ {__LINE__, -7.156042088843537e+27, "-7156042088843537207765166385.7977837", "%4.7f"},
+ {__LINE__, -7.173687683710490e+24, "-7.17369e+24", "%6g"},
+ {__LINE__, -7.190531162598206e+25, "-71905311625982060164119503", "%4.f"},
+ {__LINE__, -7.201301831373747e-09, "-7.2013e-09", "%g"},
+ {__LINE__, -7.209601436737306e+10, "-7.2096e+10", "%g"},
+ {__LINE__, -7.211058997356655e-06, "-7.211059E-06", "%E"},
+ {__LINE__, -7.226756177676272e-09, "-7.22676E-09", "%+G"},
+ {__LINE__, -7.230870817566419e+19, "-72308708175664193618.1040364", "%#.7f"},
+ {__LINE__, -7.231355992133345e-05, "-7.231356E-05", "%#E"},
+ {__LINE__, -7.245999575278407e-12, "-7.246e-12", "%g"},
+ {__LINE__, -7.247426403040390e-09, "-7.2474E-09", "%+4.5G"},
+ {__LINE__, -7.257348680308567e-12, "-7.3E-12", "%1.2G"},
+ {__LINE__, -7.258184256387366e-26, "-7.25818E-26", "%+2G"},
+ {__LINE__, -7.262633672900126e+10, "-7.26263e+10", "%#g"},
+ {__LINE__, -7.268887462426250e+03, "-7.268887e+03", "%+#e"},
+ {__LINE__, -7.275284494682963e+08, "-7.27528e+08", "%g"},
+ {__LINE__, -7.276335846256479e-07, " -0", "%4.f"},
+ {__LINE__, -7.312556378294452e+15, "-7.31256e+15", "%+6g"},
+ {__LINE__, -7.334763752442417e-15, "-0.0000", "%#.4f"},
+ {__LINE__, -7.354627097325888e-18, "-7E-18", "%0.E"},
+ {__LINE__, -7.360087573342401e-25, "-7.4E-25", "%6.2G"},
+ {__LINE__, -7.368533563361098e-29, "-7.4E-29", "%3.1E"},
+ {__LINE__, -7.379267723540596e-06, "-0.000007", "%f"},
+ {__LINE__, -7.384525781709565e-19, "-0.000000", "%+#f"},
+ {__LINE__, -7.388940868679677e-09, "-7.388941E-09", "%E"},
+ {__LINE__, -7.391602149099698e+00, "-7.391602E+00", "%E"},
+ {__LINE__, -7.393159340196723e+22, "-7.39316e+22", "%#2.6g"},
+ {__LINE__, -7.399783260198277e-16, "-7.39978E-16", "%G"},
+ {__LINE__, -7.405609590448331e-06, "-7.40561e-06", "%g"},
+ {__LINE__, -7.407396977847794e-11, "-7.40740E-11", "%#G"},
+ {__LINE__, -7.433716848698637e+20, "-7.43372e+20", "%+g"},
+ {__LINE__, -7.444176062769411e-01, "-0.744418", "%#g"},
+ {__LINE__, -7.448314697244012e+12, "-7448314697244.011739", "%f"},
+ {__LINE__, -7.449533988369018e+08, "-7.449534e+08", "%+#7e"},
+ {__LINE__, -7.465682839758801e-01, "-7E-01", "%4.E"},
+ {__LINE__, -7.466517843126368e-26, "-7.5E-26", "%.1E"},
+ {__LINE__, -7.471385785539900e+24, "-7471385785539899515583783.795591", "%f"},
+ {__LINE__, -7.478345583780341e+00, "-7.478346e+00", "%e"},
+ {__LINE__, -7.524759284626724e-06, "-7.52476e-06", "%2g"},
+ {__LINE__, -7.534831049342539e-19, "-7.53483E-19", "%G"},
+ {__LINE__, -7.540546673179273e+15, "-8e+15", "%.1g"},
+ {__LINE__, -7.543440436184003e-08, "-7.54344E-08", "%6G"},
+ {__LINE__, -7.558224240835564e-06, "-7.55822e-06", "%g"},
+ {__LINE__, -7.564132915154469e+23, "-756413291515446850610260.298708", "%+f"},
+ {__LINE__, -7.566590720355392e+15, "-7.566591e+15", "%1.6e"},
+ {__LINE__, -7.568565927479741e-01, "-7.568566e-01", "%#6e"},
+ {__LINE__, -7.615574141973305e-17, "-7.6156e-17", "%+.5g"},
+ {__LINE__, -7.641297631509318e-28, "-8e-28", "%+.1g"},
+ {__LINE__, -7.661227834163450e+09, "-7661227834.1634497", "%+#.7f"},
+ {__LINE__, -7.665934364070126e+11, "-766593436407.0", "%.1f"},
+ {__LINE__, -7.682500068463102e-27, "-0.000000", "%+#f"},
+ {__LINE__, -7.709363160273798e+15, "-7.70936e+15", "%g"},
+ {__LINE__, -7.712596019255238e+26, "-7.7e+26", "%.2g"},
+ {__LINE__, -7.730213358437991e+25, "-7.7e+25", "%6.2g"},
+ {__LINE__, -7.744420019068976e+05, "-7.74442E+05", "%.5E"},
+ {__LINE__, -7.745813181942296e+11, "-7.7458132e+11", "%+.7e"},
+ {__LINE__, -7.751004379716307e+16, "-7.751004e+16", "%e"},
+ {__LINE__, -7.759862226564527e-28, "-7.75986e-28", "%g"},
+ {__LINE__, -7.767838880221207e-27, "-7.76784e-27", "%g"},
+ {__LINE__, -7.776301142157532e-19, "-0", "%2.f"},
+ {__LINE__, -7.783944257077553e-14, "-8e-14", "%3.g"},
+ {__LINE__, -7.801587579382377e+28, "-8e+28", "%+0.g"},
+ {__LINE__, -7.806685979552780e+25, "-7.806686E+25", "%E"},
+ {__LINE__, -7.825968891331719e-05, "-7.82597E-05", "%G"},
+ {__LINE__, -7.826834158664018e+12, "-7.826834E+12", "%+#E"},
+ {__LINE__, -7.832536798726886e+24, "-7.83254E+24", "%#1G"},
+ {__LINE__, -7.840485340202362e-18, "-0.000000", "%.6f"},
+ {__LINE__, -7.843236212099233e+21, "-7.84324e+21", "%g"},
+ {__LINE__, -7.906644052019278e-13, "-7.906644E-13", "%E"},
+ {__LINE__, -7.908090440678874e-20, "-7.90809E-20", "%#G"},
+ {__LINE__, -7.917588593012283e+08, "-7.917589E+08", "%+E"},
+ {__LINE__, -7.929100086742454e+29, "-792910008674245414539427656563.930213", "%f"},
+ {__LINE__, -7.933235286034290e+26, "-7.933235E+26", "%E"},
+ {__LINE__, -7.943431966567875e-03, "-0.0079434", "%+.5g"},
+ {__LINE__, -7.950872643572970e-22, "-7.95087e-22", "%2g"},
+ {__LINE__, -7.971225555313069e-01, "-0.797123", "%f"},
+ {__LINE__, -7.978310272676090e-12, "-0.000000", "%#f"},
+ {__LINE__, -8.006805393896414e-29, "-8.00681E-29", "%G"},
+ {__LINE__, -8.006906303018830e+25, "-8.00691E+25", "%+G"},
+ {__LINE__, -8.008484654476057e+18, "-8.008485e+18", "%5.6e"},
+ {__LINE__, -8.008943512904249e+27, "-8008943512904249217854157905.0943", "%+.4f"},
+ {__LINE__, -8.016539743121665e+27, "-8.01654E+27", "%G"},
+ {__LINE__, -8.018247227006128e-05, " -8E-05", "%7.G"},
+ {__LINE__, -8.044391842561705e+21, "-8.04439e+21", "%g"},
+ {__LINE__, -8.081902305002036e-02, "-8.081902E-02", "%E"},
+ {__LINE__, -8.084193011936438e-03, "-0.0080842", "%+5.5g"},
+ {__LINE__, -8.105813534846529e-27, "-0.000000", "%f"},
+ {__LINE__, -8.128116892989251e+00, "-8.12812", "%G"},
+ {__LINE__, -8.136119035731877e+05, "-8e+05", "%+0.g"},
+ {__LINE__, -8.140584224052606e+14, "-8E+14", "%5.G"},
+ {__LINE__, -8.145928897003907e+13, "-8.15E+13", "%.3G"},
+ {__LINE__, -8.164495905907508e-02, "-0.081645", "%G"},
+ {__LINE__, -8.169602113313905e+20, "-8.16960e+20", "%#g"},
+ {__LINE__, -8.179181640418333e+24, "-8.E+24", "%#.1G"},
+ {__LINE__, -8.184324492264231e-18, "-8.18432E-18", "%G"},
+ {__LINE__, -8.186480473850516e-28, "-0.000000", "%+f"},
+ {__LINE__, -8.196858948158896e+07, "-8.1969E+07", "%.4E"},
+ {__LINE__, -8.213138534699043e-30, "-0.000000", "%f"},
+ {__LINE__, -8.221181368676532e-21, "-8.221181E-21", "%#1E"},
+ {__LINE__, -8.222605734191438e+16, "-8.22261E+16", "%+G"},
+ {__LINE__, -8.223925661091432e-14, "-8.223926e-14", "%0e"},
+ {__LINE__, -8.232281541044777e-01, "-0.823228", "%f"},
+ {__LINE__, -8.245536794508725e+22, "-8E+22", "%6.G"},
+ {__LINE__, -8.270687365305925e+25, "-82706873653059247430974210.146815", "%f"},
+ {__LINE__, -8.288978945738204e+11, "-8.28898e+11", "%5g"},
+ {__LINE__, -8.290628698333139e+02, "-829.063", "%+G"},
+ {__LINE__, -8.292416206056451e-16, "-8.29242e-16", "%+g"},
+ {__LINE__, -8.296322623746486e-13, "-8.29632E-13", "%0.6G"},
+ {__LINE__, -8.298321941376933e-16, "-0.000000", "%+f"},
+ {__LINE__, -8.302331258878365e+29, "-8.30233E+29", "%0G"},
+ {__LINE__, -8.309022429255061e+06, "-8309022.429255", "%+f"},
+ {__LINE__, -8.312786829254646e-23, "-8.312787e-23", "%e"},
+ {__LINE__, -8.313852965178063e-15, "-8.313853e-15", "%#7e"},
+ {__LINE__, -8.317529094827869e+16, "-8.31753E+16", "%2G"},
+ {__LINE__, -8.322847660882248e-17, "-0.000000", "%f"},
+ {__LINE__, -8.324060602752638e-30, "-8.32406e-30", "%#g"},
+ {__LINE__, -8.325043500735461e+27, "-8325043500735461066142306663.095951", "%#f"},
+ {__LINE__, -8.332432016286935e-02, "-0.0833243", "%g"},
+ {__LINE__, -8.334251670232117e-09, "-8.33425e-09", "%g"},
+ {__LINE__, -8.338076225141778e+02, "-833.808", "%g"},
+ {__LINE__, -8.338349587571534e-23, "-8.33835e-23", "%+2g"},
+ {__LINE__, -8.342420812231939e+23, "-834242081223193920891390.00745", "%+0.5f"},
+ {__LINE__, -8.347404637940894e+17, "-8.347405e+17", "%+e"},
+ {__LINE__, -8.367002601133880e-12, "-0.000000", "%#2.6f"},
+ {__LINE__, -8.368579538210858e-17, "-8.36858e-17", "%5g"},
+ {__LINE__, -8.392398522472401e-10, "-0.0000", "%.4f"},
+ {__LINE__, -8.393029677635258e-29, " -8E-29", "%7.G"},
+ {__LINE__, -8.393843230819225e-11, "-8.393843E-11", "%E"},
+ {__LINE__, -8.397239871789148e-11, "-8.39724e-11", "%g"},
+ {__LINE__, -8.402316358199041e-29, "-0.000", "%3.3f"},
+ {__LINE__, -8.402910159034304e-14, "-8.4e-14", "%+0.3g"},
+ {__LINE__, -8.414960962391726e+09, "-8414960962.391726", "%#f"},
+ {__LINE__, -8.417512471384889e-28, "-8.417512e-28", "%e"},
+ {__LINE__, -8.418719240222911e+21, "-8418719240222911182058.851409", "%f"},
+ {__LINE__, -8.421210956044195e-09, "-0.00000", "%.5f"},
+ {__LINE__, -8.422001733529095e+24, "-8E+24", "%0.G"},
+ {__LINE__, -8.443614453772469e+21, "-8.44361E+21", "%+G"},
+ {__LINE__, -8.445883044175737e-19, "-0", "%+1.f"},
+ {__LINE__, -8.460545304711022e-01, "-0.846055", "%G"},
+ {__LINE__, -8.470462532754567e+12, "-8.47E+12", "%6.3G"},
+ {__LINE__, -8.478488782426476e-07, "-8.478489E-07", "%E"},
+ {__LINE__, -8.478657582923923e+09, "-8.5e+09", "%.2g"},
+ {__LINE__, -8.482732098043366e+12, "-8482732098043", "%5.f"},
+ {__LINE__, -8.489112373854447e+07, "-8.489e+07", "%#3.3e"},
+ {__LINE__, -8.494153144629106e+02, "-849.415", "%+g"},
+ {__LINE__, -8.496331191616493e+28, "-8E+28", "%+6.G"},
+ {__LINE__, -8.503711894495339e+05, "-850371", "%g"},
+ {__LINE__, -8.505271893964268e+14, "-8.505272E+14", "%E"},
+ {__LINE__, -8.509873985358741e+15, "-9.e+15", "%#7.g"},
+ {__LINE__, -8.518336897898081e-20, "-8.51834E-20", "%G"},
+ {__LINE__, -8.529588044136128e+21, "-8.529588E+21", "%E"},
+ {__LINE__, -8.539706586811079e-23, "-8.53971E-23", "%G"},
+ {__LINE__, -8.545924619642008e+10, "-8.545925e+10", "%6e"},
+ {__LINE__, -8.572893681637353e+09, "-8.57289E+09", "%G"},
+ {__LINE__, -8.585483717692345e+29, "-8.58548E+29", "%+G"},
+ {__LINE__, -8.586092014292309e+27, "-8.59e+27", "%.2e"},
+ {__LINE__, -8.604716827086833e-26, "-8.60472e-26", "%g"},
+ {__LINE__, -8.621349224186615e-04, "-0.000862", "%f"},
+ {__LINE__, -8.626097065201103e-21, " -0", "%5.f"},
+ {__LINE__, -8.631700514212522e-16, "-8.631701E-16", "%+E"},
+ {__LINE__, -8.634703359975640e-09, "-0.000000", "%+5f"},
+ {__LINE__, -8.639393025443855e-17, "-8.63939e-17", "%g"},
+ {__LINE__, -8.640641942556812e-11, "-8.64064e-11", "%#g"},
+ {__LINE__, -8.646260250525495e-09, "-0.000", "%.3f"},
+ {__LINE__, -8.667322015806242e+09, "-8667322015.806242", "%+#f"},
+ {__LINE__, -8.690705655554451e+10, "-8.690706E+10", "%#E"},
+ {__LINE__, -8.714299893763934e-07, "-8.7143E-07", "%.5G"},
+ {__LINE__, -8.715729756264988e+27, "-8.71573E+27", "%+.6G"},
+ {__LINE__, -8.716518487180945e+16, "-9e+16", "%3.e"},
+ {__LINE__, -8.744404488756237e+25, "-87444044887562366596966967.335902", "%4f"},
+ {__LINE__, -8.754720498369242e+13, "-8.75472e+13", "%g"},
+ {__LINE__, -8.763198097931010e-19, "-8.76320e-19", "%#g"},
+ {__LINE__, -8.779007408852458e+28, "-8.77901E+28", "%G"},
+ {__LINE__, -8.794576202907937e+11, "-8.79458E+11", "%#2.6G"},
+ {__LINE__, -8.799091520612418e-11, "-8.799E-11", "%3.4G"},
+ {__LINE__, -8.799246265524921e+11, "-8.79925E+11", "%G"},
+ {__LINE__, -8.809010508550436e-04, "-8.8090E-04", "%.4E"},
+ {__LINE__, -8.817389999872653e-10, "-8.81739e-10", "%g"},
+ {__LINE__, -8.842022428985267e-28, "-8.842022E-28", "%E"},
+ {__LINE__, -8.851265987586864e-07, "-0.000001", "%f"},
+ {__LINE__, -8.861985131432196e+03, "-8861.985", "%+.7G"},
+ {__LINE__, -8.874449013455113e-29, "-8.874449e-29", "%e"},
+ {__LINE__, -8.878752609483453e+18, "-8.87875E+18", "%G"},
+ {__LINE__, -8.882501665315313e-04, "-0.00088825", "%+G"},
+ {__LINE__, -8.892056241505784e-14, "-8.89206E-14", "%G"},
+ {__LINE__, -8.895327674961603e-30, "-8.89533E-30", "%G"},
+ {__LINE__, -8.900059462213669e-30, "-8.900059E-30", "%+#E"},
+ {__LINE__, -8.957100548759815e+18, "-9e+18", "%3.0e"},
+ {__LINE__, -8.961352369869012e-30, "-8.961352e-30", "%+#2e"},
+ {__LINE__, -8.962296474587800e+02, "-896", "%4.f"},
+ {__LINE__, -8.962536469328530e-12, "-8.96254E-12", "%G"},
+ {__LINE__, -8.963299420391932e+21, "-8.9633e+21", "%g"},
+ {__LINE__, -8.967736672941522e-11, "-8.96774e-11", "%g"},
+ {__LINE__, -8.994077362462679e+11, "-8.9940774e+11", "%+#.7e"},
+ {__LINE__, -9.000452862345622e+15, "-9e+15", "%2.e"},
+ {__LINE__, -9.007489135361462e+07, "-9.0075E+07", "%+2.4E"},
+ {__LINE__, -9.036271805879910e+16, "-9.03627E+16", "%G"},
+ {__LINE__, -9.036319073700248e+22, "-9.03632e+22", "%1g"},
+ {__LINE__, -9.043207635989237e+11, "-9.043208e+11", "%#e"},
+ {__LINE__, -9.043856598625815e-26, "-9e-26", "%+1.g"},
+ {__LINE__, -9.052760561065698e+14, "-9.052761E+14", "%E"},
+ {__LINE__, -9.066480297957160e-06, "-9E-06", "%+1.G"},
+ {__LINE__, -9.070971376440752e-01, "-0.907097", "%g"},
+ {__LINE__, -9.073301831888273e+09, "-9.07330E+09", "%#G"},
+ {__LINE__, -9.091228662702147e+28, "-9E+28", "%4.G"},
+ {__LINE__, -9.093652024983832e+04, "-9.093652E+04", "%7.6E"},
+ {__LINE__, -9.098945831139295e-04, "-9.098946E-04", "%+1.6E"},
+ {__LINE__, -9.124981449916591e+05, "-912498", "%G"},
+ {__LINE__, -9.132038703003394e-02, "-0.0913204", "%#G"},
+ {__LINE__, -9.138271437433964e-04, "-0.000913827", "%5g"},
+ {__LINE__, -9.158186427463699e-04, "-0.000915819", "%g"},
+ {__LINE__, -9.160846358172526e+16, "-9.160846E+16", "%#E"},
+ {__LINE__, -9.160884330810163e+17, "-9E+17", "%+5.G"},
+ {__LINE__, -9.190271387375542e+21, "-9.19027e+21", "%+g"},
+ {__LINE__, -9.191651872412619e-04, "-9.191652E-04", "%E"},
+ {__LINE__, -9.196426161984341e-10, "-9E-10", "%4.G"},
+ {__LINE__, -9.201074139774962e+09, "-9E+09", "%4.G"},
+ {__LINE__, -9.223294284802762e+09, "-9.22329E+09", "%G"},
+ {__LINE__, -9.224740266754996e+02, "-9E+02", "%6.0G"},
+ {__LINE__, -9.231583780512302e-01, " -0.9", "%6.g"},
+ {__LINE__, -9.241998826543689e+07, "-92419988", "%1.f"},
+ {__LINE__, -9.243603351372128e+27, "-9.243603e+27", "%#e"},
+ {__LINE__, -9.255922697415071e+11, "-9.25592e+11", "%g"},
+ {__LINE__, -9.265734968114124e-02, "-0.092657", "%f"},
+ {__LINE__, -9.273132068521061e+11, "-9.27313E+11", "%G"},
+ {__LINE__, -9.276017912826685e+27, "-9.E+27", "%+#5.G"},
+ {__LINE__, -9.279781279788505e+17, "-9.27978E+17", "%7G"},
+ {__LINE__, -9.305057549822465e-19, "-9.30506E-19", "%5G"},
+ {__LINE__, -9.313182384508469e+18, "-9.31318E+18", "%G"},
+ {__LINE__, -9.313350925182641e-12, "-9.31E-12", "%.3G"},
+ {__LINE__, -9.362202657509130e+08, "-9e+08", "%.1g"},
+ {__LINE__, -9.367344757598381e+19, "-9.36734e+19", "%g"},
+ {__LINE__, -9.374222399774300e+26, "-9.37422e+26", "%4g"},
+ {__LINE__, -9.385734023305105e+02, "-9.385734e+02", "%+0e"},
+ {__LINE__, -9.392042570618909e+17, "-9.39204E+17", "%G"},
+ {__LINE__, -9.395742939311926e+20, "-939574293931192627837.8451", "%.4f"},
+ {__LINE__, -9.409066155962469e+09, "-9.40907E+09", "%#G"},
+ {__LINE__, -9.412851077799790e+23, "-9.412851E+23", "%E"},
+ {__LINE__, -9.431808019049818e+08, "-9.43181e+08", "%g"},
+ {__LINE__, -9.465236900519924e-27, "-9.46524e-27", "%g"},
+ {__LINE__, -9.478330386415852e+17, "-9.478330e+17", "%e"},
+ {__LINE__, -9.510393719697428e+15, "-9.51039E+15", "%+G"},
+ {__LINE__, -9.534229599909890e-09, "-0.000000", "%f"},
+ {__LINE__, -9.541731189284823e-17, "-1.E-16", "%+#7.G"},
+ {__LINE__, -9.548861908445902e+24, "-9548861908445902102471336.547751", "%f"},
+ {__LINE__, -9.578447281451794e+14, "-957844728145179", "%5.f"},
+ {__LINE__, -9.580512736933464e+11, "-9.58051E+11", "%G"},
+ {__LINE__, -9.596838169770637e-28, "-1E-27", "%+6.G"},
+ {__LINE__, -9.597528852877852e-22, "-1e-21", "%2.1g"},
+ {__LINE__, -9.599943658427051e+02, "-9.599944E+02", "%E"},
+ {__LINE__, -9.603227991185260e-14, "-1E-13", "%+0.E"},
+ {__LINE__, -9.606818733892343e+08, "-960681873.389", "%1.3f"},
+ {__LINE__, -9.617442692720937e+16, "-9.61744E+16", "%G"},
+ {__LINE__, -9.628685516961109e+29, "-9.62869e+29", "%3g"},
+ {__LINE__, -9.638354750455226e-11, "-0.000000", "%f"},
+ {__LINE__, -9.644266379029137e+16, "-96442663790291369.707575", "%f"},
+ {__LINE__, -9.645563533575482e+06, "-1E+07", "%1.G"},
+ {__LINE__, -9.645993536742941e-29, "-9.64599e-29", "%+g"},
+ {__LINE__, -9.647147223548563e+00, "-9.647147e+00", "%e"},
+ {__LINE__, -9.671225879906396e-11, "-0", "%0.f"},
+ {__LINE__, -9.675000471729906e-09, "-9.675000E-09", "%E"},
+ {__LINE__, -9.683992878297159e-26, "-9.68e-26", "%2.2e"},
+ {__LINE__, -9.695491325144765e+10, "-9.69549E+10", "%#G"},
+ {__LINE__, -9.695661526907136e-24, " -0.", "%#6.f"},
+ {__LINE__, -9.703124881970338e+07, "-9.703e+07", "%0.4g"},
+ {__LINE__, -9.707701257031864e+26, "-970770125703186437249314622.022212", "%f"},
+ {__LINE__, -9.709879792694702e+09, "-9.709880E+09", "%E"},
+ {__LINE__, -9.736052226907940e+26, "-9.73605e+26", "%+#g"},
+ {__LINE__, -9.745037157520795e+07, "-9.74504e+07", "%#5.6g"},
+ {__LINE__, -9.757293950670832e-29, "-9.757E-29", "%0.4G"},
+ {__LINE__, -9.762126832689880e+12, "-9.76213E+12", "%G"},
+ {__LINE__, -9.801328150341989e-01, " -1", "%7.G"},
+ {__LINE__, -9.837332964629669e-20, "-9.83733E-20", "%0G"},
+ {__LINE__, -9.837790327283010e+23, "-1E+24", "%.1G"},
+ {__LINE__, -9.839636176463729e+23, "-9.83964E+23", "%#6.5E"},
+ {__LINE__, -9.841454250618272e+11, "-9.84E+11", "%+2.3G"},
+ {__LINE__, -9.852920805249280e-12, "-9.852921e-12", "%.7g"},
+ {__LINE__, -9.854092850182351e+12, "-9.85409e+12", "%0g"},
+ {__LINE__, -9.866796026839712e+02, "-9.9E+02", "%#.1E"},
+ {__LINE__, -9.867413260289803e-21, "-1e-20", "%.1g"},
+ {__LINE__, -9.882136052131983e-08, "-9.88214e-08", "%g"},
+ {__LINE__, -9.882755697941866e+20, "-9.882756E+20", "%E"},
+ {__LINE__, -9.897275811087050e+20, "-9.9E+20", "%0.3G"},
+ {__LINE__, -9.899860651812364e-04, "-9.899861e-04", "%e"},
+ {__LINE__, -9.906754113555550e-11, "-9.90675e-11", "%3g"},
+ {__LINE__, -9.926067557389940e+11, "-9.92607E+11", "%G"},
+ {__LINE__, -9.929638609014063e+17, "-992963860901406292.214233", "%1f"},
+ {__LINE__, -9.941214552193284e-24, "-0.000000", "%+#f"},
+ {__LINE__, -9.942875240256573e+14, "-9.942875e+14", "%+1e"},
+ {__LINE__, -9.944492909695798e-01, "-9.944E-01", "%.3E"},
+ {__LINE__, -9.954710507359939e-27, "-1e-26", "%+0.2g"},
+ {__LINE__, -9.955410507742851e+03, "-9955.41", "%+G"},
+ {__LINE__, -9.974437672251590e+02, "-997.444", "%#G"},
+ {__LINE__, -9.975683165288929e-26, "-9.97568E-26", "%6G"},
+ {__LINE__, 1.003827370583415e+06, "1003827.370583", "%3f"},
+ {__LINE__, 1.004189065268560e-27, "1.004189E-27", "%.7G"},
+ {__LINE__, 1.005840059175462e-28, "+1.00584E-28", "%+G"},
+ {__LINE__, 1.006586790090557e-12, "0.000000", "%#f"},
+ {__LINE__, 1.007598594773359e+18, "1.0076E+18", "%G"},
+ {__LINE__, 1.007902307001894e+29, "1.0079e+29", "%g"},
+ {__LINE__, 1.008607405036580e-15, "1.00861E-15", "%6G"},
+ {__LINE__, 1.008769102466771e+16, "+1.00877E+16", "%+G"},
+ {__LINE__, 1.009545698372534e-08, "+1E-08", "%+0.0G"},
+ {__LINE__, 1.010173673945099e-12, "+1.01017e-12", "%+#0g"},
+ {__LINE__, 1.011375000606627e+09, "1011375000.606627", "%f"},
+ {__LINE__, 1.011944652221650e+15, "1011944652221649.98", "%3.2f"},
+ {__LINE__, 1.013057788090379e-21, "0.000000", "%#f"},
+ {__LINE__, 1.014525729953198e+15, "1.01453e+15", "%3g"},
+ {__LINE__, 1.016760538234615e-21, "+1.016761E-21", "%+3E"},
+ {__LINE__, 1.017052611781237e-29, "0.000000", "%f"},
+ {__LINE__, 1.018471223361229e+14, "1.01847E+14", "%G"},
+ {__LINE__, 1.021646959220873e+15, "1021646959220872.6", "%4.1f"},
+ {__LINE__, 1.022304833976590e+27, "1.0223e+27", "%g"},
+ {__LINE__, 1.022500312067325e-12, "1.0225e-12", "%6g"},
+ {__LINE__, 1.023019285462627e-20, "0.000000", "%f"},
+ {__LINE__, 1.024192579400824e+06, "1.02419e+06", "%g"},
+ {__LINE__, 1.024517953555766e-28, "1.02452E-28", "%G"},
+ {__LINE__, 1.026673589339585e+21, "1.02667E+21", "%G"},
+ {__LINE__, 1.027231090958880e-19, "1.E-19", "%#3.G"},
+ {__LINE__, 1.028249904956487e-27, "1E-27", "%5.G"},
+ {__LINE__, 1.028570144661448e-28, "+1.02857E-28", "%+G"},
+ {__LINE__, 1.028934898454705e-13, "+1.028935E-13", "%+E"},
+ {__LINE__, 1.029071053545906e-26, "1.029071E-26", "%E"},
+ {__LINE__, 1.032672895881148e-30, "+1.032673E-30", "%+E"},
+ {__LINE__, 1.033502358979511e+06, "1.0335E+06", "%.5G"},
+ {__LINE__, 1.036790427717847e+19, "1e+19", "%4.g"},
+ {__LINE__, 1.037022928821648e+03, "1037.02", "%5g"},
+ {__LINE__, 1.040551683941284e+14, "1.04055E+14", "%G"},
+ {__LINE__, 1.044499252101308e-17, "1.044499E-17", "%E"},
+ {__LINE__, 1.045791899570889e+15, "+1.04579e+15", "%+g"},
+ {__LINE__, 1.048730383198703e+28, "1.049e+28", "%.4g"},
+ {__LINE__, 1.050654419882509e-18, "0.000000", "%f"},
+ {__LINE__, 1.052600569262127e-27, "+0.000", "%+2.3f"},
+ {__LINE__, 1.053213014784149e+15, "1E+15", "%4.G"},
+ {__LINE__, 1.057553916225948e-15, "+0.000000", "%+4f"},
+ {__LINE__, 1.058191244482453e+19, "1.058e+19", "%.3e"},
+ {__LINE__, 1.058746269793972e-26, "+1.1E-26", "%+.2G"},
+ {__LINE__, 1.058793271960762e-01, "+1.058793E-01", "%+4E"},
+ {__LINE__, 1.058869592738370e-19, "1.05887e-19", "%3g"},
+ {__LINE__, 1.060402312803008e+15, "1060402312803008.229025", "%f"},
+ {__LINE__, 1.061106284763095e+00, "1.061106", "%0f"},
+ {__LINE__, 1.061180160987467e+09, "1e+09", "%2.g"},
+ {__LINE__, 1.061181537176067e-06, "+1.06118e-06", "%+g"},
+ {__LINE__, 1.065021381771174e+20, "1.06502e+20", "%g"},
+ {__LINE__, 1.065464040401130e-16, "1.065464e-16", "%e"},
+ {__LINE__, 1.065573419819459e-05, "0.00001", "%.5f"},
+ {__LINE__, 1.066107764306644e+13, "1.066108e+13", "%#e"},
+ {__LINE__, 1.071318759598956e+12, "1.071319e+12", "%e"},
+ {__LINE__, 1.071564727222321e+10, "1.072E+10", "%3.4G"},
+ {__LINE__, 1.074652481218139e+14, "1.0747E+14", "%.4E"},
+ {__LINE__, 1.078453684911309e-02, "0.0107845", "%g"},
+ {__LINE__, 1.078550811446675e-05, "1.07855e-05", "%g"},
+ {__LINE__, 1.078780494515273e-04, "0.000107878", "%4G"},
+ {__LINE__, 1.079467488876157e-16, "+1.079467E-16", "%+E"},
+ {__LINE__, 1.080529722917934e-20, "0.000000", "%f"},
+ {__LINE__, 1.082169127709439e+01, "10.8217", "%#5g"},
+ {__LINE__, 1.087241285590951e+22, "1E+22", "%4.G"},
+ {__LINE__, 1.091049208406195e-14, "0.0000", "%.4f"},
+ {__LINE__, 1.095316064213237e+16, "+1e+16", "%+0.g"},
+ {__LINE__, 1.095349083237975e-04, "1.095349e-04", "%5e"},
+ {__LINE__, 1.098002465452836e+12, "1098002465452.836205", "%f"},
+ {__LINE__, 1.098445764138997e+13, "1.09845E+13", "%G"},
+ {__LINE__, 1.099968047892474e-13, "1.1e-13", "%2.5g"},
+ {__LINE__, 1.101017598311363e-04, "0.000110102", "%G"},
+ {__LINE__, 1.102776332077817e+18, "1.103e+18", "%.3e"},
+ {__LINE__, 1.103734053887830e-01, "0.110373", "%f"},
+ {__LINE__, 1.105730106869006e-03, "0.00110573", "%g"},
+ {__LINE__, 1.106366781854058e-10, "1.10637e-10", "%g"},
+ {__LINE__, 1.107354763213839e+15, "1.107355e+15", "%6e"},
+ {__LINE__, 1.108151709609825e-10, "+1.10815E-10", "%+G"},
+ {__LINE__, 1.110054501993647e+21, "+1.11005E+21", "%+G"},
+ {__LINE__, 1.111574814737873e-17, "+1.112E-17", "%+1.4G"},
+ {__LINE__, 1.111865512360108e-15, "1E-15", "%.0G"},
+ {__LINE__, 1.112281568330498e-03, "1.112282e-03", "%.6e"},
+ {__LINE__, 1.112625415174238e+21, "+1.11263e+21", "%+g"},
+ {__LINE__, 1.112744974910395e-02, "0.011127", "%f"},
+ {__LINE__, 1.114726566979885e-10, "1.11473e-10", "%g"},
+ {__LINE__, 1.115395843055731e-20, "+0.000000", "%+6f"},
+ {__LINE__, 1.115983414693121e+15, "1.11598e+15", "%5.6g"},
+ {__LINE__, 1.116118842074266e+27, "1.116119e+27", "%e"},
+ {__LINE__, 1.118386983012328e+19, "11183869830123276400.968280", "%1f"},
+ {__LINE__, 1.119344607892718e-22, "1.119345e-22", "%e"},
+ {__LINE__, 1.120560837110279e-19, "0.000000", "%f"},
+ {__LINE__, 1.123620157906291e-02, "0.0112362", "%G"},
+ {__LINE__, 1.126804857639478e+29, "1.1268E+29", "%#0.5G"},
+ {__LINE__, 1.128962199461581e+11, "1.12896e+11", "%g"},
+ {__LINE__, 1.129878714246809e-16, "1E-16", "%0.0G"},
+ {__LINE__, 1.130331982972407e-06, "+0.", "%+#1.f"},
+ {__LINE__, 1.134167332070028e-16, "0", "%0.0f"},
+ {__LINE__, 1.134248080053598e-28, "0.000000", "%f"},
+ {__LINE__, 1.136023160708119e-10, "+0.000000", "%+1f"},
+ {__LINE__, 1.136167141059036e+23, "113616714105903593434732.101741", "%f"},
+ {__LINE__, 1.136439499920164e+10, "+1.13644E+10", "%+G"},
+ {__LINE__, 1.136859734932182e+24, "1.13686e+24", "%g"},
+ {__LINE__, 1.138985939448731e+09, "1.13899e+09", "%2g"},
+ {__LINE__, 1.139287324790407e-25, "1e-25", "%.1g"},
+ {__LINE__, 1.140559912153251e+06, "1.14056e+06", "%g"},
+ {__LINE__, 1.141318036027086e-26, "1.14132E-26", "%G"},
+ {__LINE__, 1.142586049368452e-20, "+1.14259E-20", "%+7.5E"},
+ {__LINE__, 1.143283863993333e-17, "1.143284E-17", "%3E"},
+ {__LINE__, 1.144637911632432e-28, "1.144638E-28", "%#3E"},
+ {__LINE__, 1.145791416532065e-10, "1.14579e-10", "%g"},
+ {__LINE__, 1.146958047315780e-17, "1.146958e-17", "%e"},
+ {__LINE__, 1.147898346886569e-08, "1E-08", "%3.0E"},
+ {__LINE__, 1.149724744965608e-14, "1.14972e-14", "%5g"},
+ {__LINE__, 1.155383721940441e-10, "1e-10", "%1.g"},
+ {__LINE__, 1.157066617729094e-02, "0", "%1.f"},
+ {__LINE__, 1.157893614537215e+05, "1.157894E+05", "%E"},
+ {__LINE__, 1.160476344451928e-19, "1.2e-19", "%.1e"},
+ {__LINE__, 1.161610499315966e-26, "1.161610E-26", "%E"},
+ {__LINE__, 1.162345042181490e+29, "116234504218148981813385489658.685401", "%5.6f"},
+ {__LINE__, 1.162376053722862e+23, "1.16238e+23", "%g"},
+ {__LINE__, 1.162996084782483e+18, "+1e+18", "%+0.g"},
+ {__LINE__, 1.163544861478966e+26, "1.16354E+26", "%G"},
+ {__LINE__, 1.167300137450931e+06, "1E+06", "%.0G"},
+ {__LINE__, 1.168693829096401e-30, "+1.16869e-30", "%+g"},
+ {__LINE__, 1.172791369381396e+15, "1.173E+15", "%.4G"},
+ {__LINE__, 1.174427110782028e-29, " 1E-29", "%7.G"},
+ {__LINE__, 1.179498322112450e+27, "1179498322112449759657692993.641831", "%f"},
+ {__LINE__, 1.179555606293547e+27, "1.17956e+27", "%3g"},
+ {__LINE__, 1.180815814881269e+06, "1.180816e+06", "%e"},
+ {__LINE__, 1.181494870072805e+20, "1.181495e+20", "%5e"},
+ {__LINE__, 1.181524119225619e+12, "+1181524119225.61917", "%+5.5f"},
+ {__LINE__, 1.182111212289243e-20, "1e-20", "%4.g"},
+ {__LINE__, 1.184503315019769e-27, "1.1845e-27", "%7g"},
+ {__LINE__, 1.186413646767670e+29, "1.18641e+29", "%g"},
+ {__LINE__, 1.186852938885004e-13, "1.18685e-13", "%4g"},
+ {__LINE__, 1.188837612473914e+05, "1e+05", "%.0g"},
+ {__LINE__, 1.190317482928293e-29, "1.190317e-29", "%e"},
+ {__LINE__, 1.190527491143987e+02, "1.190527E+02", "%E"},
+ {__LINE__, 1.191823062060233e-30, "1.2E-30", "%6.2G"},
+ {__LINE__, 1.191926974812428e-23, "1.2e-23", "%.2g"},
+ {__LINE__, 1.193549622366544e-25, "1E-25", "%4.1G"},
+ {__LINE__, 1.195517368629765e-21, "1.195517e-21", "%1.7g"},
+ {__LINE__, 1.195573061651289e-27, "1.19557e-27", "%#g"},
+ {__LINE__, 1.195806681188325e-03, "+0.00120", "%+#.3G"},
+ {__LINE__, 1.196842275192189e-28, "1.19684e-28", "%g"},
+ {__LINE__, 1.197307550969576e+04, "1.1973E+04", "%.4E"},
+ {__LINE__, 1.197608525847607e+15, "1197608525847606.8062805", "%4.7f"},
+ {__LINE__, 1.197801338159407e+04, "11978", "%5G"},
+ {__LINE__, 1.197813329735025e+27, "1.19781E+27", "%7G"},
+ {__LINE__, 1.199483904123253e-12, "1.19948e-12", "%g"},
+ {__LINE__, 1.199535292169766e-09, "1.199535e-09", "%e"},
+ {__LINE__, 1.201478067515135e+05, "120147.806752", "%f"},
+ {__LINE__, 1.202054662662158e+17, "1.20205E+17", "%#G"},
+ {__LINE__, 1.202111922368321e+07, "+1.202112E+07", "%+#E"},
+ {__LINE__, 1.202536892743791e-01, "0.120254", "%#g"},
+ {__LINE__, 1.205698674119882e-29, "1.2057E-29", "%G"},
+ {__LINE__, 1.208091664701942e-13, " 0.", "%#3.f"},
+ {__LINE__, 1.208942413954872e-17, "1.20894E-17", "%G"},
+ {__LINE__, 1.209704891496613e+10, "1.210e+10", "%2.3e"},
+ {__LINE__, 1.211355639334831e+29, "1E+29", "%.0G"},
+ {__LINE__, 1.211447553804203e+17, " 1E+17", "%7.E"},
+ {__LINE__, 1.212481583429790e-16, "1.212482e-16", "%e"},
+ {__LINE__, 1.212849001551862e+26, "121284900155186181613942153.4899157", "%6.7f"},
+ {__LINE__, 1.213057538677801e+06, "1213057.538678", "%#.6f"},
+ {__LINE__, 1.214609592911893e+25, "1.214610e+25", "%#e"},
+ {__LINE__, 1.216086266251665e+01, "1e+01", "%5.e"},
+ {__LINE__, 1.216468565931026e-22, "1.216469E-22", "%1E"},
+ {__LINE__, 1.216503126598765e+14, "+1E+14", "%+0.E"},
+ {__LINE__, 1.216641013695553e-14, "0.000000", "%f"},
+ {__LINE__, 1.223142246779504e-23, "0.000000", "%f"},
+ {__LINE__, 1.223884786443274e+08, "122388479", "%5.f"},
+ {__LINE__, 1.224012562770076e+29, "1.22401e+29", "%0g"},
+ {__LINE__, 1.225098157528297e+14, "1.22510e+14", "%#g"},
+ {__LINE__, 1.226306848505242e-22, "1.22631E-22", "%G"},
+ {__LINE__, 1.227487485547996e-08, "+1.22749e-08", "%+g"},
+ {__LINE__, 1.237206486909689e+02, "+123.721", "%+#.6g"},
+ {__LINE__, 1.240281126177077e-02, "+0.01", "%+3.g"},
+ {__LINE__, 1.241197211306994e-06, "1.241197E-06", "%E"},
+ {__LINE__, 1.241776311097410e+07, "1.241776E+07", "%E"},
+ {__LINE__, 1.245995986024999e-03, "0.001246", "%g"},
+ {__LINE__, 1.246082428199607e+03, "1246.082428", "%f"},
+ {__LINE__, 1.247021567954220e+05, " 1e+05", "%7.g"},
+ {__LINE__, 1.248140089618390e-30, "+1.24814E-30", "%+G"},
+ {__LINE__, 1.248403361652064e-30, "+0.000000", "%+f"},
+ {__LINE__, 1.251098538918842e-26, "+1.251099E-26", "%+E"},
+ {__LINE__, 1.251952633022061e+25, "1.25195e+25", "%g"},
+ {__LINE__, 1.253029705843461e-04, "+1.E-04", "%+#4.E"},
+ {__LINE__, 1.259562132729488e-09, "1e-09", "%1.e"},
+ {__LINE__, 1.261702205492260e-27, "0.000000", "%f"},
+ {__LINE__, 1.265910361926660e-19, "+1.265910e-19", "%+e"},
+ {__LINE__, 1.267411912651087e+12, "1.26741E+12", "%1G"},
+ {__LINE__, 1.267830718285980e-10, "1.26783e-10", "%g"},
+ {__LINE__, 1.268238378987517e-23, "1E-23", "%5.E"},
+ {__LINE__, 1.275543253354167e+10, "1.27554E+10", "%G"},
+ {__LINE__, 1.277255234454465e-10, "1.27726E-10", "%5G"},
+ {__LINE__, 1.280590949834150e-21, "1.280591E-21", "%E"},
+ {__LINE__, 1.285570453788242e-02, "1.285570E-02", "%E"},
+ {__LINE__, 1.287712130719031e+09, "1287712130.719031", "%#f"},
+ {__LINE__, 1.290142876187105e+29, "+1.290143E+29", "%+E"},
+ {__LINE__, 1.293129213191961e+21, "1.29313E+21", "%G"},
+ {__LINE__, 1.293317101334714e-23, "+0.000000", "%+f"},
+ {__LINE__, 1.294506813069071e-13, "0.0", "%3.1f"},
+ {__LINE__, 1.295576232685739e-22, "+0.000000", "%+f"},
+ {__LINE__, 1.296010470431800e-19, "+0.000000", "%+6f"},
+ {__LINE__, 1.298798231947674e+19, "1.2988E+19", "%2G"},
+ {__LINE__, 1.299521114379381e+09, "1.29952E+09", "%G"},
+ {__LINE__, 1.299847637892712e+24, "1.299848e+24", "%e"},
+ {__LINE__, 1.301269777843698e+29, "130126977784369834978406288428.232074", "%f"},
+ {__LINE__, 1.302911786437618e-15, " 0", "%6.f"},
+ {__LINE__, 1.303863159906719e+27, "1303863159906719415559450681", "%0.f"},
+ {__LINE__, 1.304396472326846e-12, "+1E-12", "%+1.0G"},
+ {__LINE__, 1.306180443528427e-30, "+1e-30", "%+.1g"},
+ {__LINE__, 1.308469138968514e+22, "1.30847E+22", "%0G"},
+ {__LINE__, 1.312700156826057e-11, "1.3127e-11", "%g"},
+ {__LINE__, 1.315364075120764e+21, "+1.31536E+21", "%+G"},
+ {__LINE__, 1.320376485288444e-09, "+1.3204E-09", "%+6.5G"},
+ {__LINE__, 1.321434154364635e-08, "1.32143e-08", "%1g"},
+ {__LINE__, 1.322777272579176e+19, "+1e+19", "%+3.e"},
+ {__LINE__, 1.322861663428564e+00, "1.322862E+00", "%#E"},
+ {__LINE__, 1.323566013489230e+14, "+1.323566E+14", "%+1E"},
+ {__LINE__, 1.327446904132973e-20, "+1.32745E-20", "%+4.6G"},
+ {__LINE__, 1.328226362528158e+19, "1e+19", "%2.g"},
+ {__LINE__, 1.329167460803610e+08, "1e+08", "%3.g"},
+ {__LINE__, 1.335371420823160e+14, "1.33537E+14", "%7G"},
+ {__LINE__, 1.336116185095935e-21, "0.000000", "%f"},
+ {__LINE__, 1.338766774704671e-22, "+1.33877e-22", "%+g"},
+ {__LINE__, 1.339199373014647e-12, "1E-12", "%1.E"},
+ {__LINE__, 1.344293357481519e+26, "134429335748151945750805680.290796", "%#2f"},
+ {__LINE__, 1.344328188122843e+29, "1.34433e+29", "%g"},
+ {__LINE__, 1.344382581316972e-05, "1E-05", "%5.0E"},
+ {__LINE__, 1.349835616116184e+11, "134983561611.6", "%2.1f"},
+ {__LINE__, 1.349955669989707e+20, "134995566998970728533.890906", "%7f"},
+ {__LINE__, 1.350230411093841e+20, "135023041109384145386.229648", "%f"},
+ {__LINE__, 1.353391369565576e+10, " 1E+10", "%7.1G"},
+ {__LINE__, 1.356889483699471e+22, "+1.35689E+22", "%+G"},
+ {__LINE__, 1.358141775798243e+24, "+1358141775798242578687791.137781", "%+f"},
+ {__LINE__, 1.358547541975523e-15, "1.35855e-15", "%g"},
+ {__LINE__, 1.363402539800791e+11, "1.3634E+11", "%G"},
+ {__LINE__, 1.363676837988798e+16, "+13636768379887982.4053", "%+2.4f"},
+ {__LINE__, 1.364592026494839e-24, "1.36459e-24", "%g"},
+ {__LINE__, 1.366664212399413e-09, "+1E-09", "%+6.G"},
+ {__LINE__, 1.367446193117463e-17, "1.3674e-17", "%2.4e"},
+ {__LINE__, 1.368681648785823e-18, "1.36868E-18", "%3G"},
+ {__LINE__, 1.370635189583606e+05, "1.370635E+05", "%E"},
+ {__LINE__, 1.371395540772186e-18, "+1.371396e-18", "%+e"},
+ {__LINE__, 1.371945318043159e+10, "1E+10", "%0.E"},
+ {__LINE__, 1.373780604772988e-21, "1e-21", "%3.g"},
+ {__LINE__, 1.374244970441862e-28, "0.000000", "%7.6f"},
+ {__LINE__, 1.375874695067149e-25, "1.37587E-25", "%#3G"},
+ {__LINE__, 1.377165614832621e+20, "1.37717E+20", "%#G"},
+ {__LINE__, 1.381541864946684e-09, "1.38154E-09", "%G"},
+ {__LINE__, 1.382901694835415e+00, "1.382902E+00", "%E"},
+ {__LINE__, 1.384250577530184e-21, "1.384e-21", "%.4g"},
+ {__LINE__, 1.385322753374640e-03, " 1E-03", "%6.E"},
+ {__LINE__, 1.387026156054724e+19, "1.387026E+19", "%E"},
+ {__LINE__, 1.388726735790498e-27, "+1.388727E-27", "%+E"},
+ {__LINE__, 1.388819105742044e+16, "1.38882e+16", "%g"},
+ {__LINE__, 1.389941086024951e-19, "0.000000", "%f"},
+ {__LINE__, 1.390101174785536e+25, "1.3901E+25", "%G"},
+ {__LINE__, 1.392210785638597e+24, "+1.39221E+24", "%+G"},
+ {__LINE__, 1.396148856283474e-26, "1.4e-26", "%7.3g"},
+ {__LINE__, 1.398153728631994e-21, "1.39815E-21", "%G"},
+ {__LINE__, 1.398332446762342e-14, "+1.39833E-14", "%+5G"},
+ {__LINE__, 1.400250919607987e+10, "1.40025E+10", "%G"},
+ {__LINE__, 1.400662469019739e+03, "1.E+03", "%#0.0E"},
+ {__LINE__, 1.401720273747805e-12, "0.000000", "%#f"},
+ {__LINE__, 1.402151358748719e+22, "1.402151e+22", "%e"},
+ {__LINE__, 1.402351913752357e-28, "1.40235E-28", "%#1.6G"},
+ {__LINE__, 1.403285877973810e+13, "+14032858779738.097255", "%+4f"},
+ {__LINE__, 1.404540981735861e+04, "14045.409817", "%4f"},
+ {__LINE__, 1.406420622355064e+19, "1.40642E+19", "%G"},
+ {__LINE__, 1.412552725962301e-29, "+1e-29", "%+1.e"},
+ {__LINE__, 1.413266982485044e+10, "1.41327e+10", "%g"},
+ {__LINE__, 1.413627189411456e+21, "1.41363E+21", "%0G"},
+ {__LINE__, 1.416647216002592e-25, "+0.000000", "%+#f"},
+ {__LINE__, 1.417107155080584e-10, "1e-10", "%1.e"},
+ {__LINE__, 1.418829895346648e+19, "14188298953466484952.912197", "%f"},
+ {__LINE__, 1.419404559267523e-11, "1.4194e-11", "%g"},
+ {__LINE__, 1.422421321425472e+15, "1.422421E+15", "%E"},
+ {__LINE__, 1.424858902008998e+18, "1.42486E+18", "%2.5E"},
+ {__LINE__, 1.428863051254205e+22, "1.428863e+22", "%e"},
+ {__LINE__, 1.429533727936725e-02, "0.0142953", "%g"},
+ {__LINE__, 1.430982219743369e-19, " 1E-19", "%6.G"},
+ {__LINE__, 1.431974118434703e+17, "1E+17", "%3.G"},
+ {__LINE__, 1.432418341970152e+16, "+1.432418e+16", "%+5e"},
+ {__LINE__, 1.433470281650523e+04, "14334.7", "%g"},
+ {__LINE__, 1.434446243424653e+24, " +1e+24", "%+7.g"},
+ {__LINE__, 1.435118019241039e+24, "+1e+24", "%+4.g"},
+ {__LINE__, 1.435691648420278e-01, "0.1435692", "%#4.7g"},
+ {__LINE__, 1.437569598098744e+27, "1.437570E+27", "%#E"},
+ {__LINE__, 1.437633484061726e-25, "+1.43763e-25", "%+7g"},
+ {__LINE__, 1.437866591230707e-13, "1.43787e-13", "%g"},
+ {__LINE__, 1.440593154445915e-01, "+0.144059", "%+1G"},
+ {__LINE__, 1.441368205977342e+16, "1.441368E+16", "%#E"},
+ {__LINE__, 1.441825266684367e+28, "1.44183e+28", "%g"},
+ {__LINE__, 1.442374183199456e+20, "1.442374E+20", "%E"},
+ {__LINE__, 1.445101893951061e-24, "0", "%0.f"},
+ {__LINE__, 1.446037835160094e-20, "+1.44604E-20", "%+2G"},
+ {__LINE__, 1.449245376093616e+04, "1.449245e+04", "%e"},
+ {__LINE__, 1.454126845620100e+09, "1.45413E+09", "%G"},
+ {__LINE__, 1.455764608801107e+09, "1.5e+09", "%6.1e"},
+ {__LINE__, 1.457176183149955e-12, "1.45718e-12", "%#g"},
+ {__LINE__, 1.458821535020046e-05, "1.45882e-05", "%#g"},
+ {__LINE__, 1.460179141161202e-19, "1.460179E-19", "%#E"},
+ {__LINE__, 1.461701055446198e-20, "1.461701e-20", "%#2.7g"},
+ {__LINE__, 1.462408181482172e+10, "1.4624082E+10", "%3.7E"},
+ {__LINE__, 1.463706296748154e+24, "1e+24", "%2.g"},
+ {__LINE__, 1.464891255780761e-19, "+1.46489e-19", "%+g"},
+ {__LINE__, 1.467903978945872e+25, "1.4679E+25", "%G"},
+ {__LINE__, 1.468585992857062e+22, "14685859928570619281629.205943", "%f"},
+ {__LINE__, 1.469803528668286e+29, "+1E+29", "%+6.G"},
+ {__LINE__, 1.469883002609266e-23, "1.E-23", "%#2.E"},
+ {__LINE__, 1.469941481858809e+08, "+146994148.185881", "%+f"},
+ {__LINE__, 1.470744493304611e+13, "1.47074e+13", "%g"},
+ {__LINE__, 1.471857261085004e+23, "1E+23", "%2.G"},
+ {__LINE__, 1.474419778873037e+06, "1474419.7789", "%#.4f"},
+ {__LINE__, 1.483134762223381e-03, "0", "%0.0f"},
+ {__LINE__, 1.483575501240724e-13, "1.48358e-13", "%g"},
+ {__LINE__, 1.486068112294452e+20, "1.486068e+20", "%e"},
+ {__LINE__, 1.488665528787761e-03, " +0", "%+4.f"},
+ {__LINE__, 1.492145267536713e+07, "14921452.675367", "%f"},
+ {__LINE__, 1.492589762884761e-01, "0.149259", "%f"},
+ {__LINE__, 1.494784286168215e+01, "1.494784E+01", "%E"},
+ {__LINE__, 1.495945331501655e+04, "1.5e+04", "%.2g"},
+ {__LINE__, 1.501383201904700e+14, "2e+14", "%1.g"},
+ {__LINE__, 1.501387105011959e-02, "0.0150139", "%g"},
+ {__LINE__, 1.505784488562271e+26, "1.50578e+26", "%5g"},
+ {__LINE__, 1.506367986495534e+10, "1.50637e+10", "%2g"},
+ {__LINE__, 1.507421710226296e+19, "1.507422E+19", "%#E"},
+ {__LINE__, 1.507960881206134e+16, "2e+16", "%.0g"},
+ {__LINE__, 1.508974301049424e+14, "+1.508974E+14", "%+E"},
+ {__LINE__, 1.509204025111090e-18, "1.509204E-18", "%E"},
+ {__LINE__, 1.511351799767759e+21, "1511351799767759462866.93397", "%.5f"},
+ {__LINE__, 1.511712197184520e-06, "+1.51171e-06", "%+1g"},
+ {__LINE__, 1.514703727491400e+02, "151.47", "%.5g"},
+ {__LINE__, 1.514855355408287e+04, "15148.6", "%g"},
+ {__LINE__, 1.516256896575301e+06, "1.516257e+06", "%.6e"},
+ {__LINE__, 1.517712083681069e+14, "1.51771e+14", "%0g"},
+ {__LINE__, 1.522102209167607e-18, "1.52210e-18", "%#g"},
+ {__LINE__, 1.526264862895663e-12, "0.000000", "%f"},
+ {__LINE__, 1.527165480858125e+10, "1.527e+10", "%.4g"},
+ {__LINE__, 1.528363280308369e+00, "+1.52836", "%+0G"},
+ {__LINE__, 1.529108490733420e-22, "1.529108E-22", "%E"},
+ {__LINE__, 1.529783364474522e+19, "15297833644745216119.531506", "%7f"},
+ {__LINE__, 1.530698363199346e-01, "0.1531", "%#.4f"},
+ {__LINE__, 1.531520796537450e+22, "1.53152E+22", "%G"},
+ {__LINE__, 1.533314559644813e+06, "+1533314.559645", "%+f"},
+ {__LINE__, 1.534682791112854e+01, "+15.3468", "%+0G"},
+ {__LINE__, 1.534714026386730e-11, "0.000000", "%f"},
+ {__LINE__, 1.537145729498115e+00, "1.537146E+00", "%E"},
+ {__LINE__, 1.538740040875751e-23, "1.538740E-23", "%E"},
+ {__LINE__, 1.546248240596482e-03, "0.001546", "%f"},
+ {__LINE__, 1.546808012239302e-09, "+1.54681E-09", "%+G"},
+ {__LINE__, 1.546903877359107e+06, "1.5e+06", "%.2g"},
+ {__LINE__, 1.550153973747718e-18, "2e-18", "%.0g"},
+ {__LINE__, 1.551703460384378e+00, "+1.5517", "%+.4f"},
+ {__LINE__, 1.553995673101369e+29, "1.554E+29", "%G"},
+ {__LINE__, 1.555477017531899e+28, "1.55548e+28", "%g"},
+ {__LINE__, 1.555548963448462e+12, "1555548963448.46227", "%6.5f"},
+ {__LINE__, 1.558702451007712e+16, "2e+16", "%5.1g"},
+ {__LINE__, 1.561641587723724e+29, "1.561642e+29", "%e"},
+ {__LINE__, 1.561868589559509e-05, "1.56187E-05", "%G"},
+ {__LINE__, 1.565229056438949e+13, "1.56523e+13", "%1.6g"},
+ {__LINE__, 1.570074406600442e+14, "+1.57007E+14", "%+4G"},
+ {__LINE__, 1.570951909913194e+13, "1.57095E+13", "%.6G"},
+ {__LINE__, 1.572186421520727e-30, "+1.57219e-30", "%+g"},
+ {__LINE__, 1.574374582066945e+12, "1.57e+12", "%5.2e"},
+ {__LINE__, 1.577789404823585e+12, "1.577789E+12", "%E"},
+ {__LINE__, 1.579641278389186e+04, "15796.413", "%7.3f"},
+ {__LINE__, 1.581602330975388e+17, "1.5816E+17", "%#.5G"},
+ {__LINE__, 1.587809692297490e-18, "+1.58781e-18", "%+2g"},
+ {__LINE__, 1.588672954832388e-05, "1.58867E-05", "%G"},
+ {__LINE__, 1.594548954259978e+25, "+1.595e+25", "%+.3e"},
+ {__LINE__, 1.596653742160718e+10, "15966537421.6072", "%.4f"},
+ {__LINE__, 1.597416186584641e+25, "1.59742e+25", "%g"},
+ {__LINE__, 1.597810706039500e-04, "0.000159781", "%g"},
+ {__LINE__, 1.601425691153542e+01, "16.0143", "%G"},
+ {__LINE__, 1.601491150913706e-15, "+1.60149e-15", "%+g"},
+ {__LINE__, 1.609357026469645e+02, "160.936", "%0g"},
+ {__LINE__, 1.611064881461188e+06, "+1.611065E+06", "%+E"},
+ {__LINE__, 1.611324319640770e-03, "0.00161132", "%G"},
+ {__LINE__, 1.613202907940803e+19, "1.6E+19", "%#.1E"},
+ {__LINE__, 1.613883500056636e-12, "0.000000", "%5f"},
+ {__LINE__, 1.618254213010772e+07, "16182542.130108", "%6f"},
+ {__LINE__, 1.620441271211248e-08, "1.62044E-08", "%0G"},
+ {__LINE__, 1.622548435024803e-01, "+0.162255", "%+5G"},
+ {__LINE__, 1.623740394555269e+19, "16237403945552689066.289531", "%3f"},
+ {__LINE__, 1.625774250389937e+18, "1.625774e+18", "%1e"},
+ {__LINE__, 1.626300864432426e-02, "0.016263", "%G"},
+ {__LINE__, 1.626351146877694e-11, "1.6263511e-11", "%2.7e"},
+ {__LINE__, 1.626568757587995e+25, "16265687575879949733348439.62220", "%6.5f"},
+ {__LINE__, 1.626717482094360e-28, "+1.626717e-28", "%+3e"},
+ {__LINE__, 1.630801585998995e-28, "1.6308e-28", "%0g"},
+ {__LINE__, 1.631827173682962e+03, "1632", "%1.4g"},
+ {__LINE__, 1.631907571243379e+18, "1631907571243378818.337533", "%f"},
+ {__LINE__, 1.632058420447239e-14, " +2E-14", "%+7.G"},
+ {__LINE__, 1.632847882621240e+18, "+1.63285E+18", "%+2G"},
+ {__LINE__, 1.637329146233172e-09, "+1.63733e-09", "%+g"},
+ {__LINE__, 1.638315287442427e-16, "+1.63832E-16", "%+G"},
+ {__LINE__, 1.641284849351445e+15, "1641284849351445.096488", "%f"},
+ {__LINE__, 1.644871927486929e+10, "2e+10", "%1.e"},
+ {__LINE__, 1.645917293047431e-19, "1.64592e-19", "%.6g"},
+ {__LINE__, 1.649201265647819e-07, "0.000000", "%f"},
+ {__LINE__, 1.650169065733559e+23, "165016906573355903731226.135278", "%3f"},
+ {__LINE__, 1.651217291298196e-30, "2E-30", "%4.G"},
+ {__LINE__, 1.652680660160331e+08, "2.e+08", "%#3.g"},
+ {__LINE__, 1.654171892948767e-15, "1.65417e-15", "%g"},
+ {__LINE__, 1.655435863725412e+17, "+1.655436e+17", "%+#e"},
+ {__LINE__, 1.656015606204101e+28, "+1.7E+28", "%+3.2G"},
+ {__LINE__, 1.656814723110478e-21, "+0.000000", "%+f"},
+ {__LINE__, 1.658632655199721e-19, "2.E-19", "%#4.G"},
+ {__LINE__, 1.659915061311444e+27, "1.66E+27", "%.3G"},
+ {__LINE__, 1.664258574522914e-29, "+1.664259E-29", "%+E"},
+ {__LINE__, 1.667662840654469e-28, "+2e-28", "%+0.g"},
+ {__LINE__, 1.673124993246863e-25, "+0.000000", "%+f"},
+ {__LINE__, 1.677788498058833e-20, "1.678e-20", "%.4g"},
+ {__LINE__, 1.681211731173386e-07, "1.68121e-07", "%0.6g"},
+ {__LINE__, 1.686341560076196e+02, "169", "%.0f"},
+ {__LINE__, 1.686507685287281e+08, "1.686508E+08", "%E"},
+ {__LINE__, 1.689500448795801e+03, "+1689.500449", "%+0f"},
+ {__LINE__, 1.690639426041009e-13, "2e-13", "%5.0g"},
+ {__LINE__, 1.691554939595928e+16, "+1.6916e+16", "%+.5g"},
+ {__LINE__, 1.698597126229626e-09, "1.699e-09", "%3.4g"},
+ {__LINE__, 1.700093083173516e+16, "17000930831735159", "%5.f"},
+ {__LINE__, 1.703653732982710e+13, "+1.70365e+13", "%+g"},
+ {__LINE__, 1.705353380573352e-16, "0.000000", "%f"},
+ {__LINE__, 1.705973328700179e-26, "1.70597e-26", "%5g"},
+ {__LINE__, 1.717797289369145e+22, "+1.717797E+22", "%+7E"},
+ {__LINE__, 1.722819196705361e-28, "1.722819E-28", "%1.7G"},
+ {__LINE__, 1.723775772891202e+01, "17.237758", "%f"},
+ {__LINE__, 1.723787102325353e-23, "0.000000", "%2f"},
+ {__LINE__, 1.724551301171870e-13, "0.000000", "%f"},
+ {__LINE__, 1.726098078655758e-20, "0.0000000", "%7.7f"},
+ {__LINE__, 1.726302822039762e+18, "+2E+18", "%+1.G"},
+ {__LINE__, 1.726659209108151e+18, "+1.72666E+18", "%+6G"},
+ {__LINE__, 1.728324925097269e-25, "1.728325e-25", "%7e"},
+ {__LINE__, 1.728357491215602e+02, "172.836", "%G"},
+ {__LINE__, 1.729612227517587e+22, "1.729612e+22", "%e"},
+ {__LINE__, 1.731753104740805e-06, "1.73175e-06", "%2g"},
+ {__LINE__, 1.736066279733589e+18, "+1.736066E+18", "%+3E"},
+ {__LINE__, 1.736626769480182e-19, "2e-19", "%.0g"},
+ {__LINE__, 1.737445267713118e-13, " 2e-13", "%7.g"},
+ {__LINE__, 1.739264683023077e+05, "173926.468302", "%f"},
+ {__LINE__, 1.739423702667596e-16, "+1.73942e-16", "%+g"},
+ {__LINE__, 1.741053616961658e-14, "1.74105E-14", "%G"},
+ {__LINE__, 1.741085952255057e+29, "1.7e+29", "%#.1e"},
+ {__LINE__, 1.743673705633426e+03, "2E+03", "%5.0G"},
+ {__LINE__, 1.750940899205665e+27, "1.75094e+27", "%g"},
+ {__LINE__, 1.753871003884151e-26, "0.", "%#.0f"},
+ {__LINE__, 1.755237470854478e-14, "1.755237e-14", "%4e"},
+ {__LINE__, 1.757491419837315e-03, "0.002", "%1.G"},
+ {__LINE__, 1.758657797688126e+26, "+1.75866E+26", "%+#G"},
+ {__LINE__, 1.760491452270889e+08, "1.76049E+08", "%G"},
+ {__LINE__, 1.760816275862939e-10, "2e-10", "%.1g"},
+ {__LINE__, 1.760905893493003e-22, "1.76e-22", "%.2e"},
+ {__LINE__, 1.762101125986743e-12, "2e-12", "%.0g"},
+ {__LINE__, 1.763855968659571e+27, "1.763856E+27", "%E"},
+ {__LINE__, 1.764595217341348e-13, "1.764595E-13", "%E"},
+ {__LINE__, 1.766737296048445e+08, "+1.77e+08", "%+.3g"},
+ {__LINE__, 1.769916386969961e-05, "+1.76992e-05", "%+g"},
+ {__LINE__, 1.773873506344176e-01, "1.773874e-01", "%e"},
+ {__LINE__, 1.775392554371421e+03, "+1775.39", "%+3.2f"},
+ {__LINE__, 1.776007623006870e+24, "1776007623006870161930237.372871", "%f"},
+ {__LINE__, 1.777418921678653e-27, " 0", "%6.f"},
+ {__LINE__, 1.780967607234234e-18, "1.780968E-18", "%E"},
+ {__LINE__, 1.782510583486435e+24, "+2e+24", "%+3.g"},
+ {__LINE__, 1.784002921603004e+14, "1.784E+14", "%G"},
+ {__LINE__, 1.784231151778382e+11, "1.7842E+11", "%.5G"},
+ {__LINE__, 1.785589091453195e+02, " 179.", "%#5.f"},
+ {__LINE__, 1.786402639400039e+19, "2e+19", "%0.g"},
+ {__LINE__, 1.786506485794647e-25, "2E-25", "%.1G"},
+ {__LINE__, 1.787513971482493e-04, "+0.000178751", "%+G"},
+ {__LINE__, 1.799765409320039e+23, "179976540932003885586710", "%6.0f"},
+ {__LINE__, 1.800451864218989e+08, "+1.80045e+08", "%+g"},
+ {__LINE__, 1.800743538258572e+04, " +18007", "%+7.f"},
+ {__LINE__, 1.801583764453362e+25, "1.8016e+25", "%0.5g"},
+ {__LINE__, 1.804502093739547e+14, "2e+14", "%2.g"},
+ {__LINE__, 1.805600104488678e-17, "1.805600E-17", "%E"},
+ {__LINE__, 1.811342448081048e+17, "1.811342e+17", "%.6e"},
+ {__LINE__, 1.812252160066930e+19, "2e+19", "%0.e"},
+ {__LINE__, 1.816287564395273e+02, "182", "%2.f"},
+ {__LINE__, 1.817097386762552e-13, "2E-13", "%3.1G"},
+ {__LINE__, 1.817881381387254e+06, "1.81788E+06", "%G"},
+ {__LINE__, 1.818416380830953e-30, "1.81842E-30", "%G"},
+ {__LINE__, 1.824788290177454e-23, "1.82479e-23", "%g"},
+ {__LINE__, 1.827832506678437e-18, "1.82783E-18", "%G"},
+ {__LINE__, 1.828048053242609e+01, "18.2805", "%g"},
+ {__LINE__, 1.828939681844203e-21, "1.82894E-21", "%.6G"},
+ {__LINE__, 1.829763900251753e+12, "1829763900251.752773", "%1f"},
+ {__LINE__, 1.833100407114602e-05, "0.000018", "%#f"},
+ {__LINE__, 1.833672780034284e-07, "1.833673e-07", "%e"},
+ {__LINE__, 1.834307692387540e+21, "2E+21", "%5.G"},
+ {__LINE__, 1.835119931666753e+14, "+1.835120e+14", "%+e"},
+ {__LINE__, 1.835956566920861e-26, "0.000000", "%#f"},
+ {__LINE__, 1.837784131899354e+22, "1.83778E+22", "%G"},
+ {__LINE__, 1.842867094224664e-09, "1.84287e-09", "%g"},
+ {__LINE__, 1.844234823805319e+28, "2E+28", "%1.G"},
+ {__LINE__, 1.844877682008962e+12, "1.84488e+12", "%g"},
+ {__LINE__, 1.846530424340488e-22, "1.846530e-22", "%#.7g"},
+ {__LINE__, 1.849111603036448e-08, "0.00", "%.2f"},
+ {__LINE__, 1.850158752678734e+04, "+18502", "%+.5G"},
+ {__LINE__, 1.851431391104701e-06, " +2e-06", "%+7.e"},
+ {__LINE__, 1.851487430609031e-04, "0.000185149", "%G"},
+ {__LINE__, 1.853171650128773e+03, "1853.17", "%G"},
+ {__LINE__, 1.854743263740068e-16, "1.854743E-16", "%6.6E"},
+ {__LINE__, 1.864399020932753e-11, "+0.000000", "%+f"},
+ {__LINE__, 1.865028568072397e-22, "1.86503E-22", "%.6G"},
+ {__LINE__, 1.868128423759223e+14, "1.86813E+14", "%4G"},
+ {__LINE__, 1.868453558435480e+21, "1.86845E+21", "%G"},
+ {__LINE__, 1.870663011627498e-06, "1.87E-06", "%.3G"},
+ {__LINE__, 1.873273487748907e+17, "+1.873273E+17", "%+E"},
+ {__LINE__, 1.878885220839805e-04, "0.000187889", "%G"},
+ {__LINE__, 1.879102515623569e+17, "1.8791e+17", "%g"},
+ {__LINE__, 1.889343972100858e-10, "2E-10", "%2.E"},
+ {__LINE__, 1.891833282879762e-24, "+2e-24", "%+.1g"},
+ {__LINE__, 1.895148778941240e-07, "0.000000", "%0f"},
+ {__LINE__, 1.896950834067578e-28, "+1.89695e-28", "%+#g"},
+ {__LINE__, 1.898464546986629e-05, "1.898465e-05", "%.7g"},
+ {__LINE__, 1.900851427578321e-19, "1.90085e-19", "%6g"},
+ {__LINE__, 1.901171344577750e+27, "1.901171e+27", "%7.7g"},
+ {__LINE__, 1.903563335316359e+02, "190.356", "%0g"},
+ {__LINE__, 1.903817306004701e-16, "+1.90e-16", "%+#6.2e"},
+ {__LINE__, 1.910606410246797e+21, "1.91061E+21", "%2.5E"},
+ {__LINE__, 1.912537759564710e+29, "1.91254E+29", "%G"},
+ {__LINE__, 1.913606675894566e+27, "1.91361E+27", "%7.6G"},
+ {__LINE__, 1.916473734025505e-05, " 2e-05", "%7.g"},
+ {__LINE__, 1.916507511720523e+23, "+2E+23", "%+.0E"},
+ {__LINE__, 1.917688262248837e-28, "1.918e-28", "%.4g"},
+ {__LINE__, 1.921375594217083e-12, "1.92138E-12", "%G"},
+ {__LINE__, 1.923916000932815e-25, "1.92392E-25", "%G"},
+ {__LINE__, 1.926303652776462e-01, "+0.2", "%+0.G"},
+ {__LINE__, 1.929411084211293e+21, "1.92941E+21", "%6G"},
+ {__LINE__, 1.929996820297491e-26, "1.93e-26", "%.6g"},
+ {__LINE__, 1.937301472034748e-29, "1.9373E-29", "%G"},
+ {__LINE__, 1.937301660220894e-11, "+1.9373E-11", "%+G"},
+ {__LINE__, 1.939038538587083e-02, "0.0193904", "%g"},
+ {__LINE__, 1.940575489112444e-09, "1.94058E-09", "%G"},
+ {__LINE__, 1.946550455606677e-26, "1.946550E-26", "%#1E"},
+ {__LINE__, 1.954250777559491e-14, "1.95425E-14", "%G"},
+ {__LINE__, 1.955646327688473e-16, "1.956E-16", "%#.3E"},
+ {__LINE__, 1.956999911995683e+20, "2E+20", "%2.G"},
+ {__LINE__, 1.959125254298784e-21, "1.95913E-21", "%#G"},
+ {__LINE__, 1.960330340481290e+26, "1.96033e+26", "%.6g"},
+ {__LINE__, 1.964156478075422e+01, "+19.6416", "%+g"},
+ {__LINE__, 1.964702507676036e+19, "2.0e+19", "%2.1e"},
+ {__LINE__, 1.965762191674409e-30, "2E-30", "%1.G"},
+ {__LINE__, 1.967492699686803e-29, "+1.967493E-29", "%+#E"},
+ {__LINE__, 1.970072604062236e-11, "+1.97007E-11", "%+G"},
+ {__LINE__, 1.975631055550387e+05, "197563.105555", "%.6f"},
+ {__LINE__, 1.975722425389177e+28, "+1.975722e+28", "%+5.6e"},
+ {__LINE__, 1.977938328895365e-05, " 2e-05", "%6.e"},
+ {__LINE__, 1.981950849019640e+13, "1.981951E+13", "%E"},
+ {__LINE__, 1.982543168856985e-26, "1.98254e-26", "%4g"},
+ {__LINE__, 1.984873317384181e-20, "1.98487E-20", "%4G"},
+ {__LINE__, 1.986146420877074e+02, "+1.986146e+02", "%+0e"},
+ {__LINE__, 1.986465942785167e-28, "1.98647e-28", "%g"},
+ {__LINE__, 1.988250323235468e-05, " +0", "%+7.f"},
+ {__LINE__, 1.989966623080645e-09, "1.989967e-09", "%e"},
+ {__LINE__, 1.991243122514519e+11, "199124312251", "%5.f"},
+ {__LINE__, 1.993287894645908e+25, "+1.993288E+25", "%+E"},
+ {__LINE__, 1.995172329888890e-30, "+1.99517e-30", "%+3g"},
+ {__LINE__, 1.997075127236432e+05, "1.997E+05", "%#.4G"},
+ {__LINE__, 2.000651599487290e+04, "2E+04", "%2.E"},
+ {__LINE__, 2.001429412876339e-28, "0.000000", "%6f"},
+ {__LINE__, 2.003535646264196e+03, " 2E+03", "%7.G"},
+ {__LINE__, 2.011751504116246e+06, "2E+06", "%2.G"},
+ {__LINE__, 2.016361237694652e-30, "2.01636e-30", "%4g"},
+ {__LINE__, 2.018266414065554e-08, "0.00", "%2.2f"},
+ {__LINE__, 2.020706780608565e+03, "2E+03", "%.0G"},
+ {__LINE__, 2.025098418552005e-16, "+2.025098E-16", "%+2E"},
+ {__LINE__, 2.026100592518976e-11, "2.026101e-11", "%6e"},
+ {__LINE__, 2.026167291572980e+11, "2.02617E+11", "%G"},
+ {__LINE__, 2.026782170272331e+07, "2.026782E+07", "%E"},
+ {__LINE__, 2.029133469449347e-06, " 2e-06", "%6.g"},
+ {__LINE__, 2.031191570768443e-20, "2.031192E-20", "%2.7G"},
+ {__LINE__, 2.031884221862863e-16, "2.031884e-16", "%e"},
+ {__LINE__, 2.032992924118323e+29, "203299292411832333016263874014.84", "%#0.2f"},
+ {__LINE__, 2.035799610097827e+28, "+20357996100978272835391180706.2104344", "%+3.7f"},
+ {__LINE__, 2.038008183612069e+25, "20380081836120691463065668", "%7.0f"},
+ {__LINE__, 2.041632205119365e-22, "+2.04163e-22", "%+g"},
+ {__LINE__, 2.042769811159352e-10, "2e-10", "%.1g"},
+ {__LINE__, 2.043034975847005e-08, "2.043035e-08", "%e"},
+ {__LINE__, 2.045930666285880e+26, "2.04593e+26", "%g"},
+ {__LINE__, 2.048377276651386e-21, "0.00000", "%2.5f"},
+ {__LINE__, 2.051785787301292e-23, "0.000000", "%f"},
+ {__LINE__, 2.055085792048183e-10, "0.000000", "%f"},
+ {__LINE__, 2.055783028451040e-21, "+0", "%+1.f"},
+ {__LINE__, 2.057641607509489e-17, "+2E-17", "%+2.G"},
+ {__LINE__, 2.058348703001600e-15, "2.05835E-15", "%#G"},
+ {__LINE__, 2.059594758787322e+24, "2.05959E+24", "%1G"},
+ {__LINE__, 2.062710740295018e+01, "20.6271", "%G"},
+ {__LINE__, 2.063240676447750e-11, "0.000000", "%f"},
+ {__LINE__, 2.063799238238917e-09, "+0.000000", "%+f"},
+ {__LINE__, 2.064564135160425e-17, "2.06456E-17", "%G"},
+ {__LINE__, 2.066363476927650e-05, "2.07E-05", "%.3G"},
+ {__LINE__, 2.066871450514214e-02, "+2.066871e-02", "%+e"},
+ {__LINE__, 2.067258256169148e+07, "2.06726e+07", "%g"},
+ {__LINE__, 2.068466590729350e-22, "0.0000", "%.4f"},
+ {__LINE__, 2.068779510112540e-26, "2.06878e-26", "%g"},
+ {__LINE__, 2.069258770387493e+19, "20692587703874929516.700831", "%3f"},
+ {__LINE__, 2.069547778447951e+26, "2.069548e+26", "%6e"},
+ {__LINE__, 2.070479507710941e-23, "2.07048E-23", "%G"},
+ {__LINE__, 2.071809640061785e+22, "2.071810E+22", "%E"},
+ {__LINE__, 2.073364463564950e-06, "2.07336e-06", "%g"},
+ {__LINE__, 2.073478953644888e-10, "+2.07E-10", "%+.3G"},
+ {__LINE__, 2.076039194312519e+12, "2.07604E+12", "%G"},
+ {__LINE__, 2.081490398946229e-07, "+2.08149e-07", "%+g"},
+ {__LINE__, 2.084941170287895e-07, "2.084941E-07", "%7E"},
+ {__LINE__, 2.087035885023382e-18, "+0.000000", "%+f"},
+ {__LINE__, 2.091025884363342e-09, "2.09103E-09", "%G"},
+ {__LINE__, 2.091830555397864e+08, "209183056", "%0.f"},
+ {__LINE__, 2.091998109232084e-22, "0.000000", "%#f"},
+ {__LINE__, 2.093406473464940e-17, "2.09341e-17", "%g"},
+ {__LINE__, 2.094646724039720e-26, "2.094647e-26", "%0.7g"},
+ {__LINE__, 2.095218667083208e-22, "2.09522e-22", "%.5e"},
+ {__LINE__, 2.096932364992728e-27, "2.1E-27", "%.2G"},
+ {__LINE__, 2.097012452732083e+17, "2.09701E+17", "%G"},
+ {__LINE__, 2.102022216908102e-07, "0.000000", "%f"},
+ {__LINE__, 2.104648382618938e-04, "0.00021", "%.3G"},
+ {__LINE__, 2.109159578853690e-19, "2.10916e-19", "%6g"},
+ {__LINE__, 2.111732624641178e-13, "+2.111733E-13", "%+7.7G"},
+ {__LINE__, 2.112676138351330e+21, " 2e+21", "%6.g"},
+ {__LINE__, 2.117332904051741e-09, "+0.000000", "%+f"},
+ {__LINE__, 2.118001353767757e-14, "2.118E-14", "%4.3E"},
+ {__LINE__, 2.119413720893955e+12, "2.119414E+12", "%.7G"},
+ {__LINE__, 2.119610992647014e+07, "+21196109.9265", "%+.4f"},
+ {__LINE__, 2.120504022069221e+25, "21205040220692210617414730.223", "%#.3f"},
+ {__LINE__, 2.120634617123718e-16, "2.120635e-16", "%#e"},
+ {__LINE__, 2.128702437175385e+12, "2128702437175.385", "%.3f"},
+ {__LINE__, 2.131148830213536e-12, "2.131149e-12", "%e"},
+ {__LINE__, 2.132682622145255e+04, "+21326.83", "%+#5.7G"},
+ {__LINE__, 2.133864841676473e-01, " +0.2", "%+6.g"},
+ {__LINE__, 2.133939058496273e+16, "2E+16", "%4.G"},
+ {__LINE__, 2.135087006806302e-24, "0.000000", "%f"},
+ {__LINE__, 2.138983961194584e-20, "+2.138984e-20", "%+7e"},
+ {__LINE__, 2.146534189669224e+17, "+2.147E+17", "%+.4G"},
+ {__LINE__, 2.147375595676503e+09, "2.147376e+09", "%e"},
+ {__LINE__, 2.152994986418075e+02, "2E+02", "%0.E"},
+ {__LINE__, 2.154127135896811e+06, "2.15E+06", "%2.3G"},
+ {__LINE__, 2.154613053892588e-29, "2.1546E-29", "%.4E"},
+ {__LINE__, 2.160830430730653e-12, "2.16083E-12", "%#G"},
+ {__LINE__, 2.161740591663027e+28, "2.161741e+28", "%e"},
+ {__LINE__, 2.167181665934011e-06, "2e-06", "%1.e"},
+ {__LINE__, 2.167348761729060e-04, "2.167349e-04", "%#e"},
+ {__LINE__, 2.170270852816708e-10, "2.17027E-10", "%0G"},
+ {__LINE__, 2.173048229189370e-06, "2.173e-06", "%.5g"},
+ {__LINE__, 2.175554537855024e+10, "2.17555E+10", "%G"},
+ {__LINE__, 2.177447372527968e-30, "+0.000000", "%+.6f"},
+ {__LINE__, 2.178591661569858e+05, "2.1786e+05", "%1.5g"},
+ {__LINE__, 2.184700207174818e-29, "0.000000", "%f"},
+ {__LINE__, 2.190817031437247e+03, "2.E+03", "%#3.0E"},
+ {__LINE__, 2.191396212145558e-01, "2.191E-01", "%6.3E"},
+ {__LINE__, 2.191786353372880e-23, "2.19179e-23", "%.5e"},
+ {__LINE__, 2.193471126151079e+19, "2.1935E+19", "%.4E"},
+ {__LINE__, 2.194750177630526e-15, "2.194750e-15", "%e"},
+ {__LINE__, 2.196145170358973e+05, "+219615", "%+g"},
+ {__LINE__, 2.199602360934320e-09, "2.19960E-09", "%#6.6G"},
+ {__LINE__, 2.202913988776998e+17, "+2.20291e+17", "%+g"},
+ {__LINE__, 2.207094560707703e-10, "2.207095e-10", "%e"},
+ {__LINE__, 2.207557214621658e-13, " 0", "%4.f"},
+ {__LINE__, 2.209428206272229e+13, "2.20943e+13", "%g"},
+ {__LINE__, 2.212662463615175e-11, " 0", "%4.0f"},
+ {__LINE__, 2.215732710968468e-30, "2E-30", "%.1G"},
+ {__LINE__, 2.218490841936778e-10, "2.21849e-10", "%2g"},
+ {__LINE__, 2.218850610567959e-01, "+0.221885", "%+G"},
+ {__LINE__, 2.220796939261542e-03, "0.002221", "%#f"},
+ {__LINE__, 2.221819894808024e+24, "2.2e+24", "%5.1e"},
+ {__LINE__, 2.223804993235507e+27, "2.223805e+27", "%1e"},
+ {__LINE__, 2.224715386046563e-17, "0.00000", "%#.5f"},
+ {__LINE__, 2.224864709983882e-16, "+2.224865e-16", "%+e"},
+ {__LINE__, 2.225764510969505e+16, "2.E+16", "%#4.G"},
+ {__LINE__, 2.233229189161284e-07, "+2.23323e-07", "%+6g"},
+ {__LINE__, 2.236522807209868e+17, "2.23652e+17", "%g"},
+ {__LINE__, 2.236641620849775e+20, "2E+20", "%0.G"},
+ {__LINE__, 2.237089952728626e-13, "2E-13", "%5.E"},
+ {__LINE__, 2.238531255563381e-11, " 2E-11", "%7.1G"},
+ {__LINE__, 2.242782296436871e+12, "2242782296436.871103", "%f"},
+ {__LINE__, 2.249177852069393e-02, "+2.249178E-02", "%+5E"},
+ {__LINE__, 2.250735782732076e+29, "+2.25074e+29", "%+g"},
+ {__LINE__, 2.257455203557544e-11, "+2e-11", "%+4.0g"},
+ {__LINE__, 2.258002527939529e+24, "2.258e+24", "%g"},
+ {__LINE__, 2.266955929448160e+20, "226695592944815960123.6056915", "%.7f"},
+ {__LINE__, 2.269019719123250e-23, "0.000000", "%f"},
+ {__LINE__, 2.269022332502809e+02, "+226.902233", "%+f"},
+ {__LINE__, 2.271165222038591e-03, "0.002", "%1.1g"},
+ {__LINE__, 2.273965946408021e+14, "+227396594640802.085507", "%+f"},
+ {__LINE__, 2.277221153386242e+22, "22772211533862418697538.032575", "%#f"},
+ {__LINE__, 2.280214920187521e-01, "0.2", "%2.G"},
+ {__LINE__, 2.280762993019740e+06, "2.28076E+06", "%G"},
+ {__LINE__, 2.283479263040833e-24, "+0.000000", "%+f"},
+ {__LINE__, 2.283686319235123e-07, "2.2837E-07", "%5.5G"},
+ {__LINE__, 2.285842617231066e-26, "0.000000", "%f"},
+ {__LINE__, 2.293145864755873e-02, "0.02", "%.0g"},
+ {__LINE__, 2.293439381531532e+03, "+2.293439E+03", "%+#1E"},
+ {__LINE__, 2.297972500660698e-22, "2.29797e-22", "%g"},
+ {__LINE__, 2.298725366073681e+23, "2.29873E+23", "%G"},
+ {__LINE__, 2.303151535483950e-29, "2.30315E-29", "%G"},
+ {__LINE__, 2.308565313657699e-25, " 0", "%4.f"},
+ {__LINE__, 2.309305373760733e-07, "2.309305E-07", "%E"},
+ {__LINE__, 2.309693761334710e-19, "2.30969e-19", "%g"},
+ {__LINE__, 2.312218220995774e-20, "+2.31222E-20", "%+.6G"},
+ {__LINE__, 2.313115729670525e+24, "2.31312E+24", "%G"},
+ {__LINE__, 2.315325159866773e-21, "2.315325E-21", "%E"},
+ {__LINE__, 2.316932917620091e-19, "0.000000", "%f"},
+ {__LINE__, 2.317548394633895e+13, "2.31755E+13", "%0G"},
+ {__LINE__, 2.318951465093612e+02, "+2.32e+02", "%+1.2e"},
+ {__LINE__, 2.319151794905482e-17, "+0.000000", "%+0f"},
+ {__LINE__, 2.319708617851078e-27, "0.000000", "%f"},
+ {__LINE__, 2.320019976591725e+20, "2e+20", "%.1g"},
+ {__LINE__, 2.322859962551666e+06, "2.32286e+06", "%g"},
+ {__LINE__, 2.326474568074649e-29, "2.326e-29", "%.4g"},
+ {__LINE__, 2.328400844172053e-07, "2.3284E-07", "%G"},
+ {__LINE__, 2.333695247698112e+16, "2.3337e+16", "%g"},
+ {__LINE__, 2.333717120257130e-19, "+0.000000", "%+f"},
+ {__LINE__, 2.334711793234782e-19, "2.33471E-19", "%5G"},
+ {__LINE__, 2.335524987281242e+02, "+233.55", "%+7.5g"},
+ {__LINE__, 2.335556767836369e-30, "2.34e-30", "%.3g"},
+ {__LINE__, 2.337696964360052e-10, "2.3377e-10", "%1g"},
+ {__LINE__, 2.337858249184500e-14, "2.337858E-14", "%5.6E"},
+ {__LINE__, 2.339984354781169e-14, "2.339984E-14", "%E"},
+ {__LINE__, 2.340849041430089e-04, "0.00023", "%0.2G"},
+ {__LINE__, 2.342388410373363e-24, "2.34239E-24", "%G"},
+ {__LINE__, 2.343933106737237e-22, "2.34393e-22", "%g"},
+ {__LINE__, 2.344870855713960e-08, "0.000000", "%.6f"},
+ {__LINE__, 2.347368965433808e+24, "2347368965433808352116785", "%4.f"},
+ {__LINE__, 2.349417462171421e-02, "+0.0234942", "%+G"},
+ {__LINE__, 2.351071111431207e+11, "235107111143.12", "%.2f"},
+ {__LINE__, 2.352756222810670e+19, "+2.e+19", "%+#4.g"},
+ {__LINE__, 2.355862529217003e-22, "2.355863e-22", "%#4e"},
+ {__LINE__, 2.356804045401445e-30, "2.3568E-30", "%G"},
+ {__LINE__, 2.362100710185559e-26, "2.3621e-26", "%g"},
+ {__LINE__, 2.368330779173562e-12, " 0", "%4.f"},
+ {__LINE__, 2.383329784369796e+22, "2.38333E+22", "%G"},
+ {__LINE__, 2.386845229536477e+01, "+23.868452", "%+#f"},
+ {__LINE__, 2.388207830036780e-05, "0.000024", "%f"},
+ {__LINE__, 2.391809468802907e+21, "+2.391809e+21", "%+e"},
+ {__LINE__, 2.395172908564692e-09, "+0.000000", "%+f"},
+ {__LINE__, 2.395447167030886e-29, "2.39545e-29", "%g"},
+ {__LINE__, 2.397292973389182e+16, "23972929733891823", "%6.f"},
+ {__LINE__, 2.401749832237687e-30, "2.401750E-30", "%E"},
+ {__LINE__, 2.403610502544347e-03, "0.00240361", "%4G"},
+ {__LINE__, 2.404676421776132e+17, "240467642177613206", "%6.f"},
+ {__LINE__, 2.406327689091479e+25, "2.406328e+25", "%e"},
+ {__LINE__, 2.407341999590511e-02, "0.024073", "%f"},
+ {__LINE__, 2.407352797581004e+05, "240735.", "%#g"},
+ {__LINE__, 2.407903467439017e+13, "2.4079E+13", "%G"},
+ {__LINE__, 2.407979635013539e+21, " +2E+21", "%+7.G"},
+ {__LINE__, 2.409513517930790e+29, "240951351793079027174826478585.600853", "%f"},
+ {__LINE__, 2.412530651221551e+10, "+2.41253E+10", "%+G"},
+ {__LINE__, 2.419943224673811e+00, "2.41994", "%#g"},
+ {__LINE__, 2.422474399040258e-15, "0.000000", "%f"},
+ {__LINE__, 2.426060206689458e+18, "2.42606E+18", "%1G"},
+ {__LINE__, 2.439982659679872e+14, "+2.439983E+14", "%+E"},
+ {__LINE__, 2.440528851375447e+13, "24405288513754.466173", "%f"},
+ {__LINE__, 2.441340473292679e+19, "2.44134E+19", "%G"},
+ {__LINE__, 2.443521636943916e+19, " 2.e+19", "%#7.g"},
+ {__LINE__, 2.445925211597624e-27, "2.445925E-27", "%E"},
+ {__LINE__, 2.446966179060722e+25, "2.446966e+25", "%5e"},
+ {__LINE__, 2.447714218717278e+11, "2e+11", "%1.e"},
+ {__LINE__, 2.448339744613286e+06, "2.4483e+06", "%3.5g"},
+ {__LINE__, 2.448772993496189e+03, "2448.77", "%G"},
+ {__LINE__, 2.448857654325229e+22, "+2.44886e+22", "%+g"},
+ {__LINE__, 2.450082452098890e-27, "2.4501E-27", "%#3.5G"},
+ {__LINE__, 2.451293602221637e+05, "245129.360222", "%f"},
+ {__LINE__, 2.454531490229426e+02, "245.453", "%G"},
+ {__LINE__, 2.458958369944980e+14, "2.5E+14", "%6.1E"},
+ {__LINE__, 2.463666680775038e+14, "+246366668077503.80", "%+#.2f"},
+ {__LINE__, 2.471582990960795e+05, "2.471583e+05", "%e"},
+ {__LINE__, 2.474107179274687e+22, "2.47411e+22", "%g"},
+ {__LINE__, 2.474332114849132e-08, "+2.47433e-08", "%+g"},
+ {__LINE__, 2.476956762431716e+18, "+2476956762431715919.348107", "%+#f"},
+ {__LINE__, 2.479091221850607e-22, "0.000000", "%f"},
+ {__LINE__, 2.479819586598431e-24, "2.47982e-24", "%g"},
+ {__LINE__, 2.480006174601455e-05, "2.48001E-05", "%G"},
+ {__LINE__, 2.482672677638334e-26, "+0.000000", "%+f"},
+ {__LINE__, 2.492816492208918e-14, " 0", "%7.f"},
+ {__LINE__, 2.492964173197140e-12, " 2e-12", "%7.g"},
+ {__LINE__, 2.494646635961173e+02, "249.465", "%g"},
+ {__LINE__, 2.494687818780545e+11, "249468781878.054546", "%#7f"},
+ {__LINE__, 2.510083560147301e-13, "+2.510084e-13", "%+#e"},
+ {__LINE__, 2.511186607989480e-30, "2.51E-30", "%.3G"},
+ {__LINE__, 2.514164516133643e-11, "2.51416e-11", "%g"},
+ {__LINE__, 2.517242520804735e+11, "2.517243e+11", "%e"},
+ {__LINE__, 2.518526126400833e-26, "2.51853e-26", "%g"},
+ {__LINE__, 2.520313416401176e+09, "2520313416.401176", "%5f"},
+ {__LINE__, 2.521653160738683e-29, "2.52165e-29", "%#g"},
+ {__LINE__, 2.521941342615338e-16, "2.52194e-16", "%g"},
+ {__LINE__, 2.523554774354461e-03, "+3E-03", "%+.0E"},
+ {__LINE__, 2.525434130825058e+06, "+2.525434E+06", "%+E"},
+ {__LINE__, 2.527616380113364e+02, "2.527616E+02", "%E"},
+ {__LINE__, 2.531871347913505e+09, "+2.53187E+09", "%+#G"},
+ {__LINE__, 2.532167428661069e+06, "2532167.428661", "%f"},
+ {__LINE__, 2.545585718405995e+14, "+2.54559E+14", "%+G"},
+ {__LINE__, 2.546305097286406e+10, "2.546305e+10", "%e"},
+ {__LINE__, 2.547467156069069e-30, "+0.00", "%+3.2f"},
+ {__LINE__, 2.548728793004506e-14, "2.54873E-14", "%G"},
+ {__LINE__, 2.560375602395090e+11, "256037560239.509032", "%0f"},
+ {__LINE__, 2.560555687476687e+03, "2561", "%.4g"},
+ {__LINE__, 2.561709077363443e-24, "+0.000000", "%+f"},
+ {__LINE__, 2.563763849675242e+10, "2.5637638E+10", "%.7E"},
+ {__LINE__, 2.567482414574355e+11, "+2.567482e+11", "%+e"},
+ {__LINE__, 2.571575046303674e-17, "3E-17", "%2.0E"},
+ {__LINE__, 2.572997971296986e+11, "257299797129.698593", "%f"},
+ {__LINE__, 2.578625935900331e+22, "25786259359003311786295.853381", "%f"},
+ {__LINE__, 2.579663282966370e+12, "2.579663e+12", "%e"},
+ {__LINE__, 2.593141782397610e-08, "0.000000", "%f"},
+ {__LINE__, 2.594386109584196e+04, "3.E+04", "%#6.0E"},
+ {__LINE__, 2.598069318007816e-22, "2.59807e-22", "%g"},
+ {__LINE__, 2.600910462290091e+09, "2.600910E+09", "%6E"},
+ {__LINE__, 2.602580183614458e-03, "2.602580e-03", "%e"},
+ {__LINE__, 2.606540360440264e+09, "+2606540360.4", "%+#0.1f"},
+ {__LINE__, 2.610016419698116e-21, "+3.e-21", "%+#3.g"},
+ {__LINE__, 2.612279323574882e-20, "2.61228E-20", "%G"},
+ {__LINE__, 2.614157324336453e-14, "2.61416e-14", "%g"},
+ {__LINE__, 2.614688721873993e-09, "2.61e-09", "%6.2e"},
+ {__LINE__, 2.616661104472416e-15, " 0", "%5.f"},
+ {__LINE__, 2.616742079283195e-09, " +3E-09", "%+7.E"},
+ {__LINE__, 2.618075304717427e+24, "2.618075e+24", "%e"},
+ {__LINE__, 2.624118573335769e+26, "262411857333576925555007619.550452", "%1f"},
+ {__LINE__, 2.625718894274227e+24, "+2625718894274227110940955.753904", "%+f"},
+ {__LINE__, 2.627081999477812e+03, "2627.081999", "%f"},
+ {__LINE__, 2.631061062224705e+14, "263106106222470.481626", "%f"},
+ {__LINE__, 2.631545877128814e+27, "+2.63155e+27", "%+g"},
+ {__LINE__, 2.632694395848818e-11, "2.63269e-11", "%g"},
+ {__LINE__, 2.636728891022008e-22, "+2.63673e-22", "%+#4g"},
+ {__LINE__, 2.638495675008130e-28, "+2.638496e-28", "%+e"},
+ {__LINE__, 2.639704195859799e-11, "0.", "%#.0f"},
+ {__LINE__, 2.641645264652665e-20, "0", "%0.f"},
+ {__LINE__, 2.642012075064497e-20, "3E-20", "%0.E"},
+ {__LINE__, 2.648725869006487e-29, " 3E-29", "%6.G"},
+ {__LINE__, 2.649060724417770e+12, "3E+12", "%3.G"},
+ {__LINE__, 2.651188545120166e-17, "0.000", "%.3f"},
+ {__LINE__, 2.652302152621621e+14, "2.7E+14", "%.2G"},
+ {__LINE__, 2.653309718412604e-28, "0.000000", "%f"},
+ {__LINE__, 2.658344750491858e-21, " 3e-21", "%6.g"},
+ {__LINE__, 2.664625074612594e+15, "3e+15", "%1.g"},
+ {__LINE__, 2.666953728270800e-15, "3e-15", "%0.e"},
+ {__LINE__, 2.674515419678877e-11, " 3E-11", "%6.E"},
+ {__LINE__, 2.680054917256578e+15, "2680054917256577.5", "%#2.1f"},
+ {__LINE__, 2.680495609883415e-11, "2.68E-11", "%#.3G"},
+ {__LINE__, 2.685757893641070e+23, "268575789364107020418259.70809", "%1.5f"},
+ {__LINE__, 2.695551226058178e+16, "26955512260581775.407786", "%f"},
+ {__LINE__, 2.696346377519671e+04, "+26963.5", "%+G"},
+ {__LINE__, 2.714262310601257e+17, "+2.714262E+17", "%+E"},
+ {__LINE__, 2.719227450016317e-01, "0.271923", "%G"},
+ {__LINE__, 2.724135433346056e-30, "+2.72414e-30", "%+g"},
+ {__LINE__, 2.725143224130276e+14, "272514322413027.576530", "%6f"},
+ {__LINE__, 2.729355189648310e-03, "+0.00273", "%+.5f"},
+ {__LINE__, 2.732872167724945e+11, "2.73287E+11", "%G"},
+ {__LINE__, 2.737709476435412e+17, "273770947643541218.141650", "%f"},
+ {__LINE__, 2.739299356074967e-15, "2.7E-15", "%.2G"},
+ {__LINE__, 2.740793612304798e-27, "2.740794E-27", "%.7G"},
+ {__LINE__, 2.742030156175960e+20, "2.74203e+20", "%2.6g"},
+ {__LINE__, 2.744455324096085e+11, "2.74446E+11", "%G"},
+ {__LINE__, 2.745179546531160e+07, "2.7452E+07", "%.5G"},
+ {__LINE__, 2.747470562525333e+04, "3E+04", "%2.E"},
+ {__LINE__, 2.750243314674629e+21, "2.75024E+21", "%#G"},
+ {__LINE__, 2.750250224436030e+20, "+2.750250e+20", "%+0.6e"},
+ {__LINE__, 2.752712858561084e-22, "2.752713e-22", "%e"},
+ {__LINE__, 2.756982987656667e-03, "0.002756983", "%#.7G"},
+ {__LINE__, 2.761841188479590e+13, "3e+13", "%1.g"},
+ {__LINE__, 2.769498440434419e+00, "+3e+00", "%+0.e"},
+ {__LINE__, 2.769993785786379e+10, "27699937857.863794", "%f"},
+ {__LINE__, 2.772900256376753e-06, "+2.7729E-06", "%+7.6G"},
+ {__LINE__, 2.774401482467457e-06, "2.8e-06", "%3.2g"},
+ {__LINE__, 2.777691370374757e-02, "+0.027777", "%+f"},
+ {__LINE__, 2.779836227365899e-09, "3e-09", "%5.0g"},
+ {__LINE__, 2.780481651765741e+01, "2.780482E+01", "%E"},
+ {__LINE__, 2.782228478714809e-26, "2.782228E-26", "%4.7G"},
+ {__LINE__, 2.790457781719376e+13, "+2.8e+13", "%+.2g"},
+ {__LINE__, 2.792026581166417e-30, " 3.e-30", "%#7.0g"},
+ {__LINE__, 2.792396278299615e-08, "0.00", "%#.2f"},
+ {__LINE__, 2.793658047689995e-10, "2.794e-10", "%#0.4g"},
+ {__LINE__, 2.795707358229888e-25, "0.000000", "%f"},
+ {__LINE__, 2.796253091758523e-06, "2.796E-06", "%.4G"},
+ {__LINE__, 2.796756564788716e-24, "2.796757e-24", "%e"},
+ {__LINE__, 2.798730444798773e-14, "2.79873e-14", "%g"},
+ {__LINE__, 2.799108397670447e-24, "3E-24", "%.0G"},
+ {__LINE__, 2.799389008872835e+06, "2799389.", "%#0.f"},
+ {__LINE__, 2.800413998518039e-14, "0.000000", "%f"},
+ {__LINE__, 2.803237602587100e+15, "+2803237602587100.418816", "%+5f"},
+ {__LINE__, 2.803474415574551e-04, "0.0002803", "%.7f"},
+ {__LINE__, 2.804957468647181e+25, "2.80496e+25", "%g"},
+ {__LINE__, 2.809345112788226e+09, "2809345112.788226", "%.6f"},
+ {__LINE__, 2.811518239408899e+10, "3e+10", "%1.g"},
+ {__LINE__, 2.813188439967416e-16, "0.0000000", "%5.7f"},
+ {__LINE__, 2.813497118051755e+08, "2.8135e+08", "%.5g"},
+ {__LINE__, 2.815748256510577e-29, "0.000000", "%2f"},
+ {__LINE__, 2.816076365485207e-01, "0.281608", "%0G"},
+ {__LINE__, 2.816083345772131e+24, "2.8161e+24", "%6.4e"},
+ {__LINE__, 2.818686957605178e+12, "2.8187E+12", "%.5G"},
+ {__LINE__, 2.821903538737691e+20, "2.8219E+20", "%G"},
+ {__LINE__, 2.823659589845680e+26, "2.82366e+26", "%2g"},
+ {__LINE__, 2.823685630865012e+22, "2.82369E+22", "%G"},
+ {__LINE__, 2.828826386007914e+21, "2.828826E+21", "%7E"},
+ {__LINE__, 2.830997901034349e+04, "+3e+04", "%+0.e"},
+ {__LINE__, 2.833886731091353e-26, "+2.833887e-26", "%+4e"},
+ {__LINE__, 2.839965144893913e+28, "28399651448939131626048038015.1421", "%.4f"},
+ {__LINE__, 2.840651452049947e-09, "2.841E-09", "%#.3E"},
+ {__LINE__, 2.843388001911757e-01, "0.284339", "%g"},
+ {__LINE__, 2.846122151080671e+14, "2.84612E+14", "%.5E"},
+ {__LINE__, 2.851257828837595e+05, "+285126", "%+5.f"},
+ {__LINE__, 2.853823884459520e+07, "+2.85382E+07", "%+G"},
+ {__LINE__, 2.853870068368765e-06, "2.854E-06", "%4.3E"},
+ {__LINE__, 2.856687358149867e+01, "+28.567", "%+6.5G"},
+ {__LINE__, 2.858946600073752e+06, "2.8589466e+06", "%3.7e"},
+ {__LINE__, 2.861525727138818e+24, "2.8615257e+24", "%2.7e"},
+ {__LINE__, 2.865104175886071e-24, "0.000000", "%f"},
+ {__LINE__, 2.870678920363198e-14, "2.87068E-14", "%G"},
+ {__LINE__, 2.873298537233691e+09, "+2.8733e+09", "%+g"},
+ {__LINE__, 2.877939609444375e-02, "0.028779", "%f"},
+ {__LINE__, 2.878253985341728e+13, "2.87825E+13", "%G"},
+ {__LINE__, 2.879299244903946e+29, "287929924490394597569320467301", "%0.f"},
+ {__LINE__, 2.885516225515485e-26, "0.000000", "%f"},
+ {__LINE__, 2.886013724129579e+20, "+3e+20", "%+4.g"},
+ {__LINE__, 2.887032786975506e-30, "0.000000", "%f"},
+ {__LINE__, 2.890415456531026e-29, "2.89042E-29", "%G"},
+ {__LINE__, 2.893177360548214e-13, "2.893E-13", "%#6.3E"},
+ {__LINE__, 2.895265536458195e+26, "2.89527e+26", "%5g"},
+ {__LINE__, 2.903844533810152e+23, "290384453381015195105874.23", "%.2f"},
+ {__LINE__, 2.909060558287504e+27, "2.90906e+27", "%g"},
+ {__LINE__, 2.911615480973172e-05, "2.91162E-05", "%3G"},
+ {__LINE__, 2.912692297221896e+09, "2912692297.221896", "%#f"},
+ {__LINE__, 2.913595662485813e-24, "2.9136E-24", "%G"},
+ {__LINE__, 2.915960840341896e-27, "0.000000", "%f"},
+ {__LINE__, 2.920451095973991e-16, "2.92e-16", "%2.2e"},
+ {__LINE__, 2.920528295810925e+06, "2.92053E+06", "%#G"},
+ {__LINE__, 2.921564671017147e+20, "2.921565E+20", "%#6E"},
+ {__LINE__, 2.921628350942189e+01, "2.921628E+01", "%E"},
+ {__LINE__, 2.921843377455232e+20, "2.921843E+20", "%#E"},
+ {__LINE__, 2.930156950319384e+29, "2.930E+29", "%1.3E"},
+ {__LINE__, 2.931229858895071e-30, "2.9e-30", "%4.2g"},
+ {__LINE__, 2.931753029689166e+20, "2.93175e+20", "%g"},
+ {__LINE__, 2.933023693079342e+15, "3.E+15", "%#.1G"},
+ {__LINE__, 2.933078733225520e+26, "2.93308E+26", "%G"},
+ {__LINE__, 2.933528170896643e-14, "+2.93353e-14", "%+g"},
+ {__LINE__, 2.938648437428148e+00, "2.938648e+00", "%e"},
+ {__LINE__, 2.940752238221344e+26, "+2.94075E+26", "%+G"},
+ {__LINE__, 2.942836470459675e+20, "2.9428e+20", "%6.4e"},
+ {__LINE__, 2.943218333254941e+29, "294321833325494086608387078740.634024", "%f"},
+ {__LINE__, 2.943690574007512e-27, "0.000000", "%f"},
+ {__LINE__, 2.945452907046501e+09, "+2.9455E+09", "%+.5G"},
+ {__LINE__, 2.946648725966953e+16, "29466487259669534.637396", "%4f"},
+ {__LINE__, 2.955119322417825e+29, "2.95512E+29", "%G"},
+ {__LINE__, 2.966481197538973e+24, "2.96648e+24", "%#g"},
+ {__LINE__, 2.969362862661362e+08, "+2.969363e+08", "%+7e"},
+ {__LINE__, 2.970062459990078e+21, "+2.97006E+21", "%+G"},
+ {__LINE__, 2.971059959019791e+10, " 3E+10", "%7.G"},
+ {__LINE__, 2.973020205606034e-29, "0.000000", "%f"},
+ {__LINE__, 2.977223210301426e+04, "2.977223e+04", "%#e"},
+ {__LINE__, 2.977467832772786e-26, "0.000000", "%f"},
+ {__LINE__, 2.981433606423384e+18, "2981433606423384397.032805", "%f"},
+ {__LINE__, 2.981615513287404e-17, "2.98162e-17", "%g"},
+ {__LINE__, 2.983880743847276e+19, " 3e+19", "%7.e"},
+ {__LINE__, 2.983927792297305e-28, "2.983928e-28", "%e"},
+ {__LINE__, 2.984807359492058e-17, " 0", "%2.f"},
+ {__LINE__, 2.985123412933032e+09, "+2.98512e+09", "%+g"},
+ {__LINE__, 2.991132955408629e-27, "+2.99113e-27", "%+4g"},
+ {__LINE__, 2.992345635923643e+19, "3E+19", "%4.G"},
+ {__LINE__, 2.993024238285395e-05, "2.99302e-05", "%2g"},
+ {__LINE__, 2.995303406756363e+16, "+2.995303E+16", "%+E"},
+ {__LINE__, 2.995492577854335e+19, "+29954925778543346481.797016", "%+f"},
+ {__LINE__, 2.996856271675341e-25, "+3e-25", "%+0.e"},
+ {__LINE__, 2.997813968112619e+12, "2.99781e+12", "%#5g"},
+ {__LINE__, 3.002097486457961e-17, "3.00210e-17", "%5.5e"},
+ {__LINE__, 3.006538123158692e+28, "+3.00654E+28", "%+#G"},
+ {__LINE__, 3.007293721729544e+04, "30072.937217", "%f"},
+ {__LINE__, 3.008301791944493e-07, "3.008e-07", "%.3e"},
+ {__LINE__, 3.011742184603817e-17, "3.011742E-17", "%#E"},
+ {__LINE__, 3.024641547299177e-30, "3.02464e-30", "%g"},
+ {__LINE__, 3.026525135110198e-28, "3e-28", "%.0e"},
+ {__LINE__, 3.026768160756558e+20, "3.02677E+20", "%G"},
+ {__LINE__, 3.031928829940975e+18, "3031928829940975234.1", "%0.1f"},
+ {__LINE__, 3.039787705138620e+24, "+3.E+24", "%+#5.G"},
+ {__LINE__, 3.039803824423916e-02, "0.030398", "%5f"},
+ {__LINE__, 3.041236293199133e-26, "3.04124e-26", "%g"},
+ {__LINE__, 3.045634954037886e+04, "30456.3", "%g"},
+ {__LINE__, 3.047528114241850e+25, "3e+25", "%0.e"},
+ {__LINE__, 3.047958193737501e-24, "3.04796E-24", "%#G"},
+ {__LINE__, 3.049537324414302e-16, "3.04954E-16", "%G"},
+ {__LINE__, 3.050500637681798e-30, "3.0505E-30", "%G"},
+ {__LINE__, 3.051769626625307e-01, "0.305177", "%f"},
+ {__LINE__, 3.057280201971847e+11, "+3.05728E+11", "%+.5E"},
+ {__LINE__, 3.060046173306881e-10, "+3.060046e-10", "%+e"},
+ {__LINE__, 3.069732667347204e+27, "+3069732667347204291274920251.453295", "%+f"},
+ {__LINE__, 3.075060836786916e-14, "0.000000", "%f"},
+ {__LINE__, 3.078175179670964e+13, "3.07818E+13", "%G"},
+ {__LINE__, 3.080305344303183e-21, "3.08031e-21", "%6g"},
+ {__LINE__, 3.088881497064043e+27, "+3.088881E+27", "%+3E"},
+ {__LINE__, 3.089196877931209e-20, "3.089197e-20", "%e"},
+ {__LINE__, 3.091400888880487e-08, "3e-08", "%2.e"},
+ {__LINE__, 3.093410684178904e+16, "3.09341e+16", "%g"},
+ {__LINE__, 3.104225344208216e-21, "0.000000", "%f"},
+ {__LINE__, 3.105843728248599e+13, "3.e+13", "%#.0g"},
+ {__LINE__, 3.106463071390893e-07, "0.0000", "%.4f"},
+ {__LINE__, 3.107784123569379e+02, "+310.778", "%+G"},
+ {__LINE__, 3.110605148983672e-20, "3.1106051E-20", "%.7E"},
+ {__LINE__, 3.111702418162670e-04, "0.00031117", "%.5G"},
+ {__LINE__, 3.117610675303153e-17, "3.11761e-17", "%g"},
+ {__LINE__, 3.123620125717981e+07, "3.1236e+07", "%2.5g"},
+ {__LINE__, 3.125648558809832e-24, "+3.125649E-24", "%+#0.6E"},
+ {__LINE__, 3.129025163659283e+10, "31290251636.592825", "%#f"},
+ {__LINE__, 3.130689119412709e-29, "+3.131E-29", "%+#.4G"},
+ {__LINE__, 3.135681222132527e+13, "3.13568E+13", "%G"},
+ {__LINE__, 3.138290485073330e-10, "3.13829E-10", "%G"},
+ {__LINE__, 3.141255250155306e-12, "3.14126E-12", "%G"},
+ {__LINE__, 3.143224520918429e+25, "3.14322E+25", "%#1G"},
+ {__LINE__, 3.144746921366173e-16, " 0", "%7.f"},
+ {__LINE__, 3.151336678241994e+19, "+3.15134E+19", "%+G"},
+ {__LINE__, 3.161752935716549e+24, "3.2E+24", "%2.1E"},
+ {__LINE__, 3.167106521258172e-10, "+3.167107e-10", "%+e"},
+ {__LINE__, 3.167266522824146e-04, "3E-04", "%3.E"},
+ {__LINE__, 3.169995217131489e+27, "3169995217131488907114089670.358226", "%f"},
+ {__LINE__, 3.172117220467692e-21, "3.1721E-21", "%.5G"},
+ {__LINE__, 3.173824170351611e+02, " 3e+02", "%6.e"},
+ {__LINE__, 3.186291452544739e-28, " 0", "%2.f"},
+ {__LINE__, 3.194750094186063e+03, "+3.194750E+03", "%+E"},
+ {__LINE__, 3.195001037118137e-20, "0", "%0.0f"},
+ {__LINE__, 3.199271564719560e+02, "319.927", "%g"},
+ {__LINE__, 3.212803450638544e+20, "3.2128e+20", "%.6g"},
+ {__LINE__, 3.214502877263883e+24, "3214502877263882840708220", "%2.f"},
+ {__LINE__, 3.214658414074286e-01, "+0.321466", "%+#g"},
+ {__LINE__, 3.217627975823673e+00, "3.217628", "%f"},
+ {__LINE__, 3.218257328710536e-07, "3.21826e-07", "%6.5e"},
+ {__LINE__, 3.221949479347008e+02, "322.194948", "%f"},
+ {__LINE__, 3.222862935507443e-14, "3.222863E-14", "%E"},
+ {__LINE__, 3.223750247261608e+19, "3.22375e+19", "%g"},
+ {__LINE__, 3.236030335782375e+05, "3.236030e+05", "%e"},
+ {__LINE__, 3.241078803072735e+19, "3.24108e+19", "%g"},
+ {__LINE__, 3.248069569167045e-06, "0.000003", "%#f"},
+ {__LINE__, 3.248148973717269e-15, "3.24815E-15", "%G"},
+ {__LINE__, 3.251150704311790e+25, "+3.25115e+25", "%+5g"},
+ {__LINE__, 3.254498593372140e+15, "+3.2545e+15", "%+g"},
+ {__LINE__, 3.254949399612861e-13, "+3.255E-13", "%+7.3E"},
+ {__LINE__, 3.255490928554106e-17, "3.255491e-17", "%e"},
+ {__LINE__, 3.262333894422112e+17, "326233389442211185.738074", "%0f"},
+ {__LINE__, 3.263923577545217e-24, "0.0000000", "%.7f"},
+ {__LINE__, 3.267125289609703e+23, "3.26713e+23", "%#.5e"},
+ {__LINE__, 3.267906049108331e+27, "3.267906E+27", "%6E"},
+ {__LINE__, 3.269885039157328e+14, "326988503915732.797722", "%f"},
+ {__LINE__, 3.296011393609953e-27, " 3E-27", "%7.E"},
+ {__LINE__, 3.296452164568996e+29, "3.296452E+29", "%E"},
+ {__LINE__, 3.296544736555325e+10, "+3.29654E+10", "%+.6G"},
+ {__LINE__, 3.301861835798572e+03, "3301.862", "%4.7g"},
+ {__LINE__, 3.311292283423002e+21, " 3E+21", "%6.G"},
+ {__LINE__, 3.314868440076262e-10, "3.3149E-10", "%.5G"},
+ {__LINE__, 3.318057982247451e-13, "3.3181e-13", "%0.5g"},
+ {__LINE__, 3.318139218410071e-22, "0.000000", "%f"},
+ {__LINE__, 3.326769904839351e-11, "+3.3268e-11", "%+0.4e"},
+ {__LINE__, 3.327483659787219e+27, "+3.32748e+27", "%+g"},
+ {__LINE__, 3.332666889640198e+17, "333266688964019763.830038", "%f"},
+ {__LINE__, 3.333807449377253e+10, "+3.33e+10", "%+.3g"},
+ {__LINE__, 3.334572302792625e-09, "3.334572E-09", "%E"},
+ {__LINE__, 3.337567126586765e-17, "0.0000000", "%#3.7f"},
+ {__LINE__, 3.340512607683786e-04, "+3E-04", "%+1.E"},
+ {__LINE__, 3.344911557516870e+04, "33449.1", "%G"},
+ {__LINE__, 3.346464302017296e+26, "+3.E+26", "%+#3.G"},
+ {__LINE__, 3.348503166628953e+00, "+3.348503e+00", "%+e"},
+ {__LINE__, 3.350025157778138e-19, "3.35003e-19", "%6g"},
+ {__LINE__, 3.352826233035342e+11, "335282623303.534200", "%7f"},
+ {__LINE__, 3.357174089765502e+10, "3.35717E+10", "%G"},
+ {__LINE__, 3.369253166475501e+03, "+3369.25", "%+G"},
+ {__LINE__, 3.371385975046735e+02, "337.", "%#.0f"},
+ {__LINE__, 3.372532650462104e-04, "+0.000", "%+.3f"},
+ {__LINE__, 3.376498162710442e-26, "3.376498e-26", "%e"},
+ {__LINE__, 3.383510307689135e-12, " 3e-12", "%7.0e"},
+ {__LINE__, 3.388427914080631e-04, "0.0003", "%2.4f"},
+ {__LINE__, 3.390757423408097e+29, "3.3908E+29", "%.4E"},
+ {__LINE__, 3.393963140962879e-11, "3.39396e-11", "%g"},
+ {__LINE__, 3.399245742994444e+24, "3.399246E+24", "%E"},
+ {__LINE__, 3.417690405546708e-26, "0.00000", "%4.5f"},
+ {__LINE__, 3.421159360472045e-30, "3.42116E-30", "%G"},
+ {__LINE__, 3.421973947898887e-06, "3.42197E-06", "%4G"},
+ {__LINE__, 3.425949002482817e-10, "+3.42595E-10", "%+G"},
+ {__LINE__, 3.428355150377972e+08, "3.42836E+08", "%G"},
+ {__LINE__, 3.445035158951526e+15, "3445035158951526.454985", "%f"},
+ {__LINE__, 3.447363996077534e+28, "+3e+28", "%+2.e"},
+ {__LINE__, 3.451571062654907e-03, "0.00345157", "%G"},
+ {__LINE__, 3.452787236877688e+09, "3.45279e+09", "%g"},
+ {__LINE__, 3.454114826574939e-22, "3.e-22", "%#3.e"},
+ {__LINE__, 3.455241965974631e-03, "0.003455", "%#f"},
+ {__LINE__, 3.456190496554365e-18, "3.E-18", "%#5.E"},
+ {__LINE__, 3.456804565717233e-19, "+0.000", "%+2.3f"},
+ {__LINE__, 3.457077651539715e-28, "3.457078E-28", "%E"},
+ {__LINE__, 3.472025705376229e+22, "3.472e+22", "%7.4g"},
+ {__LINE__, 3.473308270919079e+03, "3.473308e+03", "%e"},
+ {__LINE__, 3.474468013243007e-30, "3.47447e-30", "%g"},
+ {__LINE__, 3.477976957097698e+22, "3.47798e+22", "%g"},
+ {__LINE__, 3.501174631980057e-06, "4e-06", "%4.g"},
+ {__LINE__, 3.501808481702140e+20, "3.50181E+20", "%G"},
+ {__LINE__, 3.511760000705324e+14, "351176000070532.357000", "%f"},
+ {__LINE__, 3.511870226306087e+29, "3.51187e+29", "%.5e"},
+ {__LINE__, 3.518846859147841e+02, "+351.885", "%+G"},
+ {__LINE__, 3.521659149753418e+25, "35216591497534182053641416", "%5.f"},
+ {__LINE__, 3.521721228178747e+21, "4e+21", "%2.e"},
+ {__LINE__, 3.526696007281458e+22, "3.5267e+22", "%g"},
+ {__LINE__, 3.535631031379084e-11, "4e-11", "%5.0g"},
+ {__LINE__, 3.537219665456759e-01, "0.353722", "%f"},
+ {__LINE__, 3.537252728287785e-09, "3.537253E-09", "%E"},
+ {__LINE__, 3.542561277796815e-19, "3.542561E-19", "%E"},
+ {__LINE__, 3.548942336915745e+13, "3.54894E+13", "%.5E"},
+ {__LINE__, 3.574385715121768e-24, "3.57439E-24", "%#G"},
+ {__LINE__, 3.578068067760211e-13, "3.578068E-13", "%E"},
+ {__LINE__, 3.583296432862266e-13, "3.5833e-13", "%g"},
+ {__LINE__, 3.591567367115590e+19, "3.59157e+19", "%1g"},
+ {__LINE__, 3.594902312287635e-24, "3.5949E-24", "%G"},
+ {__LINE__, 3.602929486764515e+12, "3602929486764.514522", "%#f"},
+ {__LINE__, 3.606699462631472e-01, "+0.360670", "%+f"},
+ {__LINE__, 3.608605968319811e+17, "3.60861e+17", "%g"},
+ {__LINE__, 3.608780761567885e+24, "4e+24", "%0.e"},
+ {__LINE__, 3.623857274715022e-15, "3.62386E-15", "%1G"},
+ {__LINE__, 3.627346251764432e-22, "3.627e-22", "%.4g"},
+ {__LINE__, 3.652610391698086e-16, "0.000000", "%3f"},
+ {__LINE__, 3.657463146689917e-19, " 0", "%4.0f"},
+ {__LINE__, 3.658538858712938e-15, "4E-15", "%5.G"},
+ {__LINE__, 3.660337267266058e+16, "+36603372672660579.034698", "%+f"},
+ {__LINE__, 3.661588742065142e-01, "0.366159", "%g"},
+ {__LINE__, 3.662296387211376e-25, "0.000000", "%f"},
+ {__LINE__, 3.668511100303393e-29, "0.000000", "%7f"},
+ {__LINE__, 3.669499303661920e+06, "3.6695e+06", "%1.5g"},
+ {__LINE__, 3.676856420121343e-23, "3.6769e-23", "%0.4e"},
+ {__LINE__, 3.677197473476901e-19, "+3.6772e-19", "%+g"},
+ {__LINE__, 3.677281754506453e+12, "+3677281754506.452671", "%+f"},
+ {__LINE__, 3.678420802401506e-19, "3.67842E-19", "%G"},
+ {__LINE__, 3.679970245325769e+07, "3.67997e+07", "%g"},
+ {__LINE__, 3.682528947621349e+05, "4.e+05", "%#5.e"},
+ {__LINE__, 3.688257471304210e+22, "36882574713042104441740.320908", "%f"},
+ {__LINE__, 3.689129734472166e-01, "0.368913", "%0.6G"},
+ {__LINE__, 3.693483801463324e+12, "4E+12", "%3.E"},
+ {__LINE__, 3.694612396584729e-21, "+3.69461E-21", "%+G"},
+ {__LINE__, 3.706150073392112e-19, "0.000000", "%2f"},
+ {__LINE__, 3.706824819530577e+21, "3706824819530576853310.321894", "%f"},
+ {__LINE__, 3.709583789659276e+19, "+3.709584E+19", "%+#E"},
+ {__LINE__, 3.711137503697284e+22, "3.7111E+22", "%.5G"},
+ {__LINE__, 3.717307412969522e-22, "3.717307E-22", "%#E"},
+ {__LINE__, 3.717434999853808e+24, " 4E+24", "%6.G"},
+ {__LINE__, 3.720761662524312e+14, "+372076166252431.2285", "%+1.4f"},
+ {__LINE__, 3.721613815237707e-10, "3.72161e-10", "%g"},
+ {__LINE__, 3.725086467464346e+14, "3.72509E+14", "%G"},
+ {__LINE__, 3.727427083626536e-15, "+4E-15", "%+.0G"},
+ {__LINE__, 3.731138322599465e-13, "3.73114e-13", "%5g"},
+ {__LINE__, 3.732248129614146e-04, " 4E-04", "%7.E"},
+ {__LINE__, 3.744422223926118e-24, "3.744422E-24", "%E"},
+ {__LINE__, 3.745595428897916e+21, "+3745595428897916079336.027906", "%+f"},
+ {__LINE__, 3.751308304055989e-08, "+3.751308e-08", "%+e"},
+ {__LINE__, 3.755395417696132e-02, "0.037554", "%f"},
+ {__LINE__, 3.769103881505159e+09, "3.7691e+09", "%g"},
+ {__LINE__, 3.769535572757430e+00, "3.769536", "%6.7G"},
+ {__LINE__, 3.770823872348274e-28, "+0.000000", "%+f"},
+ {__LINE__, 3.771160653578178e+29, "3.77116e+29", "%g"},
+ {__LINE__, 3.776563752716444e-12, "4E-12", "%.0E"},
+ {__LINE__, 3.777953798674786e-28, "3.77795e-28", "%g"},
+ {__LINE__, 3.785994690686598e+28, "4E+28", "%5.G"},
+ {__LINE__, 3.787487488835162e+01, "+37.874875", "%+5f"},
+ {__LINE__, 3.788249311173359e-18, "3.788249E-18", "%E"},
+ {__LINE__, 3.798728360791314e-08, "3.798728E-08", "%2E"},
+ {__LINE__, 3.799038238867092e+05, "3.79904E+05", "%.5E"},
+ {__LINE__, 3.799822564549600e+06, "3.79982E+06", "%.5E"},
+ {__LINE__, 3.804862840499834e-16, "0", "%1.f"},
+ {__LINE__, 3.805375156822481e+12, "3805375156822.4814861", "%.7f"},
+ {__LINE__, 3.821612790153376e-17, "3.821613e-17", "%e"},
+ {__LINE__, 3.825193659558693e+14, "3.82519E+14", "%#G"},
+ {__LINE__, 3.834180638680996e+17, "+383418063868099565.638659", "%+f"},
+ {__LINE__, 3.834759760605814e-12, "3.83476E-12", "%G"},
+ {__LINE__, 3.839786235582770e+16, "+3.84e+16", "%+0.3g"},
+ {__LINE__, 3.843164462248778e+28, "3.84316e+28", "%#g"},
+ {__LINE__, 3.845599697858050e+22, "3.8456E+22", "%G"},
+ {__LINE__, 3.850147271017228e-21, "3.85e-21", "%.4g"},
+ {__LINE__, 3.850283557812101e+07, "3.85028E+07", "%G"},
+ {__LINE__, 3.854235609725703e+03, "3854.24", "%G"},
+ {__LINE__, 3.864901885489405e-15, "3.8649E-15", "%G"},
+ {__LINE__, 3.868630187629983e-24, "3.868630e-24", "%e"},
+ {__LINE__, 3.876764606134972e-03, "+3.8767646e-03", "%+#0.7e"},
+ {__LINE__, 3.884553592855422e+08, "+3.8845536e+08", "%+4.7e"},
+ {__LINE__, 3.887417494351062e+03, "3887.42", "%0g"},
+ {__LINE__, 3.887561018972304e+03, "3887.56", "%G"},
+ {__LINE__, 3.888554801724658e-24, "3.888555e-24", "%e"},
+ {__LINE__, 3.892806891909861e-01, "0.389281", "%f"},
+ {__LINE__, 3.914459791345755e+15, "+3.914460E+15", "%+E"},
+ {__LINE__, 3.918383209642759e+01, "39.1838", "%#G"},
+ {__LINE__, 3.923970658741865e-10, "3.92397E-10", "%G"},
+ {__LINE__, 3.928163650272335e+18, "3928163650272335161.162118", "%f"},
+ {__LINE__, 3.933053127721002e-20, "3.933053e-20", "%e"},
+ {__LINE__, 3.939306552155218e-29, "3.93931E-29", "%G"},
+ {__LINE__, 3.953007066379472e+07, "3.953007E+07", "%E"},
+ {__LINE__, 3.954924824986267e-01, "3.954925E-01", "%E"},
+ {__LINE__, 3.956156072067987e+15, "3.956E+15", "%0.4G"},
+ {__LINE__, 3.957756196797224e+22, "4.0E+22", "%4.1E"},
+ {__LINE__, 3.960011413261009e+27, "+3960011413261008783592842519.283295", "%+f"},
+ {__LINE__, 3.961789076323378e+20, "396178907632337828914.614875", "%f"},
+ {__LINE__, 3.961985468081708e-28, "3.96199E-28", "%1G"},
+ {__LINE__, 3.975007582283812e-27, "0.000000", "%0.6f"},
+ {__LINE__, 3.987586813142132e+15, "+3.98759e+15", "%+g"},
+ {__LINE__, 3.992250836957379e+21, "3.99225E+21", "%0G"},
+ {__LINE__, 3.992985048620057e+00, "3.9930", "%.4f"},
+ {__LINE__, 4.000000000000000e+02, "400.00", "%.2f"},
+ {__LINE__, 4.000145414240556e+14, "4.00015e+14", "%#6g"},
+ {__LINE__, 4.000774453529974e-25, "4E-25", "%.0E"},
+ {__LINE__, 4.002041494804383e+17, "4.002041E+17", "%E"},
+ {__LINE__, 4.005505415013214e+17, " 4E+17", "%6.2G"},
+ {__LINE__, 4.008960306876491e-28, "0.000", "%.3f"},
+ {__LINE__, 4.032337828117640e+16, "4.03234E+16", "%G"},
+ {__LINE__, 4.035414597530057e+26, "403541459753005682387083652.429283", "%f"},
+ {__LINE__, 4.037065874793069e-01, "0.403707", "%f"},
+ {__LINE__, 4.047856284449970e-14, "4.04786E-14", "%#G"},
+ {__LINE__, 4.049037221323070e-04, "4.049037e-04", "%e"},
+ {__LINE__, 4.053458853142009e-07, "4E-07", "%2.0E"},
+ {__LINE__, 4.056455443275955e-22, "4.056455e-22", "%e"},
+ {__LINE__, 4.058158020771355e-22, "4.05816e-22", "%#2g"},
+ {__LINE__, 4.067283508945137e+02, "+4.07e+02", "%+5.2e"},
+ {__LINE__, 4.072155715199509e+11, "4.072e+11", "%.4g"},
+ {__LINE__, 4.074643403755990e-22, "4e-22", "%0.g"},
+ {__LINE__, 4.077450352325251e+08, "4.1e+08", "%3.2g"},
+ {__LINE__, 4.081492619284916e-08, "4.081493E-08", "%E"},
+ {__LINE__, 4.083271801996951e-10, "4.083272E-10", "%#E"},
+ {__LINE__, 4.090188547940879e-15, "4.090189E-15", "%#E"},
+ {__LINE__, 4.091167728938537e-11, "4e-11", "%1.g"},
+ {__LINE__, 4.091916745541154e+15, "4091916745541153.588306", "%f"},
+ {__LINE__, 4.092366122921161e+23, "4E+23", "%0.E"},
+ {__LINE__, 4.094638368212577e-11, "4.09464E-11", "%#G"},
+ {__LINE__, 4.097148443124199e-16, "0.000000", "%f"},
+ {__LINE__, 4.101057893946401e+06, "4e+06", "%4.g"},
+ {__LINE__, 4.101209521231476e+28, "41012095212314756409455185348.633677", "%f"},
+ {__LINE__, 4.105683659045903e+05, "+4.E+05", "%+#1.G"},
+ {__LINE__, 4.111553717385758e-16, "4.11155e-16", "%g"},
+ {__LINE__, 4.112186409918593e+14, "+4.11219e+14", "%+g"},
+ {__LINE__, 4.117782144860865e+25, "4.117782E+25", "%5E"},
+ {__LINE__, 4.119420921722146e-27, "4.11942e-27", "%g"},
+ {__LINE__, 4.134953783635018e+14, "+4.1349538e+14", "%+.7e"},
+ {__LINE__, 4.136990822648468e+11, "4.136991E+11", "%E"},
+ {__LINE__, 4.140475788523046e+14, "+4E+14", "%+5.G"},
+ {__LINE__, 4.149589679915584e+24, "4.14959E+24", "%2G"},
+ {__LINE__, 4.151240342256744e-22, " 0", "%2.f"},
+ {__LINE__, 4.155533104307272e-04, "+0.000416", "%+f"},
+ {__LINE__, 4.155890511880097e+25, "4.155891e+25", "%e"},
+ {__LINE__, 4.159907901074450e-19, "4.159908E-19", "%7E"},
+ {__LINE__, 4.171899783464252e+18, "4E+18", "%.0E"},
+ {__LINE__, 4.177920266276382e-17, "+0.0000", "%+1.4f"},
+ {__LINE__, 4.181728014477237e-20, "4.18173e-20", "%.6g"},
+ {__LINE__, 4.203600495086497e-30, " 4E-30", "%6.G"},
+ {__LINE__, 4.211166112605717e-08, "4E-08", "%5.1G"},
+ {__LINE__, 4.219513437404614e+18, "+4E+18", "%+.0E"},
+ {__LINE__, 4.221426315236785e+08, "4.221426E+08", "%#E"},
+ {__LINE__, 4.226224756005934e-13, " 4.e-13", "%#7.g"},
+ {__LINE__, 4.226979046489921e-01, "4.226979e-01", "%#.6e"},
+ {__LINE__, 4.236283521629158e-08, "+4.23628E-08", "%+G"},
+ {__LINE__, 4.239850628514233e-07, "4.23985E-07", "%.6G"},
+ {__LINE__, 4.241177358638621e+04, "42411.773586", "%2f"},
+ {__LINE__, 4.245306724398964e-13, "0.000000", "%#f"},
+ {__LINE__, 4.246194290300334e+16, "42461942903003340.177293", "%2f"},
+ {__LINE__, 4.251238996137952e-05, "4.25124E-05", "%3G"},
+ {__LINE__, 4.262432542017438e+13, "42624325420174.375978", "%1f"},
+ {__LINE__, 4.266383084300715e+16, "4E+16", "%4.G"},
+ {__LINE__, 4.292963398931474e-11, "4.292963E-11", "%E"},
+ {__LINE__, 4.296530271399131e-29, "0.000000", "%6f"},
+ {__LINE__, 4.303753949741171e+19, "4.30375E+19", "%2G"},
+ {__LINE__, 4.303767633827431e-28, "4.30377e-28", "%g"},
+ {__LINE__, 4.316181911403991e-30, "4.3162e-30", "%#7.5g"},
+ {__LINE__, 4.318654697213126e-18, "4.31865e-18", "%g"},
+ {__LINE__, 4.320618603119499e+05, "432061.860312", "%3f"},
+ {__LINE__, 4.322443609118441e+21, "4.32244E+21", "%7.5E"},
+ {__LINE__, 4.322522446810708e-15, "4.32252e-15", "%.6g"},
+ {__LINE__, 4.334728493589115e-18, "0.000000", "%f"},
+ {__LINE__, 4.335342531476346e-19, "4.33534E-19", "%G"},
+ {__LINE__, 4.340579325084176e-30, "4.34058e-30", "%#0.6g"},
+ {__LINE__, 4.340775659883185e+04, "43407.756599", "%6f"},
+ {__LINE__, 4.361131891528634e-14, " 4E-14", "%6.G"},
+ {__LINE__, 4.366662624371249e-02, "+0.04", "%+4.g"},
+ {__LINE__, 4.369919308458348e+28, "+4.36992e+28", "%+2g"},
+ {__LINE__, 4.369930393192433e-24, "4.369930e-24", "%e"},
+ {__LINE__, 4.376283118322521e-01, "0.437628", "%g"},
+ {__LINE__, 4.386868840825930e+19, "4.3869E+19", "%.5G"},
+ {__LINE__, 4.389349113395235e+05, "+4.389349e+05", "%+e"},
+ {__LINE__, 4.392447466753053e-08, "+4.392E-08", "%+.4G"},
+ {__LINE__, 4.394068619246889e-13, "4.39407e-13", "%6g"},
+ {__LINE__, 4.404889573700147e-09, "4.404890E-09", "%E"},
+ {__LINE__, 4.410531039373014e+05, "+4.41e+05", "%+.2e"},
+ {__LINE__, 4.412466606726400e-08, " 0.0", "%6.1f"},
+ {__LINE__, 4.414693719279123e+17, "4.414694e+17", "%e"},
+ {__LINE__, 4.417050329080679e-01, "+0.441705", "%+g"},
+ {__LINE__, 4.419509841929196e-10, "4.4195098E-10", "%.7E"},
+ {__LINE__, 4.421012777695611e+07, "+4.42101E+07", "%+0.6G"},
+ {__LINE__, 4.426387732151208e+11, "4.42639e+11", "%g"},
+ {__LINE__, 4.439567017550398e+26, "4.439567E+26", "%E"},
+ {__LINE__, 4.446479816166258e-21, "4.446480e-21", "%0e"},
+ {__LINE__, 4.453486178424380e+05, "445348.617842", "%f"},
+ {__LINE__, 4.455733696043438e+06, "4.45573e+06", "%3g"},
+ {__LINE__, 4.455870606312063e+16, "4.45587e+16", "%g"},
+ {__LINE__, 4.458776435431700e+22, "4e+22", "%1.g"},
+ {__LINE__, 4.466448605584151e-30, "0.000000", "%f"},
+ {__LINE__, 4.471063097005706e+16, "4.47106E+16", "%G"},
+ {__LINE__, 4.482001890035190e-22, "+4.482E-22", "%+G"},
+ {__LINE__, 4.493246870093631e+05, "449325", "%1G"},
+ {__LINE__, 4.496089639281023e+17, "4.49609e+17", "%g"},
+ {__LINE__, 4.515066070117557e+15, "4.51507e+15", "%g"},
+ {__LINE__, 4.518296460916194e+24, "+4.5183E+24", "%+G"},
+ {__LINE__, 4.526548719445596e+02, "452.655", "%6.3f"},
+ {__LINE__, 4.532756455106440e-26, "4.53e-26", "%4.2e"},
+ {__LINE__, 4.534466782633055e-14, "4.53447E-14", "%G"},
+ {__LINE__, 4.541313061854649e-14, "4.54131E-14", "%G"},
+ {__LINE__, 4.541848265404338e+02, " 5E+02", "%7.G"},
+ {__LINE__, 4.546603085406363e-26, "5E-26", "%3.G"},
+ {__LINE__, 4.557349604829375e+28, "+45573496048293753446500886639.", "%+#1.f"},
+ {__LINE__, 4.560736449944898e-27, "4.56074e-27", "%g"},
+ {__LINE__, 4.563726230559341e-15, "+0.0", "%+2.1f"},
+ {__LINE__, 4.572650965532532e-26, "+5E-26", "%+4.G"},
+ {__LINE__, 4.574369572115099e-10, "+0.000000", "%+2.6f"},
+ {__LINE__, 4.576480601519729e+28, "+4.576481e+28", "%+e"},
+ {__LINE__, 4.587487640650499e+02, "+458.75", "%+3.2f"},
+ {__LINE__, 4.598365231538559e-27, "4.59837E-27", "%G"},
+ {__LINE__, 4.599348244725009e-28, "+4.5993482e-28", "%+#3.7e"},
+ {__LINE__, 4.599897524047587e+22, "45998975240475870052136.997401", "%#f"},
+ {__LINE__, 4.605415604725077e-25, "0.000000", "%f"},
+ {__LINE__, 4.613055015797716e+28, "4.613055E+28", "%E"},
+ {__LINE__, 4.618715275814238e-10, "4.618715E-10", "%E"},
+ {__LINE__, 4.619044579489540e-14, "0.00", "%.2f"},
+ {__LINE__, 4.633693310095410e-20, "+0.000000", "%+f"},
+ {__LINE__, 4.648505395281916e-28, "0.000000", "%f"},
+ {__LINE__, 4.651232770446398e+21, "4.65e+21", "%.2e"},
+ {__LINE__, 4.659743589975352e+28, "+4.65974e+28", "%+g"},
+ {__LINE__, 4.660181457075208e-13, "4.66018e-13", "%g"},
+ {__LINE__, 4.669787018529686e+20, "4.66979e+20", "%g"},
+ {__LINE__, 4.672649286126732e-21, "4.6726E-21", "%4.5G"},
+ {__LINE__, 4.675431901120643e-11, " 0", "%3.f"},
+ {__LINE__, 4.684404068169945e+26, "468440406816994503458317922.2", "%6.1f"},
+ {__LINE__, 4.685438834234642e+19, "5.E+19", "%#6.G"},
+ {__LINE__, 4.688915890732712e+00, "+5e+00", "%+2.e"},
+ {__LINE__, 4.692999432046297e+00, "4.692999E+00", "%E"},
+ {__LINE__, 4.708690772584701e+11, "4.70869e+11", "%g"},
+ {__LINE__, 4.711821455782105e-11, "+4.71182e-11", "%+1g"},
+ {__LINE__, 4.712413965116830e-01, "4.712414E-01", "%E"},
+ {__LINE__, 4.719504715401049e-08, "0.000000", "%f"},
+ {__LINE__, 4.719767896031655e+27, "4.71977e+27", "%#g"},
+ {__LINE__, 4.722493017411588e-05, "0.000047", "%4f"},
+ {__LINE__, 4.729482386761477e+08, "4.72948e+08", "%1g"},
+ {__LINE__, 4.730102169800602e-06, "0.000005", "%f"},
+ {__LINE__, 4.743951614209393e+24, "4.743952E+24", "%#E"},
+ {__LINE__, 4.746077075605921e-16, "4.746E-16", "%.3E"},
+ {__LINE__, 4.747802537919248e+24, "4747802537919247889419694", "%4.f"},
+ {__LINE__, 4.754727690703025e-26, "0", "%0.f"},
+ {__LINE__, 4.756952432926979e-29, " 0.", "%#3.f"},
+ {__LINE__, 4.758335147956709e+03, "4758.335148", "%f"},
+ {__LINE__, 4.760141880810268e-25, "4.760142e-25", "%e"},
+ {__LINE__, 4.767079423650815e-07, "5.E-07", "%#0.G"},
+ {__LINE__, 4.785662728343338e-28, "4.78566e-28", "%g"},
+ {__LINE__, 4.787146245774150e-13, "+4.78715E-13", "%+G"},
+ {__LINE__, 4.787415449888824e-17, "4.78742e-17", "%3g"},
+ {__LINE__, 4.794589807429657e-05, "4.79459E-05", "%6G"},
+ {__LINE__, 4.794948299666205e+08, "4.79495e+08", "%g"},
+ {__LINE__, 4.802292865915992e-04, "4.802293e-04", "%e"},
+ {__LINE__, 4.802513688198601e+07, "+4.8e+07", "%+2.3g"},
+ {__LINE__, 4.810456746192536e+06, "5E+06", "%0.0G"},
+ {__LINE__, 4.820631660081696e+20, "+4.82063E+20", "%+G"},
+ {__LINE__, 4.827865857270075e-20, "4.82787e-20", "%g"},
+ {__LINE__, 4.835054268490970e+21, "4835054268490970308391.752042", "%#f"},
+ {__LINE__, 4.838136770808465e-18, "4.83814E-18", "%G"},
+ {__LINE__, 4.839342397882353e-26, "4.839342E-26", "%E"},
+ {__LINE__, 4.845130210072029e-16, "0", "%1.f"},
+ {__LINE__, 4.845161043167169e-12, "+4.845e-12", "%+.4g"},
+ {__LINE__, 4.857425142494964e+01, "48.574251", "%f"},
+ {__LINE__, 4.858118337285513e-10, "+4.8581e-10", "%+.5g"},
+ {__LINE__, 4.867478343525339e-15, "+4.867478E-15", "%+E"},
+ {__LINE__, 4.886137001331278e-11, "0.000000", "%f"},
+ {__LINE__, 4.886835850687998e-20, " 0", "%6.0f"},
+ {__LINE__, 4.886880737482383e+26, "488688073748238327453918827.814050", "%4f"},
+ {__LINE__, 4.888812049144075e-22, "4.888812E-22", "%E"},
+ {__LINE__, 4.895869618002905e+02, "+489.587", "%+.7g"},
+ {__LINE__, 4.902046593298549e+09, " 5e+09", "%7.g"},
+ {__LINE__, 4.907918627564751e-05, "4.91e-05", "%.3g"},
+ {__LINE__, 4.916048355579009e+19, "49160483555790088772", "%2.f"},
+ {__LINE__, 4.917197806128638e+14, "+5e+14", "%+5.g"},
+ {__LINE__, 4.918303274189911e+13, "4.918303e+13", "%e"},
+ {__LINE__, 4.922687970321108e+26, "492268797032110771993984599.2485", "%0.4f"},
+ {__LINE__, 4.929263362431195e+14, "4.92926e+14", "%g"},
+ {__LINE__, 4.933385398543267e-17, "0.000000", "%#f"},
+ {__LINE__, 4.942367126455025e+00, " +5", "%+6.f"},
+ {__LINE__, 4.947687486717652e-04, "0.000495", "%.6f"},
+ {__LINE__, 4.960855200003128e-08, "+4.960855e-08", "%+e"},
+ {__LINE__, 4.968485435774085e-21, "0.0000", "%#2.4f"},
+ {__LINE__, 4.972088381506133e+01, "49.7", "%.1f"},
+ {__LINE__, 4.977561524480392e-15, "4.977562E-15", "%7E"},
+ {__LINE__, 4.984592111249502e-13, "5.0e-13", "%.1e"},
+ {__LINE__, 4.997502335602838e-14, "4.998e-14", "%6.4g"},
+ {__LINE__, 5.001731554335935e-09, "5.00173e-09", "%g"},
+ {__LINE__, 5.006231697107042e-17, "5.0062e-17", "%1.5g"},
+ {__LINE__, 5.008035801093423e+24, "5.008036E+24", "%#E"},
+ {__LINE__, 5.008756965733827e-28, "5.009E-28", "%.4G"},
+ {__LINE__, 5.009774027622812e+20, "+5.00977E+20", "%+G"},
+ {__LINE__, 5.010576312346293e+29, "5.01058E+29", "%G"},
+ {__LINE__, 5.012335250996786e+29, "5.012335e+29", "%.7g"},
+ {__LINE__, 5.012404365186907e+20, "5E+20", "%3.2G"},
+ {__LINE__, 5.024670103250229e-01, "+5.024670E-01", "%+E"},
+ {__LINE__, 5.025765369164560e+03, "5025.77", "%g"},
+ {__LINE__, 5.027173841003918e+11, "+5.02717E+11", "%+G"},
+ {__LINE__, 5.032093817639893e-26, "5e-26", "%3.e"},
+ {__LINE__, 5.039636818525848e-02, "0.050396", "%#f"},
+ {__LINE__, 5.040626671307691e+23, "5.040627E+23", "%E"},
+ {__LINE__, 5.040788233368296e-11, "+5.04079e-11", "%+g"},
+ {__LINE__, 5.040903321336150e-28, "5.0409E-28", "%G"},
+ {__LINE__, 5.042078512958994e+12, "5.04208E+12", "%G"},
+ {__LINE__, 5.045957900223303e+15, "5045957900223303", "%0.f"},
+ {__LINE__, 5.048298764352134e-14, "5.048299e-14", "%1e"},
+ {__LINE__, 5.048827326763192e+28, "50488273267631917917697137454.524636", "%f"},
+ {__LINE__, 5.049714558347361e-23, "5e-23", "%5.0g"},
+ {__LINE__, 5.051509904923853e+16, "50515099049238534", "%5.f"},
+ {__LINE__, 5.052789863743305e-10, "5.05279E-10", "%6G"},
+ {__LINE__, 5.057429728861999e-29, "0.000", "%#1.3f"},
+ {__LINE__, 5.075313093968501e-13, "+5.07531e-13", "%+g"},
+ {__LINE__, 5.075874503501582e+29, "5e+29", "%2.e"},
+ {__LINE__, 5.079468079020803e+01, "50.795", "%.5G"},
+ {__LINE__, 5.086214826494080e-28, " 0.0", "%4.1f"},
+ {__LINE__, 5.096054881114421e+13, "5.096e+13", "%.4g"},
+ {__LINE__, 5.099045274853458e-23, "5.09905E-23", "%0G"},
+ {__LINE__, 5.100248195124433e+00, "5.100248", "%f"},
+ {__LINE__, 5.101016114276598e-20, "5e-20", "%4.1g"},
+ {__LINE__, 5.103213528670269e+07, "51032135.286703", "%6f"},
+ {__LINE__, 5.108373625126768e+08, "+510837362.512677", "%+f"},
+ {__LINE__, 5.113097157183416e+07, "5.1131E+07", "%#.4E"},
+ {__LINE__, 5.114452611789777e+08, "+5.11445E+08", "%+G"},
+ {__LINE__, 5.117099184715288e-16, "5.1171E-16", "%G"},
+ {__LINE__, 5.119910534665511e-13, "+5.11991E-13", "%+G"},
+ {__LINE__, 5.121320931953720e+23, "+5.121321e+23", "%+#e"},
+ {__LINE__, 5.121900318443998e+06, "5.121900e+06", "%e"},
+ {__LINE__, 5.135698679084286e+00, "5.1357", "%2g"},
+ {__LINE__, 5.146355903104154e-10, "+5.14636E-10", "%+.6G"},
+ {__LINE__, 5.148754210958986e-24, "+5.148754e-24", "%+e"},
+ {__LINE__, 5.156238368448428e+26, "5e+26", "%5.g"},
+ {__LINE__, 5.159924520667922e-19, "+5E-19", "%+0.1G"},
+ {__LINE__, 5.159938266135425e-27, "0.000000", "%f"},
+ {__LINE__, 5.165915205175676e-01, "5.165915e-01", "%e"},
+ {__LINE__, 5.190205499401547e-11, "5e-11", "%2.1g"},
+ {__LINE__, 5.193260005542003e+26, "5.19326e+26", "%#g"},
+ {__LINE__, 5.194732077318269e+08, "519473207.731827", "%f"},
+ {__LINE__, 5.196394616633798e-19, "0", "%.0f"},
+ {__LINE__, 5.206753628035638e+19, "5.20675e+19", "%6.6g"},
+ {__LINE__, 5.207364136540851e-23, " 0.000", "%6.3f"},
+ {__LINE__, 5.210672737132108e-09, "5.21067E-09", "%G"},
+ {__LINE__, 5.211423933057123e-20, "+5.21142E-20", "%+G"},
+ {__LINE__, 5.219749528363367e-27, "5.219750e-27", "%e"},
+ {__LINE__, 5.228031587478653e-06, "+5.2E-06", "%+3.1E"},
+ {__LINE__, 5.229303095005359e-25, "+0.000000", "%+#f"},
+ {__LINE__, 5.234703511938320e-06, " 0", "%7.f"},
+ {__LINE__, 5.235655046937822e-20, "5.235655E-20", "%.6E"},
+ {__LINE__, 5.237924986002288e-01, "+0.52379", "%+.5f"},
+ {__LINE__, 5.249148093603826e+20, "5.24915E+20", "%0G"},
+ {__LINE__, 5.262680920244596e+16, "5.26268E+16", "%G"},
+ {__LINE__, 5.267944704715845e-06, "5.e-06", "%#3.g"},
+ {__LINE__, 5.268543533730505e-08, "5.26854E-08", "%G"},
+ {__LINE__, 5.275727269515247e-02, "0.0527573", "%.6g"},
+ {__LINE__, 5.279215316873723e+24, "5279215316873722585455652.733799", "%f"},
+ {__LINE__, 5.284326985680811e+16, "52843269856808108.286828", "%6f"},
+ {__LINE__, 5.286192957344040e-10, "5.3E-10", "%.1E"},
+ {__LINE__, 5.289451976001091e-23, "5.28945E-23", "%G"},
+ {__LINE__, 5.289512908209300e+09, "+5.289513e+09", "%+e"},
+ {__LINE__, 5.295696957972123e+11, "5.296E+11", "%#.3E"},
+ {__LINE__, 5.303584684011050e+16, "53035846840110503.208621", "%f"},
+ {__LINE__, 5.310315581980172e+23, "531031558198017172855998", "%4.f"},
+ {__LINE__, 5.317492728410062e-14, "5.31749e-14", "%7g"},
+ {__LINE__, 5.324506949499409e+18, "5.3245E+18", "%.5G"},
+ {__LINE__, 5.329238068668336e-20, "5e-20", "%4.g"},
+ {__LINE__, 5.336050125161774e+14, "5.33605e+14", "%g"},
+ {__LINE__, 5.349921315003169e-17, "5.34992E-17", "%.6G"},
+ {__LINE__, 5.355648481782587e-20, "5.355648e-20", "%e"},
+ {__LINE__, 5.358945557589489e-26, "+5e-26", "%+0.g"},
+ {__LINE__, 5.359638846465574e+21, "5.359639E+21", "%E"},
+ {__LINE__, 5.377048469393900e+14, "5.377E+14", "%.5G"},
+ {__LINE__, 5.387471194156434e+23, "5.387471E+23", "%.7G"},
+ {__LINE__, 5.401622578962497e-03, "+0.0054", "%+5.2g"},
+ {__LINE__, 5.406882732497444e-16, "5.406883E-16", "%E"},
+ {__LINE__, 5.421474560523198e-11, "+5.42147e-11", "%+g"},
+ {__LINE__, 5.440249323479418e-26, "5.44025E-26", "%7G"},
+ {__LINE__, 5.440922682921101e-05, "5e-05", "%.1g"},
+ {__LINE__, 5.444400103673185e-01, "0.54444", "%G"},
+ {__LINE__, 5.449339470916152e+09, "5449339470.9162", "%.4f"},
+ {__LINE__, 5.451583259558706e-15, "5.e-15", "%#4.e"},
+ {__LINE__, 5.460153018660573e+26, "+546015301866057267687892817.775719", "%+f"},
+ {__LINE__, 5.477591210511918e+08, "+5.47759E+08", "%+0.5E"},
+ {__LINE__, 5.481665401407188e-02, "5.481665e-02", "%e"},
+ {__LINE__, 5.482670784411319e-16, "5E-16", "%4.G"},
+ {__LINE__, 5.487494580636099e+12, "5.48749e+12", "%g"},
+ {__LINE__, 5.508630369473937e-10, "5.508630e-10", "%e"},
+ {__LINE__, 5.528898001438273e+20, "6e+20", "%4.g"},
+ {__LINE__, 5.530331734443152e-24, " 6e-24", "%6.g"},
+ {__LINE__, 5.531704398969656e-24, "0.000000", "%f"},
+ {__LINE__, 5.539906569043238e+05, "+553990.656904", "%+f"},
+ {__LINE__, 5.554571854756323e-08, "+0.00000", "%+4.5f"},
+ {__LINE__, 5.555155069925145e-28, "5.55516e-28", "%g"},
+ {__LINE__, 5.555302705075539e-08, "+5.5553e-08", "%+g"},
+ {__LINE__, 5.563805076159055e-05, "5.563805e-05", "%e"},
+ {__LINE__, 5.565063508995002e+07, "5.565E+07", "%.3E"},
+ {__LINE__, 5.566281664807526e-08, "5.56628E-08", "%G"},
+ {__LINE__, 5.575245679736338e-08, "5.575246e-08", "%e"},
+ {__LINE__, 5.578254777281501e-21, "0.", "%#.0f"},
+ {__LINE__, 5.582389275770848e-01, " 0.6", "%5.G"},
+ {__LINE__, 5.592215029176133e-04, "0.00056", "%.2g"},
+ {__LINE__, 5.593536789867047e-25, "5.59354e-25", "%g"},
+ {__LINE__, 5.605652054074862e-03, " 0.006", "%8.G"},
+ {__LINE__, 5.606982382643258e+20, "+5.60698E+20", "%+G"},
+ {__LINE__, 5.614646821116853e-18, "5.6E-18", "%.2G"},
+ {__LINE__, 5.625586848606565e-11, "+5.62559E-11", "%+G"},
+ {__LINE__, 5.626300428046732e+26, " 6e+26", "%7.g"},
+ {__LINE__, 5.638236626881086e-17, " 6E-17", "%6.G"},
+ {__LINE__, 5.645744817075691e+04, "5.645745E+04", "%E"},
+ {__LINE__, 5.651410004691736e+06, "6.E+06", "%#3.E"},
+ {__LINE__, 5.659582345929256e-11, "+0.000000", "%+f"},
+ {__LINE__, 5.670968861413510e+16, "+5.67097E+16", "%+G"},
+ {__LINE__, 5.672476851235796e+01, "+56.724769", "%+0f"},
+ {__LINE__, 5.674563779921248e+28, " 6E+28", "%6.0G"},
+ {__LINE__, 5.675558529939025e+19, "5.67556e+19", "%3g"},
+ {__LINE__, 5.676326888314589e-08, " 6e-08", "%7.g"},
+ {__LINE__, 5.677928507840897e-30, "5.67793e-30", "%0g"},
+ {__LINE__, 5.686622552402630e-15, "5.69E-15", "%1.3G"},
+ {__LINE__, 5.710441686922142e-14, "5.710442E-14", "%E"},
+ {__LINE__, 5.713234603280163e-21, "0.00000", "%0.5f"},
+ {__LINE__, 5.714968959046963e+12, "5.71497e+12", "%g"},
+ {__LINE__, 5.722025141555638e-23, "5.72e-23", "%.2e"},
+ {__LINE__, 5.725398571007033e-09, "5.7254E-09", "%.6G"},
+ {__LINE__, 5.751604813862738e+18, "6E+18", "%.1G"},
+ {__LINE__, 5.761025444751985e+20, "5.76103e+20", "%g"},
+ {__LINE__, 5.762315767948593e+15, "5.76232e+15", "%4g"},
+ {__LINE__, 5.764528858586032e-15, "5.764529E-15", "%6.7G"},
+ {__LINE__, 5.766408541535810e-07, " 6E-07", "%6.1G"},
+ {__LINE__, 5.771831571087174e-01, "0.577183", "%f"},
+ {__LINE__, 5.790102497364865e-15, "+5.790102e-15", "%+e"},
+ {__LINE__, 5.790222335547785e-08, "5.79022e-08", "%0.6g"},
+ {__LINE__, 5.794082127091130e+21, "5794082127091130018925.468903", "%f"},
+ {__LINE__, 5.804568463644165e+28, "5.80457e+28", "%g"},
+ {__LINE__, 5.827356651901066e+20, "582735665190106555400.006982", "%f"},
+ {__LINE__, 5.837553387436408e+18, "5.837553E+18", "%3E"},
+ {__LINE__, 5.844458110907209e+22, "5.84446e+22", "%g"},
+ {__LINE__, 5.851672125746866e-19, "5.85167e-19", "%g"},
+ {__LINE__, 5.868843476784172e-12, "5.868843e-12", "%1.7g"},
+ {__LINE__, 5.870854146748864e-04, "0.000587", "%2.3g"},
+ {__LINE__, 5.877787821470433e+01, "+58.77788", "%+#3.5f"},
+ {__LINE__, 5.881333514866498e+04, "5.881334E+04", "%E"},
+ {__LINE__, 5.908427816128965e+28, "+5.908428E+28", "%+E"},
+ {__LINE__, 5.918139800007388e+07, "59181398.000074", "%f"},
+ {__LINE__, 5.925587467475260e+21, "5925587467475259551008.548442", "%f"},
+ {__LINE__, 5.930403502679683e-22, "5.9304E-22", "%.6G"},
+ {__LINE__, 5.961572644847521e+02, "+596.157", "%+G"},
+ {__LINE__, 5.968917715225198e-21, "5.96892e-21", "%4g"},
+ {__LINE__, 5.982184454670110e-08, "0", "%0.f"},
+ {__LINE__, 5.988414319040855e+09, "6E+09", "%0.G"},
+ {__LINE__, 5.996263783103995e-10, "5.996264e-10", "%e"},
+ {__LINE__, 6.004634162276014e-18, "6.00463e-18", "%g"},
+ {__LINE__, 6.018734975519166e-08, "6.01873E-08", "%G"},
+ {__LINE__, 6.029071822986717e-14, "0.0000000", "%.7f"},
+ {__LINE__, 6.030392278117406e+23, "6.030392e+23", "%e"},
+ {__LINE__, 6.034553399237175e-27, "+6.03455e-27", "%+g"},
+ {__LINE__, 6.034938873443862e+24, "6034938873443861595546877.651941", "%f"},
+ {__LINE__, 6.038929148003457e-16, "6.03893e-16", "%g"},
+ {__LINE__, 6.039149626573702e-13, "6.0391E-13", "%3.5G"},
+ {__LINE__, 6.041247664739301e+29, "6.041248E+29", "%3E"},
+ {__LINE__, 6.044220746789781e+20, "+6.04422e+20", "%+g"},
+ {__LINE__, 6.045775647107433e+19, "6E+19", "%2.G"},
+ {__LINE__, 6.051917010461611e-05, "6.05192E-05", "%G"},
+ {__LINE__, 6.059773181566425e+17, "+605977318156642486", "%+5.f"},
+ {__LINE__, 6.082239575475813e+01, "+6E+01", "%+.1G"},
+ {__LINE__, 6.093984174629151e+18, "6.093984e+18", "%e"},
+ {__LINE__, 6.102368380479137e+22, "6.1E+22", "%.2G"},
+ {__LINE__, 6.103097446204007e+25, "61030974462040070704915706.301108", "%#0f"},
+ {__LINE__, 6.105244994410556e-24, "0.0000000", "%2.7f"},
+ {__LINE__, 6.110828906801633e-14, "+6.110829e-14", "%+3e"},
+ {__LINE__, 6.124439072468681e-30, "6.12444e-30", "%g"},
+ {__LINE__, 6.127714703273447e-15, "0", "%0.f"},
+ {__LINE__, 6.128539582408870e-15, "6.12854e-15", "%g"},
+ {__LINE__, 6.145470264744349e+24, "6145470264744348654062378.045637", "%f"},
+ {__LINE__, 6.159177701667455e+26, "615917770166745537352426254.074089", "%#f"},
+ {__LINE__, 6.159348213337442e+17, "6.15935e+17", "%g"},
+ {__LINE__, 6.161953891020492e-21, "0.000000", "%f"},
+ {__LINE__, 6.169474192777305e+29, "+6.169E+29", "%+.4G"},
+ {__LINE__, 6.198519761010651e-15, "+0", "%+1.f"},
+ {__LINE__, 6.201381824304919e-27, " 0", "%5.f"},
+ {__LINE__, 6.204387065736372e-18, "6.204387E-18", "%7E"},
+ {__LINE__, 6.209270088144063e-24, "0.000000", "%f"},
+ {__LINE__, 6.209871738353546e-20, "6.20987E-20", "%G"},
+ {__LINE__, 6.222733191871026e+14, "+6.22273e+14", "%+g"},
+ {__LINE__, 6.234670085354310e+04, "+62346.700854", "%+f"},
+ {__LINE__, 6.258389346602224e-09, "6E-09", "%.0G"},
+ {__LINE__, 6.263326582587503e+12, "6263326582588.", "%#5.f"},
+ {__LINE__, 6.272768026763922e+03, "+6272.77", "%+g"},
+ {__LINE__, 6.287747868625765e+00, "6E+00", "%.0E"},
+ {__LINE__, 6.297724027388795e-17, "+6E-17", "%+3.G"},
+ {__LINE__, 6.309940679156400e+27, "6.30994e+27", "%6.5e"},
+ {__LINE__, 6.312960327030170e+06, "+6.312960E+06", "%+E"},
+ {__LINE__, 6.317658179632976e+02, "+631.766", "%+g"},
+ {__LINE__, 6.321255960699571e-27, "0.000000", "%f"},
+ {__LINE__, 6.323069932833900e+03, "6323", "%.4G"},
+ {__LINE__, 6.337027835933034e+21, "6.33703e+21", "%#g"},
+ {__LINE__, 6.343583177899838e-03, "0.00634358", "%7G"},
+ {__LINE__, 6.347464241733904e-03, "6.e-03", "%#0.e"},
+ {__LINE__, 6.352038720353924e+07, "63520387.203539", "%f"},
+ {__LINE__, 6.355292378565109e+23, "+635529237856510942350496.407016", "%+f"},
+ {__LINE__, 6.377901944439164e-29, "0.000", "%2.3f"},
+ {__LINE__, 6.378660255554053e-04, "6.37866E-04", "%.5E"},
+ {__LINE__, 6.382838195255167e-18, "0.000000", "%f"},
+ {__LINE__, 6.391046303581911e+22, "6E+22", "%.0G"},
+ {__LINE__, 6.404812348309621e+22, "6.404812E+22", "%.7G"},
+ {__LINE__, 6.406154091357119e+16, "6.40615E+16", "%G"},
+ {__LINE__, 6.419414726557980e+21, "+6.41941e+21", "%+g"},
+ {__LINE__, 6.432166563008504e+10, " +6e+10", "%+7.g"},
+ {__LINE__, 6.438463704193190e+19, "6.438464e+19", "%e"},
+ {__LINE__, 6.445270237908565e+15, "+6.445270E+15", "%+E"},
+ {__LINE__, 6.445536770502964e+09, "6.446e+09", "%.3e"},
+ {__LINE__, 6.446614224811444e+28, "64466142248114444157636171439.662576", "%f"},
+ {__LINE__, 6.457046289718297e+18, "6457046289718297416.015957", "%4f"},
+ {__LINE__, 6.457682856890173e+01, "6.457683E+01", "%2E"},
+ {__LINE__, 6.471026352792729e-16, "+6.47103e-16", "%+g"},
+ {__LINE__, 6.474527749567342e+19, "6E+19", "%.1G"},
+ {__LINE__, 6.481178401781131e-24, "+6.48E-24", "%+6.3G"},
+ {__LINE__, 6.490736647261461e-15, "+6.49074e-15", "%+g"},
+ {__LINE__, 6.493196535069719e+23, "+6.4932E+23", "%+G"},
+ {__LINE__, 6.500296992935538e-20, "+0.0", "%+.1f"},
+ {__LINE__, 6.502867735895890e-19, "+0.000000", "%+6f"},
+ {__LINE__, 6.506627529164683e+14, "650662752916468", "%5.f"},
+ {__LINE__, 6.511909298966434e-15, "+6.51191E-15", "%+G"},
+ {__LINE__, 6.514463062693312e+01, "65.1446", "%G"},
+ {__LINE__, 6.520721469484543e+16, "6.52072E+16", "%G"},
+ {__LINE__, 6.528064508731680e-05, "6.528065E-05", "%7E"},
+ {__LINE__, 6.529007214194039e-24, "0.000000", "%f"},
+ {__LINE__, 6.537822760557410e-23, "0.000000", "%f"},
+ {__LINE__, 6.552222096390805e+29, "+6.55222E+29", "%+G"},
+ {__LINE__, 6.554569862717104e+12, "6.55457E+12", "%G"},
+ {__LINE__, 6.563440840359989e-30, "7E-30", "%4.G"},
+ {__LINE__, 6.586246985535526e+17, "6.58625E+17", "%#4G"},
+ {__LINE__, 6.593339522442827e+16, "6.6E+16", "%#4.1E"},
+ {__LINE__, 6.611179030024350e+02, "7E+02", "%4.E"},
+ {__LINE__, 6.617541638586767e-10, "6.617542E-10", "%E"},
+ {__LINE__, 6.619147920886991e-28, "7e-28", "%.1g"},
+ {__LINE__, 6.622304444772819e-21, "6.62230E-21", "%#4G"},
+ {__LINE__, 6.634766655157910e+12, "6634766655158", "%2.f"},
+ {__LINE__, 6.635639771921218e+25, "+6.63564E+25", "%+G"},
+ {__LINE__, 6.644575305929087e+17, "+6.64458e+17", "%+g"},
+ {__LINE__, 6.648697591328432e+04, "6.648698E+04", "%3E"},
+ {__LINE__, 6.665426012448100e+09, "6.66543E+09", "%G"},
+ {__LINE__, 6.675222780441723e-23, "6.67522e-23", "%1g"},
+ {__LINE__, 6.689765053880623e+00, "6.6898", "%.5g"},
+ {__LINE__, 6.693874943680238e+25, "7.e+25", "%#1.g"},
+ {__LINE__, 6.695033453546435e+19, "6.695033E+19", "%E"},
+ {__LINE__, 6.720131534244976e+03, "+6720.132", "%+.3f"},
+ {__LINE__, 6.725287004784564e+19, "+6.72529e+19", "%+g"},
+ {__LINE__, 6.743599626906313e-18, "0.0000000", "%7.7f"},
+ {__LINE__, 6.755534260704152e+29, "7.e+29", "%#5.e"},
+ {__LINE__, 6.761855244766418e-18, "6.8E-18", "%.2G"},
+ {__LINE__, 6.764974143681080e-02, "6.765E-02", "%2.3E"},
+ {__LINE__, 6.766924477711975e-17, "0.000000", "%4f"},
+ {__LINE__, 6.772195434106330e-19, "6.7722E-19", "%G"},
+ {__LINE__, 6.779433073319225e-23, "0.00", "%.2f"},
+ {__LINE__, 6.790317710068964e+05, "6.8e+05", "%.1e"},
+ {__LINE__, 6.791378160292960e+02, "679.137816", "%f"},
+ {__LINE__, 6.798381262104190e-27, "0.000000", "%f"},
+ {__LINE__, 6.804165939424860e-14, "7e-14", "%4.g"},
+ {__LINE__, 6.810668670623699e+11, "681066867062.369852", "%f"},
+ {__LINE__, 6.838942637635821e-17, "+6.84e-17", "%+.2e"},
+ {__LINE__, 6.868523988329111e-09, "+6.868524e-09", "%+e"},
+ {__LINE__, 6.873228061403223e-15, "6.873228E-15", "%3E"},
+ {__LINE__, 6.879370500093334e-12, "+0.000000", "%+f"},
+ {__LINE__, 6.891525498686674e-10, "7e-10", "%0.g"},
+ {__LINE__, 6.923027319286220e+21, "7.e+21", "%#1.g"},
+ {__LINE__, 6.923565533024560e-11, "+6.92357e-11", "%+g"},
+ {__LINE__, 6.931415640770737e-24, "+6.93142e-24", "%+g"},
+ {__LINE__, 6.936582619246057e+09, "6.936583e+09", "%7e"},
+ {__LINE__, 6.938661496670582e+05, "693866.1496671", "%2.7f"},
+ {__LINE__, 6.946115378286550e-25, "0.000000", "%f"},
+ {__LINE__, 6.955823211921219e-09, "6.95582e-09", "%g"},
+ {__LINE__, 6.962365243425770e+29, "696236524342577034474288666388.019919", "%7f"},
+ {__LINE__, 6.970432274812882e+05, "+7e+05", "%+1.0e"},
+ {__LINE__, 6.975784942897122e-13, "6.975785e-13", "%e"},
+ {__LINE__, 6.976786489904214e-07, "6.97679E-07", "%3G"},
+ {__LINE__, 6.985245976357042e-05, "0.00", "%.2f"},
+ {__LINE__, 6.993402879410720e-21, "6.9934e-21", "%g"},
+ {__LINE__, 7.012183985341519e+28, "+70121839853415188770213717362", "%+2.f"},
+ {__LINE__, 7.028670648856025e-15, "7.028671e-15", "%.7g"},
+ {__LINE__, 7.034042985683665e-03, " 0", "%2.f"},
+ {__LINE__, 7.044054273278726e+18, "7.044e+18", "%7.4g"},
+ {__LINE__, 7.049706744250734e-06, "7E-06", "%0.E"},
+ {__LINE__, 7.061982657056197e+13, "+7.061983e+13", "%+e"},
+ {__LINE__, 7.066873668945899e+21, "7.06687E+21", "%G"},
+ {__LINE__, 7.087941418633258e+26, "7.08794E+26", "%G"},
+ {__LINE__, 7.108268134631547e+22, "7.108268E+22", "%E"},
+ {__LINE__, 7.112095848565475e-19, "7.1121e-19", "%g"},
+ {__LINE__, 7.116326241291862e+16, "7.116326e+16", "%e"},
+ {__LINE__, 7.118854843597607e-22, "0.000000", "%f"},
+ {__LINE__, 7.121423043456375e-27, "0.000000", "%f"},
+ {__LINE__, 7.131415427096460e-03, "0.007131", "%3f"},
+ {__LINE__, 7.132023279679892e+22, "7.e+22", "%#3.e"},
+ {__LINE__, 7.146250280189992e-18, "0.000000", "%f"},
+ {__LINE__, 7.150059058390724e+03, "7150.06", "%g"},
+ {__LINE__, 7.161081578177381e-02, "+0.0716108", "%+G"},
+ {__LINE__, 7.164935125149336e-27, "7.2E-27", "%#6.2G"},
+ {__LINE__, 7.173125717489549e-10, "7.173126e-10", "%e"},
+ {__LINE__, 7.174199549624193e+00, "7.1741995", "%.7f"},
+ {__LINE__, 7.192493588077649e+27, "7.19249e+27", "%g"},
+ {__LINE__, 7.215209568601445e-06, "7.215210e-06", "%e"},
+ {__LINE__, 7.238322284100497e+03, "7238.3", "%.1f"},
+ {__LINE__, 7.239203871123613e+06, "7239204", "%4.f"},
+ {__LINE__, 7.245809072577019e-09, "+7.245809E-09", "%+E"},
+ {__LINE__, 7.256275686433336e+03, "7.256276e+03", "%e"},
+ {__LINE__, 7.265774291605193e+27, "+7.26577E+27", "%+G"},
+ {__LINE__, 7.287968172227119e-21, "+7.287968e-21", "%+e"},
+ {__LINE__, 7.306020169678527e+12, "7E+12", "%2.E"},
+ {__LINE__, 7.315587463572568e-04, "0.", "%#.0f"},
+ {__LINE__, 7.324627764547963e+09, "7.324628E+09", "%#E"},
+ {__LINE__, 7.331904966719081e-06, "+7.3319E-06", "%+G"},
+ {__LINE__, 7.334448152798243e-02, "0.07", "%0.g"},
+ {__LINE__, 7.334487195961240e-01, "+0.733449", "%+#g"},
+ {__LINE__, 7.381283575515707e+13, "7.381284E+13", "%E"},
+ {__LINE__, 7.394854567245476e-11, "0.000000", "%7f"},
+ {__LINE__, 7.401950211415377e-08, " 7e-08", "%6.e"},
+ {__LINE__, 7.409023867864680e+03, "7409.023868", "%#3f"},
+ {__LINE__, 7.411912956257733e-20, "7e-20", "%0.g"},
+ {__LINE__, 7.445275019272160e+11, "744527501927.2159511", "%.7f"},
+ {__LINE__, 7.450279765616891e-16, "7.45028e-16", "%.6g"},
+ {__LINE__, 7.467047411334495e+14, "7.46705E+14", "%G"},
+ {__LINE__, 7.485628870972725e+28, "7E+28", "%.0G"},
+ {__LINE__, 7.495391782588563e+11, "749539178258.856253", "%f"},
+ {__LINE__, 7.495824101611911e+06, "7.49582e+06", "%.6g"},
+ {__LINE__, 7.499759867592402e+20, "+749975986759240154100.3", "%+.1f"},
+ {__LINE__, 7.508983397140368e+04, "75089.8", "%g"},
+ {__LINE__, 7.512585199581016e-27, "7.512585E-27", "%.6E"},
+ {__LINE__, 7.516831372212545e-29, "+7.516831e-29", "%+e"},
+ {__LINE__, 7.525789465978582e+00, "7.52579", "%G"},
+ {__LINE__, 7.528655653725963e+06, "7.5287e+06", "%3.4e"},
+ {__LINE__, 7.533217421035612e+28, "75332174210356122046050586504.861712", "%f"},
+ {__LINE__, 7.534147071756384e+03, "7534.15", "%g"},
+ {__LINE__, 7.542648637430919e-25, "+0.000000", "%+#f"},
+ {__LINE__, 7.554380140947798e-15, " 8e-15", "%7.g"},
+ {__LINE__, 7.557366996007743e+25, " 8E+25", "%7.G"},
+ {__LINE__, 7.579228950138068e+08, "8e+08", "%3.e"},
+ {__LINE__, 7.579773904052487e-13, "0.000000", "%3f"},
+ {__LINE__, 7.580377544554059e+27, "7.58038e+27", "%#g"},
+ {__LINE__, 7.589615147875915e-15, "7.59E-15", "%.3G"},
+ {__LINE__, 7.593317194045158e-12, "+0.", "%+#1.f"},
+ {__LINE__, 7.605535657484387e-07, "7.60554E-07", "%G"},
+ {__LINE__, 7.609171121278006e-08, " 0", "%5.f"},
+ {__LINE__, 7.612033900317304e-14, "7.61203e-14", "%g"},
+ {__LINE__, 7.628040858080326e+23, "+7.62804e+23", "%+g"},
+ {__LINE__, 7.632109382948695e-01, "0.763211", "%#f"},
+ {__LINE__, 7.633415922627254e+28, "76334159226272539910951309138.908982", "%#f"},
+ {__LINE__, 7.636190400774419e+22, "+7.636190E+22", "%+E"},
+ {__LINE__, 7.636228368661314e-23, "0.000000", "%f"},
+ {__LINE__, 7.653292362739654e-17, "7.65329E-17", "%#G"},
+ {__LINE__, 7.664044705231460e+03, "7.664045E+03", "%5E"},
+ {__LINE__, 7.664257283149626e-05, "7.66426E-05", "%0G"},
+ {__LINE__, 7.668996632821614e-19, " 0.0", "%4.1f"},
+ {__LINE__, 7.674502669497263e-24, "7.6745e-24", "%g"},
+ {__LINE__, 7.681870119755193e+12, "+7.68187e+12", "%+#g"},
+ {__LINE__, 7.693453198401315e+02, "769.3453198", "%5.7f"},
+ {__LINE__, 7.705080073293603e-29, "7.705080E-29", "%1E"},
+ {__LINE__, 7.707244083934683e-07, "7.71E-07", "%2.3G"},
+ {__LINE__, 7.749445584970652e-17, "7.75E-17", "%6.3G"},
+ {__LINE__, 7.755369447889403e+09, "7.8e+09", "%#4.2g"},
+ {__LINE__, 7.760378169707072e-06, "7.76038e-06", "%g"},
+ {__LINE__, 7.763518882114968e-10, "0.000000", "%f"},
+ {__LINE__, 7.764720069569677e-18, "0.000000", "%0f"},
+ {__LINE__, 7.768821339438552e-03, "0.00776882", "%g"},
+ {__LINE__, 7.774767835990679e-29, "7.774768E-29", "%7E"},
+ {__LINE__, 7.805567188246987e-04, "0.000780557", "%2G"},
+ {__LINE__, 7.825157442935941e-26, "0.000000", "%f"},
+ {__LINE__, 7.833373563161910e+29, "+783337356316190991378789476584.643126", "%+f"},
+ {__LINE__, 7.875872661746674e-16, "7.875873E-16", "%E"},
+ {__LINE__, 7.880664458920439e-28, "7.881E-28", "%#0.3E"},
+ {__LINE__, 7.893084198630288e+18, "7893084198630288206", "%1.f"},
+ {__LINE__, 7.912222737877417e+04, "79122.2", "%G"},
+ {__LINE__, 7.913004582748724e-26, "0.000000", "%f"},
+ {__LINE__, 7.913749944463836e+17, "791374994446383617.230367", "%f"},
+ {__LINE__, 7.923881665760883e-24, "0.000000", "%f"},
+ {__LINE__, 7.926699779993694e-03, "0.007927", "%5.6f"},
+ {__LINE__, 7.941991860623354e-20, "7.941992e-20", "%e"},
+ {__LINE__, 7.942700358097138e+17, "794270035809713803.587329", "%2f"},
+ {__LINE__, 7.945451569935757e-16, "7.94545E-16", "%#4.6G"},
+ {__LINE__, 7.948277588625241e-04, "0", "%.0f"},
+ {__LINE__, 7.952265062569124e+21, "+7.95227e+21", "%+#g"},
+ {__LINE__, 7.959953534668040e+11, "8e+11", "%2.e"},
+ {__LINE__, 7.962059154424500e-22, "7.96206E-22", "%G"},
+ {__LINE__, 7.962856142535673e-26, "7.9629E-26", "%#.5G"},
+ {__LINE__, 7.966528574505771e+12, "7.96653e+12", "%g"},
+ {__LINE__, 8.006496880305429e-21, "8.0065E-21", "%G"},
+ {__LINE__, 8.023374861440542e+06, "+8023375", "%+6.f"},
+ {__LINE__, 8.041139717082990e-20, "8.04114e-20", "%g"},
+ {__LINE__, 8.044201752824126e+15, "8.04420E+15", "%.5E"},
+ {__LINE__, 8.044262927409321e-10, "+8E-10", "%+2.2G"},
+ {__LINE__, 8.058285708061202e+02, "+8.058286e+02", "%+e"},
+ {__LINE__, 8.104422320765144e+10, "8.10442e+10", "%#4g"},
+ {__LINE__, 8.104572628022330e-11, "0.000000", "%f"},
+ {__LINE__, 8.112156369917432e+15, "+8.11216E+15", "%+G"},
+ {__LINE__, 8.114566569709531e-18, "8.11457E-18", "%G"},
+ {__LINE__, 8.114795069552519e+13, "8.114795E+13", "%E"},
+ {__LINE__, 8.121382719830660e+03, "8121.382720", "%f"},
+ {__LINE__, 8.125179335533733e-12, "+8.125179e-12", "%+e"},
+ {__LINE__, 8.126383949107055e+19, "81263839491070548604.056967", "%f"},
+ {__LINE__, 8.129961701307842e-04, "+0.00081", "%+5.2g"},
+ {__LINE__, 8.143780077390936e+15, "8.14378E+15", "%G"},
+ {__LINE__, 8.149891507777399e+16, "+8E+16", "%+1.G"},
+ {__LINE__, 8.167395708830107e+03, "8167", "%3.f"},
+ {__LINE__, 8.167703619221975e+01, "81.677", "%G"},
+ {__LINE__, 8.178463030771759e+06, "+8.17846E+06", "%+G"},
+ {__LINE__, 8.188188531273697e+12, "8.18819E+12", "%G"},
+ {__LINE__, 8.189094866416537e+11, "+8E+11", "%+.1G"},
+ {__LINE__, 8.205086844365809e-18, "+8.205087E-18", "%+#E"},
+ {__LINE__, 8.205762333408320e-26, "0.000000", "%f"},
+ {__LINE__, 8.212370598174696e-10, "8.2124E-10", "%.5G"},
+ {__LINE__, 8.228054316085489e-14, "0.000000", "%3f"},
+ {__LINE__, 8.244313484402404e-16, "8.24431e-16", "%g"},
+ {__LINE__, 8.244472235472472e+19, "8.24447E+19", "%G"},
+ {__LINE__, 8.245421473302411e-09, "+8.2454e-09", "%+1.5g"},
+ {__LINE__, 8.252286626634840e-22, "8E-22", "%3.G"},
+ {__LINE__, 8.259969177912707e-19, "0.000000", "%f"},
+ {__LINE__, 8.265769991725211e+18, "8.26577e+18", "%.5e"},
+ {__LINE__, 8.293986939496488e+25, "8.3E+25", "%.1E"},
+ {__LINE__, 8.310348813512608e-23, "+8.31035e-23", "%+g"},
+ {__LINE__, 8.316951996533247e-20, "0.000000", "%f"},
+ {__LINE__, 8.318818016883803e+05, " 8e+05", "%6.1g"},
+ {__LINE__, 8.324896920131877e-13, "+8.324897e-13", "%+e"},
+ {__LINE__, 8.325228630004624e-03, "0.0083252", "%5.7f"},
+ {__LINE__, 8.332538660129034e+14, "8.3e+14", "%5.2g"},
+ {__LINE__, 8.343325212751775e+07, "8.34333e+07", "%#4g"},
+ {__LINE__, 8.363117398136236e+20, "+8.36e+20", "%+.3g"},
+ {__LINE__, 8.364181324448165e+27, "8.36418e+27", "%#g"},
+ {__LINE__, 8.372159259848738e+10, "8.37216e+10", "%4g"},
+ {__LINE__, 8.379252006152759e-26, "8.37925e-26", "%g"},
+ {__LINE__, 8.392670395720252e+09, "8392670395.720252", "%f"},
+ {__LINE__, 8.423360059147756e+05, "+842336.", "%+#G"},
+ {__LINE__, 8.425921213167943e+09, "8.425921e+09", "%1.7g"},
+ {__LINE__, 8.431664412515776e-16, "8.43166E-16", "%#G"},
+ {__LINE__, 8.448608859842500e+02, "844.861", "%1.3f"},
+ {__LINE__, 8.456292247478771e-14, "8.45629E-14", "%G"},
+ {__LINE__, 8.460077225296853e-04, "0.000846008", "%G"},
+ {__LINE__, 8.478635925746218e-10, "0.000000", "%f"},
+ {__LINE__, 8.492455774427448e+06, "8.49246e+06", "%g"},
+ {__LINE__, 8.494450528380746e-07, "8.494451e-07", "%e"},
+ {__LINE__, 8.516435842947605e-23, "+0.000000", "%+1f"},
+ {__LINE__, 8.519057789029134e-18, "0.000000", "%0f"},
+ {__LINE__, 8.522602111109066e+18, " 9.e+18", "%#7.g"},
+ {__LINE__, 8.529176788022152e-24, "8.529E-24", "%0.4G"},
+ {__LINE__, 8.534979605642793e-07, "0.000001", "%f"},
+ {__LINE__, 8.546859563634342e-07, "8.546860E-07", "%E"},
+ {__LINE__, 8.552370027054106e+12, "9e+12", "%.0g"},
+ {__LINE__, 8.561781328234041e+10, "8.56178e+10", "%4g"},
+ {__LINE__, 8.562688793145107e-20, "8.562689e-20", "%1.7g"},
+ {__LINE__, 8.573130147270046e-07, " 9E-07", "%7.G"},
+ {__LINE__, 8.584571984387802e-18, "8.5846e-18", "%.5g"},
+ {__LINE__, 8.596407996491291e+11, "8.596408E+11", "%#E"},
+ {__LINE__, 8.604843726850381e+10, " 9E+10", "%6.G"},
+ {__LINE__, 8.626884271938994e-23, "8.62688e-23", "%g"},
+ {__LINE__, 8.631140282429168e+24, "8631140282429168308908629.", "%#.0f"},
+ {__LINE__, 8.635194331917948e-16, "8.63519E-16", "%G"},
+ {__LINE__, 8.641417311588688e-24, "+0.000000", "%+f"},
+ {__LINE__, 8.649120264278466e+26, "8.65E+26", "%1.3G"},
+ {__LINE__, 8.649745523383894e+06, "8.649746e+06", "%e"},
+ {__LINE__, 8.654720740091021e+16, "8.65472e+16", "%g"},
+ {__LINE__, 8.655445556834509e-08, "9e-08", "%4.g"},
+ {__LINE__, 8.658954696751902e+06, "8.65895E+06", "%G"},
+ {__LINE__, 8.665712368800818e-10, "+8.66571E-10", "%+G"},
+ {__LINE__, 8.666937057116442e-10, "8.666937e-10", "%e"},
+ {__LINE__, 8.670981239765155e+05, "867098", "%G"},
+ {__LINE__, 8.679631934294932e-25, "+9.E-25", "%+#0.G"},
+ {__LINE__, 8.683595173050962e-21, "8.68360E-21", "%#G"},
+ {__LINE__, 8.684938704958039e+25, "8.684939E+25", "%E"},
+ {__LINE__, 8.686745463281227e-12, "8.686745E-12", "%5.7G"},
+ {__LINE__, 8.700227628706534e-12, "8.700228e-12", "%#e"},
+ {__LINE__, 8.705101179577200e+04, "87051.011796", "%#2f"},
+ {__LINE__, 8.707824829984700e-24, "9e-24", "%.1g"},
+ {__LINE__, 8.717654041009233e+21, "+9E+21", "%+6.0E"},
+ {__LINE__, 8.741736299906572e-11, "8.74174E-11", "%#0G"},
+ {__LINE__, 8.742228350419966e+18, "+8742228350419965821.060941", "%+f"},
+ {__LINE__, 8.743045146087558e-17, "+8.74305E-17", "%+2G"},
+ {__LINE__, 8.747820269457588e+18, "8.74782E+18", "%G"},
+ {__LINE__, 8.756274717008537e-28, "8.756275E-28", "%E"},
+ {__LINE__, 8.769782309254687e-24, "+8.769782E-24", "%+2.6E"},
+ {__LINE__, 8.788151659193398e-16, " 9E-16", "%6.E"},
+ {__LINE__, 8.789514812202340e-07, "9E-07", "%0.G"},
+ {__LINE__, 8.792657843164822e-07, "8.79266e-07", "%0g"},
+ {__LINE__, 8.810976223440985e+05, "881097.622344", "%f"},
+ {__LINE__, 8.822553973113614e+10, "8.82255E+10", "%G"},
+ {__LINE__, 8.839440421530611e-04, "0.000883944", "%G"},
+ {__LINE__, 8.842539073558434e-12, "0", "%1.f"},
+ {__LINE__, 8.882818021261782e-13, "+8.9e-13", "%+4.2g"},
+ {__LINE__, 8.899833909201039e+05, "8.8998E+05", "%.5G"},
+ {__LINE__, 8.903167498000181e-13, "9e-13", "%0.g"},
+ {__LINE__, 8.933727737932164e+09, "+8933727738", "%+4.f"},
+ {__LINE__, 8.946226267100711e+06, "8.946E+06", "%1.4G"},
+ {__LINE__, 8.953203780849794e-21, "8.9532E-21", "%G"},
+ {__LINE__, 8.959934262635649e+28, "+8.959934e+28", "%+e"},
+ {__LINE__, 8.969485341781558e-25, "0.000000", "%#f"},
+ {__LINE__, 8.970058187654221e+02, "897.005819", "%f"},
+ {__LINE__, 8.979846508565979e+02, "8.979847E+02", "%E"},
+ {__LINE__, 8.984561117901212e+01, "8.984561E+01", "%E"},
+ {__LINE__, 8.992157765875611e-12, "8.99216e-12", "%g"},
+ {__LINE__, 9.004487016708012e+01, "9.004487e+01", "%#e"},
+ {__LINE__, 9.007306978283218e-24, "9.007307e-24", "%e"},
+ {__LINE__, 9.014546375043562e+17, "901454637504356171.007203", "%#3f"},
+ {__LINE__, 9.028177786002161e-12, "9.02818E-12", "%G"},
+ {__LINE__, 9.029635986381795e-02, "0.09", "%.1g"},
+ {__LINE__, 9.032389962233431e-07, "+0.000001", "%+f"},
+ {__LINE__, 9.038466945070887e+10, "+9.038467E+10", "%+E"},
+ {__LINE__, 9.040166964322772e-27, "9.04017e-27", "%g"},
+ {__LINE__, 9.044627673694681e-11, "9.04463E-11", "%G"},
+ {__LINE__, 9.045906217628948e+17, "904590621762894819.823941", "%1f"},
+ {__LINE__, 9.051764975661710e+11, "9.05176e+11", "%#g"},
+ {__LINE__, 9.053142913711405e+29, "9.053143e+29", "%#e"},
+ {__LINE__, 9.073185209160657e-19, "+9.07319e-19", "%+g"},
+ {__LINE__, 9.074372574441451e+02, "907.437", "%g"},
+ {__LINE__, 9.084624602048136e+08, "9.084625E+08", "%E"},
+ {__LINE__, 9.088839346363631e+18, "9.09e+18", "%.2e"},
+ {__LINE__, 9.091945159170871e-15, "9.09195e-15", "%5g"},
+ {__LINE__, 9.115304318083716e+10, "9.115304e+10", "%e"},
+ {__LINE__, 9.115978352902710e+28, "9.11598E+28", "%G"},
+ {__LINE__, 9.121415008221017e-17, "9.E-17", "%#6.G"},
+ {__LINE__, 9.127270978060388e+18, "9.E+18", "%#5.G"},
+ {__LINE__, 9.143941729069086e+08, "9.143942E+08", "%#E"},
+ {__LINE__, 9.162740105978580e-19, " 9.E-19", "%#7.G"},
+ {__LINE__, 9.221509957559626e-18, "9.22151e-18", "%g"},
+ {__LINE__, 9.227419774250317e-28, " 0.", "%#3.f"},
+ {__LINE__, 9.230846660807540e-21, "0.000000", "%f"},
+ {__LINE__, 9.238091727277130e-06, "+0.00001", "%+.5f"},
+ {__LINE__, 9.244337357684406e+10, "9E+10", "%5.G"},
+ {__LINE__, 9.259179793993285e-19, " 9E-19", "%7.0G"},
+ {__LINE__, 9.274068541525759e-17, "9.274069e-17", "%e"},
+ {__LINE__, 9.283833535882367e+16, "9.28383e+16", "%#g"},
+ {__LINE__, 9.295693096364605e+11, "+9.295693E+11", "%+E"},
+ {__LINE__, 9.301820438602407e+05, "930182", "%G"},
+ {__LINE__, 9.322805251555376e-29, "9e-29", "%1.e"},
+ {__LINE__, 9.358443042421307e-27, "9.35844e-27", "%g"},
+ {__LINE__, 9.372658444745124e-23, "9.372658e-23", "%e"},
+ {__LINE__, 9.380302971355292e+05, "938030.3", "%.7g"},
+ {__LINE__, 9.381976354968076e-26, "+9.382E-26", "%+5.4G"},
+ {__LINE__, 9.391072061980585e-15, "9.391072E-15", "%E"},
+ {__LINE__, 9.403554117166546e-06, "0.000009", "%f"},
+ {__LINE__, 9.403712900426614e-28, "9.40371e-28", "%g"},
+ {__LINE__, 9.419046629820578e+03, "9419.046630", "%f"},
+ {__LINE__, 9.422344695378412e+22, "94223446953784115720509.362291", "%f"},
+ {__LINE__, 9.433327680467576e+01, "9.433328e+01", "%e"},
+ {__LINE__, 9.443975205260596e+20, "9.44398e+20", "%g"},
+ {__LINE__, 9.445134851965593e-04, "+9.445135E-04", "%+E"},
+ {__LINE__, 9.448403585149890e+24, "9e+24", "%0.g"},
+ {__LINE__, 9.463149430113036e+18, "9.46315e+18", "%g"},
+ {__LINE__, 9.465735160722534e+27, "+9465735160722534402566452627.070248", "%+f"},
+ {__LINE__, 9.495210794344892e-04, "0.000950", "%f"},
+ {__LINE__, 9.501916506373814e-25, "9.50192E-25", "%#G"},
+ {__LINE__, 9.514641335897739e+29, "9.51464E+29", "%G"},
+ {__LINE__, 9.524633436992819e-04, " 0.001", "%6.G"},
+ {__LINE__, 9.530925101873022e-18, "9.530925e-18", "%2e"},
+ {__LINE__, 9.557903833216979e-22, "9.557904E-22", "%E"},
+ {__LINE__, 9.587709102390903e-01, " 1", "%2.f"},
+ {__LINE__, 9.592723000828453e-02, "9.592723E-02", "%5E"},
+ {__LINE__, 9.603430008794172e+27, "9.60343e+27", "%g"},
+ {__LINE__, 9.622648414989433e-18, "9.622648e-18", "%1e"},
+ {__LINE__, 9.633326171289319e-23, "9.633326e-23", "%e"},
+ {__LINE__, 9.662064616152408e+19, "96620646161524081918.5146393", "%1.7f"},
+ {__LINE__, 9.668544846563163e-23, "9.668545e-23", "%e"},
+ {__LINE__, 9.691014191346685e+28, "9.69101E+28", "%G"},
+ {__LINE__, 9.693075414840598e+02, "+969.308", "%+G"},
+ {__LINE__, 9.695013453291907e-30, "9.695013e-30", "%5e"},
+ {__LINE__, 9.705983477801926e-24, "9.70598e-24", "%g"},
+ {__LINE__, 9.709022568030226e-17, "0.000000", "%f"},
+ {__LINE__, 9.715194901854826e+20, "9.715195e+20", "%e"},
+ {__LINE__, 9.721011821337717e+16, "1E+17", "%0.G"},
+ {__LINE__, 9.734895542899672e+14, "9.734896e+14", "%e"},
+ {__LINE__, 9.741486438769710e-29, " 1e-28", "%6.g"},
+ {__LINE__, 9.766657482315475e-24, "9.76666E-24", "%7G"},
+ {__LINE__, 9.767283293054552e-02, "0.09767", "%5.5f"},
+ {__LINE__, 9.769553159146005e-20, "9.76955E-20", "%G"},
+ {__LINE__, 9.777220880605434e-10, "0.00", "%4.2f"},
+ {__LINE__, 9.790290569034575e+20, "979029056903457473027.", "%#6.f"},
+ {__LINE__, 9.793128245822718e-01, "0.979313", "%G"},
+ {__LINE__, 9.804758536498200e+08, "980475853.650", "%.3f"},
+ {__LINE__, 9.816883664191066e-02, "0.1", "%.0g"},
+ {__LINE__, 9.836109821010300e+25, "9.83611e+25", "%g"},
+ {__LINE__, 9.846197559631225e+03, "1E+04", "%2.G"},
+ {__LINE__, 9.863289416819924e+12, "9.86329e+12", "%g"},
+ {__LINE__, 9.865893798657353e+12, "9.866e+12", "%0.4g"},
+ {__LINE__, 9.868248446640862e-15, "0.000000", "%#f"},
+ {__LINE__, 9.869973080775134e+04, "98699.7", "%G"},
+ {__LINE__, 9.899444006312953e+20, "1E+21", "%.1G"},
+ {__LINE__, 9.904083146074285e-08, "9.904083e-08", "%6e"},
+ {__LINE__, 9.909790408255471e+15, "9909790408255471.305665", "%f"},
+ {__LINE__, 9.930297455798394e-13, "+9.930297E-13", "%+5.6E"},
+ {__LINE__, 9.933314448709083e-15, "9.93331E-15", "%#.6G"},
+ {__LINE__, 9.938714530509870e+29, "9.938715e+29", "%e"},
+ {__LINE__, 9.953892603540162e+07, "9.95389E+07", "%G"},
+ {__LINE__, 9.962084643867200e+14, "+996208464386720.038419", "%+f"},
+ {__LINE__, 9.977706708809947e-09, "9.9777E-09", "%#.4E"},
+#endif
+ {__LINE__, 9.978034352999867e+15, "9.978034e+15", "%2.6e"},
+ {__LINE__, 9.998315286730175e-30, "9.998315e-30", "%6e"},
+// For ±(x + 0.25), we diverge from the glibc implementation in how the
+// rounding happens. Glibc uses "round to nearest, ties to even", which
+// rounds them to ±(x + 0.2), but we use double-conversion, which
+// implements the ECMAScript spec, which instead uses "round to nearest,
+// ties away from zero", which rounds them to ±(x + 0.3).
+// Both behaviors are valid.
+ {__LINE__, 1.25, "1.3", "%.1f"},
+ {__LINE__, 11.25, "11.3", "%.1f"},
+ {__LINE__, 1.75, "1.8", "%.1f"},
+ {__LINE__, 11.75, "11.8", "%.1f"},
+ {__LINE__, -1.25, "-1.3", "%.1f"},
+ {__LINE__, -11.25, "-11.3", "%.1f"},
+ {__LINE__, -1.75, "-1.8", "%.1f"},
+ {__LINE__, -11.75, "-11.8", "%.1f"},
+ {__LINE__, 16, "0x1.0p+4", "%.1a"},
+ {__LINE__, 16, "0x1.00000000000000000000p+4", "%.20a"},
+ {__LINE__, 4444.88888888, "4445", "%2.F"},
+ {__LINE__, 0.956, "1", "%.0g"},
+ {__LINE__, 1.0956, "1.", "%#.0g"},
+ {__LINE__, 0.956, "1.", "%#.0g"},
+ {__LINE__, 0.0956, "0.1", "%#.0g"},
+ {__LINE__, 0.00956, "0.01", "%#.0g"},
+ {__LINE__, 0.000956, "0.001", "%#.0g"},
+ {__LINE__, 0.000098, "0.0001", "%#.0g"},
+ {__LINE__, 0.0000996, "0.00010", "%#.2g"},
+ {__LINE__, 9.999999999999999e-05, "0.0001", "%g"},
+ {__LINE__, 1.0, "1.000000e+00", "%e"},
+ {__LINE__, .9999999999999999, "1.000000e+00", "%e"},
+
+ {__LINE__, 912.98, "913.0", "%#.4g"},
+ {__LINE__, 50.999999, "51.000", "%#.5g"},
+ {__LINE__, 0.956, "1", "%.1g"},
+ {__LINE__, 0.956, "1.", "%#.1g"},
+ {__LINE__, 0.996, "1", "%.2g"},
+ {__LINE__, 0.996, "1.0", "%#.2g"},
+ {__LINE__, 999.98, "1000", "%.4g"},
+ {__LINE__, 999.98, "1000.", "%#.4g"},
+ {__LINE__, 999.998, "1000", "%.5g"},
+ {__LINE__, 999.998, "1000.0", "%#.5g"},
+ {__LINE__, 999.9998, "1000", "%g"},
+ {__LINE__, 999.9998, "1000.00", "%#g"},
+ {__LINE__, 912.98, "913", "%.4g"},
+ {__LINE__, 50.999999, "51", "%.5g"},
+
+ {__LINE__, 0.0, "0000.00000", "%010.5f"},
+ {__LINE__, 0.0, " 000.00000", "% 010.5f"},
+ {__LINE__, -0.0, "-000.00000", "% 010.5f"},
+
+ {__LINE__, NAN, "nan", "%f"},
+ {__LINE__, NAN, "+nan", "%+f"},
+ {__LINE__, NAN, " nan", "%010.2f"},
+ {__LINE__, NAN, " +nan", "%+010.2f"},
+ {__LINE__, -NAN, "-nan", "%f"},
+ {__LINE__, -NAN, "-nan", "%+f"},
+ {__LINE__, -NAN, " -nan", "%010.2f"},
+ {__LINE__, -NAN, " -nan", "%+010.2f"},
+ {__LINE__, NAN, "NAN", "%F"},
+ {__LINE__, INFINITY, "inf", "%f"},
+ {__LINE__, INFINITY, "+inf", "%+f"},
+ {__LINE__, INFINITY, " inf", "%010.2f"},
+ {__LINE__, INFINITY, " +inf", "%+010.2f"},
+ {__LINE__, -INFINITY, "-inf", "%f"},
+ {__LINE__, -INFINITY, "-inf", "%+f"},
+ {__LINE__, -INFINITY, " -inf", "%010.2f"},
+ {__LINE__, -INFINITY, " -inf", "%+010.2f"},
+ {__LINE__, INFINITY, "INF", "%F"},
+
+ {0 }
+
+};
+
+/* matches(s1, s2) is true if s1 is "approximately" equal to s2.
+ Any digits after the first required_precision digits do not have to match.
+ */
+
+int required_precision = 13;
+
+static int
+matches (char *result, const char *desired)
+{
+ int digits_seen = 0;
+ for (;; result++, desired++) {
+ if (*result == *desired) {
+ if (*result == 0)
+ return 1;
+ else if (*result >= '0' && *result <= '9')
+ digits_seen++;
+ }
+ else if (digits_seen >= required_precision
+ && *result >= '0' && *result <= '9'
+ && *desired >= '0' && *desired <= '9')
+ continue;
+ else
+ return 0;
+ }
+}
+
+int main(int argc, char *argv[])
+{
+ int errcount = 0;
+ int testcount = 0;
+ double d;
+#define BSIZE 1024
+ char buffer[BSIZE];
+ sprint_double_type *dptr;
+ for (dptr = sprint_doubles; dptr->line; dptr++)
+ {
+ snprintf (buffer, sizeof(buffer), dptr->format_string, dptr->value);
+ if (!matches(buffer, dptr->result))
+ {
+ errcount++;
+ printf(
+ "Error in line %d using \"%s\". Result is \"%s\"; should be: \"%s\".\n",
+ dptr->line, dptr->format_string, buffer, dptr->result);
+ }
+
+ snprintf (buffer, sizeof(buffer), "%.999g", dptr->value);
+ sscanf (buffer, "%lg", &d);
+ if (dptr->value != d && !isnan(d))
+ {
+ errcount++;
+ printf ("Error in line %d. String is \"%s\", value is %g.\n",
+ dptr->line, buffer, d);
+ }
+ testcount++;
+ }
+
+ /* And one special test. */
+ {
+ static const char ref[] = "1.7763568394002504646778106689453125e-15";
+ int i;
+ d = 1.0;
+ for (i = 1; i < 50; ++i)
+ d /= 2;
+ snprintf (buffer, sizeof(buffer), "%.100g", d);
+ if (!matches (buffer, ref))
+ {
+ ++errcount;
+ printf (
+ "Error in line %d using \"%s\". Result is \"%s\"; should be: \"%s\".\n",
+ __LINE__, "%.100g", buffer, ref);
+ }
+ }
+
+ if (errcount == 0)
+ {
+ printf("Encountered no errors in %d tests.\n", testcount);
+ return 0;
+ }
+ else
+ {
+ printf("Encountered %d errors in %d tests.\n",
+ errcount, testcount);
+ return 1;
+ }
+}
diff --git a/mozglue/tests/glibc_printf_tests/tiformat.c b/mozglue/tests/glibc_printf_tests/tiformat.c
new file mode 100644
index 0000000000..82226be689
--- /dev/null
+++ b/mozglue/tests/glibc_printf_tests/tiformat.c
@@ -0,0 +1,5070 @@
+#include <stdio.h>
+#include <string.h>
+
+/* Tests taken from Cygnus C library. */
+typedef struct {
+ int line;
+ long value;
+ const char *result;
+ const char *format_string;
+} sprint_int_type;
+
+sprint_int_type sprint_ints[] =
+{
+ {__LINE__, 0x000838d2, "838d2", "%.4x"},
+ {__LINE__, 0x0063be46, "63BE46", "%-6X"},
+ {__LINE__, -0x1b236c0, "-28456640", "%#0.d"},
+ {__LINE__, -0x0000003, "-3", "% 0d"},
+ {__LINE__, 0x0000ed51, "ed51", "%2.x"},
+ {__LINE__, -0x00001f2, "-498", "%1ld"},
+ {__LINE__, 0x0ea3e927, "EA3E927", "%+X"},
+ {__LINE__, 0xffbef8da, "FFBEF8DA", "%5X"},
+ {__LINE__, 0x62ff9f56, "62ff9f56", "%0x"},
+ {__LINE__, 0x00000ad2, "AD2", "%.0X"},
+ {__LINE__, 0x00000000, " ", "% 6.ld"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%1.4X"},
+ {__LINE__, 0x0000208c, " 208C", "%5X"},
+ {__LINE__, 0x0000003c, "3c", "%x"},
+ {__LINE__, 0xffff6177, "0xffff6177", "%+#x"},
+ {__LINE__, 0xffffdc8d, "ffffdc8d", "%+x"},
+ {__LINE__, 0x00000000, "0", "%X"},
+ {__LINE__, 0x00002434, "9268", "%0d"},
+ {__LINE__, 0xd2c72cdb, "d2c72cdb", "%-x"},
+ {__LINE__, 0xfe38012b, "0xfe38012b", "%+#7x"},
+ {__LINE__, 0x00000001, "0001", "%#.4d"},
+ {__LINE__, -0x008525a, "-0545370", "%06.7ld"},
+ {__LINE__, 0xffffffac, "ffffffac", "%3.7x"},
+ {__LINE__, 0x007424d2, "+7611602", "%+ld"},
+ {__LINE__, 0x00001a85, "1A85", "%.4X"},
+ {__LINE__, -0x0000019, "-25", "%3.d"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%-x"},
+ {__LINE__, -0x34473b2, "-54817714", "% d"},
+ {__LINE__, 0x000000ea, "234", "%1.ld"},
+ {__LINE__, -0x0000004, "-4 ", "%-7.ld"},
+ {__LINE__, 0x00006c94, "27796", "%0d"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, 0x00000619, "619", "%1x"},
+ {__LINE__, 0x0000209c, "8348", "%ld"},
+ {__LINE__, -0x327f8ff, "-52951295", "%-0ld"},
+ {__LINE__, 0xffffff0b, "FFFFFF0B", "%2.X"},
+ {__LINE__, 0xf199d6ae, "F199D6AE", "%X"},
+ {__LINE__, 0x3ca5602e, "1017471022", "%-1.ld"},
+ {__LINE__, -0xfb2080b, "-263325707", "%3.5d"},
+ {__LINE__, 0x00001cb8, "7352", "%d"},
+ {__LINE__, 0x00000000, "0000000", "%3.7d"},
+ {__LINE__, 0xffffff40, "FFFFFF40", "%+X"},
+ {__LINE__, 0x14664450, "0x14664450", "%#x"},
+ {__LINE__, 0x0000002e, "2e", "%1x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, 0xffff606a, "0XFFFF606A", "%#X"},
+ {__LINE__, 0xffffff33, "0XFFFFFF33", "%#X"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, -0x0000012, "-00018", "%-2.5d"},
+ {__LINE__, 0x0001fbe6, "130022", "%1.d"},
+ {__LINE__, 0xfff59dd9, "fff59dd9", "%+x"},
+ {__LINE__, 0x00000002, "2", "%0.0d"},
+ {__LINE__, 0x00000fe1, "fe1 ", "%-7.x"},
+ {__LINE__, 0x001f8f6a, "1F8F6A", "%1.X"},
+ {__LINE__, 0x0000001b, "000001B", "%04.7X"},
+ {__LINE__, 0x126a2609, " 308946441", "% 4d"},
+ {__LINE__, 0xffffffe3, "0XFFFFFFE3", "%+#.1X"},
+ {__LINE__, 0x1858f1c9, "1858f1c9", "%.3x"},
+ {__LINE__, 0x003fc672, "3fc672", "%1x"},
+ {__LINE__, 0x00c0bddc, "12631516", "%#d"},
+ {__LINE__, 0x000006d6, "1750", "%#d"},
+ {__LINE__, 0x000006a0, "6A0", "%X"},
+ {__LINE__, 0x000007be, "7BE", "%X"},
+ {__LINE__, -0x1c7cd1a, "-29871386", "%ld"},
+ {__LINE__, 0x000000cc, "204", "%ld"},
+ {__LINE__, 0x000002db, "731 ", "%-#5d"},
+ {__LINE__, 0xffff67ad, "FFFF67AD", "% X"},
+ {__LINE__, 0x00000008, "8", "%d"},
+ {__LINE__, 0xffe07007, "FFE07007", "%5X"},
+ {__LINE__, -0x0000001, " -1", "% 7d"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%x"},
+ {__LINE__, 0x00027b68, "+162664", "%+ld"},
+ {__LINE__, 0x0a7c1997, "+175905175", "%+2ld"},
+ {__LINE__, 0xfe300896, "fe300896", "%.4x"},
+ {__LINE__, 0x00000537, "537", "%-0.x"},
+ {__LINE__, 0x3e981779, "3e981779", "%.6x"},
+ {__LINE__, 0xfffff05e, "FFFFF05E", "%1.0X"},
+ {__LINE__, -0x07bc0cf, "-8110287", "%-7d"},
+ {__LINE__, -0x01371bc, "-1274300", "%.7ld"},
+ {__LINE__, -0x0000013, "-19", "%.2ld"},
+ {__LINE__, 0x000000d1, "0xd1", "%#x"},
+ {__LINE__, -0x0000003, "-3", "%-ld"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%4.1X"},
+ {__LINE__, 0x00000000, "0", "%ld"},
+ {__LINE__, 0x0001c8af, "116911", "%d"},
+ {__LINE__, 0x000048c3, "48C3", "%X"},
+ {__LINE__, 0x00000079, "0x0000079", "%-#0.7x"},
+ {__LINE__, 0x0000615a, " 24922", "% d"},
+ {__LINE__, 0xfffffff5, "fffffff5", "%x"},
+ {__LINE__, 0x00000308, "0000308", "%+07.7x"},
+ {__LINE__, 0xfcadc983, "fcadc983", "%x"},
+ {__LINE__, 0x00000097, "151", "%#d"},
+ {__LINE__, 0x000001c5, "453", "%0.2ld"},
+ {__LINE__, 0x00000000, "00", "%-1.2x"},
+ {__LINE__, 0x00000001, "+1", "%+02.d"},
+ {__LINE__, 0x01eb4354, "1EB4354", "% X"},
+ {__LINE__, 0xffffa7d1, "ffffa7d1", "%5.x"},
+ {__LINE__, 0x0003170e, "0x3170e", "%#x"},
+ {__LINE__, 0x000001ce, "1CE", "% .2X"},
+ {__LINE__, 0x3a2991fb, "975802875", "%d"},
+ {__LINE__, -0xcdad8e2, "-215668962", "%-d"},
+ {__LINE__, 0xfe0261c3, "fe0261c3", "%x"},
+ {__LINE__, -0x0006ea7, "-28327", "% ld"},
+ {__LINE__, 0x032854a3, "0X32854A3", "% #6X"},
+ {__LINE__, 0x0000004b, "4b", "%x"},
+ {__LINE__, 0xffff6ca3, "FFFF6CA3", "%4.X"},
+ {__LINE__, 0x00000000, "0", "%X"},
+ {__LINE__, 0x00611f04, "611F04", "%.1X"},
+ {__LINE__, 0x00000000, " 0", "%#6d"},
+ {__LINE__, 0x0002c711, "2c711", "%-02.x"},
+ {__LINE__, -0x07a2fe4, "-8007652", "%d"},
+ {__LINE__, -0x0000547, "-1351", "%ld"},
+ {__LINE__, 0x00013954, "0x13954", "%#x"},
+ {__LINE__, -0x00523b7, "-336823", "%ld"},
+ {__LINE__, -0x00f6c6e, "-1010798", "%6.ld"},
+ {__LINE__, 0xffea6427, "FFEA6427", "%3X"},
+ {__LINE__, -0x0000005, "-5", "%d"},
+ {__LINE__, -0x04fe618, "-5236248", "% .7d"},
+ {__LINE__, 0xffa80a28, "ffa80a28", "%-0x"},
+ {__LINE__, 0x00000047, "71", "%ld"},
+ {__LINE__, 0x001dc6bb, "1951419", "%#4ld"},
+ {__LINE__, 0x00000868, " 2152", "%#6d"},
+ {__LINE__, 0x000002fb, "2fb", "%x"},
+ {__LINE__, 0x00607fa0, "6324128", "%4d"},
+ {__LINE__, 0xfffed161, "fffed161", "%x"},
+ {__LINE__, 0x0001c6e4, " 116452", "% 2.5d"},
+ {__LINE__, 0x0003dda8, "3DDA8", "%4X"},
+ {__LINE__, 0xfffffff8, "fffffff8", "%x"},
+ {__LINE__, 0xfacf664a, "facf664a", "%x"},
+ {__LINE__, 0x000000c1, "C1", "% 1X"},
+ {__LINE__, 0x0000839c, " 839C", "%6X"},
+ {__LINE__, 0xfffff69a, "FFFFF69A", "%X"},
+ {__LINE__, 0x000e5c2e, "+941102", "%+d"},
+ {__LINE__, -0x0000004, "-4", "%#d"},
+ {__LINE__, 0x00000000, "00000", "%#.5ld"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%3.1x"},
+ {__LINE__, 0x0010ed68, "1109352", "%-ld"},
+ {__LINE__, 0xffffffe9, "ffffffe9", "%.6x"},
+ {__LINE__, 0x00000007, " 7", "% 4.ld"},
+ {__LINE__, 0x0000caba, "51898", "%ld"},
+ {__LINE__, -0x0000119, "-281", "% d"},
+ {__LINE__, 0x0c3012a9, "204477097", "%03.6ld"},
+ {__LINE__, -0x001c98f, "-117135", "%ld"},
+ {__LINE__, 0x000017b1, "+6065", "%+d"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, -0x0000019, "-25", "% .2d"},
+ {__LINE__, 0x0009ae28, "9AE28", "%X"},
+ {__LINE__, 0xe861c4fe, "e861c4fe", "%7.x"},
+ {__LINE__, 0xffac88d3, "FFAC88D3", "%X"},
+ {__LINE__, -0x00005df, "-01503", "%-5.5ld"},
+ {__LINE__, 0x0000013e, "318", "%-0d"},
+ {__LINE__, 0x04b6f58f, "4b6f58f", "%x"},
+ {__LINE__, 0xfffe3978, "fffe3978", "%+0.6x"},
+ {__LINE__, 0x57ee5244, "57ee5244", "%+7.4x"},
+ {__LINE__, 0xfffb5610, "fffb5610", "% 6x"},
+ {__LINE__, 0x00000006, " 6", "%#7d"},
+ {__LINE__, 0x0000000c, "0x0000c", "%#.5x"},
+ {__LINE__, -0xec59362, "-247829346", "%1.7d"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, -0x0007e4b, "-32331", "% d"},
+ {__LINE__, 0x0ececa6f, "248433263", "%0d"},
+ {__LINE__, 0x00000578, " 578", "%+6.x"},
+ {__LINE__, -0x0000003, "-3", "%ld"},
+ {__LINE__, 0x000002bb, "2bb", "% 0x"},
+ {__LINE__, -0x0000006, "-6", "%-ld"},
+ {__LINE__, 0x000002f9, "761", "%d"},
+ {__LINE__, 0xffffd736, "ffffd736", "%3.4x"},
+ {__LINE__, 0x0010ba79, "1096313", "%7.4d"},
+ {__LINE__, -0x0001244, "-4676", "%#.1d"},
+ {__LINE__, 0x00000dbe, "DBE", "%1X"},
+ {__LINE__, -0x0000015, "-21", "%-0.d"},
+ {__LINE__, 0xffffffff, "0xffffffff", "%#x"},
+ {__LINE__, -0x6cdf4a3, "-114160803", "%ld"},
+ {__LINE__, 0x00008ac9, "8AC9", "%1X"},
+ {__LINE__, 0x00000000, "00", "%.2X"},
+ {__LINE__, -0x2263dba, "-36060602", "%5.5d"},
+ {__LINE__, 0x00007da9, "32169", "%0d"},
+ {__LINE__, 0xfffffff7, "FFFFFFF7", "% 4.X"},
+ {__LINE__, 0xfbf36cca, "FBF36CCA", "%.1X"},
+ {__LINE__, 0x00000040, "64", "%.0ld"},
+ {__LINE__, 0x0000001c, " 28", "% d"},
+ {__LINE__, 0xfffffadb, "0xfffffadb", "%#.5x"},
+ {__LINE__, 0x0eb95847, "247027783", "%d"},
+ {__LINE__, 0xfffd7030, "FFFD7030", "%+02X"},
+ {__LINE__, 0x00000005, "00005", "%.5x"},
+ {__LINE__, 0xfffffffd, "FFFFFFFD", "%X"},
+ {__LINE__, 0x98975b15, "98975B15", "%02X"},
+ {__LINE__, -0x0000034, " -52", "%6ld"},
+ {__LINE__, 0xffd7d0cc, "ffd7d0cc", "% 5.6x"},
+ {__LINE__, 0xffffffa6, "FFFFFFA6", "%X"},
+ {__LINE__, 0xfff27132, "fff27132", "%x"},
+ {__LINE__, -0x065b74d, "-6666061", "%+6ld"},
+ {__LINE__, 0xf6ac99d6, "0XF6AC99D6", "%#X"},
+ {__LINE__, 0xfffff4bd, "FFFFF4BD", "%X"},
+ {__LINE__, 0xfffffb62, "FFFFFB62", "%6X"},
+ {__LINE__, 0xf8434543, "f8434543", "%-0x"},
+ {__LINE__, 0x0002b374, "0x2b374", "%-#6x"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0xffb5751d, "ffb5751d", "%-3.x"},
+ {__LINE__, 0x34ea7347, "887780167", "%d"},
+ {__LINE__, -0x008f457, "-586839", "%0ld"},
+ {__LINE__, 0x00000001, " 1", "%#4d"},
+ {__LINE__, 0xc32d7ad4, "c32d7ad4", "%0x"},
+ {__LINE__, 0xfffffb80, "FFFFFB80", "%-.2X"},
+ {__LINE__, 0x00000756, "756 ", "%-6x"},
+ {__LINE__, 0xfffb020f, "FFFB020F", "%+.2X"},
+ {__LINE__, -0xe68619f, "-241721759", "%#1.6ld"},
+ {__LINE__, 0x180166cd, "402745037", "%3.7ld"},
+ {__LINE__, -0x0000001, "-1", "%+00d"},
+ {__LINE__, 0xfdbc3611, "fdbc3611", "%x"},
+ {__LINE__, -0x000005b, "-91", "%d"},
+ {__LINE__, 0xffffe77f, "ffffe77f", "%x"},
+ {__LINE__, -0x0000019, "-25", "%ld"},
+ {__LINE__, 0x00000016, "22", "%#d"},
+ {__LINE__, -0x0000025, "-37", "%ld"},
+ {__LINE__, 0xffffe43f, "ffffe43f", "%x"},
+ {__LINE__, 0x000050a5, "00050a5", "%.7x"},
+ {__LINE__, 0x0000000c, " 12", "% 5.ld"},
+ {__LINE__, -0x001faff, "-129791", "%4d"},
+ {__LINE__, 0x239d7cf2, "597523698", "%0.7ld"},
+ {__LINE__, 0x04092183, "4092183", "% 7X"},
+ {__LINE__, -0x0043498, "-275608", "%-ld"},
+ {__LINE__, -0x0018dbe, "-101822", "%d"},
+ {__LINE__, 0xff3e09c3, "FF3E09C3", "%X"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, -0x15d57558, "-366310744", "%+0.7ld"},
+ {__LINE__, 0x0004fb06, "326406", "%0.0d"},
+ {__LINE__, 0x00000119, "0X119", "%#X"},
+ {__LINE__, -0x14c53e19, "-348470809", "%d"},
+ {__LINE__, 0x00000019, "0000019", "% .7X"},
+ {__LINE__, -0x0000654, "-1620", "%0.4ld"},
+ {__LINE__, -0xde5899b, "-233146779", "%#.1d"},
+ {__LINE__, 0x0013c1f0, "1294832", "%4.ld"},
+ {__LINE__, 0x0a9fe761, "A9FE761", "%X"},
+ {__LINE__, -0x00000e5, "-229", "%1ld"},
+ {__LINE__, 0x00000161, "000353", "%.6ld"},
+ {__LINE__, 0x6b04e4bd, "0x6b04e4bd", "%#7.0x"},
+ {__LINE__, -0x0000ef0, "-3824 ", "%-6.ld"},
+ {__LINE__, -0x026306e, "-2502766", "%ld"},
+ {__LINE__, 0x00000000, "0", "%-X"},
+ {__LINE__, 0xfffffe1f, "fffffe1f", "%-x"},
+ {__LINE__, 0x0003aecf, " 241359", "% 2.1ld"},
+ {__LINE__, -0x0000014, "-20", "%d"},
+ {__LINE__, 0x00000002, "0002", "%-.4ld"},
+ {__LINE__, 0xfffff662, "0XFFFFF662", "% #.6X"},
+ {__LINE__, 0x00000006, "6", "%0x"},
+ {__LINE__, 0x0001f4c4, " 128196", "% 0d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%5X"},
+ {__LINE__, 0x05605e38, "90201656", "%ld"},
+ {__LINE__, 0xffffffde, "0XFFFFFFDE", "% #X"},
+ {__LINE__, 0x000001e0, " 1e0", "%7.x"},
+ {__LINE__, 0x00000007, "7", "%X"},
+ {__LINE__, 0x00000001, "+1", "%+d"},
+ {__LINE__, 0xffffffe0, "FFFFFFE0", "% X"},
+ {__LINE__, 0xffd7f77a, "FFD7F77A", "%+00.1X"},
+ {__LINE__, 0xfffffffe, "0xfffffffe", "%-#x"},
+ {__LINE__, 0x01b0a63b, "1b0a63b", "%x"},
+ {__LINE__, -0x06554b7, "-6640823", "%d"},
+ {__LINE__, 0xfffffff8, "fffffff8", "%x"},
+ {__LINE__, 0x00000b2d, "b2d", "%x"},
+ {__LINE__, -0x2664ba2, "-40258466", "%-d"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%X"},
+ {__LINE__, -0x0000552, " -1362", "%6.2ld"},
+ {__LINE__, 0x00000009, " 00009", "%6.5x"},
+ {__LINE__, 0x00035c72, "220274", "%05.ld"},
+ {__LINE__, -0x014d09d, "-1364125", "%d"},
+ {__LINE__, -0x0000002, " -2", "% 4d"},
+ {__LINE__, 0x00000001, "1", "%+X"},
+ {__LINE__, 0x00000028, "28", "%X"},
+ {__LINE__, 0xf25c9eb2, "F25C9EB2", "%7.X"},
+ {__LINE__, -0x7ae4b62, "-128863074", "%d"},
+ {__LINE__, 0x00630d87, "630D87", "%2X"},
+ {__LINE__, 0x000000f8, "F8", "%-X"},
+ {__LINE__, 0xfffffff9, "FFFFFFF9", "%X"},
+ {__LINE__, -0x0000007, "-7", "%0d"},
+ {__LINE__, -0x2518fcd, "-38899661", "% 3ld"},
+ {__LINE__, 0xfffff4b4, "FFFFF4B4", "%-5X"},
+ {__LINE__, 0x01cc36c8, "30160584", "%ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%-x"},
+ {__LINE__, 0x0000000b, " 11", "%6.ld"},
+ {__LINE__, 0x00010d55, " 68949", "% d"},
+ {__LINE__, -0x0c01306, "-12587782", "% 6.1ld"},
+ {__LINE__, 0x001719d7, "1513943", "%.1ld"},
+ {__LINE__, -0x0000002, " -2", "%+3.ld"},
+ {__LINE__, 0x0000018e, "398", "%d"},
+ {__LINE__, 0x000000a6, "0xa6", "%-#3x"},
+ {__LINE__, 0x00006f66, " 28518", "% #d"},
+ {__LINE__, 0x0000032a, "32A", "%X"},
+ {__LINE__, -0x0000145, "-325", "%0d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%2.x"},
+ {__LINE__, 0x00287171, "2650481", "%ld"},
+ {__LINE__, 0x0000004b, "+75", "%+02.ld"},
+ {__LINE__, 0xfffffff8, "fffffff8", "%-0x"},
+ {__LINE__, 0x00000064, "64", "% X"},
+ {__LINE__, 0xfffffca2, "fffffca2", "%0x"},
+ {__LINE__, 0x000010b6, "10b6", "% .0x"},
+ {__LINE__, -0x003806f, "-229487", "%7d"},
+ {__LINE__, -0x00000b7, "-183", "%3ld"},
+ {__LINE__, 0xffffe5ba, "FFFFE5BA", "%0X"},
+ {__LINE__, 0x001f0da8, "1f0da8", "%+x"},
+ {__LINE__, 0x000ce185, "844165", "%0ld"},
+ {__LINE__, 0x00000c96, "3222", "%0d"},
+ {__LINE__, -0x0013099, "-77977", "%1.ld"},
+ {__LINE__, -0x5f3c47a, "-99861626", "%.6ld"},
+ {__LINE__, 0x00000cbf, " CBF", "%+5.X"},
+ {__LINE__, -0x0000001, "-1", "%+ld"},
+ {__LINE__, 0x0d793bc3, "d793bc3", "%6.x"},
+ {__LINE__, 0xfffffffd, "0xfffffffd", "%+#x"},
+ {__LINE__, -0x0000070, " -112", "%6.d"},
+ {__LINE__, 0xfffffb3f, "FFFFFB3F", "%.7X"},
+ {__LINE__, 0x037dfc78, "0X37DFC78", "%#X"},
+ {__LINE__, 0x00009ba5, "39845", "%3ld"},
+ {__LINE__, 0x0000004a, "4a", "%0x"},
+ {__LINE__, 0xffffff81, "ffffff81", "%5.5x"},
+ {__LINE__, -0x86ef222, "-141488674", "%ld"},
+ {__LINE__, -0xac5531e, "-180704030", "% 4ld"},
+ {__LINE__, 0x00002493, "2493", "%+X"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%1.3X"},
+ {__LINE__, 0x0005c875, "378997", "%.0ld"},
+ {__LINE__, 0x0301d345, "50451269", "%d"},
+ {__LINE__, 0xfff6b589, "fff6b589", "%2.4x"},
+ {__LINE__, -0x00001db, "-475 ", "%-7.0d"},
+ {__LINE__, 0x0000d1e7, "0x000d1e7", "%#2.7x"},
+ {__LINE__, 0xf4c4d2bb, "f4c4d2bb", "%.6x"},
+ {__LINE__, 0x00c89f54, "13147988", "%ld"},
+ {__LINE__, -0x6599253c, "-1704535356", "%+ld"},
+ {__LINE__, 0xab7d61ea, "ab7d61ea", "% x"},
+ {__LINE__, 0x00000006, "6", "%1ld"},
+ {__LINE__, 0xffff5ab7, "ffff5ab7", "%0x"},
+ {__LINE__, -0x1cfeca5b, "-486459995", "%#ld"},
+ {__LINE__, 0x000000f3, " f3", "% 6.x"},
+ {__LINE__, -0x0000021, "-33", "%d"},
+ {__LINE__, 0xfe7246ac, "fe7246ac", "%-5.x"},
+ {__LINE__, 0x00000017, "00017", "%-.5X"},
+ {__LINE__, -0x0cc250a, "-13378826", "%0.0d"},
+ {__LINE__, -0x00010ae, "-04270", "%#.5ld"},
+ {__LINE__, -0x7952c8b, "-127216779", "% ld"},
+ {__LINE__, 0x0002a53e, "173374", "%4.0d"},
+ {__LINE__, 0x03801bbf, "3801BBF", "%0X"},
+ {__LINE__, 0x0368645f, "+57173087", "%+#0.6ld"},
+ {__LINE__, 0x0000002f, "47", "%d"},
+ {__LINE__, 0x00000003, "3", "%x"},
+ {__LINE__, 0x000005f7, "5F7", "%0X"},
+ {__LINE__, -0x06e5e76, "-7233142", "% 0.1ld"},
+ {__LINE__, 0x053da936, "53da936", "%1.4x"},
+ {__LINE__, -0x0df0c2f, "-14617647", "%.5ld"},
+ {__LINE__, 0xfffffffd, "FFFFFFFD", "%-0X"},
+ {__LINE__, 0x000104bf, "104BF", "%X"},
+ {__LINE__, 0x000353fc, "353FC", "%X"},
+ {__LINE__, 0x182a18dc, "+405412060", "%+ld"},
+ {__LINE__, 0x0000000e, " 14", "% 2d"},
+ {__LINE__, -0x0000091, "-145", "%+ld"},
+ {__LINE__, 0x0029a9d6, "2730454", "%d"},
+ {__LINE__, 0x00009d57, "009d57", "% .6x"},
+ {__LINE__, 0x4c4d4f79, "1280135033", "%5.ld"},
+ {__LINE__, -0x000075b, "-1883", "% 03d"},
+ {__LINE__, -0x001b718, "-112408", "%+d"},
+ {__LINE__, 0xfffaaf57, "FFFAAF57", "%+1X"},
+ {__LINE__, 0x00f44e52, "F44E52", "% 4X"},
+ {__LINE__, 0x00000002, "0X2", "%#X"},
+ {__LINE__, 0x000a85e9, "A85E9", "%+0X"},
+ {__LINE__, 0xffff70bb, "ffff70bb", "%6x"},
+ {__LINE__, 0x00004e15, "4e15", "%x"},
+ {__LINE__, 0x000eeb60, " 977760", "% ld"},
+ {__LINE__, 0xfffffff1, "fffffff1", "%0x"},
+ {__LINE__, -0x294d7e2, "-43309026", "% 02.d"},
+ {__LINE__, 0x0001aaeb, "0109291", "%02.7ld"},
+ {__LINE__, 0x000a01fc, "0xa01fc", "%-#.5x"},
+ {__LINE__, 0x002c3c30, "+2898992", "%+#d"},
+ {__LINE__, 0x015667ae, "+22439854", "%+5ld"},
+ {__LINE__, -0x05af42b, "-5960747", "%+d"},
+ {__LINE__, 0x0000be36, "be36", "%+2x"},
+ {__LINE__, 0x005e3f67, "5e3f67", "% x"},
+ {__LINE__, -0x0000020, "-32", "% ld"},
+ {__LINE__, -0x0003617, "-13847", "% d"},
+ {__LINE__, 0x00000014, "14 ", "%-4.X"},
+ {__LINE__, 0x00000001, "001", "%0.3d"},
+ {__LINE__, 0xfffffea9, "fffffea9", "%3.x"},
+ {__LINE__, 0xe447099e, "E447099E", "%0X"},
+ {__LINE__, 0x00049c71, "302193", "%d"},
+ {__LINE__, 0x76356ed3, "0x76356ed3", "%#4.1x"},
+ {__LINE__, 0x00000005, " 0X5", "%#5X"},
+ {__LINE__, 0x00004da2, "0x004da2", "%#1.6x"},
+ {__LINE__, 0xffdfb36c, "FFDFB36C", "%4X"},
+ {__LINE__, 0xffffe3c5, "FFFFE3C5", "%+4.X"},
+ {__LINE__, 0x00000006, "6", "%0x"},
+ {__LINE__, -0x914ff17, "-152370967", "% .5ld"},
+ {__LINE__, -0x0000002, "-2", "%0ld"},
+ {__LINE__, 0xffffff36, "FFFFFF36", "% 2X"},
+ {__LINE__, -0x0bb1598, "-12260760", "%-ld"},
+ {__LINE__, 0x00006db5, "28085", "%0.5ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, -0x0000001, "-1", "%0ld"},
+ {__LINE__, 0x0fa37e79, "FA37E79", "%1.X"},
+ {__LINE__, -0x00000ac, "-172", "%.2d"},
+ {__LINE__, 0xffffffd8, "ffffffd8", "%.7x"},
+ {__LINE__, -0x000a513, "-42259", "%ld"},
+ {__LINE__, 0x00001294, "4756", "%2ld"},
+ {__LINE__, -0x56bae0b4, "-1455087796", "%.1ld"},
+ {__LINE__, 0x3b26d5fa, "3b26d5fa", "%x"},
+ {__LINE__, 0xff657013, "ff657013", "%x"},
+ {__LINE__, -0x00005f5, "-1525", "%0.0ld"},
+ {__LINE__, -0x0000001, " -1", "% 7d"},
+ {__LINE__, -0x02396b2, "-2332338", "%d"},
+ {__LINE__, -0x0000003, "-000003", "%+7.6d"},
+ {__LINE__, 0xfd3ec7c1, "fd3ec7c1", "% 3.4x"},
+ {__LINE__, -0x076e338, "-7791416", "%0.d"},
+ {__LINE__, -0x000015e, "-350", "%3ld"},
+ {__LINE__, 0x0a0f0b71, "a0f0b71", "%x"},
+ {__LINE__, 0xfffe00ba, "FFFE00BA", "%X"},
+ {__LINE__, 0x00036bd8, " 36bd8", "% 06.x"},
+ {__LINE__, 0xfffff2df, "0XFFFFF2DF", "%#2.6X"},
+ {__LINE__, 0x004687fb, "4622331", "%ld"},
+ {__LINE__, -0x0000331, " -817", "%+6.d"},
+ {__LINE__, 0xfcd5b090, "fcd5b090", "%+0x"},
+ {__LINE__, 0x0334f94c, "334F94C", "%.6X"},
+ {__LINE__, 0x00000bce, "3022", "%.3ld"},
+ {__LINE__, 0xf28d9ddd, "f28d9ddd", "%x"},
+ {__LINE__, 0x00003a79, " 14969", "% ld"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%.7X"},
+ {__LINE__, 0x0043d7fe, "43D7FE", "%X"},
+ {__LINE__, -0x0000b82, "-2946", "%-ld"},
+ {__LINE__, -0x00e29d8, "-928216", "%d"},
+ {__LINE__, 0xffffffec, "ffffffec", "%-x"},
+ {__LINE__, 0x0aeaf557, "0xaeaf557", "%-#x"},
+ {__LINE__, 0x00c07fe6, "C07FE6", "%X"},
+ {__LINE__, 0x307414d8, "307414d8", "% 0x"},
+ {__LINE__, -0x045ef67, "-4583271", "%d"},
+ {__LINE__, 0x0000024a, " 0000586", "% .7d"},
+ {__LINE__, 0xfffffc42, "fffffc42", "%x"},
+ {__LINE__, 0xfc38c249, "fc38c249", "%5.x"},
+ {__LINE__, -0x000d096, "-53398", "%-d"},
+ {__LINE__, -0x213a345, "-34841413", "%ld"},
+ {__LINE__, -0x0000130, "-304", "%ld"},
+ {__LINE__, -0x000efd1, "-61393", "%ld"},
+ {__LINE__, 0xfffff867, "FFFFF867", "%2X"},
+ {__LINE__, 0x00113ed0, "0x113ed0", "%-#7x"},
+ {__LINE__, 0x00000677, " 1655", "% 3.ld"},
+ {__LINE__, 0x0000002f, "2f", "%x"},
+ {__LINE__, 0xfffffd38, "fffffd38", "%-4x"},
+ {__LINE__, -0x000b3cc, "-46028", "%1.2d"},
+ {__LINE__, 0x45da719b, "45DA719B", "%+0X"},
+ {__LINE__, -0x000a454, " -42068", "%7.3ld"},
+ {__LINE__, 0x01cc7c30, " 30178352", "% d"},
+ {__LINE__, -0x05ae80e, "-5957646", "%#.4ld"},
+ {__LINE__, 0x000000b9, "185", "%d"},
+ {__LINE__, 0x003fcaf4, "4180724", "%1.ld"},
+ {__LINE__, 0x02da1b74, "2DA1B74", "%X"},
+ {__LINE__, 0xffffffd9, "FFFFFFD9", "%X"},
+ {__LINE__, 0x00064359, "64359 ", "%-6X"},
+ {__LINE__, 0x000000f0, "240", "%ld"},
+ {__LINE__, -0x01715e5, "-1512933", "%ld"},
+ {__LINE__, 0xc8f6e118, "0XC8F6E118", "%#X"},
+ {__LINE__, 0xfffffd8f, "FFFFFD8F", "%X"},
+ {__LINE__, 0x0000176d, "5997 ", "%-6d"},
+ {__LINE__, 0x00003cab, "0x3cab", "%#0.3x"},
+ {__LINE__, 0x00000001, " 1", "% d"},
+ {__LINE__, 0xfffff610, "0XFFFFF610", "%#X"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%5.7X"},
+ {__LINE__, 0x00000001, "1", "%0x"},
+ {__LINE__, 0x00000001, "00001", "%.5ld"},
+ {__LINE__, -0x0000d51, "-3409", "%d"},
+ {__LINE__, -0x08639ee, "-8796654", "%ld"},
+ {__LINE__, 0x00003121, "12577", "%#1.2ld"},
+ {__LINE__, 0x0000004e, "78", "%d"},
+ {__LINE__, 0xfffff64f, "fffff64f", "%-x"},
+ {__LINE__, 0x0000002a, "2a", "%0x"},
+ {__LINE__, 0x00000020, "20", "%x"},
+ {__LINE__, -0x00000b8, "-184", "%#ld"},
+ {__LINE__, 0x0000000a, "10", "%-#d"},
+ {__LINE__, 0x00000364, "868", "%.1ld"},
+ {__LINE__, 0x00d1f9b6, "D1F9B6", "%0.X"},
+ {__LINE__, 0x008cfda1, "8CFDA1", "% 6.X"},
+ {__LINE__, 0xffd58cce, "FFD58CCE", "%X"},
+ {__LINE__, 0x00000008, "0000008", "%6.7ld"},
+ {__LINE__, 0x00000318, " 318", "%4X"},
+ {__LINE__, 0x000172d8, "94936", "%2ld"},
+ {__LINE__, -0x056ccbf, "-5688511", "%ld"},
+ {__LINE__, 0x000000c7, "+000199", "%+0.6d"},
+ {__LINE__, 0x00000002, "0X2", "%-#X"},
+ {__LINE__, 0xfffff634, "FFFFF634", "%.1X"},
+ {__LINE__, -0x00001f3, "-499", "%-ld"},
+ {__LINE__, -0x000081b, "-2075", "%-d"},
+ {__LINE__, 0x000000b5, "181", "%0d"},
+ {__LINE__, 0xfe961ee8, "fe961ee8", "%0x"},
+ {__LINE__, 0x000028a2, "10402", "%d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%.4X"},
+ {__LINE__, -0x000058a, "-1418", "%.3ld"},
+ {__LINE__, 0x00001ceb, "1CEB", "%X"},
+ {__LINE__, 0x00000021, "21", "% X"},
+ {__LINE__, 0x00000002, "2", "%0d"},
+ {__LINE__, -0x2f9bbf5, "-49921013", "%.4ld"},
+ {__LINE__, 0x00000e91, "03729", "%#.5ld"},
+ {__LINE__, 0xf1116740, "f1116740", "%2x"},
+ {__LINE__, 0x00014f72, "14F72", "%X"},
+ {__LINE__, 0xfffffced, "FFFFFCED", "%X"},
+ {__LINE__, 0xffffffff, "ffffffff", "%.5x"},
+ {__LINE__, 0x0017cf0c, " 1560332", "% 0ld"},
+ {__LINE__, 0x0000000a, "A", "% X"},
+ {__LINE__, 0xff3a39d4, "ff3a39d4", "%x"},
+ {__LINE__, 0xfffef05f, "FFFEF05F", "%X"},
+ {__LINE__, 0xfedfe708, "fedfe708", "%03.0x"},
+ {__LINE__, 0x000345a0, "345A0", "% X"},
+ {__LINE__, -0x1ed5b6f7, "-517322487", "%d"},
+ {__LINE__, 0xd2d56c22, "D2D56C22", "%0.X"},
+ {__LINE__, 0x00002cbf, "2CBF", "%.2X"},
+ {__LINE__, 0x00000db4, "db4", "%3x"},
+ {__LINE__, -0x000b154, "-45396", "%d"},
+ {__LINE__, 0x002bf4c7, "2BF4C7", "%X"},
+ {__LINE__, 0x6954abf4, "+1767156724", "%+d"},
+ {__LINE__, 0xfffffffb, "fffffffb", "%x"},
+ {__LINE__, -0x29e0050e, "-702547214", "%-0ld"},
+ {__LINE__, -0x0014989, "-84361", "%-#0.3ld"},
+ {__LINE__, 0x001a557c, "+1725820", "%+6.5d"},
+ {__LINE__, -0x56689a81, "-1449695873", "%.2d"},
+ {__LINE__, 0x00000016, " 16", "%05.X"},
+ {__LINE__, 0x0001da1e, " 121374", "% d"},
+ {__LINE__, -0x04deac7, "-5106375", "%03.4d"},
+ {__LINE__, 0x000012b1, "4785", "%d"},
+ {__LINE__, 0x0009a116, "9a116", "%-x"},
+ {__LINE__, -0x0000003, "-000003", "%4.6ld"},
+ {__LINE__, 0x00000000, "", "%.0x"},
+ {__LINE__, 0x0000000a, " A", "% 3X"},
+ {__LINE__, 0xfffffff0, "0xfffffff0", "%-#0.1x"},
+ {__LINE__, 0x00000086, "86", "%0X"},
+ {__LINE__, 0x0000001f, "31", "%-d"},
+ {__LINE__, 0x0386f706, "59176710", "%3.6ld"},
+ {__LINE__, 0xffe437ae, "0XFFE437AE", "%#X"},
+ {__LINE__, 0x0e5405c6, "e5405c6", "%-x"},
+ {__LINE__, 0xfffdee46, "FFFDEE46", "%+X"},
+ {__LINE__, 0xff861e9d, "FF861E9D", "%5.X"},
+ {__LINE__, 0xfffff570, "FFFFF570", "%-X"},
+ {__LINE__, 0x045c90bd, "45c90bd", "%0x"},
+ {__LINE__, 0x000000aa, "AA", "%+X"},
+ {__LINE__, -0x747262e, "-122103342", "%0ld"},
+ {__LINE__, 0xffffad89, "FFFFAD89", "%X"},
+ {__LINE__, 0x00000018, "18", "%0.2X"},
+ {__LINE__, 0x00057a2d, " 358957", "% #7.d"},
+ {__LINE__, 0x73a0e21d, "1939923485", "%ld"},
+ {__LINE__, -0x00021e1, "-8673", "%0d"},
+ {__LINE__, 0x000000e9, " 233", "% 06.3ld"},
+ {__LINE__, 0xffffcc0d, "ffffcc0d", "%x"},
+ {__LINE__, 0x00000052, "52", "%x"},
+ {__LINE__, 0x01c155af, "1C155AF", "%.5X"},
+ {__LINE__, 0xffffffff, "ffffffff", "%0.x"},
+ {__LINE__, -0x00400a4, "-262308", "%-d"},
+ {__LINE__, -0x0000001, "-0000001", "%#.7ld"},
+ {__LINE__, 0x01fb9c99, "1fb9c99", "% 03.5x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%6.x"},
+ {__LINE__, 0xff5e5eea, "FF5E5EEA", "%X"},
+ {__LINE__, 0x0000000f, "F", "%+0X"},
+ {__LINE__, 0xfffffe3a, "fffffe3a", "% x"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%-X"},
+ {__LINE__, -0x0000007, "-7", "%0ld"},
+ {__LINE__, -0x002f635, "-194101", "%d"},
+ {__LINE__, -0x0000005, "-5", "%ld"},
+ {__LINE__, -0x0000059, "-89", "%0ld"},
+ {__LINE__, -0x1ccda96, "-30202518", "%d"},
+ {__LINE__, -0x0000002, "-2", "%-d"},
+ {__LINE__, 0xffffffda, "0XFFFFFFDA", "%#X"},
+ {__LINE__, 0x00036cc5, "224453", "%#d"},
+ {__LINE__, 0x00000010, "+16", "%+ld"},
+ {__LINE__, 0x0b6039c7, "190855623", "%d"},
+ {__LINE__, -0x0000002, "-002", "%#.3d"},
+ {__LINE__, 0xfff3e746, "FFF3E746", "%-4X"},
+ {__LINE__, 0x0361b3de, "361B3DE", "% 04X"},
+ {__LINE__, 0xffffe6a2, "ffffe6a2", "%-x"},
+ {__LINE__, 0x00032790, "0x0032790", "%#7.7x"},
+ {__LINE__, 0xffe33b4e, "ffe33b4e", "%-0x"},
+ {__LINE__, -0x0094663, "-607843", "%.3ld"},
+ {__LINE__, -0x00a3efa, "-671482", "%4d"},
+ {__LINE__, 0x000000e6, " 00E6", "%7.4X"},
+ {__LINE__, 0x000125cb, "125CB", "%+X"},
+ {__LINE__, 0x0000b97e, "b97e", "%x"},
+ {__LINE__, -0x0000039, "-57", "%+ld"},
+ {__LINE__, 0xffffe39a, "ffffe39a", "%5.4x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%6.1x"},
+ {__LINE__, -0xdee910c, "-233738508", "%-#2d"},
+ {__LINE__, -0x14044930, "-335825200", "%6.ld"},
+ {__LINE__, 0x00a81259, "a81259", "%x"},
+ {__LINE__, 0x020e74c6, "20E74C6", "%X"},
+ {__LINE__, -0x00000fb, "-251", "%01.d"},
+ {__LINE__, 0x034ceb45, "34CEB45", "%5.X"},
+ {__LINE__, 0xfeacb66a, "feacb66a", "% x"},
+ {__LINE__, 0x00003eb6, "3EB6", "% X"},
+ {__LINE__, 0x000009ef, "9ef", "% x"},
+ {__LINE__, 0xf9d9dd07, "F9D9DD07", "%0X"},
+#ifndef __PCCNECV70__
+
+ {__LINE__, 0x000154d7, "087255", "%.6ld"},
+ {__LINE__, -0x000036e, "-878", "%-ld"},
+ {__LINE__, -0x0007dcc, "-32204", "% d"},
+ {__LINE__, 0x000019dc, "6620", "%d"},
+ {__LINE__, 0xffffff6e, "FFFFFF6E", "%2X"},
+ {__LINE__, 0x00000016, "0x16", "%-#x"},
+ {__LINE__, 0xffdb3e96, "ffdb3e96", "%+.5x"},
+ {__LINE__, 0xffffffef, "FFFFFFEF", "% 04.X"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%5X"},
+ {__LINE__, 0x000c08cd, "C08CD", "%-X"},
+ {__LINE__, 0x18de71ee, "18de71ee", "%x"},
+ {__LINE__, 0xffffffff, "ffffffff", "% x"},
+ {__LINE__, -0x00025bd, "-009661", "%#.6d"},
+ {__LINE__, 0x2f05de14, " 788913684", "% 6.4ld"},
+ {__LINE__, 0x0c99cf86, "211406726", "%.5d"},
+ {__LINE__, 0x09e6a21d, " 166109725", "% 0d"},
+ {__LINE__, -0x013da65, "-1301093", "%+ld"},
+ {__LINE__, 0x000003d0, " 976", "% 4.2d"},
+ {__LINE__, -0xef9e3cc, "-251257804", "%-7.0d"},
+ {__LINE__, 0x0000000c, "+12", "%+00ld"},
+ {__LINE__, 0xffffffe2, "ffffffe2", "%x"},
+ {__LINE__, 0x000000fe, "fe", "%-x"},
+ {__LINE__, 0xfffffc5f, "fffffc5f", "%x"},
+ {__LINE__, -0x0005c55, "-23637", "%d"},
+ {__LINE__, -0x0111ff2, "-1122290", "% 7.d"},
+ {__LINE__, -0x1a1746e5, "-437733093", "%.4ld"},
+ {__LINE__, 0x00001007, "004103", "%00.6d"},
+ {__LINE__, 0xffffffe1, "ffffffe1", "%x"},
+ {__LINE__, 0x0000d80f, "55311", "%d"},
+ {__LINE__, 0x00000004, "4", "%+X"},
+ {__LINE__, 0xfffffffd, "fffffffd", "%6x"},
+ {__LINE__, -0x2afbcc3c, "-721144892", "%4.6ld"},
+ {__LINE__, 0x00377f96, "377F96", "%6.X"},
+ {__LINE__, 0xffffffc8, "FFFFFFC8", "%0X"},
+ {__LINE__, 0x007ed9d1, "8313297", "%-3d"},
+ {__LINE__, 0x00000000, "0", "%-X"},
+ {__LINE__, 0x001e122d, "1970733", "%01.d"},
+ {__LINE__, -0x000029b, "-667", "%ld"},
+ {__LINE__, -0x002f563, "-193891", "% 2.5d"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%+3.7x"},
+ {__LINE__, 0xfff7658c, "fff7658c", "%x"},
+ {__LINE__, -0x0006d08, "-0027912", "%7.7ld"},
+ {__LINE__, 0x00000080, "80", "%X"},
+ {__LINE__, 0x0000078f, " 1935", "% 6ld"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "% X"},
+ {__LINE__, 0x000000ae, " AE", "%7.X"},
+ {__LINE__, -0x000d6aa, "-54954", "%-ld"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%6.X"},
+ {__LINE__, 0x000003bf, "+959", "%+d"},
+ {__LINE__, -0x7242d04b, "-1916981323", "% ld"},
+ {__LINE__, 0xf0e6546f, "F0E6546F", "% .7X"},
+ {__LINE__, 0x047e196a, "75372906", "%ld"},
+ {__LINE__, 0x0240174e, "240174E", "%+0X"},
+ {__LINE__, -0x0000006, "-006", "%.3ld"},
+ {__LINE__, 0x00068aac, "428716", "%#ld"},
+ {__LINE__, 0xffffffa1, "ffffffa1", "%0x"},
+ {__LINE__, 0x000adab3, "adab3", "%x"},
+ {__LINE__, -0x00000ae, "-0000174", "%7.7ld"},
+ {__LINE__, 0x0f0a8f4b, "f0a8f4b", "% x"},
+ {__LINE__, 0xfee229bc, "fee229bc", "%x"},
+ {__LINE__, -0x275b8455, "-660309077", "%.2ld"},
+ {__LINE__, -0xca4b2a5, "-212120229", "%d"},
+ {__LINE__, 0x000000b5, " 181", "%04.d"},
+ {__LINE__, 0xfff213f2, "FFF213F2", "%X"},
+ {__LINE__, 0x00000003, "3", "%-X"},
+ {__LINE__, 0x0ebb978b, "247175051", "%.6ld"},
+ {__LINE__, 0xffffffca, "FFFFFFCA", "%X"},
+ {__LINE__, -0x0000003, "-03", "%+0.2d"},
+ {__LINE__, -0x178ff86, "-24706950", "%+d"},
+ {__LINE__, 0x0000003c, " 60", "%7.ld"},
+ {__LINE__, -0x001012d, "-65837", "%.5d"},
+ {__LINE__, 0x03673fd2, "3673fd2", "%.5x"},
+ {__LINE__, -0x001fe74, "-130676", "%#0.6ld"},
+ {__LINE__, 0x004f6226, "4f6226", "%-0x"},
+ {__LINE__, 0xfffffa0f, "fffffa0f", "%7x"},
+ {__LINE__, 0xfffffff8, "fffffff8", "%-.6x"},
+ {__LINE__, -0x0000001, "-1", "%#d"},
+ {__LINE__, 0xffffe43d, "ffffe43d", "%7x"},
+ {__LINE__, 0x00009d47, "0040263", "%7.7ld"},
+ {__LINE__, 0xff0fc79f, "FF0FC79F", "%-4.X"},
+ {__LINE__, 0x2d610907, "2d610907", "%x"},
+ {__LINE__, -0x00002de, "-734", "%04d"},
+ {__LINE__, 0x0000036b, " 36B", "%7.1X"},
+ {__LINE__, 0x00000002, "2", "%.0x"},
+ {__LINE__, -0x1f577b3e, "-525826878", "%d"},
+ {__LINE__, 0x0000002d, "45", "%#ld"},
+ {__LINE__, 0xfffffffb, "fffffffb", "%x"},
+ {__LINE__, -0x0000004, "-4", "%-.0d"},
+ {__LINE__, 0x00016ba4, "16ba4", "%x"},
+ {__LINE__, -0x1ad853d5, "-450384853", "% 0ld"},
+ {__LINE__, 0x00366899, "366899", "%2.x"},
+ {__LINE__, 0x1659158b, "1659158B", "%X"},
+ {__LINE__, 0x000076c7, "76c7", "%x"},
+ {__LINE__, 0x00000674, "674", "%0x"},
+ {__LINE__, 0x016c9d8a, "+23895434", "%+ld"},
+ {__LINE__, 0xfffffc43, "FFFFFC43", "%0X"},
+ {__LINE__, 0xfff249d2, "fff249d2", "%-2.x"},
+ {__LINE__, 0xffffffdd, "ffffffdd", "%5x"},
+ {__LINE__, 0xffffa7ef, "FFFFA7EF", "%0.3X"},
+ {__LINE__, 0x030d4d06, "30d4d06", "%x"},
+ {__LINE__, -0x0e4694b, "-14969163", "%d"},
+ {__LINE__, 0x00000078, "120", "%.3ld"},
+ {__LINE__, -0x16c1273e, "-381757246", "%0d"},
+ {__LINE__, 0xffffd183, "FFFFD183", "% 0X"},
+ {__LINE__, -0x2dfdadd, "-48224989", "%ld"},
+ {__LINE__, -0x5767fe5c, "-1466433116", "%ld"},
+ {__LINE__, 0x01bea036, "29270070", "%#4.3d"},
+ {__LINE__, 0x00000027, "27", "%-x"},
+ {__LINE__, 0x0004d183, "4D183", "%X"},
+ {__LINE__, 0xffdaf9c8, "FFDAF9C8", "%.7X"},
+ {__LINE__, 0xfffffd95, "fffffd95", "%x"},
+ {__LINE__, -0x0059acb, "-367307", "%00.d"},
+ {__LINE__, 0x017d8db4, "17d8db4", "% 05.x"},
+ {__LINE__, 0x0001f084, "001F084", "%5.7X"},
+ {__LINE__, 0x00000006, " 6", "% ld"},
+ {__LINE__, 0x011b0802, "18548738", "%.3ld"},
+ {__LINE__, 0x00000006, " 6", "%#3.d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%6x"},
+ {__LINE__, 0x00000001, "1", "% x"},
+ {__LINE__, 0x00000750, " 01872", "% .5d"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%x"},
+ {__LINE__, -0x00f842c, "-1016876", "%+d"},
+ {__LINE__, -0x001dcf0, "-122096", "%-0d"},
+ {__LINE__, 0x000000c9, "0XC9", "% #3X"},
+ {__LINE__, 0x1e368e86, "1e368e86", "%7x"},
+ {__LINE__, -0x0001157, "-4439", "% 03.4d"},
+ {__LINE__, 0xfff91e87, "FFF91E87", "%3.5X"},
+ {__LINE__, 0x00000006, "6", "%x"},
+ {__LINE__, 0x00000bca, "3018", "%ld"},
+ {__LINE__, 0x00495ff6, "495ff6", "%01.0x"},
+ {__LINE__, -0x0267f7a, "-2523002", "% #5d"},
+ {__LINE__, 0x00000060, "96", "%-d"},
+ {__LINE__, 0x000850c6, "544966", "%#.1d"},
+ {__LINE__, 0x00231457, "231457", "%-6.4X"},
+ {__LINE__, 0x0000000b, "11", "%-d"},
+ {__LINE__, 0x000003bd, "957", "%#d"},
+ {__LINE__, 0xfd51d970, "FD51D970", "%+.7X"},
+ {__LINE__, 0x000007bf, "1983", "%-ld"},
+ {__LINE__, 0x000034b2, "34B2", "%0.X"},
+ {__LINE__, 0x0000c18d, "C18D", "%0.X"},
+ {__LINE__, 0xffffbb83, "ffffbb83", "% 3x"},
+ {__LINE__, 0x000001d0, "0x1d0", "%#x"},
+ {__LINE__, -0x003c784, "-247684", "%#ld"},
+ {__LINE__, 0x0210cffa, "210CFFA", "%X"},
+ {__LINE__, -0x33093a1, "-53515169", "% 0d"},
+ {__LINE__, 0x00000001, " 1", "% #ld"},
+ {__LINE__, 0xffffaa53, "ffffaa53", "%-4.5x"},
+ {__LINE__, 0x2935c056, "691388502", "%1.d"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, 0x000013d1, "0X013D1", "%+#2.5X"},
+ {__LINE__, -0x000035c, "-860", "%-.2d"},
+ {__LINE__, 0x00000000, " ", "%-4.X"},
+ {__LINE__, -0x0000147, "-327", "%d"},
+ {__LINE__, 0x0a317eb0, "171015856", "%.7d"},
+ {__LINE__, 0x00000003, "3", "%ld"},
+ {__LINE__, 0x000001d6, "1d6", "%-x"},
+ {__LINE__, 0x18185214, "404247060", "%-.2ld"},
+ {__LINE__, 0x00574140, "0574140", "%.7X"},
+ {__LINE__, 0x00002ea5, "02ea5", "%.5x"},
+ {__LINE__, 0x00000005, "5", "% x"},
+ {__LINE__, 0xffc47ed6, "ffc47ed6", "%-x"},
+ {__LINE__, 0x0001f5da, "0X1F5DA", "%#X"},
+ {__LINE__, 0xfffffcc9, "fffffcc9", "% x"},
+ {__LINE__, 0x02586c98, "2586C98", "%X"},
+ {__LINE__, -0x0000036, "-54", "% ld"},
+ {__LINE__, 0x00064b57, "412503", "%1.5d"},
+ {__LINE__, -0x0000007, "-7", "%#0.0ld"},
+ {__LINE__, 0x00023a03, "145923", "%ld"},
+ {__LINE__, -0x0000065, "-101", "%+#d"},
+ {__LINE__, 0x00000208, "208", "%X"},
+ {__LINE__, 0x00e97728, "15300392", "%-ld"},
+ {__LINE__, 0x0000030a, "+778", "%+d"},
+ {__LINE__, 0xf4d7deee, "F4D7DEEE", "%+X"},
+ {__LINE__, -0x000009a, "-154", "%+.3ld"},
+ {__LINE__, 0x000002c0, "+704", "%+ld"},
+ {__LINE__, 0x0067ec23, "67ec23", "%x"},
+ {__LINE__, 0x005ca7fc, "+6072316", "%+d"},
+ {__LINE__, 0xfffff5f1, "fffff5f1", "%x"},
+ {__LINE__, 0x00000601, " 0X601", "%#7.2X"},
+ {__LINE__, -0x0000057, "-87", "% ld"},
+ {__LINE__, -0x0000078, " -120", "%7.d"},
+ {__LINE__, -0x000001f, "-31 ", "%-6d"},
+ {__LINE__, 0x0160c000, "23117824", "%ld"},
+ {__LINE__, -0x0000007, "-7", "%0ld"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%+x"},
+ {__LINE__, 0x5b6ef898, "5b6ef898", "%+0x"},
+ {__LINE__, 0x0009bfb6, "638902", "%d"},
+ {__LINE__, -0x0000145, " -325", "%#6.0d"},
+ {__LINE__, -0x508c048, "-84459592", "%-5.ld"},
+ {__LINE__, 0x00000002, " 0x2", "% #4x"},
+ {__LINE__, 0x0001486e, "84078", "%#d"},
+ {__LINE__, 0x006ac76a, "6997866", "%.6d"},
+ {__LINE__, 0xffffff98, "FFFFFF98", "%X"},
+ {__LINE__, 0xfffffe08, "fffffe08", "%6.x"},
+ {__LINE__, -0x24ef47e, "-38728830", "%1.6ld"},
+ {__LINE__, 0x39d1b2db, "39D1B2DB", "% X"},
+ {__LINE__, 0xfffc9ce2, "0xfffc9ce2", "%#x"},
+ {__LINE__, 0x59485e14, "1497914900", "%#4ld"},
+ {__LINE__, 0x000022eb, "22EB", "%3.X"},
+ {__LINE__, 0xfa410352, "FA410352", "%-X"},
+ {__LINE__, -0x4a342f0, "-77808368", "% ld"},
+ {__LINE__, 0xef5825a4, "EF5825A4", "%.6X"},
+ {__LINE__, 0x01b0185a, "0x1b0185a", "% #x"},
+ {__LINE__, -0x0004290, "-17040", "%.3d"},
+ {__LINE__, -0x10f88659, "-284722777", "%+6.2ld"},
+ {__LINE__, 0x00003216, "12822", "%-d"},
+ {__LINE__, 0x4a31a219, "1244766745", "%d"},
+ {__LINE__, 0xffffffb5, "FFFFFFB5", "%-X"},
+ {__LINE__, 0x0000d586, "D586", "%-2.X"},
+ {__LINE__, 0x00008496, "33942", "%1.d"},
+ {__LINE__, -0x0000011, "-17", "%1ld"},
+ {__LINE__, 0x0000003c, "3C", "%2.X"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%.3X"},
+ {__LINE__, 0x0000152a, "152A", "%X"},
+ {__LINE__, 0xfffe876e, "FFFE876E", "%X"},
+ {__LINE__, -0x0003874, "-14452", "%-ld"},
+ {__LINE__, -0x004918a, "-299402", "%#.6d"},
+ {__LINE__, -0x000000c, "-12", "%-d"},
+ {__LINE__, 0xffffd812, "FFFFD812", "%+X"},
+ {__LINE__, -0x000000c, "-12", "%0d"},
+ {__LINE__, -0x0000229, "-553", "%0d"},
+ {__LINE__, 0x00002ab8, "2AB8", "%4.X"},
+ {__LINE__, 0x0000004b, "+75", "%+ld"},
+ {__LINE__, 0x001c3178, " 1847672", "% ld"},
+ {__LINE__, -0x0000006, "-6", "%.0ld"},
+ {__LINE__, 0x0003be65, "245349", "%ld"},
+ {__LINE__, -0x0000001, "-1", "%#1ld"},
+ {__LINE__, 0x0000007f, "+127", "%+ld"},
+ {__LINE__, 0x0000020e, "526 ", "%-5ld"},
+ {__LINE__, 0x00000002, "2", "%d"},
+ {__LINE__, 0x03bd0873, "0X3BD0873", "%#X"},
+ {__LINE__, 0x00093a52, "604754", "%-2d"},
+ {__LINE__, -0x00823fc, "-0533500", "%+.7ld"},
+ {__LINE__, 0x00000000, " ", "%4.X"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, 0xfff09ede, "fff09ede", "%-x"},
+ {__LINE__, 0x01e28c24, "31624228", "%ld"},
+ {__LINE__, 0x00001dcc, "1DCC", "%X"},
+ {__LINE__, -0x0f0ea0d, "-15788557", "%-00.ld"},
+ {__LINE__, 0xffff73a1, "FFFF73A1", "%X"},
+ {__LINE__, -0x0004040, "-16448", "%+#d"},
+ {__LINE__, 0x0073b158, "0x73b158", "%#7x"},
+ {__LINE__, 0xfffff8ff, "FFFFF8FF", "% 5X"},
+ {__LINE__, -0x0000004, "-4", "%0d"},
+ {__LINE__, 0xffff56a3, "ffff56a3", "%1.6x"},
+ {__LINE__, -0x0000041, "-65", "%0d"},
+ {__LINE__, 0x00000009, "+0000009", "%+2.7d"},
+ {__LINE__, 0xffffe13d, "0XFFFFE13D", "%+#2.X"},
+ {__LINE__, -0x00002ce, "-00718", "%.5ld"},
+ {__LINE__, 0xffc53e28, "ffc53e28", "%03.4x"},
+ {__LINE__, 0x00000005, "0X5", "%#X"},
+ {__LINE__, 0x00000004, "4", "%x"},
+ {__LINE__, 0xe21b35eb, "e21b35eb", "%-x"},
+ {__LINE__, -0x0000098, "-152", "%-ld"},
+ {__LINE__, 0xffffff81, "FFFFFF81", "%2X"},
+ {__LINE__, 0x00000003, "00003", "%.5ld"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%+x"},
+ {__LINE__, 0x000491f5, "299509", "%1.ld"},
+ {__LINE__, 0xf06bfd7d, "F06BFD7D", "%X"},
+ {__LINE__, -0x0000006, "-6", "%0d"},
+ {__LINE__, -0x0a4af7d, "-10792829", "%-0d"},
+ {__LINE__, -0x11a74ef, "-18511087", "%ld"},
+ {__LINE__, 0x2dc95e17, "768171543", "%-1.d"},
+ {__LINE__, -0x0000001, "-1", "%#ld"},
+ {__LINE__, 0x00000033, "51", "%-#d"},
+ {__LINE__, 0x002d0219, "2949657", "%ld"},
+ {__LINE__, 0xfffffffd, "FFFFFFFD", "%2.4X"},
+ {__LINE__, 0x00000f20, "+3872", "%+ld"},
+ {__LINE__, -0x0000047, "-071", "%4.3ld"},
+ {__LINE__, 0x00000010, " 16", "%6d"},
+ {__LINE__, 0x00000000, "0", "%0d"},
+ {__LINE__, 0xffffff57, "FFFFFF57", "%X"},
+ {__LINE__, -0x0000700, "-1792", "%-#d"},
+ {__LINE__, -0x0000064, "-100", "%-ld"},
+ {__LINE__, 0xff26d49a, "FF26D49A", "%-0X"},
+ {__LINE__, -0x0000006, "-6", "%.1ld"},
+ {__LINE__, 0x1391edc5, "1391edc5", "%.1x"},
+ {__LINE__, 0x0000014a, "330", "%-#ld"},
+ {__LINE__, 0x07ecd1e1, "7ecd1e1", "%6x"},
+ {__LINE__, -0xa2b8898, "-170625176", "%3.d"},
+ {__LINE__, 0x00035287, "0x35287", "%#.0x"},
+ {__LINE__, 0x00000000, "00000", "%0.5X"},
+ {__LINE__, -0x0000153, "-339", "%d"},
+ {__LINE__, 0x0000ad6e, " 44398", "% 0.d"},
+ {__LINE__, 0x00000001, "1", "%-X"},
+ {__LINE__, -0x000000d, "-13 ", "%-6.2d"},
+ {__LINE__, -0x01bff8a, "-1834890", "%d"},
+ {__LINE__, 0x000a0fa8, "+659368", "%+ld"},
+ {__LINE__, 0xac044dc0, "ac044dc0", "%.0x"},
+ {__LINE__, 0x0003a729, "239401", "%ld"},
+ {__LINE__, -0x00004f0, "-1264", "%+ld"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0x00000012, "12", "% x"},
+ {__LINE__, 0xffff770b, "ffff770b", "%7.1x"},
+ {__LINE__, 0xd7458572, "d7458572", "%x"},
+ {__LINE__, 0x01f1b4f9, "1f1b4f9", "% 0x"},
+ {__LINE__, 0xfffb2198, "0XFFFB2198", "% #1.X"},
+ {__LINE__, 0x00ef6189, " 15688073", "% ld"},
+ {__LINE__, -0x3f0ae63, "-66104931", "% #d"},
+ {__LINE__, -0x0006075, "-24693", "%ld"},
+ {__LINE__, 0x000000a1, "161", "%d"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%3.2x"},
+ {__LINE__, 0xff6b4125, "FF6B4125", "%+5.X"},
+ {__LINE__, 0x00000001, " 1", "%6.d"},
+ {__LINE__, -0x0000001, "-1", "%+0d"},
+ {__LINE__, -0x000096c, "-2412", "%0.4d"},
+ {__LINE__, 0x00039c6f, "236655", "%.0d"},
+ {__LINE__, 0x3625286c, "908404844", "%.1d"},
+ {__LINE__, 0xfffffffa, "fffffffa", "%x"},
+ {__LINE__, 0x00000000, "0", "%X"},
+ {__LINE__, 0x00c34353, "12796755", "%#.4d"},
+ {__LINE__, 0x000002df, "735", "%ld"},
+ {__LINE__, 0xffff38fa, "FFFF38FA", "%5.1X"},
+ {__LINE__, -0x000002a, "-42", "%0.d"},
+ {__LINE__, 0x0000077e, "1918", "%ld"},
+ {__LINE__, 0x000001f7, "503", "%ld"},
+ {__LINE__, 0x00000004, "4", "%ld"},
+ {__LINE__, 0x0021fb02, "2226946", "%d"},
+ {__LINE__, 0x007c858d, "8160653", "%-0d"},
+ {__LINE__, -0x0000109, "-265", "%.0d"},
+ {__LINE__, 0xfffffffa, "fffffffa", "% x"},
+ {__LINE__, 0x0097932d, "97932d", "%+x"},
+ {__LINE__, 0xfffbbd03, "fffbbd03", "%-.5x"},
+ {__LINE__, -0x0000005, "-5", "%0d"},
+ {__LINE__, 0x03ee3a95, "65944213", "%ld"},
+ {__LINE__, -0x0000002, " -00002", "%7.5d"},
+ {__LINE__, 0xea1a4e54, "EA1A4E54", "%X"},
+ {__LINE__, -0x000a9d6, "-43478", "%+d"},
+ {__LINE__, -0x0fd8d65, "-16616805", "%5ld"},
+ {__LINE__, 0x00000001, "1", "%-d"},
+ {__LINE__, 0x00000072, "72", "%2.X"},
+ {__LINE__, 0xffffff94, "FFFFFF94", "%X"},
+ {__LINE__, 0x00000d2a, "D2A", "%+X"},
+ {__LINE__, 0xffff614f, "ffff614f", "%x"},
+ {__LINE__, -0x0000018, "-24", "%ld"},
+ {__LINE__, 0x0000003b, "059", "%2.3d"},
+ {__LINE__, 0x0000001a, "1A", "%0X"},
+ {__LINE__, -0x0000109, "-265", "%02ld"},
+ {__LINE__, 0x00000f9d, "3997", "%#1d"},
+ {__LINE__, 0x0000001b, "1b", "%x"},
+ {__LINE__, 0xffffff07, "ffffff07", "%x"},
+ {__LINE__, 0xfff1a425, "0xfff1a425", "%#x"},
+ {__LINE__, 0x00000005, "5", "%-1d"},
+ {__LINE__, -0x53a6efd, "-87715581", "%ld"},
+ {__LINE__, 0x042f37db, "42F37DB", "%6.X"},
+ {__LINE__, 0x00053bd5, "+342997", "%+5ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "% x"},
+ {__LINE__, 0xffffffef, "FFFFFFEF", "%6.X"},
+ {__LINE__, -0x10ec29a, "-17744538", "%+2.d"},
+ {__LINE__, 0x01dcc901, "1dcc901", "%x"},
+ {__LINE__, 0x0007dc68, "515176", "%-3.d"},
+ {__LINE__, -0x0000062, "-0098", "%#2.4d"},
+ {__LINE__, 0x00000000, " ", "%3.0X"},
+ {__LINE__, -0x00000de, "-222", "%ld"},
+ {__LINE__, 0x000c1fb8, "C1FB8", "%0X"},
+ {__LINE__, 0x0005bf58, "5BF58", "%X"},
+ {__LINE__, -0x000dd1b, "-56603", "%-03.1d"},
+ {__LINE__, 0x00000b14, "B14", "%+3.X"},
+ {__LINE__, 0x00000799, "799", "%-x"},
+ {__LINE__, 0xfffffffa, "fffffffa", "%x"},
+ {__LINE__, 0x00000003, "0x00003", "% #7.5x"},
+ {__LINE__, -0x002b9f1, "-178673", "%+d"},
+ {__LINE__, -0x001b817, "-112663", "%0d"},
+ {__LINE__, 0xf6f98533, "f6f98533", "%.1x"},
+ {__LINE__, 0x00338ffc, "3379196", "%d"},
+ {__LINE__, 0x0409e9b5, "0X409E9B5", "%#X"},
+ {__LINE__, 0x00b8e98e, " 12118414", "% 0d"},
+ {__LINE__, -0x002a8f6, "-174326", "%ld"},
+ {__LINE__, 0x13bb9722, "331061026", "%0d"},
+ {__LINE__, 0x00063c71, "63c71", "%x"},
+ {__LINE__, 0xfffffe37, "FFFFFE37", "%.1X"},
+ {__LINE__, 0xffff7b3e, "ffff7b3e", "%+.1x"},
+ {__LINE__, 0x005eeab1, "5eeab1", "%+x"},
+ {__LINE__, 0xffc69e99, "ffc69e99", "%x"},
+ {__LINE__, -0x000005c, " -92", "%5ld"},
+ {__LINE__, 0x07d8fa8a, "7d8fa8a", "%x"},
+ {__LINE__, 0x00030e0a, "200202", "%-4.1d"},
+ {__LINE__, 0x00001dc1, "1DC1", "%.0X"},
+ {__LINE__, 0x00000008, "8", "%0ld"},
+ {__LINE__, -0x01b5397, "-1790871", "%3.d"},
+ {__LINE__, 0x27fbb4b5, "27fbb4b5", "%x"},
+ {__LINE__, -0xe3fdcfc, "-239066364", "%4ld"},
+ {__LINE__, 0x0008bcb1, "8bcb1", "%0x"},
+ {__LINE__, 0xffff039e, "ffff039e", "%.6x"},
+ {__LINE__, 0x000d0bd4, "d0bd4", "%-x"},
+ {__LINE__, 0x00000000, "+0", "%+d"},
+ {__LINE__, -0x2a49ea4, "-44342948", "%1d"},
+ {__LINE__, -0x0000055, "-85", "%0d"},
+ {__LINE__, -0x0000a05, "-2565", "%3.3ld"},
+ {__LINE__, -0x000000b, "-11 ", "%-4d"},
+ {__LINE__, 0xfff30444, "FFF30444", "%7.X"},
+ {__LINE__, 0x0000003f, "63", "%-0d"},
+ {__LINE__, 0x00046779, "46779", "%X"},
+ {__LINE__, 0x000028d7, " 0X28D7", "%#7.X"},
+ {__LINE__, 0x00000019, " 19", "%5x"},
+ {__LINE__, 0x0032291d, "3287325", "%2.ld"},
+ {__LINE__, 0x00057afa, "57AFA", "%X"},
+ {__LINE__, 0xfffe8c64, "fffe8c64", "%3.4x"},
+ {__LINE__, -0x624110d6, "-1648431318", "%+6d"},
+ {__LINE__, 0x0000001a, " 26", "% 5.d"},
+ {__LINE__, 0xfffffffd, "FFFFFFFD", "%6.X"},
+ {__LINE__, 0x00199490, "1676432", "%-1d"},
+ {__LINE__, -0xfff8265, "-268403301", "%-0ld"},
+ {__LINE__, 0x0000000e, "e", "%-x"},
+ {__LINE__, 0x00c38aec, "c38aec", "%x"},
+ {__LINE__, -0x00658f4, "-415988", "%#ld"},
+ {__LINE__, 0x0066ac4e, "6728782", "%0d"},
+ {__LINE__, 0xc4a808d5, "c4a808d5", "%x"},
+ {__LINE__, 0x00000000, " 0", "%6.1x"},
+ {__LINE__, 0x00066d24, "66d24", "%x"},
+ {__LINE__, 0x00002117, "2117", "%X"},
+ {__LINE__, 0xfe06fdf4, "FE06FDF4", "%0X"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%x"},
+ {__LINE__, 0x1c6bb795, "+476821397", "%+d"},
+ {__LINE__, 0xfffffba4, "FFFFFBA4", "%X"},
+ {__LINE__, 0xfffd7d44, "fffd7d44", "%0x"},
+ {__LINE__, 0x0019dd17, "1694999", "%d"},
+ {__LINE__, 0x6475851e, "0x6475851e", "% #7.x"},
+ {__LINE__, -0x00330d5, "-209109", "%0ld"},
+ {__LINE__, 0x009f53f7, "09F53F7", "%+6.7X"},
+ {__LINE__, -0x00172f9, " -94969", "%7.5ld"},
+ {__LINE__, 0xffffffdc, "FFFFFFDC", "%X"},
+ {__LINE__, -0x013bdec, "-1293804", "%+#2ld"},
+ {__LINE__, 0xfff845c0, "fff845c0", "%+7.x"},
+ {__LINE__, -0x0fbe712, "-16508690", "%.7d"},
+ {__LINE__, 0xffffe13f, "ffffe13f", "%x"},
+ {__LINE__, 0xbbc19951, "BBC19951", "%-4X"},
+ {__LINE__, -0x28d6d1b, "-42822939", "%#d"},
+ {__LINE__, -0x93cda6b, "-154983019", "%-d"},
+ {__LINE__, 0xffc93342, "FFC93342", "%7.X"},
+ {__LINE__, 0x072ac8b3, " 120244403", "% ld"},
+ {__LINE__, 0xfff8d17b, "FFF8D17B", "% X"},
+ {__LINE__, 0x00000da5, "DA5", "%0.X"},
+ {__LINE__, 0x055ad3ac, "0x55ad3ac", "%#1x"},
+ {__LINE__, 0x00000e5a, " 3674", "% .4ld"},
+ {__LINE__, 0xffffff79, "FFFFFF79", "%+X"},
+ {__LINE__, 0xffffe167, "ffffe167", "%+5x"},
+ {__LINE__, 0x0000fa50, "0064080", "%.7ld"},
+ {__LINE__, 0x00000001, "1", "%-d"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%x"},
+ {__LINE__, 0x000009ac, " 2476", "% #2.ld"},
+ {__LINE__, 0x00000e78, "0003704", "%.7ld"},
+ {__LINE__, -0x000dfc3, "-57283", "%6.d"},
+ {__LINE__, 0x00000ee0, "EE0", "%0X"},
+ {__LINE__, -0x293703b3, "-691471283", "%ld"},
+ {__LINE__, 0x000073e8, " 73e8", "%6x"},
+ {__LINE__, 0xffffdffd, "ffffdffd", "%5.5x"},
+ {__LINE__, 0x00000004, "4", "%+00.x"},
+ {__LINE__, 0x00000008, "0X8", "%#X"},
+ {__LINE__, 0x0003044c, "3044c", "%0x"},
+ {__LINE__, 0xffc2095e, "FFC2095E", "%0X"},
+ {__LINE__, 0x00000aac, "0002732", "%-.7ld"},
+ {__LINE__, 0xffffff79, "FFFFFF79", "%+1.X"},
+ {__LINE__, 0x53a0f94a, " 1403058506", "% 2.4ld"},
+ {__LINE__, 0x000e928d, "e928d", "%x"},
+ {__LINE__, 0x0024127a, "2364026", "%5.d"},
+ {__LINE__, 0x000f7c1c, " 1014812", "% 2.d"},
+ {__LINE__, -0x000003d, "-61 ", "%-#4ld"},
+ {__LINE__, -0x0000122, "-290", "%+ld"},
+ {__LINE__, 0x00000006, "+6", "%+0d"},
+ {__LINE__, 0x00000129, " 000129", "%7.6X"},
+ {__LINE__, 0x15d873e5, " 366506981", "% 5.7d"},
+ {__LINE__, 0x00000001, "1", "%d"},
+ {__LINE__, 0x038d6110, "+59597072", "%+d"},
+ {__LINE__, 0x0f46ccc3, "256298179", "%-1.4d"},
+ {__LINE__, 0xfe434d21, "fe434d21", "%x"},
+ {__LINE__, -0x179797d7, "-395810775", "%d"},
+ {__LINE__, 0xe35807bf, "e35807bf", "%x"},
+ {__LINE__, 0x00000003, " +3", "%+7d"},
+ {__LINE__, 0x017e699e, "25061790", "%#ld"},
+ {__LINE__, -0x0000029, "-41", "%d"},
+ {__LINE__, 0xffffff11, "ffffff11", "%1.x"},
+ {__LINE__, -0x0001bf6, "-7158", "%+0ld"},
+ {__LINE__, 0xffffff4b, "FFFFFF4B", "%4X"},
+ {__LINE__, -0x0000040, "-64", "%ld"},
+ {__LINE__, 0x000034d6, "+13526", "%+ld"},
+ {__LINE__, 0xffffffa7, "ffffffa7", "%x"},
+ {__LINE__, 0xfffffe8e, "fffffe8e", "%+.3x"},
+ {__LINE__, 0x00000000, "0", "%0.1d"},
+ {__LINE__, -0x007cdf1, "-511473", "%ld"},
+ {__LINE__, 0xfffffeef, "FFFFFEEF", "%-X"},
+ {__LINE__, 0x00002d91, "2d91", "%x"},
+ {__LINE__, -0x000025b, "-603", "%#ld"},
+ {__LINE__, -0x000001b, "-27", "%-ld"},
+ {__LINE__, 0x042b6752, "42B6752", "%+X"},
+ {__LINE__, -0x75afb0a6, "-1974448294", "% ld"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, 0x00000542, " 1346", "%6d"},
+ {__LINE__, -0x0000010, "-16", "%+0d"},
+ {__LINE__, 0xfffed8f7, "FFFED8F7", "%5.X"},
+ {__LINE__, 0x0541852e, "541852e", "% 2.x"},
+ {__LINE__, 0xff22aec3, "ff22aec3", "% .1x"},
+ {__LINE__, 0x5e34b745, "1580513093", "%ld"},
+ {__LINE__, 0xfffffff3, "fffffff3", "%x"},
+ {__LINE__, 0x0eda7b86, "+249199494", "%+.3d"},
+ {__LINE__, 0xffffe40f, "ffffe40f", "%+x"},
+ {__LINE__, -0x0003484, "-13444", "%-1.5ld"},
+ {__LINE__, 0x0000334b, " 13131", "%6.ld"},
+ {__LINE__, -0x0000149, "-329", "%ld"},
+ {__LINE__, 0x00000001, " 001", "% 5.3x"},
+ {__LINE__, 0xffeaa035, "ffeaa035", "%+3.5x"},
+ {__LINE__, 0x00211dff, "2170367", "%ld"},
+ {__LINE__, 0x007e91f4, "7e91f4", "%x"},
+ {__LINE__, 0xfffffffc, "0xfffffffc", "%+#5x"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%6.X"},
+ {__LINE__, 0x0156a9b5, "156a9b5", "%x"},
+ {__LINE__, 0xfffffe58, "fffffe58", "%+x"},
+ {__LINE__, 0xffff8c66, "FFFF8C66", "%.0X"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, 0x00000005, " 5", "%7.d"},
+ {__LINE__, -0x0000002, "-2", "%ld"},
+ {__LINE__, 0x000076b9, " 30393", "% ld"},
+ {__LINE__, 0x00003824, "3824", "%4X"},
+ {__LINE__, 0x00000cdf, " CDF", "% 7X"},
+ {__LINE__, 0x017c9e8f, "17C9E8F", "%-X"},
+ {__LINE__, -0x20f582d, "-34560045", "%-.5d"},
+ {__LINE__, 0x0000732e, " 29486", "% 7.ld"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%+0X"},
+ {__LINE__, 0xf379a4a2, "F379A4A2", "% .7X"},
+ {__LINE__, -0x0000028, "-40", "%-d"},
+ {__LINE__, 0xe73cf79e, "e73cf79e", "%x"},
+ {__LINE__, 0x00000002, " 2", "%7ld"},
+ {__LINE__, -0x00029b1, "-10673", "%-#1.ld"},
+ {__LINE__, -0x0002a58, "-10840", "%3.d"},
+ {__LINE__, 0x00000002, "2", "%-X"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%X"},
+ {__LINE__, -0x000003a, " -58", "%5ld"},
+ {__LINE__, 0x0245ef3b, "245ef3b", "%.3x"},
+ {__LINE__, 0x00026cca, "158922", "%-06.3ld"},
+ {__LINE__, 0x01016fd3, "16871379", "%-d"},
+ {__LINE__, 0x000016fc, "5884", "%0ld"},
+ {__LINE__, -0x00007fb, " -2043", "%7.3d"},
+ {__LINE__, 0xfff73d3c, "fff73d3c", "%0x"},
+ {__LINE__, -0x0000110, "-272", "% 04.3d"},
+ {__LINE__, 0x0000000e, " 014", "% 04ld"},
+ {__LINE__, -0x0000039, "-57", "%.0ld"},
+ {__LINE__, 0x00000c95, "c95", "%0x"},
+ {__LINE__, 0xffff3b2e, "ffff3b2e", "%x"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%X"},
+ {__LINE__, 0x00000015, "21", "%.1d"},
+ {__LINE__, 0x0000000c, "+12", "%+ld"},
+ {__LINE__, 0x00000000, "0", "%+X"},
+ {__LINE__, 0xfffc9a14, "fffc9a14", "%-.5x"},
+ {__LINE__, 0x0000003c, "60", "%.2ld"},
+ {__LINE__, -0x0000023, " -35", "%6.d"},
+ {__LINE__, 0x00000740, "1856", "%ld"},
+ {__LINE__, 0x00000160, "160", "% 3.X"},
+ {__LINE__, 0x00000006, " 6", "%5.X"},
+ {__LINE__, -0x0000677, "-1655", "%.3ld"},
+ {__LINE__, 0x12709c7e, "12709C7E", "%.7X"},
+ {__LINE__, 0x0000090f, "+2319", "%+#d"},
+ {__LINE__, 0xffffffe0, "0xffffffe0", "%#4.1x"},
+ {__LINE__, 0x00132ce0, "1256672", "%ld"},
+ {__LINE__, 0x00000059, "59", "%+X"},
+ {__LINE__, -0x0000017, "-23", "%0d"},
+ {__LINE__, -0x01fade6, "-2076134", "%-4.3ld"},
+ {__LINE__, 0x000df3fa, "914426", "%.5ld"},
+ {__LINE__, 0xfffffd0f, "fffffd0f", "%7x"},
+ {__LINE__, -0x000c212, "-49682", "%0.1ld"},
+ {__LINE__, 0xffff8bcb, "FFFF8BCB", "%.3X"},
+ {__LINE__, 0x0000000a, "a", "% x"},
+ {__LINE__, 0x00000021, "21", "%x"},
+ {__LINE__, -0x0000040, "-64", "% 1ld"},
+ {__LINE__, 0x00000009, " 9", "%6.ld"},
+ {__LINE__, -0x0000d67, "-3431", "% 5.3d"},
+ {__LINE__, 0x03a85f1b, "61366043", "%ld"},
+ {__LINE__, 0x00000035, "000053", "%0.6d"},
+ {__LINE__, 0xfffda5cb, "fffda5cb", "%+x"},
+ {__LINE__, 0xffffff78, "FFFFFF78", "%-7.0X"},
+ {__LINE__, 0xfffffd6d, "fffffd6d", "%7.x"},
+ {__LINE__, 0xfffffc08, "fffffc08", "%7.3x"},
+ {__LINE__, 0x00003335, " 13109", "% #d"},
+ {__LINE__, -0x0000002, " -2", "%5.d"},
+ {__LINE__, -0x13767a48, "-326531656", "%+ld"},
+ {__LINE__, 0x00000be5, "3045", "%4.0ld"},
+ {__LINE__, 0xfffdb28c, "FFFDB28C", "%X"},
+ {__LINE__, 0x00127118, "1208600", "%ld"},
+ {__LINE__, 0x00000086, " 134", "% ld"},
+ {__LINE__, 0x0002214c, "2214c", "%+x"},
+ {__LINE__, 0x0000a0c2, " a0c2", "%5.0x"},
+ {__LINE__, -0x000007c, "-124", "%ld"},
+ {__LINE__, 0x0000012a, "00298", "%3.5d"},
+ {__LINE__, 0xfd4f1257, "FD4F1257", "%+2.X"},
+ {__LINE__, 0xffffd8aa, "ffffd8aa", "%5x"},
+ {__LINE__, -0x00000a7, "-167", "%+ld"},
+ {__LINE__, -0x0009c69, "-40041", "%0.0ld"},
+ {__LINE__, 0x02230418, "35849240", "%-0.6ld"},
+ {__LINE__, 0x00000000, " 0", "%6x"},
+ {__LINE__, 0xfffff184, "fffff184", "%02.5x"},
+ {__LINE__, -0x0ae967b, "-11441787", "%d"},
+ {__LINE__, 0x0015de3a, "1433146", "%-5.3d"},
+ {__LINE__, -0x0071e93, "-466579", "%1.ld"},
+ {__LINE__, 0xfffff8bd, "fffff8bd", "%+x"},
+ {__LINE__, -0x00000e4, "-228", "%+ld"},
+ {__LINE__, 0x000001d8, " 472", "% .3ld"},
+ {__LINE__, 0x00315faa, "315faa", "%-0x"},
+ {__LINE__, 0x00000e59, "e59", "%0x"},
+ {__LINE__, -0x0000005, "-5", "%ld"},
+ {__LINE__, 0x000018ec, "6380", "%ld"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%5.2x"},
+ {__LINE__, -0xe7cfd39, "-243072313", "%-d"},
+ {__LINE__, 0x0002c30b, "2C30B", "%1.2X"},
+ {__LINE__, 0x0000007a, "7A", "%X"},
+ {__LINE__, 0xf604ecb2, "F604ECB2", "%2X"},
+ {__LINE__, -0x05f602c, "-6250540", "%d"},
+ {__LINE__, 0xffff9c86, "ffff9c86", "%2.x"},
+ {__LINE__, -0x00d7f55, "-884565", "%#d"},
+ {__LINE__, 0xd2a37824, "D2A37824", "%4X"},
+ {__LINE__, 0x00000000, "", "%-.0x"},
+ {__LINE__, 0x000d4b51, "0d4b51", "%3.6x"},
+ {__LINE__, 0x000ecd97, "ecd97", "% x"},
+ {__LINE__, -0x0000018, "-024", "%+04ld"},
+ {__LINE__, -0x009f292, "-651922", "%ld"},
+ {__LINE__, -0x0002da9, "-11689", "%-0ld"},
+ {__LINE__, -0x000a218, "-41496", "%4.5d"},
+ {__LINE__, 0xffff85ac, "FFFF85AC", "% 04.X"},
+ {__LINE__, -0x0d9ffbe, "-14286782", "%0d"},
+ {__LINE__, 0xfb18cc8e, "fb18cc8e", "%x"},
+ {__LINE__, 0xffffe5d3, "FFFFE5D3", "%-X"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, -0x0000006, "-6", "% d"},
+ {__LINE__, 0x0002fc62, "2fc62", "% 03.x"},
+ {__LINE__, 0x00000000, "00", "%.2d"},
+ {__LINE__, -0x00000fd, " -253", "%6ld"},
+ {__LINE__, -0x000000b, "-11", "%d"},
+ {__LINE__, -0x00042a3, "-17059", "% 6d"},
+ {__LINE__, 0x00000002, "2", "% X"},
+ {__LINE__, -0x61ead93e, "-1642780990", "%-0d"},
+ {__LINE__, 0xf2e61f6d, "f2e61f6d", "%-.4x"},
+ {__LINE__, 0xffd31b93, "ffd31b93", "%x"},
+ {__LINE__, -0x0000008, "-8", "%ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%00x"},
+ {__LINE__, 0x000000fb, "+000251", "%+2.6d"},
+ {__LINE__, 0x00000015, " 15", "%4.X"},
+ {__LINE__, 0x06ec6d96, "6EC6D96", "%+2.X"},
+ {__LINE__, 0xffff1df7, "0xffff1df7", "% #1x"},
+ {__LINE__, -0x000004b, "-75", "%-ld"},
+ {__LINE__, 0x00000008, "8", "%#.0d"},
+ {__LINE__, 0x00001355, "4949", "%3.4ld"},
+ {__LINE__, -0x00000f7, "-247", "%d"},
+ {__LINE__, 0x0000001f, "31", "%.2ld"},
+ {__LINE__, 0x0000d556, "D556", "%-X"},
+ {__LINE__, 0xffffd5a5, "ffffd5a5", "% x"},
+ {__LINE__, -0x0000e34, "-3636", "%#d"},
+ {__LINE__, -0x0000007, "-7", "%d"},
+ {__LINE__, 0x01ba10a4, "1ba10a4", "%x"},
+ {__LINE__, 0xfffff759, "FFFFF759", "% X"},
+ {__LINE__, -0x80d0adb, "-135072475", "%d"},
+ {__LINE__, 0x0002bf61, "2bf61", "%x"},
+ {__LINE__, 0xffff008b, "FFFF008B", "%-7X"},
+ {__LINE__, 0x00000e72, "E72", "%X"},
+ {__LINE__, -0x00000ea, "-234", "%0ld"},
+ {__LINE__, -0x0007b9d, "-0031645", "%0.7ld"},
+ {__LINE__, 0x0001baaa, "0X1BAAA", "%#4X"},
+ {__LINE__, 0x0000a57f, " a57f", "%6.x"},
+ {__LINE__, -0x21a73726, "-564606758", "%ld"},
+ {__LINE__, 0x06f45c9f, "0x6f45c9f", "%#.3x"},
+ {__LINE__, 0x00018e5d, "101981", "%-d"},
+ {__LINE__, 0x0001e69a, "124570", "%-d"},
+ {__LINE__, -0x0000d26, " -3366", "% 07.d"},
+ {__LINE__, 0x00000000, "+", "%+0.ld"},
+ {__LINE__, 0x00003916, "14614", "%ld"},
+ {__LINE__, 0xfffffd8f, "fffffd8f", "%-3.x"},
+ {__LINE__, 0x00000011, "11", "%x"},
+ {__LINE__, 0x000000e7, "E7", "%X"},
+ {__LINE__, 0xfdf9d89b, "FDF9D89B", "%X"},
+ {__LINE__, 0x00000a7c, "a7c", "%x"},
+ {__LINE__, 0x0000003f, "00003F", "%.6X"},
+ {__LINE__, 0xffffe729, "FFFFE729", "%X"},
+ {__LINE__, 0xfffffffe, "fffffffe", "% .6x"},
+ {__LINE__, -0x0000a4b, "-2635", "%+d"},
+ {__LINE__, 0xffffff50, "ffffff50", "%0.7x"},
+ {__LINE__, 0xfaf57e8b, "faf57e8b", "% 4.x"},
+ {__LINE__, -0x0000056, "-86", "%ld"},
+ {__LINE__, 0x08ed2a4d, "8ed2a4d", "%4x"},
+ {__LINE__, 0xff8d9081, "FF8D9081", "%+0.X"},
+ {__LINE__, 0x002730a1, "2568353", "%4d"},
+ {__LINE__, 0xffff9564, "ffff9564", "%x"},
+ {__LINE__, -0x0000006, " -6", "%4ld"},
+ {__LINE__, -0x19890310, "-428409616", "%0ld"},
+ {__LINE__, 0xd2ce636c, "d2ce636c", "%+x"},
+ {__LINE__, -0x00001fe, "-510", "%d"},
+ {__LINE__, 0x00000006, "0000006", "%+0.7x"},
+ {__LINE__, 0xffffffc2, "0XFFFFFFC2", "%-#.5X"},
+ {__LINE__, -0x00000fd, "-253", "%+d"},
+ {__LINE__, 0x000216aa, "0x216aa", "%#x"},
+ {__LINE__, 0xffe36c66, "ffe36c66", "%x"},
+ {__LINE__, 0x00000002, "2", "%x"},
+ {__LINE__, -0x0000025, "-37", "% d"},
+ {__LINE__, 0x0000007e, "126", "%d"},
+ {__LINE__, 0x0003c1f9, "+246265", "%+ld"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, -0x00539e7, "-342503", "%06.ld"},
+ {__LINE__, 0x00000d42, " 3394", "%#6.ld"},
+ {__LINE__, 0xf73b7c4e, "F73B7C4E", "%X"},
+ {__LINE__, 0x00000022, "22", "%.1x"},
+ {__LINE__, 0xffffa883, "FFFFA883", "%X"},
+ {__LINE__, 0x016ec247, "16ec247", "%x"},
+ {__LINE__, 0x00000019, "19", "%+X"},
+ {__LINE__, 0x0000665a, "665A", "% 2.X"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%-5.X"},
+ {__LINE__, 0x008e3fbc, "8E3FBC", "%X"},
+ {__LINE__, 0xfffffffa, "FFFFFFFA", "%X"},
+ {__LINE__, 0x1b806597, "461399447", "%.2d"},
+ {__LINE__, 0x00000366, "0000870", "%#1.7ld"},
+ {__LINE__, 0x0001d92e, "1d92e", "%x"},
+ {__LINE__, 0x000104ce, "104CE", "%-X"},
+ {__LINE__, 0xfffffe4c, "fffffe4c", "%x"},
+ {__LINE__, 0x000000e9, "E9", "%X"},
+ {__LINE__, 0x000a855c, " 689500", "% d"},
+ {__LINE__, 0x00000075, "75", "% X"},
+ {__LINE__, -0x0000026, "-38", "%ld"},
+ {__LINE__, 0xfffff169, "fffff169", "%-04.2x"},
+ {__LINE__, 0xffffff6f, "ffffff6f", "%x"},
+ {__LINE__, 0x00000003, "0x3", "%#x"},
+ {__LINE__, 0x00623bab, "6437803", "%.0d"},
+ {__LINE__, -0x2260224c, "-576725580", "%ld"},
+ {__LINE__, 0xe7e7a998, "E7E7A998", "%.1X"},
+ {__LINE__, 0x00000005, "5", "%X"},
+ {__LINE__, 0x0000b560, "0xb560", "%#x"},
+ {__LINE__, 0xfe11854d, "fe11854d", "%-.5x"},
+ {__LINE__, 0x00190014, "1638420", "%ld"},
+ {__LINE__, 0x0001d22a, "0X1D22A", "%-#X"},
+ {__LINE__, 0x00000c16, "c16", "%2x"},
+ {__LINE__, 0x00000d1a, "3354", "%#d"},
+ {__LINE__, 0x000165f6, "91638", "%d"},
+ {__LINE__, 0xfffff557, "0XFFFFF557", "%#X"},
+ {__LINE__, 0x00000588, " 588", "%07.X"},
+ {__LINE__, 0xf4a72708, "f4a72708", "%x"},
+ {__LINE__, 0xfff1cba9, "0xfff1cba9", "% #2.5x"},
+ {__LINE__, 0x000333a4, "209828", "%d"},
+ {__LINE__, 0x0000179b, "179B", "% 2.X"},
+ {__LINE__, 0x00000460, "1120", "%0ld"},
+ {__LINE__, 0xffffff89, "FFFFFF89", "%X"},
+ {__LINE__, -0x0000012, "-18", "%ld"},
+ {__LINE__, 0x00004fe0, "20448", "%0.d"},
+ {__LINE__, 0x00532e77, "532e77", "%00.x"},
+ {__LINE__, 0xf7b92efe, "f7b92efe", "%0x"},
+ {__LINE__, -0x0000243, "-579", "%+1.d"},
+ {__LINE__, 0x34894bb7, "+881413047", "%+d"},
+ {__LINE__, 0xfffaa189, "FFFAA189", "% 6X"},
+ {__LINE__, -0x0000579, "-1401", "%+ld"},
+ {__LINE__, 0x005acb12, "5acb12", "%5.0x"},
+ {__LINE__, 0xffff890a, "FFFF890A", "%X"},
+ {__LINE__, 0x010dff2f, "10DFF2F", "%.7X"},
+ {__LINE__, 0x00005a7f, "23167", "%#ld"},
+ {__LINE__, 0x000005e3, "1507", "%#3d"},
+ {__LINE__, -0xa815bcb, "-176249803", "%d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%+x"},
+ {__LINE__, 0xfffe0ff7, "fffe0ff7", "%3x"},
+ {__LINE__, 0xffffffff, "0XFFFFFFFF", "%#2.1X"},
+ {__LINE__, -0x1cc5ea52, "-482732626", "%6.d"},
+ {__LINE__, 0x000425ed, "+0271853", "%+.7d"},
+ {__LINE__, 0x00000001, "1", "%+x"},
+ {__LINE__, -0x48f2a72, "-76491378", "%7.0d"},
+ {__LINE__, 0xfffffff7, "FFFFFFF7", "% 0X"},
+ {__LINE__, 0xfd8ffc0a, "fd8ffc0a", "%.1x"},
+ {__LINE__, 0x0001f56d, " 1F56D", "%+7.2X"},
+ {__LINE__, 0x000000db, " DB", "%6.X"},
+ {__LINE__, 0xffffffc2, "ffffffc2", "%x"},
+ {__LINE__, 0x00000001, "001", "%03ld"},
+ {__LINE__, 0xffd89f58, "ffd89f58", "% 0.x"},
+ {__LINE__, 0xfe1a72fc, "fe1a72fc", "%x"},
+ {__LINE__, 0xfffff9b6, "FFFFF9B6", "%X"},
+ {__LINE__, 0x00243633, "243633", "%X"},
+ {__LINE__, 0x00821bc7, "+8526791", "%+#0ld"},
+ {__LINE__, 0xfe63f348, "0XFE63F348", "%#3X"},
+ {__LINE__, 0xff729f19, "ff729f19", "%4x"},
+ {__LINE__, 0xffff570f, "FFFF570F", "%+X"},
+ {__LINE__, 0x00a57a42, "10844738", "%6.3d"},
+ {__LINE__, 0xfe4a3ed0, "FE4A3ED0", "%6.X"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, 0x000001bb, "01bb", "% .4x"},
+ {__LINE__, 0x02b4a1e9, "2b4a1e9", "%-7.x"},
+ {__LINE__, 0x31750683, "31750683", "%x"},
+ {__LINE__, 0x00001cd7, "7383", "%#ld"},
+ {__LINE__, 0x0000079d, "1949", "%d"},
+ {__LINE__, 0xffb8ff3b, "FFB8FF3B", "%X"},
+ {__LINE__, 0x00a768b6, "0A768B6", "%-6.7X"},
+ {__LINE__, 0x1c665b48, "0X1C665B48", "% #X"},
+ {__LINE__, -0x000037d, "-000893", "%3.6d"},
+ {__LINE__, 0x29890443, "29890443", "%+0x"},
+ {__LINE__, 0x000000e5, "e5 ", "%-4x"},
+ {__LINE__, 0xfff2b5fa, "FFF2B5FA", "%X"},
+ {__LINE__, -0x5d32c2b, "-97725483", "%05ld"},
+ {__LINE__, -0x00016c5, " -05829", "%+#7.5ld"},
+ {__LINE__, 0x00000644, "644", "%X"},
+ {__LINE__, -0x018c027, "-1622055", "%+.1d"},
+ {__LINE__, 0x0000013c, "0x13c", "%#x"},
+ {__LINE__, 0x00000009, "+9", "%+#ld"},
+ {__LINE__, 0x00000000, "0", "%ld"},
+ {__LINE__, -0x018eb19, "-1633049", "%4.3ld"},
+ {__LINE__, 0xfffff429, "FFFFF429", "% X"},
+ {__LINE__, 0x0032de67, "32DE67", "%X"},
+ {__LINE__, 0x0016bdfa, " 1490426", "% .2ld"},
+ {__LINE__, 0x00000065, "65", "%+.0X"},
+ {__LINE__, 0x00000072, " 72", "%+4.2X"},
+ {__LINE__, 0x00075119, "75119", "%2x"},
+ {__LINE__, 0x000000b8, "b8", "%x"},
+ {__LINE__, 0x000000d0, "d0", "%x"},
+ {__LINE__, 0x000000b9, "b9", "%x"},
+ {__LINE__, 0x003fda9d, " 4184733", "% #3.d"},
+ {__LINE__, 0x00029a24, "170532", "%4.d"},
+ {__LINE__, -0x132a337d, "-321532797", "% ld"},
+ {__LINE__, 0x0000047a, "0X47A", "%-#X"},
+ {__LINE__, 0x00000000, "0", "%-ld"},
+ {__LINE__, -0x0d9750b, "-14251275", "% ld"},
+ {__LINE__, 0x00029d6c, "29d6c", "%x"},
+ {__LINE__, 0xfb060cc0, "fb060cc0", "%x"},
+ {__LINE__, 0xffffd524, "0XFFFFD524", "%#X"},
+ {__LINE__, 0xffffff30, "ffffff30", "%-5x"},
+ {__LINE__, 0x00001650, "0005712", "%#0.7d"},
+ {__LINE__, 0x0000b702, "0B702", "%03.5X"},
+ {__LINE__, 0x000003c1, "3c1", "% .1x"},
+ {__LINE__, -0x0290412, "-2688018", "%d"},
+ {__LINE__, -0x00008bf, "-2239", "%#d"},
+ {__LINE__, -0x0000001, "-1", "%d"},
+ {__LINE__, 0x0001d750, "1D750", "%-X"},
+ {__LINE__, 0x006eee92, "6EEE92", "%-X"},
+ {__LINE__, 0xff812b02, "ff812b02", "%0x"},
+ {__LINE__, 0xfffffeac, "FFFFFEAC", "%+0X"},
+ {__LINE__, 0x000003a5, "3a5", "%x"},
+ {__LINE__, -0x15270cee, "-354880750", "%2.ld"},
+ {__LINE__, 0x06b686d2, "6b686d2", "%0x"},
+ {__LINE__, 0xffe9cdcc, "ffe9cdcc", "%x"},
+ {__LINE__, 0x0ecb168e, "ecb168e", "%x"},
+ {__LINE__, 0x00000051, "51", "%-X"},
+ {__LINE__, -0x0018860, "-100448", "%-0d"},
+ {__LINE__, 0x8f08b82b, "0x8f08b82b", "%-#.5x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, 0x0000000e, "e", "%+01x"},
+ {__LINE__, 0x04cf15bc, " 80680380", "% #ld"},
+ {__LINE__, 0x50006e8a, "50006e8a", "%x"},
+ {__LINE__, 0x0002f669, "194153", "%0d"},
+ {__LINE__, 0x000000a6, " 166", "% 5.ld"},
+ {__LINE__, -0x04036bb, "-4208315", "%7.5d"},
+ {__LINE__, 0x00070dea, "70DEA", "%+X"},
+ {__LINE__, 0x00000964, "0x964", "%#x"},
+ {__LINE__, 0x0000004d, "0x4d", "% #3.x"},
+ {__LINE__, -0x0000001, "-1", "%-0d"},
+ {__LINE__, 0x0000043e, "1086", "%ld"},
+ {__LINE__, -0x0000001, "-1", "%-d"},
+ {__LINE__, 0x00000000, "+0", "%+d"},
+ {__LINE__, 0xfffe68d9, "FFFE68D9", "%7.X"},
+ {__LINE__, -0x0169199, "-1479065", "%#.5ld"},
+ {__LINE__, -0x000003d, "-61", "%ld"},
+ {__LINE__, 0x00000001, "+1", "%+.1d"},
+ {__LINE__, 0x0001a65d, "1a65d", "%.5x"},
+ {__LINE__, 0x00000141, "+000321", "%+#5.6ld"},
+ {__LINE__, 0x00000000, " 0", "%4x"},
+ {__LINE__, 0x00000408, "1032", "%-2.3ld"},
+ {__LINE__, 0xffffffed, "FFFFFFED", "%-X"},
+ {__LINE__, 0xfe832351, "FE832351", "% .4X"},
+ {__LINE__, 0x003a421b, "3A421B", "%-X"},
+ {__LINE__, -0x53ed7f25, "-1408073509", "%ld"},
+ {__LINE__, -0x0000003, "-0003", "%-5.4ld"},
+ {__LINE__, 0x00000ad0, " 2768", "%7d"},
+ {__LINE__, 0xfffaf30b, "FFFAF30B", "%X"},
+ {__LINE__, 0x006349d3, " 6506963", "% 6.2ld"},
+ {__LINE__, 0x07f0146a, "7f0146a", "%+3.4x"},
+ {__LINE__, -0x0000002, " -2", "% 3.ld"},
+ {__LINE__, -0x26e94f3, "-40801523", "%-#ld"},
+ {__LINE__, -0x0000004, " -004", "%7.3d"},
+ {__LINE__, 0xfffe8cc9, "FFFE8CC9", "%0X"},
+ {__LINE__, 0x00000018, " 18", "%5.x"},
+ {__LINE__, -0x4941de83, "-1229053571", "% 0.5ld"},
+ {__LINE__, 0x00000000, " 0", "%6ld"},
+ {__LINE__, 0xfffffffe, "0XFFFFFFFE", "%-#X"},
+ {__LINE__, -0x0142ae1, "-1321697", "%4.ld"},
+ {__LINE__, -0x0319e7f, "-3251839", "%0ld"},
+ {__LINE__, 0x000004ff, " 4FF", "%7.2X"},
+ {__LINE__, -0x0001c3e, "-7230", "%#.2ld"},
+ {__LINE__, 0xffffe522, "ffffe522", "%x"},
+ {__LINE__, 0x0001d1cb, "+119243", "%+.3ld"},
+ {__LINE__, 0xfad19d52, "FAD19D52", "%+X"},
+ {__LINE__, 0x00002a7c, " 10876", "% 0.ld"},
+ {__LINE__, 0x00001449, "1449", "%X"},
+ {__LINE__, 0x000732b8, "471736", "%d"},
+ {__LINE__, -0x211a496e, "-555370862", "%ld"},
+ {__LINE__, -0x0000004, "-4", "%1.d"},
+ {__LINE__, 0x0295c03d, "43368509", "%5.ld"},
+ {__LINE__, 0x01fa5722, "33183522", "%0ld"},
+ {__LINE__, 0xfffbff62, "0xfffbff62", "%#x"},
+ {__LINE__, 0x000000f5, " 245", "% 2.d"},
+ {__LINE__, 0x000000a0, "160", "%-d"},
+ {__LINE__, 0x0000000f, "15", "%.2ld"},
+ {__LINE__, 0x0bf5f077, "+200667255", "%+ld"},
+ {__LINE__, -0x14d3e5a, "-21839450", "%#2.3d"},
+ {__LINE__, -0x21cbe656, "-567010902", "%ld"},
+ {__LINE__, 0x000002b9, "697", "%ld"},
+ {__LINE__, 0xfffff9b0, "FFFFF9B0", "%X"},
+ {__LINE__, 0x007fd9c7, "8378823", "%3.4d"},
+ {__LINE__, 0x00036d06, "36d06", "%x"},
+ {__LINE__, 0xffde8052, "FFDE8052", "%4.6X"},
+ {__LINE__, 0x0000000d, "13", "%#d"},
+ {__LINE__, 0x68157d93, "68157d93", "%x"},
+ {__LINE__, 0x00000005, "5", "%1x"},
+ {__LINE__, 0xfffffff4, "FFFFFFF4", "%X"},
+ {__LINE__, 0xf5bbf7e9, "f5bbf7e9", "%+.1x"},
+ {__LINE__, 0x0be98f98, "BE98F98", "%X"},
+ {__LINE__, 0x00000122, "00122", "%.5X"},
+ {__LINE__, -0x0000936, "-2358", "%+#3.0ld"},
+ {__LINE__, 0xfd230f09, "FD230F09", "%-7X"},
+ {__LINE__, 0x00000089, "137", "%ld"},
+ {__LINE__, 0x00000078, " 120", "%7d"},
+ {__LINE__, -0x68ef2b6b, "-1760504683", "%-ld"},
+ {__LINE__, 0xc24480bb, "C24480BB", "%+4X"},
+ {__LINE__, 0xfefe36a2, "FEFE36A2", "%0X"},
+ {__LINE__, -0x35344ba, "-55788730", "%7.d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%+.6X"},
+ {__LINE__, -0x0000f40, "-3904", "% ld"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "%X"},
+ {__LINE__, 0x58b37c4b, "58b37c4b", "%2.2x"},
+ {__LINE__, 0x000000e2, "226", "%#ld"},
+ {__LINE__, 0xfff5ebde, "fff5ebde", "%-7.1x"},
+ {__LINE__, 0x0c6ea9be, "208579006", "%-ld"},
+ {__LINE__, 0xff708c74, "FF708C74", "% 4.X"},
+ {__LINE__, 0x00000000, " 0", "% 3X"},
+ {__LINE__, 0x00000004, " 4", "%03.d"},
+ {__LINE__, 0x0919be7c, "+152682108", "%+6.d"},
+ {__LINE__, 0x00d4fd1e, "13958430", "%0d"},
+ {__LINE__, 0xfe77a69e, "fe77a69e", "%-7.x"},
+ {__LINE__, 0x284ded44, "676195652", "%-#2ld"},
+ {__LINE__, -0x00006e6, "-1766", "% ld"},
+ {__LINE__, -0x7dac7ea, "-131778538", "%.0ld"},
+ {__LINE__, 0x0003c50f, "247055", "%#d"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%-x"},
+ {__LINE__, 0xfe0f0d1f, "fe0f0d1f", "% 5.1x"},
+ {__LINE__, 0x00000009, "9", "%0ld"},
+ {__LINE__, -0x0175cc1, "-1531073", "%-04.d"},
+ {__LINE__, 0x000e4da2, " 937378", "% 4.ld"},
+ {__LINE__, 0x00000762, "762", "%-0.X"},
+ {__LINE__, 0x005211bf, "5211bf", "%-x"},
+ {__LINE__, 0xfffffffb, "fffffffb", "%+2.6x"},
+ {__LINE__, 0x00008862, "34914", "%ld"},
+ {__LINE__, 0xfffc9754, "fffc9754", "%+x"},
+ {__LINE__, 0x0000716e, "716E", "%X"},
+ {__LINE__, 0x000000a8, "a8", "%x"},
+ {__LINE__, 0xffff84f5, "ffff84f5", "%0x"},
+ {__LINE__, 0x00005032, "5032", "%x"},
+ {__LINE__, 0xffe242b4, "ffe242b4", "%6x"},
+ {__LINE__, 0x002df9bd, "3013053", "%ld"},
+ {__LINE__, 0xffffe267, "FFFFE267", "%.5X"},
+ {__LINE__, 0xffffffc7, "0xffffffc7", "%#x"},
+ {__LINE__, -0x1727c38, "-24280120", "%d"},
+ {__LINE__, 0x01308072, "1308072", "%x"},
+ {__LINE__, -0x5883c7c, "-92814460", "%+ld"},
+ {__LINE__, 0x000030ad, "30ad", "%x"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%X"},
+ {__LINE__, -0x2090a708, "-546350856", "% d"},
+ {__LINE__, 0x0024e6b4, "2418356", "%#ld"},
+ {__LINE__, 0x02db71ac, "2DB71AC", "% 6.3X"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%2.7X"},
+ {__LINE__, -0x000074e, " -1870", "%7.ld"},
+ {__LINE__, -0x0011d84, "-73092", "%d"},
+ {__LINE__, 0x00160723, "160723", "%1.3x"},
+ {__LINE__, 0x00412929, "4270377", "%-d"},
+ {__LINE__, -0x0008fc6, "-36806", "% d"},
+ {__LINE__, 0x00000002, "2", "%d"},
+ {__LINE__, 0x0eb67ffa, "eb67ffa", "%.4x"},
+ {__LINE__, 0x05b86c3c, "95972412", "%4.4d"},
+ {__LINE__, 0xffffca9c, "FFFFCA9C", "% 4.X"},
+ {__LINE__, 0x0007d571, "7d571", "%-0x"},
+ {__LINE__, -0x000239b, "-09115", "%5.5d"},
+ {__LINE__, -0x0000155, " -341", "%5.3ld"},
+ {__LINE__, 0x00000034, "34", "%x"},
+ {__LINE__, -0x0000051, "-81", "%.1ld"},
+ {__LINE__, 0x309bbbe0, "309bbbe0", "%x"},
+ {__LINE__, 0x0075be1e, " 7716382", "% #ld"},
+ {__LINE__, 0x000002d5, "2d5", "%x"},
+ {__LINE__, 0x006b466d, "6B466D", "%-0X"},
+ {__LINE__, 0x01d6c30f, "1D6C30F", "%4.X"},
+ {__LINE__, 0x00000003, " 3", "%07.x"},
+ {__LINE__, 0xfffcc102, "FFFCC102", "%6.X"},
+ {__LINE__, 0xffffffff, "0XFFFFFFFF", "%#X"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%+x"},
+ {__LINE__, 0x00000005, "5", "%ld"},
+ {__LINE__, 0xff060284, "ff060284", "%x"},
+ {__LINE__, 0x007a3325, "7A3325", "%-X"},
+ {__LINE__, 0xf5f595bd, "F5F595BD", "%0X"},
+ {__LINE__, 0xfffa3a10, "FFFA3A10", "%0X"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, -0x15078f9, "-22051065", "%7d"},
+ {__LINE__, -0x0000002, "-000002", "%.6d"},
+ {__LINE__, 0x00000036, "54", "%1.1ld"},
+ {__LINE__, -0xbbecf6a, "-197054314", "%ld"},
+ {__LINE__, 0x0000043d, "43D", "%X"},
+ {__LINE__, 0xfffffffa, "0xfffffffa", "% #6.x"},
+ {__LINE__, 0x016759f8, "23550456", "%0.ld"},
+ {__LINE__, 0x000052d2, "+21202", "%+6.2d"},
+ {__LINE__, -0x007d232, "-512562", "%ld"},
+ {__LINE__, 0x00240be0, "2362336", "%.1d"},
+ {__LINE__, -0x0000001, "-1", "%0d"},
+ {__LINE__, 0xfffffffa, "FFFFFFFA", "%X"},
+ {__LINE__, -0x0000e88, "-3720", "%ld"},
+ {__LINE__, 0xfffffa9b, "FFFFFA9B", "%.5X"},
+ {__LINE__, 0x09296eeb, "153710315", "%-1.0d"},
+ {__LINE__, 0x001f46fc, "0X1F46FC", "%#X"},
+ {__LINE__, 0x00000006, "6", "%X"},
+ {__LINE__, 0xffffff87, "0XFFFFFF87", "%+#X"},
+ {__LINE__, 0x00000469, "0469", "%04X"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, 0x00000000, "", "%.0ld"},
+ {__LINE__, -0x52bc137, "-86753591", "%-#3ld"},
+ {__LINE__, -0x2bddb08, "-45996808", "%-3.d"},
+ {__LINE__, 0x041367f7, "41367F7", "%+X"},
+ {__LINE__, -0x0018eb5, "-102069", "%+ld"},
+ {__LINE__, -0x0000537, "-1335", "%#ld"},
+ {__LINE__, -0x6f159ff4, "-1863688180", "%+1.d"},
+ {__LINE__, 0x00112ac8, "0X112AC8", "%#6.3X"},
+ {__LINE__, 0x00000000, " ", "%3.d"},
+ {__LINE__, 0x0008afe8, "08afe8", "%+3.6x"},
+ {__LINE__, 0x00000015, "21", "%ld"},
+ {__LINE__, -0x02b7130, "-2847024", "% #2.4d"},
+ {__LINE__, 0xffffffd0, "FFFFFFD0", "%X"},
+ {__LINE__, -0x6970fa1, "-110563233", "%+#.4ld"},
+ {__LINE__, 0x06387dcc, "0X6387DCC", "%-#X"},
+ {__LINE__, 0xffffd506, "ffffd506", "%+6x"},
+ {__LINE__, -0x00fe5cd, "-1041869", "%-#7d"},
+ {__LINE__, -0x0c35bf6, "-12803062", "%-03d"},
+ {__LINE__, -0x0020d89, "-134537", "%#d"},
+ {__LINE__, -0x0c7aed3, "-13086419", "%-ld"},
+ {__LINE__, -0x000362a, "-13866", "%#.4ld"},
+ {__LINE__, -0x02d05f0, "-2950640", "%#ld"},
+ {__LINE__, 0x02de1321, "0x2de1321", "%#7.x"},
+ {__LINE__, 0xffb56428, "0xffb56428", "%#x"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%X"},
+ {__LINE__, 0xf072292d, "F072292D", "%.5X"},
+ {__LINE__, -0x0f4b0f2, "-16036082", "%.5ld"},
+ {__LINE__, 0x01b81885, "28842117", "%5d"},
+ {__LINE__, -0x009cfa6, "-642982", "%d"},
+ {__LINE__, 0xfffffffd, "0XFFFFFFFD", "%-#.5X"},
+ {__LINE__, 0x0dc97a66, "DC97A66", "%2.X"},
+ {__LINE__, 0x000000be, "190", "%.0d"},
+ {__LINE__, 0xffffe1c7, "FFFFE1C7", "% X"},
+ {__LINE__, 0x01883b9a, "1883b9a", "%3x"},
+ {__LINE__, 0xffffdde1, "ffffdde1", "%+x"},
+ {__LINE__, 0x2f1b4e32, "+790318642", "%+ld"},
+ {__LINE__, 0x000129aa, "129aa", "%x"},
+ {__LINE__, -0x00092c2, "-37570", "%d"},
+ {__LINE__, 0x00070fbd, "70fbd", "%x"},
+ {__LINE__, -0x00000ea, "-234", "%+4ld"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%x"},
+ {__LINE__, 0x0091c7f7, "91C7F7", "% .3X"},
+ {__LINE__, -0x0c14fe2, "-12668898", "%d"},
+ {__LINE__, -0x0017c15, "-97301", "%d"},
+ {__LINE__, -0x00005d0, "-0001488", "%5.7d"},
+ {__LINE__, 0x0114c36e, "18137966", "%0d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%+x"},
+ {__LINE__, 0x0ac76e78, "180842104", "%d"},
+ {__LINE__, 0x001976cd, " 1668813", "% 4.ld"},
+ {__LINE__, -0x0642319, "-6562585", "% d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%X"},
+ {__LINE__, -0x035019d, "-3473821", "%.7d"},
+ {__LINE__, -0x0000061, "-97", "%#3.d"},
+ {__LINE__, 0x0000001f, " 31", "% 6.1ld"},
+ {__LINE__, -0x0000024, "-36", "%d"},
+ {__LINE__, 0x000b3785, "735109", "%ld"},
+ {__LINE__, 0xfffffda9, "fffffda9", "%-x"},
+ {__LINE__, 0x00254832, "2443314", "%-ld"},
+ {__LINE__, 0xfffffd40, "FFFFFD40", "%0X"},
+ {__LINE__, -0x0006105, "-24837", "%+#d"},
+ {__LINE__, 0x00000006, "+6", "%+d"},
+ {__LINE__, 0xffd40fd8, "ffd40fd8", "%3.x"},
+ {__LINE__, -0x000988e, "-39054", "%03d"},
+ {__LINE__, 0x0005ad8b, "5AD8B", "%0.0X"},
+ {__LINE__, 0x00000001, "1", "%d"},
+ {__LINE__, 0xfe1f59b7, "fe1f59b7", "%4.x"},
+ {__LINE__, -0x0000022, "-34", "%#d"},
+ {__LINE__, 0x0018e3e9, "18E3E9", "% X"},
+ {__LINE__, 0xffffff25, "FFFFFF25", "%2.X"},
+ {__LINE__, -0x00002c6, "-710", "%1.ld"},
+ {__LINE__, 0x00009765, "38757", "%5ld"},
+ {__LINE__, 0xfe197646, "FE197646", "%-X"},
+ {__LINE__, 0x00000001, " 1", "%+5.x"},
+ {__LINE__, -0x0000002, "-2", "%#ld"},
+ {__LINE__, 0x0072f6be, "72F6BE", "%1X"},
+ {__LINE__, -0x000f06d, "-61549", "%-d"},
+ {__LINE__, 0x00000001, " 1", "%5X"},
+ {__LINE__, 0x328cba28, " 848083496", "% 2.ld"},
+ {__LINE__, 0x0000cddc, "cddc", "%.1x"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%7x"},
+ {__LINE__, 0x00baf511, "BAF511", "%-5.6X"},
+ {__LINE__, 0x00000001, " 1", "%4.ld"},
+ {__LINE__, 0x0001e4b0, "+124080", "%+ld"},
+ {__LINE__, -0x07548f3, "-7686387", "% 6.d"},
+ {__LINE__, -0x01b14ea, "-1774826", "% #0d"},
+ {__LINE__, -0x000005c, "-92 ", "%-04ld"},
+ {__LINE__, -0x00000ae, "-174", "%+.3ld"},
+ {__LINE__, 0x0000008c, "0X8C", "%+#X"},
+ {__LINE__, 0x14c02360, "14C02360", "%.6X"},
+ {__LINE__, 0xfffffff6, "FFFFFFF6", "%X"},
+ {__LINE__, 0x009f4ee5, "9f4ee5", "%x"},
+ {__LINE__, 0x00000035, "35", "%X"},
+ {__LINE__, -0x00000eb, "-235", "%ld"},
+ {__LINE__, 0x1552ced8, "1552CED8", "%04X"},
+ {__LINE__, 0x0000002a, " 2A", "%5X"},
+ {__LINE__, 0xffffffff, "ffffffff", "% x"},
+ {__LINE__, -0xdec0db2, "-233573810", "%d"},
+ {__LINE__, 0x001e2ef0, "1978096", "%2.d"},
+ {__LINE__, 0xffffef24, "ffffef24", "%.5x"},
+ {__LINE__, 0xfffe6a6c, "fffe6a6c", "%+x"},
+ {__LINE__, -0x0000004, "-4", "% ld"},
+ {__LINE__, 0xfe3c6743, "fe3c6743", "%.1x"},
+ {__LINE__, 0x0000033d, "829", "%0ld"},
+ {__LINE__, -0x00006a0, " -1696", "% 7.ld"},
+ {__LINE__, 0xffffffdb, "ffffffdb", "%0.0x"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%3.3X"},
+ {__LINE__, -0x0000004, "-4", "%#ld"},
+ {__LINE__, 0x00b32b56, "B32B56", "%X"},
+ {__LINE__, 0xffffffff, "0xffffffff", "%+#x"},
+ {__LINE__, 0x01cd1a48, "1cd1a48", "%+7x"},
+ {__LINE__, 0xffffffda, "ffffffda", "%x"},
+ {__LINE__, 0x1886509e, "1886509E", "% X"},
+ {__LINE__, 0x000000eb, "235", "%0d"},
+ {__LINE__, 0xfffffff4, "fffffff4", "%0x"},
+ {__LINE__, 0x00000547, "547", "% X"},
+ {__LINE__, 0x000017e6, "17e6", "%-2.x"},
+ {__LINE__, 0x00001dc4, "7620", "%d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%3.0X"},
+ {__LINE__, 0xffff93fa, "0XFFFF93FA", "%#X"},
+ {__LINE__, 0xfffffe1c, "FFFFFE1C", "%-X"},
+ {__LINE__, 0x00000000, "", "% .0x"},
+ {__LINE__, 0x000000a1, "A1", "%X"},
+ {__LINE__, 0xffffffff, "0xffffffff", "%#x"},
+ {__LINE__, -0x0001460, "-05216", "%+#.5d"},
+ {__LINE__, 0x00000001, "1 ", "%-6.x"},
+ {__LINE__, 0xfffd5324, "FFFD5324", "%+2.6X"},
+ {__LINE__, 0x00000007, " 07", "%06.2d"},
+ {__LINE__, 0x00000003, "3", "%-X"},
+ {__LINE__, 0xfffffdb7, "0XFFFFFDB7", "%+#X"},
+ {__LINE__, 0xfffff4cc, "fffff4cc", "%0x"},
+ {__LINE__, 0x00000000, "0 ", "%-5X"},
+ {__LINE__, 0x00758c96, "758C96", "%X"},
+ {__LINE__, -0x0000001, "-1", "%-ld"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, 0x03f03caf, "66075823", "%.2ld"},
+ {__LINE__, 0x0000a87c, "a87c", "%1.x"},
+ {__LINE__, 0x00000034, "34", "%X"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0x00010167, "10167", "%x"},
+ {__LINE__, -0x00007ce, "-1998 ", "%-6ld"},
+ {__LINE__, 0x00000001, "1", "%.0d"},
+ {__LINE__, 0x00d94cee, "14241006", "%ld"},
+ {__LINE__, -0x0000008, "-8", "% d"},
+ {__LINE__, -0x71520839, "-1901201465", "%+0d"},
+ {__LINE__, 0x0000035a, "35a", "%-x"},
+ {__LINE__, 0xfffd2f68, "FFFD2F68", "%-X"},
+ {__LINE__, 0x0006ea53, "453203", "%1d"},
+ {__LINE__, 0x000000df, "DF", "% 1X"},
+ {__LINE__, 0xfffffffe, "fffffffe", "% 7x"},
+ {__LINE__, 0x00000156, "156", "% X"},
+ {__LINE__, 0x00037ac9, " 228041", "% ld"},
+ {__LINE__, 0xffffffde, "FFFFFFDE", "%0.5X"},
+ {__LINE__, 0x00000025, "37", "%-0.ld"},
+ {__LINE__, -0x4133686, "-68368006", "%2ld"},
+ {__LINE__, -0x000003b, "-59", "%.2ld"},
+ {__LINE__, 0xfffff910, "fffff910", "% 00.0x"},
+ {__LINE__, 0xff9ec802, "FF9EC802", "%2.6X"},
+ {__LINE__, 0x00000008, "0X8", "%#1X"},
+ {__LINE__, 0xfffffff7, "FFFFFFF7", "%-X"},
+ {__LINE__, 0x0029a4da, "2729178", "%04.ld"},
+ {__LINE__, 0x007d1588, "8197512", "%#d"},
+ {__LINE__, 0x0007e86d, "518253", "%0d"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%x"},
+ {__LINE__, 0x00000002, "002", "%.3d"},
+ {__LINE__, 0x00006ec1, "6EC1", "%2X"},
+ {__LINE__, 0x0000300c, "12300", "%-d"},
+ {__LINE__, -0x0000002, "-2", "%+ld"},
+ {__LINE__, -0x0000002, "-2", "%ld"},
+ {__LINE__, -0x00015d5, "-005589", "%#.6ld"},
+ {__LINE__, 0x00000041, "65", "%d"},
+ {__LINE__, 0x00000229, "0000229", "% 0.7x"},
+ {__LINE__, 0xfffffffb, "fffffffb", "%03.x"},
+ {__LINE__, 0x00093262, "0602722", "%.7d"},
+ {__LINE__, -0x00037b4, "-14260", "%-0ld"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%-x"},
+ {__LINE__, 0xf24cb3e6, "f24cb3e6", "%1x"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "%0X"},
+ {__LINE__, 0x00000031, "0000049", "%00.7ld"},
+ {__LINE__, 0x00000bb3, "BB3", "%.1X"},
+ {__LINE__, -0x0000001, "-0001", "%+#4.4ld"},
+ {__LINE__, -0x0000001, "-1", "% d"},
+ {__LINE__, 0x00022c0c, "22c0c", "%-x"},
+ {__LINE__, 0xffffffd4, "ffffffd4", "%x"},
+ {__LINE__, 0x000729c6, "469446", "%3.d"},
+ {__LINE__, 0xb180feae, "b180feae", "%3.x"},
+ {__LINE__, 0x124fac15, "307211285", "%-0ld"},
+ {__LINE__, -0x0000004, "-4", "%ld"},
+ {__LINE__, 0x0000006a, "106", "%#d"},
+ {__LINE__, 0x0000297f, "297F", "%+3X"},
+ {__LINE__, 0x0000000e, "14", "%0ld"},
+ {__LINE__, 0x00000027, "27", "%0.1X"},
+ {__LINE__, 0xffeb98eb, "ffeb98eb", "% 05.2x"},
+ {__LINE__, 0xfffff19b, "FFFFF19B", "%+X"},
+ {__LINE__, 0x00025992, "154002", "%6.6d"},
+ {__LINE__, 0x00000040, " 040", "%6.3X"},
+ {__LINE__, 0x00000a9e, " 0a9e", "%5.4x"},
+ {__LINE__, 0x00c7f2cc, "c7f2cc", "%x"},
+ {__LINE__, 0x000325e6, " 325E6", "%6.X"},
+ {__LINE__, -0x69faad3, "-111127251", "%d"},
+ {__LINE__, -0x059a307, "-5874439", "% ld"},
+ {__LINE__, 0xfffffff6, "0xfffffff6", "%#0.0x"},
+ {__LINE__, 0x0030fdf3, "30fdf3", "%x"},
+ {__LINE__, 0x00007343, "+29507", "%+#2d"},
+ {__LINE__, 0x0003cf4b, "0X3CF4B", "% #.2X"},
+ {__LINE__, 0x00000433, "+1075", "%+0ld"},
+ {__LINE__, 0xfffffffd, "fffffffd", "%+.3x"},
+ {__LINE__, 0x0ae30c4e, "ae30c4e", "%+00x"},
+ {__LINE__, 0x0002540f, "02540f", "%-.6x"},
+ {__LINE__, -0x0000001, " -01", "% #5.2ld"},
+ {__LINE__, 0xffffffe7, "0xffffffe7", "% #5.x"},
+ {__LINE__, 0x0000005b, "91", "%d"},
+ {__LINE__, 0x00001f9b, "8091", "%.4ld"},
+ {__LINE__, 0xfffff315, "fffff315", "%4.x"},
+ {__LINE__, -0x130eec41, "-319745089", "% ld"},
+ {__LINE__, 0xfff8fe13, "FFF8FE13", "%X"},
+ {__LINE__, -0x0000004, "-00004", "%5.5d"},
+ {__LINE__, 0x00000669, "669", "%0X"},
+ {__LINE__, -0x0000004, "-4", "%d"},
+ {__LINE__, 0xf5e81496, "F5E81496", "% 6X"},
+ {__LINE__, -0x0000001, "-1", "% 0d"},
+ {__LINE__, 0xfffffff7, "fffffff7", "%x"},
+ {__LINE__, 0x000001de, "478", "%d"},
+ {__LINE__, 0x0000623e, "25150", "%5.0d"},
+ {__LINE__, 0xffffffa8, "FFFFFFA8", "%+X"},
+ {__LINE__, -0x0000117, "-279", "% ld"},
+ {__LINE__, -0x0000517, "-1303", "%d"},
+ {__LINE__, 0xfffff9d5, "fffff9d5", "% x"},
+ {__LINE__, 0x000001cc, "1CC", "%-X"},
+ {__LINE__, 0x0000019a, "0000410", "%.7d"},
+ {__LINE__, 0x00000003, "3 ", "%-06X"},
+ {__LINE__, 0x00000009, "0x9", "%#0x"},
+ {__LINE__, 0xfd544610, "0XFD544610", "% #X"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%+x"},
+ {__LINE__, 0x00009437, "37943", "%ld"},
+ {__LINE__, -0x00b5ea6, "-745126", "%d"},
+ {__LINE__, 0xffffffd8, "ffffffd8", "%6x"},
+ {__LINE__, 0x00002a2d, "10797", "%.3ld"},
+ {__LINE__, 0x00275238, "2576952", "%0ld"},
+ {__LINE__, 0xfff90a34, "FFF90A34", "%-7X"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "% .7X"},
+ {__LINE__, -0xb3b673e, "-188442430", "% ld"},
+ {__LINE__, 0xfffff67a, "0xfffff67a", "%#0.x"},
+ {__LINE__, 0x0000dff6, " dff6", "%+7.x"},
+ {__LINE__, 0xffee46e3, "ffee46e3", "%x"},
+ {__LINE__, 0x00001a66, " 0006758", "% 7.7d"},
+ {__LINE__, 0x0002b475, "2B475", "%.4X"},
+ {__LINE__, 0x0002090d, "002090d", "%.7x"},
+ {__LINE__, -0x0057838, "-358456", "%#ld"},
+ {__LINE__, 0x00000004, "0x4", "%#x"},
+ {__LINE__, 0x0574cb62, "91540322", "%#7d"},
+ {__LINE__, -0x0054388, "-344968", "% #d"},
+ {__LINE__, 0x000421c2, "421C2", "% X"},
+ {__LINE__, 0x00000003, "3", "%0d"},
+ {__LINE__, 0xffffe2e2, "ffffe2e2", "% 5.x"},
+ {__LINE__, 0x00000021, "+33", "%+d"},
+ {__LINE__, -0x0020033, "-131123", "%ld"},
+ {__LINE__, -0x0000001, " -1", "%4.ld"},
+ {__LINE__, 0x000000fd, "000fd", "%3.5x"},
+ {__LINE__, 0x023e4337, "37634871", "%1d"},
+ {__LINE__, 0x6e823d96, "6E823D96", "% X"},
+ {__LINE__, 0xfff0e133, "fff0e133", "%x"},
+ {__LINE__, -0x000decc, "-57036", "%3d"},
+ {__LINE__, 0x004397b8, "4429752", "%0d"},
+ {__LINE__, -0x0000023, " -35", "%6d"},
+ {__LINE__, 0xffe701ca, "FFE701CA", "%3X"},
+ {__LINE__, 0x000c0319, "+787225", "%+.6d"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0xfffffe1d, "FFFFFE1D", "%X"},
+ {__LINE__, 0xfffffb33, "fffffb33", "%x"},
+ {__LINE__, 0x02b5e30a, "45474570", "%d"},
+ {__LINE__, 0x000074eb, "29931", "%03.ld"},
+ {__LINE__, -0x4e42e310, "-1313006352", "%-0.d"},
+ {__LINE__, -0x000007b, "-123", "%d"},
+ {__LINE__, 0x00000160, " 352", "% d"},
+ {__LINE__, -0x16af31ec, "-380580332", "%#ld"},
+ {__LINE__, -0x000006e, "-000110", "%07ld"},
+ {__LINE__, 0x232699a0, "232699a0", "%7.x"},
+ {__LINE__, 0x00f9b8e5, "+16365797", "%+0d"},
+ {__LINE__, 0x0000000c, "C", "%X"},
+ {__LINE__, 0xfffffd4f, "FFFFFD4F", "%X"},
+ {__LINE__, 0xffffe7bb, "FFFFE7BB", "%.7X"},
+ {__LINE__, -0x0000163, "-355", "%d"},
+ {__LINE__, 0x00070315, " 459541", "% #2.d"},
+ {__LINE__, -0x7d5c12a, "-131449130", "% 6.ld"},
+ {__LINE__, 0xffffffb2, "FFFFFFB2", "%X"},
+ {__LINE__, -0x0004aad, "-19117", "%+6.4ld"},
+ {__LINE__, 0x00115586, "1136006", "%0d"},
+ {__LINE__, -0x0000021, "-33", "%d"},
+ {__LINE__, 0x093ce01e, "93ce01e", "% 5x"},
+ {__LINE__, 0x00672135, "672135", "% x"},
+ {__LINE__, 0x05f4abd5, "0x5f4abd5", "%+#6.x"},
+ {__LINE__, -0x0448b03, "-4492035", "%-0.2ld"},
+ {__LINE__, 0x00000000, "0", "%#x"},
+ {__LINE__, 0x1987217e, "428286334", "%d"},
+ {__LINE__, 0x000010f6, "10f6", "%-x"},
+ {__LINE__, 0x0000177a, "177a", "%1x"},
+ {__LINE__, 0xfffffefd, "FFFFFEFD", "%7X"},
+ {__LINE__, -0x095cbf8, "-9817080", "%-5ld"},
+ {__LINE__, 0x0000008a, "138", "%2.0ld"},
+ {__LINE__, 0xfffe80ad, "fffe80ad", "%0x"},
+ {__LINE__, -0x1a4c8f7, "-27576567", "%d"},
+ {__LINE__, 0x00000000, "0", "%-x"},
+ {__LINE__, 0x0000a82b, "43051", "%-ld"},
+ {__LINE__, 0x000000eb, "235", "%2.3ld"},
+ {__LINE__, -0x0002747, "-10055", "%d"},
+ {__LINE__, 0x00000319, "0X319", "%#X"},
+ {__LINE__, 0xfffffcfe, "FFFFFCFE", "% X"},
+ {__LINE__, 0x00050f0e, "50f0e", "%-1x"},
+ {__LINE__, -0x398e09e, "-60350622", "%0.7ld"},
+ {__LINE__, 0x00000000, " ", "%2.ld"},
+ {__LINE__, 0x00000049, "00049", "% .5X"},
+ {__LINE__, -0x00000dd, " -221", "%+#5ld"},
+ {__LINE__, 0xf6db2fac, "f6db2fac", "%-07x"},
+ {__LINE__, 0x0000004f, "4F", "% .0X"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0xfd07f692, "fd07f692", "%x"},
+ {__LINE__, 0xdb98bde0, "db98bde0", "%x"},
+ {__LINE__, 0x00000271, "0271", "% 3.4x"},
+ {__LINE__, -0x000115a, "-4442", "%#1.ld"},
+ {__LINE__, 0x0002f5f2, "194034", "%ld"},
+ {__LINE__, -0x0000152, " -338", "%+7ld"},
+ {__LINE__, 0x00059336, "365366", "%d"},
+ {__LINE__, 0xfffffff6, "fffffff6", "%-7x"},
+ {__LINE__, 0xfb916c51, "fb916c51", "%-x"},
+ {__LINE__, 0xffff413d, "FFFF413D", "%-X"},
+ {__LINE__, 0xf2576910, "F2576910", "%-4.X"},
+ {__LINE__, 0xfffc7730, "fffc7730", "%5.x"},
+ {__LINE__, 0x000002e6, "+742", "%+1d"},
+ {__LINE__, -0x00001bf, "-447", "%3d"},
+ {__LINE__, 0x000002e1, "2E1", "%-X"},
+ {__LINE__, 0x00000096, "150", "%#0ld"},
+ {__LINE__, 0x000002bd, "701", "%d"},
+ {__LINE__, -0x0053386, "-340870", "%#d"},
+ {__LINE__, 0xfffdb076, "FFFDB076", "%X"},
+ {__LINE__, 0x00004dc5, " +19909", "%+07.ld"},
+ {__LINE__, 0x00000f7a, " F7A", "%4X"},
+ {__LINE__, 0x02405000, " 37769216", "% ld"},
+ {__LINE__, 0xfffce68d, "fffce68d", "%0x"},
+ {__LINE__, -0x35b3af2, "-56310514", "%-ld"},
+ {__LINE__, -0x0238631, "-2328113", "%.4d"},
+ {__LINE__, -0x000001e, "-030", "%.3ld"},
+ {__LINE__, 0xffffffdd, "FFFFFFDD", "%.4X"},
+ {__LINE__, 0x0013f6ac, "13f6ac", "%02.x"},
+ {__LINE__, 0xfffffffa, "fffffffa", "%+07.x"},
+ {__LINE__, -0x000192b, " -6443", "%6.d"},
+ {__LINE__, 0x0000058b, "+1419", "%+d"},
+ {__LINE__, 0x00001391, "5009", "%ld"},
+ {__LINE__, -0x0041a57, "-268887", "%1ld"},
+ {__LINE__, -0x0041a57, "-268887", "%1ld"},
+ {__LINE__, 0xfffff266, "0xfffff266", "%+#6.6x"},
+ {__LINE__, 0x0000018b, " 395", "%6.ld"},
+ {__LINE__, 0x009ae24d, "+10150477", "%+ld"},
+ {__LINE__, 0x0000007e, "7E", "%X"},
+ {__LINE__, 0xfffffd53, "FFFFFD53", "% 0X"},
+ {__LINE__, 0x000002fa, "2FA", "%-1.3X"},
+ {__LINE__, 0x000000a4, "164", "%0d"},
+ {__LINE__, 0x00001833, "6195", "%ld"},
+ {__LINE__, -0x0000001, "-1", "%d"},
+ {__LINE__, 0xf2fcbd9b, "F2FCBD9B", "%+0.2X"},
+ {__LINE__, 0x00004a8a, "4A8A", "%X"},
+ {__LINE__, -0x10695cda, "-275340506", "%d"},
+ {__LINE__, 0x00000037, "37", "%X"},
+ {__LINE__, 0x00082d5c, "82D5C", "%+0.5X"},
+ {__LINE__, 0xfffffe01, "fffffe01", "% 5.3x"},
+ {__LINE__, 0x000005ea, "05EA", "% 1.4X"},
+ {__LINE__, 0x0e0b8826, "e0b8826", "%2x"},
+ {__LINE__, -0x0000161, "-353", "%+d"},
+ {__LINE__, 0x19e3014a, "19E3014A", "%+5X"},
+ {__LINE__, 0x00000140, "140", "%x"},
+ {__LINE__, 0xffff84b9, "FFFF84B9", "%X"},
+ {__LINE__, -0x0005776, "-22390", "%+5ld"},
+ {__LINE__, 0x0162ad61, "162AD61", "% X"},
+ {__LINE__, 0x00002395, "2395", "%X"},
+ {__LINE__, 0x003702ec, "3605228", "%5.2d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%7X"},
+ {__LINE__, 0x00001778, "0x1778", "%#5.x"},
+ {__LINE__, 0xc52bef7f, "C52BEF7F", "%X"},
+ {__LINE__, 0xfffffec4, "FFFFFEC4", "%X"},
+ {__LINE__, 0x00000006, "6", "%X"},
+ {__LINE__, 0x00000000, "000", "%03.3x"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0xffff6c46, "FFFF6C46", "% 2.2X"},
+ {__LINE__, -0x1506098, "-22044824", "%01.d"},
+ {__LINE__, 0x03415caf, "3415caf", "%x"},
+ {__LINE__, -0x00007b4, "-1972", "%#4.4d"},
+ {__LINE__, -0x00158c9, "-88265", "%03.4d"},
+ {__LINE__, 0x6947c336, "1766310710", "%.6d"},
+ {__LINE__, 0x0000017c, "17C", "% 0X"},
+ {__LINE__, -0x00001b7, "-439", "% 0ld"},
+ {__LINE__, 0x06a7575a, "6A7575A", "%-.0X"},
+ {__LINE__, 0x000b3459, "734297", "%ld"},
+ {__LINE__, -0x395d8dd, "-60152029", "%ld"},
+ {__LINE__, 0x00036bb3, "224179", "%-6.d"},
+ {__LINE__, 0xffff14ff, "FFFF14FF", "%X"},
+ {__LINE__, -0x15910e4f, "-361827919", "%-0d"},
+ {__LINE__, -0x0000004, "-4", "%#d"},
+ {__LINE__, 0xf7f7adac, "F7F7ADAC", "% 3.X"},
+ {__LINE__, 0xffffff74, "FFFFFF74", "%0X"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, -0x000007b, "-123 ", "%-7.d"},
+ {__LINE__, -0x000002c, "-44", "%d"},
+ {__LINE__, -0x000002b, " -43", "%5d"},
+ {__LINE__, 0x0000ae5f, "44639", "%d"},
+ {__LINE__, 0x003cbc63, "3CBC63", "%X"},
+ {__LINE__, 0xfffffffc, "0XFFFFFFFC", "%#5.7X"},
+ {__LINE__, 0x0003e044, "3E044", "%X"},
+ {__LINE__, -0x0000c46, "-3142", "%.1d"},
+ {__LINE__, 0xff18f4bb, "FF18F4BB", "%0X"},
+ {__LINE__, 0xfffffffd, "FFFFFFFD", "%.1X"},
+ {__LINE__, -0x01c0f27, "-1838887", "%0d"},
+ {__LINE__, -0x1242901f, "-306352159", "%.4ld"},
+ {__LINE__, 0x1775c10a, "393593098", "%6.ld"},
+ {__LINE__, 0x00000001, " 1", "%03.d"},
+ {__LINE__, 0xfff1fd30, "0xfff1fd30", "%#x"},
+ {__LINE__, 0x00000191, "191", "%0.X"},
+ {__LINE__, 0x2e597178, "777613688", "%2.ld"},
+ {__LINE__, -0x4ef0cf3, "-82775283", "%+.6ld"},
+ {__LINE__, -0x0000085, " -133", "%6.d"},
+ {__LINE__, 0x0000014d, "333 ", "%-5ld"},
+ {__LINE__, -0xc03bd74, "-201571700", "%07.6ld"},
+ {__LINE__, -0x000000a, "-10", "%d"},
+ {__LINE__, 0x01f5e86e, "32893038", "%#2.ld"},
+ {__LINE__, 0x00000033, "0X33", "% #X"},
+ {__LINE__, 0x0087c797, " 8898455", "% 7.d"},
+ {__LINE__, -0x0001205, "-4613", "%5d"},
+ {__LINE__, 0x00000192, " 192", "%7.X"},
+ {__LINE__, 0x000e6c00, "945152", "%6.1ld"},
+ {__LINE__, 0x00018629, " 99881", "% d"},
+ {__LINE__, -0x04739c6, "-4667846", "%-01.3ld"},
+ {__LINE__, 0x00001f42, "8002", "%d"},
+ {__LINE__, 0x00000caf, "3247", "%d"},
+ {__LINE__, -0x4992e24, "-77147684", "%#.6d"},
+ {__LINE__, 0x0000001d, "1d", "%-0x"},
+ {__LINE__, 0x14d79f03, "349675267", "%0ld"},
+ {__LINE__, 0x00000dd4, " 03540", "%#6.5ld"},
+ {__LINE__, 0x0005f30e, "0X5F30E", "%#X"},
+ {__LINE__, 0x00000157, "157", "%X"},
+ {__LINE__, -0x9281698, "-153622168", "%d"},
+ {__LINE__, -0x000004a, "-74", "%d"},
+ {__LINE__, -0x0010c9e, "-68766", "%-0d"},
+ {__LINE__, 0x00000059, "00089", "%.5ld"},
+ {__LINE__, -0x06959e3, "-6904291", "% 4.d"},
+ {__LINE__, 0xfbea12b1, "0XFBEA12B1", "%+#X"},
+ {__LINE__, 0xffffdfb1, "FFFFDFB1", "%2.6X"},
+ {__LINE__, 0x0434faac, "434faac", "%.5x"},
+ {__LINE__, 0xffffffff, "ffffffff", "% x"},
+ {__LINE__, 0x00000b32, "B32", "%0X"},
+ {__LINE__, 0x00000047, "71", "%.1d"},
+ {__LINE__, 0x00070bef, " 0461807", "% .7d"},
+ {__LINE__, 0x00000038, "38", "% 0x"},
+ {__LINE__, 0x00000000, " 0", "%6X"},
+ {__LINE__, 0xfff9c011, "FFF9C011", "%2X"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%7x"},
+ {__LINE__, 0xfffffff9, "FFFFFFF9", "%X"},
+ {__LINE__, -0x016a095, "-1482901", "%4.0ld"},
+ {__LINE__, -0x000001c, "-28", "% ld"},
+ {__LINE__, 0xfffd6133, "0xfffd6133", "%#x"},
+ {__LINE__, 0x000004a4, "0x4a4", "%#x"},
+ {__LINE__, 0x000003c2, "0962", "%.4d"},
+ {__LINE__, -0x000323b, "-12859", "%+#d"},
+ {__LINE__, 0x0f620237, "F620237", "%X"},
+ {__LINE__, 0x00007863, "007863", "%.6X"},
+ {__LINE__, 0x0000002c, " 44", "% #ld"},
+ {__LINE__, 0xfffffff0, "fffffff0", "%03.6x"},
+ {__LINE__, 0xffff6346, "FFFF6346", "%1.X"},
+ {__LINE__, 0x00063188, "63188", "% x"},
+ {__LINE__, 0xfffff91c, "fffff91c", "%-.3x"},
+ {__LINE__, 0x004cd0b4, "4CD0B4", "%-2.X"},
+ {__LINE__, 0x06b4d739, "112514873", "%0.1d"},
+ {__LINE__, -0x0009beb, "-39915", "%.2d"},
+ {__LINE__, 0x0000831b, "33563", "%d"},
+ {__LINE__, 0x00000001, "1", "%X"},
+ {__LINE__, -0x942d76b, "-155375467", "% #0ld"},
+ {__LINE__, 0xffff2a95, "FFFF2A95", "%2X"},
+ {__LINE__, 0x00548d5e, "5541214", "%.3ld"},
+ {__LINE__, 0x0b5e1a01, "B5E1A01", "% .7X"},
+ {__LINE__, 0xfffffc22, "fffffc22", "%6x"},
+ {__LINE__, -0x0000dd7, "-3543", "%-.3ld"},
+ {__LINE__, 0xfffff834, "FFFFF834", "%X"},
+ {__LINE__, 0x0365f762, "57014114", "%ld"},
+ {__LINE__, -0x0000003, "-3", "%d"},
+ {__LINE__, 0x3bd998a3, "1004116131", "%d"},
+ {__LINE__, 0xfffff6c9, "FFFFF6C9", "%+X"},
+ {__LINE__, 0xffffded9, "FFFFDED9", "%-.1X"},
+ {__LINE__, -0x00fbb5a, "-1031002", "% 1.0d"},
+ {__LINE__, 0xffffffb7, "ffffffb7", "%6.x"},
+ {__LINE__, 0xff1b8ac3, "FF1B8AC3", "%-X"},
+ {__LINE__, 0xfffffff2, "FFFFFFF2", "%00.X"},
+ {__LINE__, -0x000013d, " -317", "%05.d"},
+ {__LINE__, 0x0000f5e2, "+62946", "%+0.2ld"},
+ {__LINE__, 0x16ac6358, "16ac6358", "%x"},
+ {__LINE__, 0xffff8728, "FFFF8728", "%+X"},
+ {__LINE__, -0x0014a6d, "-084589", "%0.6ld"},
+ {__LINE__, 0xfc904514, "FC904514", "%+0X"},
+ {__LINE__, 0x00000004, "4", "%ld"},
+ {__LINE__, 0xffffffe0, "ffffffe0", "%+x"},
+ {__LINE__, -0x0a0ffdd, "-10551261", "%+02d"},
+ {__LINE__, -0x0000bbc, "-3004", "%+d"},
+ {__LINE__, 0x00000006, " +6", "%+7ld"},
+ {__LINE__, 0x17afa6e5, "397387493", "%ld"},
+ {__LINE__, 0xfffff6bf, "fffff6bf", "%+04.4x"},
+ {__LINE__, 0x000001dc, "01dc", "% 02.4x"},
+ {__LINE__, 0x0000000e, " 14", "% d"},
+ {__LINE__, 0xfffffff9, "0XFFFFFFF9", "%#4.X"},
+ {__LINE__, 0x0000005d, "93", "%0d"},
+ {__LINE__, -0x004fa05, "-0326149", "%.7d"},
+ {__LINE__, -0x0000018, "-24", "%ld"},
+ {__LINE__, 0xfffff7eb, "FFFFF7EB", "%X"},
+ {__LINE__, 0x0072b044, " 7516228", "% .7ld"},
+ {__LINE__, 0xffffffed, "0xffffffed", "%#x"},
+ {__LINE__, 0x0010364d, "10364D", "%X"},
+ {__LINE__, 0xfff90469, "0XFFF90469", "%#X"},
+ {__LINE__, 0x000001b4, " 436", "% 0d"},
+ {__LINE__, 0x00000000, "0", "% X"},
+ {__LINE__, 0xfffffff3, "fffffff3", "%x"},
+ {__LINE__, 0x19335d40, "19335d40", "%6x"},
+ {__LINE__, 0x00039c24, "236580", "%ld"},
+ {__LINE__, 0x000021f7, "8695", "%0.4ld"},
+ {__LINE__, -0x057b406, "-5747718", "%d"},
+ {__LINE__, -0x017b371, "-1553265", "%#ld"},
+ {__LINE__, 0x0003e405, "254981", "%2.d"},
+ {__LINE__, 0x00000001, "1", "%-.1x"},
+ {__LINE__, 0x000000ae, "AE", "%.1X"},
+ {__LINE__, 0xffd85825, "ffd85825", "%-7.x"},
+ {__LINE__, 0xfffad763, "fffad763", "%x"},
+ {__LINE__, 0x002431d4, "2372052", "%6.ld"},
+ {__LINE__, 0x00000003, "000003", "%-05.6d"},
+ {__LINE__, 0xffffffeb, "0xffffffeb", "%#x"},
+ {__LINE__, 0xff8cf3b0, "ff8cf3b0", "%x"},
+ {__LINE__, 0xfe88d2ff, "0xfe88d2ff", "%+#.2x"},
+ {__LINE__, 0xffffff6b, "ffffff6b", "%6.3x"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%-x"},
+ {__LINE__, 0xe998945a, "e998945a", "%2.x"},
+ {__LINE__, 0x03b9c50f, "3B9C50F", "%+X"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%3.7X"},
+ {__LINE__, 0x000024ef, "24ef", "%+x"},
+ {__LINE__, 0xfffffc04, "FFFFFC04", "%X"},
+ {__LINE__, 0x0d4bef7c, " 223080316", "% .1ld"},
+ {__LINE__, -0xc33f3bc, "-204731324", "%.5ld"},
+ {__LINE__, 0xffffffff, "0XFFFFFFFF", "%#2X"},
+ {__LINE__, 0x0000e493, "e493", "%x"},
+ {__LINE__, 0x000001b4, "1b4", "%x"},
+ {__LINE__, 0xffffffd6, "0xffffffd6", "% #1x"},
+ {__LINE__, 0x00000001, "1", "%d"},
+ {__LINE__, -0x0000f28, "-3880", "%ld"},
+ {__LINE__, 0x00000277, "631", "%-1ld"},
+ {__LINE__, 0x00000001, " 1", "%2x"},
+ {__LINE__, -0x0ff4d2c, "-16731436", "%#ld"},
+ {__LINE__, 0x0bb80344, "196608836", "%00ld"},
+ {__LINE__, 0xffffffdc, "FFFFFFDC", "%X"},
+ {__LINE__, 0x00000484, "1156", "%ld"},
+ {__LINE__, 0x00000341, "341", "%-.2x"},
+ {__LINE__, 0x0000ee62, "ee62", "%x"},
+ {__LINE__, 0xfffffe20, "fffffe20", "%+x"},
+ {__LINE__, -0x00076eb, "-30443", "%.2d"},
+ {__LINE__, 0x2c4a7407, "2c4a7407", "% x"},
+ {__LINE__, 0x00000000, " ", "%3.X"},
+ {__LINE__, 0xffffff60, "ffffff60", "% 4.x"},
+ {__LINE__, 0x000e4cf2, "+937202", "%+.5ld"},
+ {__LINE__, 0x00000008, " 00008", "%06.5X"},
+ {__LINE__, 0x0002f612, "194066", "%d"},
+ {__LINE__, 0xfffffc96, "fffffc96", "%-3.3x"},
+ {__LINE__, -0x0000001, "-1", "% ld"},
+ {__LINE__, 0x00000000, " ", "% 6.0X"},
+ {__LINE__, 0xfffffff5, "fffffff5", "%3.x"},
+ {__LINE__, 0x0bfd63a1, "201155489", "%d"},
+ {__LINE__, -0x1547c214, "-357024276", "%ld"},
+ {__LINE__, 0x00000004, "4", "%#0.d"},
+ {__LINE__, -0x000f2f3, "-62195", "%.2d"},
+ {__LINE__, 0xfff843dd, "FFF843DD", "%X"},
+ {__LINE__, 0x00966e36, "9858614", "%.0ld"},
+ {__LINE__, 0x0000782e, "0X782E", "% #X"},
+ {__LINE__, 0x00bd36c0, "12400320", "%ld"},
+ {__LINE__, 0x00000000, "00", "% .2X"},
+ {__LINE__, 0x00000000, "0", "%1X"},
+ {__LINE__, 0x0003f416, "3f416 ", "%-6.x"},
+ {__LINE__, -0x00b74bd, "-750781", "% ld"},
+ {__LINE__, 0x0000138a, "138a", "% x"},
+ {__LINE__, 0x024df7f0, "24DF7F0", "% 0.6X"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%X"},
+ {__LINE__, -0x0003284, "-12932 ", "%-07.ld"},
+ {__LINE__, 0x000094d3, "94d3", "%x"},
+ {__LINE__, 0x000000bf, "bf", "%.2x"},
+ {__LINE__, 0x00000000, "00000", "%-1.5X"},
+ {__LINE__, -0x04899b8, "-4757944", "%d"},
+ {__LINE__, 0x2b51bf20, "+726777632", "%+d"},
+ {__LINE__, -0x000000d, "-13", "%.2d"},
+ {__LINE__, 0x04f78fbd, "4F78FBD", "% 7.X"},
+ {__LINE__, 0x00011684, "71300", "%5.d"},
+ {__LINE__, 0x0000539d, "21405", "%0d"},
+ {__LINE__, 0x00000008, "000008", "%-3.6X"},
+ {__LINE__, 0xfc7a2cdc, "fc7a2cdc", "%2.3x"},
+ {__LINE__, 0xffc21da1, "ffc21da1", "%x"},
+ {__LINE__, 0x00000273, "273", "%x"},
+ {__LINE__, 0x00000000, "0", "%#X"},
+ {__LINE__, -0x31cd6b9, "-52221625", "% d"},
+ {__LINE__, 0xfffffff8, "FFFFFFF8", "%.0X"},
+ {__LINE__, 0x00000002, "2", "%#ld"},
+ {__LINE__, 0x00e8922c, "15241772", "%d"},
+ {__LINE__, 0xfeb19ea7, "FEB19EA7", "%0.1X"},
+ {__LINE__, 0x00003931, "014641", "%06ld"},
+ {__LINE__, 0x00000015, "0X00015", "%#.5X"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%1.X"},
+ {__LINE__, 0xfff17103, "0XFFF17103", "% #X"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%+X"},
+ {__LINE__, 0x00000002, "00002", "%.5x"},
+ {__LINE__, 0x00001617, " 5655", "% 7.d"},
+ {__LINE__, -0x0000010, "-000016", "%00.6d"},
+ {__LINE__, 0x000000b0, "B0", "% X"},
+ {__LINE__, 0xfc9362b2, "FC9362B2", "%-X"},
+ {__LINE__, 0xfc3d8276, "fc3d8276", "% 1x"},
+ {__LINE__, 0x00001405, "5125", "%#d"},
+ {__LINE__, 0x02250183, " 35979651", "% ld"},
+ {__LINE__, 0xffc9b007, "ffc9b007", "% 4.x"},
+ {__LINE__, 0x00000311, "785", "%0d"},
+ {__LINE__, 0x0004d273, " 316019", "% d"},
+ {__LINE__, 0x00000001, "1", "%1.x"},
+ {__LINE__, 0xffff240f, "FFFF240F", "%4.X"},
+ {__LINE__, 0x0049cfda, "+4837338", "%+ld"},
+ {__LINE__, 0x012f6dd5, "12F6DD5", "% 6.2X"},
+ {__LINE__, 0x00000002, "0x2", "%#2.0x"},
+ {__LINE__, 0xfffd834a, "FFFD834A", "%.6X"},
+ {__LINE__, 0xfe2a40f8, "0XFE2A40F8", "%#X"},
+ {__LINE__, 0xffffffeb, "ffffffeb", "%x"},
+ {__LINE__, -0x00ac5cb, "-705995", "%d"},
+ {__LINE__, -0x3021108c, "-807473292", "% .4d"},
+ {__LINE__, -0x0000035, "-53", "%-ld"},
+ {__LINE__, -0x1a36475, "-27485301", "% d"},
+ {__LINE__, -0x0000011, "-17", "%d"},
+ {__LINE__, 0x000001a3, "000419", "%.6ld"},
+ {__LINE__, 0x0030a0a8, "3186856", "%.5ld"},
+ {__LINE__, 0x00000019, "25", "%d"},
+ {__LINE__, 0xf32deac1, "F32DEAC1", "%06.2X"},
+ {__LINE__, -0x0000004, " -00004", "%7.5ld"},
+ {__LINE__, 0x00000000, "0", "%ld"},
+ {__LINE__, 0x0006bf19, "442137", "%#0.d"},
+ {__LINE__, 0x566f6c44, "1450142788", "%1.6d"},
+ {__LINE__, 0xfffffc10, "fffffc10", "%.2x"},
+ {__LINE__, -0x000e04d, "-57421", "%+0d"},
+ {__LINE__, 0x00000000, "0000000", "%+.7X"},
+ {__LINE__, 0x00b5c74d, " 11913037", "% ld"},
+ {__LINE__, -0x028dfe2, "-2678754", "%05.1d"},
+ {__LINE__, 0xfffffee0, "fffffee0", "%0x"},
+ {__LINE__, -0x030c077, "-3194999", "%-.6d"},
+ {__LINE__, 0x00055ca1, "055ca1", "%-.6x"},
+ {__LINE__, 0x00000000, " ", "%7.X"},
+ {__LINE__, 0xfffffe3b, "FFFFFE3B", "%X"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "% 3X"},
+ {__LINE__, 0x00000857, "2135", "%-#1.d"},
+ {__LINE__, -0x00546a2, "-345762", "%0.5d"},
+ {__LINE__, 0x0000000b, "0xb ", "%-#6x"},
+ {__LINE__, 0x00000d2b, "d2b ", "%-4.0x"},
+ {__LINE__, 0x0ae02b9e, "AE02B9E", "%X"},
+ {__LINE__, 0xfffffa7b, "fffffa7b", "%-2.x"},
+ {__LINE__, 0x00000001, "1", "%X"},
+ {__LINE__, 0x000006ad, "01709", "%05.5ld"},
+ {__LINE__, -0x0000102, "-258", "%-0.ld"},
+ {__LINE__, 0x00000000, "0", "%.1X"},
+ {__LINE__, -0x01daa95, "-1944213", "%-1ld"},
+ {__LINE__, 0x02b99040, "2B99040", "%2.X"},
+ {__LINE__, 0x1b3d5621, "1B3D5621", "%X"},
+ {__LINE__, 0x0312d16b, "51564907", "%-1.7ld"},
+ {__LINE__, 0x000aa76c, " 698220", "% 2d"},
+ {__LINE__, 0x00000000, "0", "%ld"},
+ {__LINE__, 0xfff8a4ec, "FFF8A4EC", "%-X"},
+ {__LINE__, 0xffffe06d, "ffffe06d", "%x"},
+ {__LINE__, 0x00000003, "3", "% x"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0xd3e244dd, "D3E244DD", "%+5X"},
+ {__LINE__, 0x000028b3, " 28b3", "% 5.x"},
+ {__LINE__, 0x0001aceb, "109803", "%6d"},
+ {__LINE__, 0xfffbc5ca, "0xfffbc5ca", "%-#5x"},
+ {__LINE__, 0x00000097, " 151", "% 7ld"},
+ {__LINE__, 0x00001fcc, "+8140", "%+d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%0x"},
+ {__LINE__, -0x00052a9, "-21161", "%ld"},
+ {__LINE__, 0xfffffc76, "FFFFFC76", "%.1X"},
+ {__LINE__, -0x2acb012, "-44871698", "%0.1ld"},
+ {__LINE__, 0xffffff81, "ffffff81", "%x"},
+ {__LINE__, -0x0018394, "-99220", "%-ld"},
+ {__LINE__, 0x0000001b, "1B", "%X"},
+ {__LINE__, 0x00000033, "51", "%1d"},
+ {__LINE__, 0xffec37e5, "FFEC37E5", "%-1X"},
+ {__LINE__, -0x000000a, " -10", "%#5.d"},
+ {__LINE__, -0x0000412, "-1042", "%ld"},
+ {__LINE__, 0x000cd0b1, "cd0b1 ", "%-7.5x"},
+ {__LINE__, 0x0b445370, "B445370", "%+2.0X"},
+ {__LINE__, 0xfffffff3, "0XFFFFFFF3", "%-#X"},
+ {__LINE__, 0xffff9f33, "FFFF9F33", "%5.X"},
+ {__LINE__, 0x00010a1e, "10A1E", "%-2X"},
+ {__LINE__, -0xede156f, "-249435503", "% 7.1ld"},
+ {__LINE__, 0xfc6d63aa, "fc6d63aa", "% .6x"},
+ {__LINE__, 0x0000311c, " 12572", "% ld"},
+ {__LINE__, 0x00001f8a, "8074", "%00.d"},
+ {__LINE__, 0x00000199, "199", "%-X"},
+ {__LINE__, 0xfffffc60, "FFFFFC60", "%+3X"},
+ {__LINE__, -0x000022c, "-556", "%+0ld"},
+ {__LINE__, 0x021d8407, "35488775", "%-#.7ld"},
+ {__LINE__, 0x0000020f, "527", "%d"},
+ {__LINE__, -0x000064b, "-1611", "%#ld"},
+ {__LINE__, -0x0c15aef, "-12671727", "%d"},
+ {__LINE__, -0x1f1a6881, "-521824385", "%ld"},
+ {__LINE__, 0xffffc115, "ffffc115", "% x"},
+ {__LINE__, 0x00000017, " 23", "% #ld"},
+ {__LINE__, 0x00000dc1, "DC1 ", "%-4X"},
+ {__LINE__, 0x000002ca, "2CA", "%X"},
+ {__LINE__, 0x000f052c, " 984364", "%7.d"},
+ {__LINE__, 0x0000005a, "0090", "%0.4d"},
+ {__LINE__, -0x001e463, "-124003", "% 4.ld"},
+ {__LINE__, 0x00000001, "0000001", "%+.7X"},
+ {__LINE__, 0x00000bfb, "0000bfb", "%5.7x"},
+ {__LINE__, 0x0002484b, "149579", "%#1d"},
+ {__LINE__, 0x0043ba18, "4438552", "%-ld"},
+ {__LINE__, 0x000078f8, "0X78F8", "%#X"},
+ {__LINE__, 0x00000001, " 1", "%4d"},
+ {__LINE__, 0x0cedaeed, "CEDAEED", "%X"},
+ {__LINE__, 0x00000003, "+3", "%+ld"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "%7.4X"},
+ {__LINE__, 0x00000169, "361", "%ld"},
+ {__LINE__, 0x00003c7a, "+15482", "%+ld"},
+ {__LINE__, -0x0159d93, "-1416595", "% 0.0d"},
+ {__LINE__, 0x0000775c, "+30556", "%+3.d"},
+ {__LINE__, 0x10284768, "+271075176", "%+0.0ld"},
+ {__LINE__, -0xf8b610e, "-260792590", "%0d"},
+ {__LINE__, 0xfdd8d369, "fdd8d369", "%-.3x"},
+ {__LINE__, 0x000c9495, "+824469", "%+ld"},
+ {__LINE__, -0x000003f, " -063", "%7.3d"},
+ {__LINE__, -0x000073b, "-1851", "%+03.ld"},
+ {__LINE__, 0xfffe4e23, "0xfffe4e23", "%#.5x"},
+ {__LINE__, 0x0081788c, "81788c", "%5x"},
+ {__LINE__, -0x015f888, "-1439880", "%+1d"},
+ {__LINE__, -0x31d64b4, "-52257972", "%0.2d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%6.5X"},
+ {__LINE__, -0x0000072, "-114", "%+.1d"},
+ {__LINE__, -0x00000e1, "-225", "%ld"},
+ {__LINE__, 0x000006a8, "0x6a8", "%+#x"},
+ {__LINE__, 0xfffe673a, "fffe673a", "%01.x"},
+ {__LINE__, 0xfff2ee0d, "FFF2EE0D", "%-X"},
+ {__LINE__, 0x0290320a, "43004426", "%0ld"},
+ {__LINE__, -0xeb7a832, "-246917170", "% ld"},
+ {__LINE__, 0x02ae9265, "2ae9265", "%1.x"},
+ {__LINE__, 0xffffffd2, "ffffffd2", "%+2.x"},
+ {__LINE__, 0x00e6e858, "0xe6e858", "%#0.x"},
+ {__LINE__, 0x00000c4a, "+3146", "%+3.1d"},
+ {__LINE__, -0x6943c1a, "-110378010", "% 0ld"},
+ {__LINE__, 0x0167b119, "167b119", "%0x"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%+x"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%X"},
+ {__LINE__, 0x000b861e, "755230", "%ld"},
+ {__LINE__, 0x0000015b, "347", "%-#ld"},
+ {__LINE__, 0xfffffffa, "0XFFFFFFFA", "%#X"},
+ {__LINE__, 0x000de9e5, "911845", "%d"},
+ {__LINE__, 0x00000001, "01", "%.2d"},
+ {__LINE__, 0x000007a5, "1957", "%0d"},
+ {__LINE__, 0x0000000f, "f", "%x"},
+ {__LINE__, 0x00c38cbf, " 12815551", "% .2d"},
+ {__LINE__, -0x7bd1b6e, "-129833838", "% d"},
+ {__LINE__, -0x000013c, "-316", "%0d"},
+ {__LINE__, 0x00001aad, "1AAD", "%-0X"},
+ {__LINE__, 0x0034f903, "3471619", "%00d"},
+ {__LINE__, 0xff925717, "ff925717", "%4x"},
+ {__LINE__, 0x00000002, "02", "%.2d"},
+ {__LINE__, 0x00000f34, "F34", "%+X"},
+ {__LINE__, 0xffffeefe, "FFFFEEFE", "%X"},
+ {__LINE__, 0xfffeecb4, "FFFEECB4", "% 2.X"},
+ {__LINE__, 0x00034421, "214049", "%0ld"},
+ {__LINE__, 0x00000000, " 0", "%+6X"},
+ {__LINE__, -0x0000062, "-98", "%-#2d"},
+ {__LINE__, -0x0000557, "-1367", "%-4.4d"},
+ {__LINE__, 0xffffe17c, "FFFFE17C", "%X"},
+ {__LINE__, 0x00000097, "00097", "%.5X"},
+ {__LINE__, 0xfffcb278, "FFFCB278", "%0.7X"},
+ {__LINE__, -0x0000001, "-0001 ", "%-7.4d"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, 0x000002c4, "708", "%d"},
+ {__LINE__, 0x04946f45, "4946F45", "%-2.X"},
+ {__LINE__, 0x000000ff, "00ff", "% 2.4x"},
+ {__LINE__, 0x00073307, "471815", "%3ld"},
+ {__LINE__, 0x0085b7b6, "+8763318", "%+ld"},
+ {__LINE__, -0x0000002, "-2", "%1ld"},
+ {__LINE__, -0x0000001, "-1", "%-2d"},
+ {__LINE__, -0x00000b5, " -181", "%7ld"},
+ {__LINE__, -0x0412486, "-4269190", "%+2.1ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%0x"},
+ {__LINE__, 0x0000006d, "6d", "%x"},
+ {__LINE__, 0x000000da, "218", "%-.3ld"},
+ {__LINE__, 0xfffffcfe, "fffffcfe", "%x"},
+ {__LINE__, 0x652e60c7, "652E60C7", "%7.7X"},
+ {__LINE__, 0x00000035, " 53", "% #2d"},
+ {__LINE__, 0x000000fc, "FC", "%-X"},
+ {__LINE__, 0x00000019, " 25", "% ld"},
+ {__LINE__, 0xfffffcf4, "fffffcf4", "%6x"},
+ {__LINE__, 0xffffff41, "ffffff41", "%x"},
+ {__LINE__, 0x00000034, " 52", "%3.ld"},
+ {__LINE__, 0xffffffb2, "ffffffb2", "%-x"},
+ {__LINE__, -0x6dc43e7c, "-1841577596", "% .2ld"},
+ {__LINE__, 0x00000004, "4", "%d"},
+ {__LINE__, -0x000023b, "-571", "%ld"},
+ {__LINE__, -0x000004d, "-77", "%ld"},
+ {__LINE__, 0x0000e3ba, "58298", "%.0ld"},
+ {__LINE__, 0xfffffff2, "fffffff2", "%0.0x"},
+ {__LINE__, -0x0000020, "-32", "%ld"},
+ {__LINE__, 0xffffb33e, "0XFFFFB33E", "%-#X"},
+ {__LINE__, 0x00000000, " ", "% 4.x"},
+ {__LINE__, 0xffd96f92, "FFD96F92", "%X"},
+ {__LINE__, 0x0000002e, " 46", "% 0ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, -0x5008ba3, "-83921827", "%+d"},
+ {__LINE__, 0xfdc1df3d, "FDC1DF3D", "%0X"},
+ {__LINE__, 0xfc7410e5, "fc7410e5", "%7x"},
+ {__LINE__, 0xfffffffa, "FFFFFFFA", "% 6.X"},
+ {__LINE__, 0x00000000, "0", "%X"},
+ {__LINE__, -0x040fd4e, "-4259150", "% 05.d"},
+ {__LINE__, 0x0000003b, " 59", "%3.2d"},
+ {__LINE__, 0xff776dd8, "ff776dd8", "%x"},
+ {__LINE__, 0x0000055b, "+1371", "%+#2d"},
+ {__LINE__, 0x00004841, "4841", "%.1x"},
+ {__LINE__, 0x0229d710, "36296464", "%-.2ld"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0xfffe8376, "fffe8376", "%0x"},
+ {__LINE__, 0x000a7b83, "a7b83", "%x"},
+ {__LINE__, 0x0000000d, " 013", "%#7.3d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%5.0X"},
+ {__LINE__, 0x00000704, " 0x704", "%#7.0x"},
+ {__LINE__, 0xfff970b9, "FFF970B9", "%.1X"},
+ {__LINE__, -0x000b60a, "-46602", "%+d"},
+ {__LINE__, 0x00000000, " 00000", "%6.5x"},
+ {__LINE__, 0x00000003, "3", "%X"},
+ {__LINE__, 0x0000c14b, "c14b", "%0x"},
+ {__LINE__, 0x066d7860, "107837536", "%-d"},
+ {__LINE__, 0x00000013, " 13", "%4.x"},
+ {__LINE__, 0xfff96f18, "FFF96F18", "%4X"},
+ {__LINE__, 0xffffff30, "FFFFFF30", "%X"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "% .7X"},
+ {__LINE__, -0x72a9e985, "-1923737989", "%2.d"},
+ {__LINE__, 0x00000002, "0x2", "%#x"},
+ {__LINE__, 0x0000050e, "50e", "%2.3x"},
+ {__LINE__, 0x0000605c, "24668", "%4.1d"},
+ {__LINE__, 0xffffff3e, "ffffff3e", "%x"},
+ {__LINE__, -0x0000010, "-16", "%-2d"},
+ {__LINE__, 0x000061aa, "61AA", "%X"},
+ {__LINE__, 0x000c2ec3, "C2EC3", "%0X"},
+ {__LINE__, -0x0000001, "-1", "%-0d"},
+ {__LINE__, 0x00130e17, "+1248791", "%+.6ld"},
+ {__LINE__, 0x000000ef, "EF", "%-X"},
+ {__LINE__, -0x0000001, " -1", "%+5ld"},
+ {__LINE__, 0x0000989d, "39069", "%d"},
+ {__LINE__, 0x00000000, "0", "%-x"},
+ {__LINE__, 0x00000417, "417", "%X"},
+ {__LINE__, 0x00005e86, "5E86", "%+X"},
+ {__LINE__, -0x0007c08, "-31752", "%ld"},
+ {__LINE__, 0x00da8e0f, "DA8E0F", "%2.2X"},
+ {__LINE__, -0x3ee095ec, "-1054905836", "% 0d"},
+ {__LINE__, 0xfffdb5a3, "fffdb5a3", "%x"},
+ {__LINE__, 0xffffff83, "FFFFFF83", "%X"},
+ {__LINE__, 0xfff8efd7, "0xfff8efd7", "%#x"},
+ {__LINE__, 0x00000020, " 32", "% d"},
+ {__LINE__, 0xfff7c002, "fff7c002", "%.7x"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, 0x00000000, " 000", "%05.3X"},
+ {__LINE__, 0xfff190ee, "FFF190EE", "%X"},
+ {__LINE__, 0x00000a6c, " 2668", "%#6.ld"},
+ {__LINE__, 0x00037024, "37024", "%x"},
+ {__LINE__, 0xfffec37f, "FFFEC37F", "%X"},
+ {__LINE__, 0x007ee9bb, "8317371", "%#0.ld"},
+ {__LINE__, 0x00000122, "290", "%ld"},
+ {__LINE__, -0x0013b5f, "-80735", "%ld"},
+ {__LINE__, 0xfffffff6, "FFFFFFF6", "%X"},
+ {__LINE__, -0x0000c16, "-0003094", "%-00.7d"},
+ {__LINE__, -0x00010ed, "-4333", "%ld"},
+ {__LINE__, 0x00000007, " 0X007", "%#6.3X"},
+ {__LINE__, 0x0053781e, " 5470238", "% 2d"},
+ {__LINE__, 0xffff03e9, "0XFFFF03E9", "%+#7.3X"},
+ {__LINE__, 0xfffffdc2, "0xfffffdc2", "% #4.x"},
+ {__LINE__, -0x00018e1, "-6369", "%d"},
+ {__LINE__, 0xf3a4abc6, "F3A4ABC6", "%-.2X"},
+ {__LINE__, 0xfff64a27, "FFF64A27", "%7.7X"},
+ {__LINE__, 0x00195ae5, "195AE5", "%+03.X"},
+ {__LINE__, 0xfff8849a, "fff8849a", "%.1x"},
+ {__LINE__, -0x001b045, "-110661", "%+ld"},
+ {__LINE__, 0x01e8a106, "32022790", "%7.ld"},
+ {__LINE__, 0x0008ee94, "8EE94", "%X"},
+ {__LINE__, 0xfffcdabc, "FFFCDABC", "%X"},
+ {__LINE__, 0xfda75cd2, "fda75cd2", "%x"},
+ {__LINE__, 0x00fd505a, "fd505a", "%x"},
+ {__LINE__, 0x00003748, "3748", "%+x"},
+ {__LINE__, 0xffffffe5, "ffffffe5", "% 3.6x"},
+ {__LINE__, -0x1d1c4045, "-488390725", "%d"},
+ {__LINE__, 0xfffffff9, "0xfffffff9", "%#x"},
+ {__LINE__, -0x0000001, "-1", "%-#ld"},
+ {__LINE__, 0x00000191, "191", "%X"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%-X"},
+ {__LINE__, -0x0000006, "-6", "%ld"},
+ {__LINE__, 0x00000033, " 33", "% 4x"},
+ {__LINE__, -0x0159a14, "-1415700", "% ld"},
+ {__LINE__, 0x000001c3, "00001c3", "%07x"},
+ {__LINE__, 0xffffe9e2, "ffffe9e2", "%-x"},
+ {__LINE__, 0x5b19abd9, "0x5b19abd9", "%-#x"},
+ {__LINE__, 0xffff1bae, "0xffff1bae", "%#x"},
+ {__LINE__, 0x00000001, "+1", "%+d"},
+ {__LINE__, 0x006a23c7, "6A23C7", "%2.X"},
+ {__LINE__, 0x000008a4, " 8a4", "% 4.1x"},
+ {__LINE__, 0xfffffcd9, "fffffcd9", "%.1x"},
+ {__LINE__, 0x0000121b, "121B", "%X"},
+ {__LINE__, 0x001231aa, "1192362", "%7.d"},
+ {__LINE__, -0x008026d, "-524909", "%4.2d"},
+ {__LINE__, 0x192ea594, "422487444", "%ld"},
+ {__LINE__, 0x0001a800, "108544", "%0d"},
+ {__LINE__, 0x000062f1, "62f1", "%.4x"},
+ {__LINE__, 0xff8b39b0, "ff8b39b0", "% x"},
+ {__LINE__, 0x00000001, "0x1", "%+#x"},
+ {__LINE__, 0x0000144a, "5194", "%ld"},
+ {__LINE__, 0x00002599, "9625", "%d"},
+ {__LINE__, 0xffa0a2ef, "ffa0a2ef", "%0x"},
+ {__LINE__, 0xff6712e1, "FF6712E1", "%0X"},
+ {__LINE__, 0x0007ebb3, "519091", "%1ld"},
+ {__LINE__, 0x0000000f, "15 ", "%-4.ld"},
+ {__LINE__, -0x0000096, "-150", "%2.ld"},
+ {__LINE__, 0x0000004f, "4F", "%.2X"},
+ {__LINE__, 0xfffffc29, "fffffc29", "%-4.x"},
+ {__LINE__, 0x00000019, "19", "%x"},
+ {__LINE__, 0x00000c4e, "c4e", "%x"},
+ {__LINE__, 0x0000006b, " 0006B", "%6.5X"},
+ {__LINE__, 0x00c8d2c6, "c8d2c6", "%.0x"},
+ {__LINE__, -0x256fb8de, "-628078814", "%ld"},
+ {__LINE__, 0x4f51fcf4, "4F51FCF4", "%+X"},
+ {__LINE__, 0x000f000e, "983054", "%1.ld"},
+ {__LINE__, 0xfffff03f, "fffff03f", "%x"},
+ {__LINE__, 0x0000001d, " 1D", "%05.X"},
+ {__LINE__, 0x0072ea14, "72ea14", "%x"},
+ {__LINE__, -0xc6098b9, "-207657145", "%-7d"},
+ {__LINE__, 0x00000a76, "2678", "%3ld"},
+ {__LINE__, 0xfff84db3, "FFF84DB3", "%X"},
+ {__LINE__, 0x0fb52870, "fb52870", "%+x"},
+ {__LINE__, 0x08bc170a, "0x8bc170a", "%#x"},
+ {__LINE__, 0xfffeeb00, "fffeeb00", "%0.5x"},
+ {__LINE__, 0x000ece95, "970389", "%d"},
+ {__LINE__, 0x00000000, "0", "%0X"},
+ {__LINE__, 0x07f98e8a, "7f98e8a", "% x"},
+ {__LINE__, 0x000499eb, " 499eb", "% 6.x"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%-X"},
+ {__LINE__, 0x0aa45e86, "178544262", "%#.2d"},
+ {__LINE__, 0xff73387d, "FF73387D", "%03.X"},
+ {__LINE__, 0xfffffb51, "FFFFFB51", "%.3X"},
+ {__LINE__, 0xffffffdc, "ffffffdc", "%6.x"},
+ {__LINE__, 0xffffffed, "FFFFFFED", "%-X"},
+ {__LINE__, 0x0001c4c2, "1c4c2", "%0.3x"},
+ {__LINE__, -0x0000001, "-0000001", "%-#.7d"},
+ {__LINE__, 0x00000007, "7", "%0.x"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, 0xffffd000, "ffffd000", "%4.3x"},
+ {__LINE__, 0x00000030, "48", "%2.d"},
+ {__LINE__, -0x6c121ce, "-113320398", "%.5ld"},
+ {__LINE__, 0x000001ed, "1ED", "% 3.X"},
+ {__LINE__, 0xfffff0f3, "FFFFF0F3", "%+.6X"},
+ {__LINE__, 0xffffffec, "ffffffec", "%x"},
+ {__LINE__, 0x002d5ab8, "0x2d5ab8", "%-#x"},
+ {__LINE__, 0x0026acff, "2534655", "%0ld"},
+ {__LINE__, 0x01d90cd7, "+31001815", "%+.2ld"},
+ {__LINE__, -0x1f7abc0, "-33008576", "%7.6d"},
+ {__LINE__, 0xfc5babcc, "fc5babcc", "%x"},
+ {__LINE__, -0x9b74892, "-163006610", "% .6d"},
+ {__LINE__, 0x03931d84, "59972996", "%0.d"},
+ {__LINE__, 0x07d261ce, "131228110", "%#ld"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0x00000002, "2", "%+X"},
+ {__LINE__, -0x0000604, "-1540", "%+d"},
+ {__LINE__, 0x00000000, " ", "%7.x"},
+ {__LINE__, 0x00000001, "1", "%.0X"},
+ {__LINE__, -0x0005a8e, "-23182", "% d"},
+ {__LINE__, 0x03fb2730, "3fb2730", "%7.x"},
+ {__LINE__, 0xffffff03, "ffffff03", "%x"},
+ {__LINE__, 0x00000000, " ", "%-#3.d"},
+ {__LINE__, 0x04025a4b, "0X4025A4B", "%+#X"},
+ {__LINE__, -0x0000001, " -1", "%4.d"},
+ {__LINE__, 0xfffe00a3, "FFFE00A3", "%+X"},
+ {__LINE__, -0x1b26e3c8, "-455533512", "% ld"},
+ {__LINE__, 0x000017e5, "6117", "%d"},
+ {__LINE__, -0x0e4f3b6, "-15004598", "%0ld"},
+ {__LINE__, 0x00000034, "52", "%ld"},
+ {__LINE__, 0x0000024c, " 24C", "%4X"},
+ {__LINE__, 0xfffedf65, "FFFEDF65", "%-0X"},
+ {__LINE__, -0x000ff1f, "-65311", "%+#d"},
+ {__LINE__, 0x00000007, " 7", "%7.x"},
+ {__LINE__, 0x018656ae, "18656ae", "%3.7x"},
+ {__LINE__, -0x0000004, "-4", "%d"},
+ {__LINE__, 0x7081292d, "1887512877", "%d"},
+ {__LINE__, 0x87d3e48c, "87d3e48c", "%-x"},
+ {__LINE__, 0xf99c516e, "0xf99c516e", "% #7.4x"},
+ {__LINE__, 0xfffffffa, "FFFFFFFA", "%-1X"},
+ {__LINE__, -0x000001d, "-29", "%#ld"},
+ {__LINE__, -0x0000001, "-1", "%+ld"},
+ {__LINE__, 0x28ab3350, " 682308432", "% 1d"},
+ {__LINE__, -0x0000006, "-6", "%ld"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "%.5X"},
+ {__LINE__, -0x0000007, "-7", "%#d"},
+ {__LINE__, -0x0000328, " -808", "%6.ld"},
+ {__LINE__, -0x29386f00, "-691564288", "%.3d"},
+ {__LINE__, -0x059f38a, "-5895050", "%.4ld"},
+ {__LINE__, 0xfffff888, "FFFFF888", "%3X"},
+ {__LINE__, 0xffffffdf, "ffffffdf", "%0.0x"},
+ {__LINE__, -0xb4fc354, "-189776724", "%2d"},
+ {__LINE__, 0x00058c07, "363527", "%1.d"},
+ {__LINE__, 0x0a256162, "a256162", "%x"},
+ {__LINE__, -0x05c87b0, "-6064048", "%0ld"},
+ {__LINE__, 0xfffffda1, "fffffda1", "%x"},
+ {__LINE__, 0x000034b7, "13495", "%d"},
+ {__LINE__, -0x6d1a8918, "-1830455576", "%.1d"},
+ {__LINE__, 0x00022290, "139920", "%05ld"},
+ {__LINE__, 0x00000000, "0", "%-x"},
+ {__LINE__, -0x1f8eafce, "-529444814", "%4.d"},
+ {__LINE__, -0x7bf32808, "-2079533064", "% ld"},
+ {__LINE__, 0x0000023c, "23c", "% x"},
+ {__LINE__, 0x00000039, "39", "%X"},
+ {__LINE__, -0x000556d, "-21869", "%ld"},
+ {__LINE__, -0x00000ca, "-202", "%ld"},
+ {__LINE__, 0x00002e28, "11816", "%-d"},
+ {__LINE__, 0x00000011, "17", "%-ld"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "%-X"},
+ {__LINE__, 0xfffdd67f, "0XFFFDD67F", "%#X"},
+ {__LINE__, -0x000003d, "-61", "%d"},
+ {__LINE__, 0x0000bfce, "0XBFCE", "%-#5.2X"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%x"},
+ {__LINE__, -0x00aea17, "-715287", "%.5d"},
+ {__LINE__, -0x02fce89, "-3133065", "%0d"},
+ {__LINE__, 0x007f6ed1, "7F6ED1", "%6X"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%X"},
+ {__LINE__, -0x0002761, "-10081", "%#6.2d"},
+ {__LINE__, 0x003be8d8, "3BE8D8", "%-X"},
+ {__LINE__, 0x00000901, " 2305", "%6.d"},
+ {__LINE__, 0x00049916, "0301334", "%3.7ld"},
+ {__LINE__, 0x0678ffea, "0X678FFEA", "%#4X"},
+ {__LINE__, 0xffffffff, "ffffffff", "%+.0x"},
+ {__LINE__, -0x31d2ec61, "-835906657", "%.0d"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%0X"},
+ {__LINE__, -0x0015588, "-87432", "%d"},
+ {__LINE__, 0xffffff3e, "ffffff3e", "%.4x"},
+ {__LINE__, 0x0000000a, "10", "%d"},
+ {__LINE__, -0x0000003, "-3", "%2.1ld"},
+ {__LINE__, -0x000d29a, "-53914", "%ld"},
+ {__LINE__, -0x04ccbe0, "-5032928", "%2.2ld"},
+ {__LINE__, 0x0357c2a5, "357c2a5", "% 7.x"},
+ {__LINE__, 0x00000009, " 9", "% 1.ld"},
+ {__LINE__, -0x005908d, "-364685", "%0d"},
+ {__LINE__, -0x0000de6, "-3558", "%0ld"},
+ {__LINE__, 0x2d395e6b, "+758734443", "%+6d"},
+ {__LINE__, 0x001aba58, "1ABA58", "% X"},
+ {__LINE__, 0x0ceba5ab, "0XCEBA5AB", "%#.1X"},
+ {__LINE__, -0x01a8575, "-1738101", "% 2ld"},
+ {__LINE__, 0x0000000d, "13", "%#ld"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, 0x4b856407, "4b856407", "%5x"},
+ {__LINE__, 0x006f333c, "6F333C", "%-X"},
+ {__LINE__, 0x000000d0, "d0", "%x"},
+ {__LINE__, 0x2ecf0d4e, "2ecf0d4e", "%0x"},
+ {__LINE__, -0x0000188, "-0000392", "%#1.7ld"},
+ {__LINE__, -0x0000037, "-55", "%d"},
+ {__LINE__, 0xfffffff1, "FFFFFFF1", "% .1X"},
+ {__LINE__, 0x00000001, "0x1", "%#3x"},
+ {__LINE__, 0x000005ed, "5ED", "%3X"},
+ {__LINE__, 0x031183a3, "31183A3", "%X"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, -0x0018695, "-99989", "%-0.5ld"},
+ {__LINE__, -0x0000001, "-01", "%0.2ld"},
+ {__LINE__, 0x00007822, "7822", "%+x"},
+ {__LINE__, 0x00000000, "0", "% x"},
+ {__LINE__, 0xfda2461a, "FDA2461A", "%X"},
+ {__LINE__, 0x065c50ef, "106713327", "%2.ld"},
+ {__LINE__, 0x00000a81, "a81", "% 0x"},
+ {__LINE__, -0x000022e, "-558", "%.0ld"},
+ {__LINE__, 0x00013d2f, "81199", "%.2ld"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%+X"},
+ {__LINE__, 0x000015f9, "5625", "%04.ld"},
+ {__LINE__, 0x0ab575a2, "179664290", "%0d"},
+ {__LINE__, 0x0024d07f, "0X24D07F", "%#X"},
+ {__LINE__, 0x07ee35e1, "7EE35E1", "%+X"},
+ {__LINE__, -0x00c114c, "-790860", "%#ld"},
+ {__LINE__, 0x00003be3, " 15331", "%07.d"},
+ {__LINE__, 0xfff87570, "FFF87570", "%4.0X"},
+ {__LINE__, -0x14eab419, "-350925849", "%-ld"},
+ {__LINE__, -0x000001b, "-27", "%ld"},
+ {__LINE__, 0x167ce2ea, "0x167ce2ea", "%#0.x"},
+ {__LINE__, -0x00009bc, "-002492", "% 3.6d"},
+ {__LINE__, 0xfffffdb9, "0XFFFFFDB9", "%#7.X"},
+ {__LINE__, 0x008b2b9d, "8B2B9D", "% X"},
+ {__LINE__, 0x000cfec3, "CFEC3", "% 05X"},
+ {__LINE__, 0x05970be6, "5970be6", "%x"},
+ {__LINE__, 0x00002780, "010112", "%2.6d"},
+ {__LINE__, 0x00000005, "+5", "%+d"},
+ {__LINE__, 0xfffffffb, "0xfffffffb", "%#3.x"},
+ {__LINE__, 0x00000001, "1 ", "%-#5.ld"},
+ {__LINE__, -0x0000017, "-23", "%ld"},
+ {__LINE__, -0x023b943, "-2341187", "%d"},
+ {__LINE__, 0x0000000d, "13", "%ld"},
+ {__LINE__, 0x00025a03, "25a03", "% .5x"},
+ {__LINE__, 0x3e1ebe24, "3e1ebe24", "% x"},
+ {__LINE__, 0x0000013a, "0x13a", "%#5.0x"},
+ {__LINE__, 0xfff6f5b3, "FFF6F5B3", "%4.X"},
+ {__LINE__, -0x0000a8a, "-2698", "%.3d"},
+ {__LINE__, 0x0009dd5f, "9dd5f", "%x"},
+ {__LINE__, 0x000003c7, " 3C7", "%04.2X"},
+ {__LINE__, 0x1bcfa2f2, "1bcfa2f2", "%+1.x"},
+ {__LINE__, 0x0001b4f4, "1b4f4", "%+1.x"},
+ {__LINE__, 0x1bc19a90, "465672848", "%#d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%+06x"},
+ {__LINE__, -0x0000a88, "-2696", "%3.d"},
+ {__LINE__, 0x00084a19, "84A19", "%-X"},
+ {__LINE__, 0xffe1fc8f, "FFE1FC8F", "%0.1X"},
+ {__LINE__, -0x0000a3a, "-2618", "%5d"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, -0x5c6183d, "-96868413", "%+ld"},
+ {__LINE__, -0x0000001, "-1", "%-d"},
+ {__LINE__, 0x0000faa8, "64168", "%05.d"},
+ {__LINE__, 0x003913ef, "3740655", "%ld"},
+ {__LINE__, 0x0dde330a, "232665866", "%#ld"},
+ {__LINE__, 0xfcfb1a7b, "FCFB1A7B", "%+X"},
+ {__LINE__, 0x07b1a81f, " 129083423", "% 0d"},
+ {__LINE__, 0x00000001, "1", "%d"},
+ {__LINE__, 0x00000070, " 112", "%5ld"},
+ {__LINE__, 0xffff74d9, "ffff74d9", "%x"},
+ {__LINE__, -0x001ab93, "-109459", "%03.d"},
+ {__LINE__, 0x0eb6b497, "EB6B497", "%+X"},
+ {__LINE__, 0x07adbac2, "128826050", "%#0.4d"},
+ {__LINE__, 0xff747068, "FF747068", "%6.X"},
+ {__LINE__, -0x190ce98f, "-420276623", "%06.6ld"},
+ {__LINE__, -0x0000007, "-7", "%.0d"},
+ {__LINE__, 0x0001240f, "1240f", "% 3x"},
+ {__LINE__, 0x267ae4a0, "645588128", "%-#ld"},
+ {__LINE__, -0x0000001, "-1", "% ld"},
+ {__LINE__, -0x0000066, "-00102", "%.5ld"},
+ {__LINE__, 0x868fa035, "868fa035", "%x"},
+ {__LINE__, 0x00000000, " ", "%-4.ld"},
+ {__LINE__, 0xfffffe72, "FFFFFE72", "%4.4X"},
+ {__LINE__, 0x00a6b4f4, "10925300", "%#ld"},
+ {__LINE__, -0x0000002, "-2", "%00.1d"},
+ {__LINE__, -0x00000a3, "-163", "%ld"},
+ {__LINE__, 0xfffffffe, "fffffffe", "% 3.x"},
+ {__LINE__, 0xffe25941, "ffe25941", "% x"},
+ {__LINE__, 0x0000a20f, "41487", "%ld"},
+ {__LINE__, -0x000009b, "-155", "%#.3ld"},
+ {__LINE__, 0x000c5dc1, "810433", "%4.ld"},
+ {__LINE__, 0x00003ec4, "16068", "%ld"},
+ {__LINE__, 0x000002f3, "0755", "%04ld"},
+ {__LINE__, 0xffffff28, "FFFFFF28", "%.5X"},
+ {__LINE__, -0x08450ff, "-8671487", "%-3.0ld"},
+ {__LINE__, 0x00000092, "92", "%x"},
+ {__LINE__, -0x0000317, "-791", "%d"},
+ {__LINE__, 0x0000000d, "d", "%x"},
+ {__LINE__, 0x00000036, "36", "%x"},
+ {__LINE__, -0x112693f, "-17983807", "%ld"},
+ {__LINE__, 0x00004226, "16934", "%0.d"},
+ {__LINE__, 0x000001ba, " 442", "% ld"},
+ {__LINE__, 0xfffffffc, "0XFFFFFFFC", "%#4X"},
+ {__LINE__, 0xffdb3d23, "0xffdb3d23", "% #x"},
+ {__LINE__, 0x039eb84d, "39EB84D", "%+.6X"},
+ {__LINE__, 0xffffc7da, "ffffc7da", "%0x"},
+ {__LINE__, 0xfffffdb6, "FFFFFDB6", "%6X"},
+ {__LINE__, 0x001b75b0, "1799600", "%ld"},
+ {__LINE__, 0xfffffca2, "FFFFFCA2", "%-X"},
+ {__LINE__, 0xffffffba, "ffffffba", "%7.4x"},
+ {__LINE__, -0x000124e, "-4686", "%3.ld"},
+ {__LINE__, -0x000bec0, "-48832", "% 0d"},
+ {__LINE__, 0xfffffca0, "fffffca0", "%2.x"},
+ {__LINE__, 0x00b2a462, "11707490", "%ld"},
+ {__LINE__, 0x0745a647, "745a647", "%+4.x"},
+ {__LINE__, 0xfffffbac, "0XFFFFFBAC", "%#3.X"},
+ {__LINE__, -0x0000002, "-2", "%-0.1d"},
+ {__LINE__, 0x0006cfdb, "446427", "%#5.d"},
+ {__LINE__, -0x0000001, "-1", "%d"},
+ {__LINE__, 0x043b134e, "43B134E", "%X"},
+ {__LINE__, -0x0000015, "-21", "%ld"},
+ {__LINE__, -0x0000114, "-276", "%0d"},
+ {__LINE__, -0x0004d4a, "-19786", "%-d"},
+ {__LINE__, -0x000001c, "-28", "%ld"},
+ {__LINE__, -0x0cb89fc, "-13339132", "%ld"},
+ {__LINE__, 0xffffffcf, "ffffffcf", "%x"},
+ {__LINE__, 0xf6d2387a, "f6d2387a", "%-x"},
+ {__LINE__, -0x00000cd, "-205", "%#ld"},
+ {__LINE__, 0x00000000, "0", "%#x"},
+ {__LINE__, 0xfffffc81, "fffffc81", "%x"},
+ {__LINE__, 0x00000000, " 0", "% ld"},
+ {__LINE__, 0x00024fb5, "24fb5", "%x"},
+ {__LINE__, 0x000012fa, "12FA", "%X"},
+ {__LINE__, 0x0318ce7c, "51957372", "%0d"},
+ {__LINE__, 0x02280a99, "2280a99", "%-x"},
+ {__LINE__, 0xffffff5c, "FFFFFF5C", "%2.X"},
+ {__LINE__, -0x000002e, " -46", "%7ld"},
+ {__LINE__, -0x04a73e8, "-4879336", "%4ld"},
+ {__LINE__, 0x000007f3, "7f3", "% 1.3x"},
+ {__LINE__, 0x00000114, "0x114", "%#x"},
+ {__LINE__, 0x0000030c, "30c", "%-x"},
+ {__LINE__, 0x001dd0dd, "0x1dd0dd", "%+#5.5x"},
+ {__LINE__, 0xfff23de3, "fff23de3", "%-x"},
+ {__LINE__, -0x0178f9c, "-1544092", "%d"},
+ {__LINE__, 0x02ded8da, "2DED8DA", "%X"},
+ {__LINE__, -0x0991672, "-10032754", "%3.d"},
+ {__LINE__, 0x6943c150, "6943c150", "%x"},
+ {__LINE__, 0xffffc25d, "FFFFC25D", "%4X"},
+ {__LINE__, 0x00000c9c, " 0003228", "% .7d"},
+ {__LINE__, 0xffffffdf, "FFFFFFDF", "% 6.X"},
+ {__LINE__, 0x0001a145, " 1a145", "%6.0x"},
+ {__LINE__, 0xffdc832f, "0xffdc832f", "%#.1x"},
+ {__LINE__, 0x00699f7b, "699f7b", "%x"},
+ {__LINE__, 0xf9575268, "F9575268", "%+0X"},
+ {__LINE__, 0x04eb4783, "82528131", "%-ld"},
+ {__LINE__, -0x0000023, "-35", "%0ld"},
+ {__LINE__, -0x012b08a, "-1224842", "%0d"},
+ {__LINE__, 0xffffb587, "FFFFB587", "%X"},
+ {__LINE__, 0xffffffe9, "ffffffe9", "%x"},
+ {__LINE__, 0x006b5596, " 7034262", "% 0d"},
+ {__LINE__, 0x004d0d2a, "+5049642", "%+ld"},
+ {__LINE__, -0x002a099, "-172185", "%d"},
+ {__LINE__, 0x00000224, "548", "%ld"},
+ {__LINE__, 0x03e0cca8, "65064104", "%d"},
+ {__LINE__, -0x7bb389d, "-129710237", "%.3ld"},
+ {__LINE__, 0xffc630f5, "ffc630f5", "%-07.0x"},
+ {__LINE__, 0xfffffff8, "FFFFFFF8", "%X"},
+ {__LINE__, 0x0030225b, "3154523", "%#d"},
+ {__LINE__, 0xff7f4e28, "ff7f4e28", "%+4.x"},
+ {__LINE__, 0x14ee154d, "+351147341", "%+ld"},
+ {__LINE__, 0x00000003, "03", "%.2d"},
+ {__LINE__, 0xfe0359d6, "fe0359d6", "%x"},
+ {__LINE__, 0x002b71c3, "2847171", "%d"},
+ {__LINE__, 0x055c4d4a, "55C4D4A", "%-X"},
+ {__LINE__, 0xfffb17d2, "fffb17d2", "% .0x"},
+ {__LINE__, 0x00000002, "2", "%x"},
+ {__LINE__, 0x000018e1, "18E1", "%1.1X"},
+ {__LINE__, 0x00000331, "817", "%0d"},
+ {__LINE__, -0x0000982, "-2434 ", "%-06.ld"},
+ {__LINE__, -0x0000168, "-0000360", "%.7ld"},
+ {__LINE__, 0xffffffe9, "FFFFFFE9", "%-0.4X"},
+ {__LINE__, 0xe42084ef, "E42084EF", "%X"},
+ {__LINE__, 0x000000aa, "aa", "%x"},
+ {__LINE__, -0xe8b98b5, "-244029621", "%+d"},
+ {__LINE__, -0x00000d9, "-217", "%+2.d"},
+ {__LINE__, 0x0000027b, "27B", "%+.0X"},
+ {__LINE__, 0x002e52db, "3035867", "%-ld"},
+ {__LINE__, -0x00e2ba8, "-928680", "%0.2ld"},
+ {__LINE__, 0x003b74d8, "3B74D8", "%X"},
+ {__LINE__, -0x000006f, "-111", "%+ld"},
+ {__LINE__, 0xf8507e22, "0XF8507E22", "%-#X"},
+ {__LINE__, 0x0629f4c0, "103412928", "%-ld"},
+ {__LINE__, -0x000002d, "-45", "%0d"},
+ {__LINE__, -0x0001db0, "-7600", "%d"},
+ {__LINE__, -0x00001bb, " -443", "%5.ld"},
+ {__LINE__, 0xffffd2b9, "ffffd2b9", "%+x"},
+ {__LINE__, 0xffffe685, "0XFFFFE685", "%#0.7X"},
+ {__LINE__, 0x0000a4ce, "A4CE", "% X"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%X"},
+ {__LINE__, 0x0000000c, "C", "% X"},
+ {__LINE__, 0xfff59369, "FFF59369", "%7X"},
+ {__LINE__, 0x00000156, " 156", "%5.X"},
+ {__LINE__, 0x02833aa9, "+42154665", "%+2d"},
+ {__LINE__, 0x0004a8f3, "+305395", "%+d"},
+ {__LINE__, 0x01a09267, "1A09267", "%0.3X"},
+ {__LINE__, 0x000004f1, "4f1", "%x"},
+ {__LINE__, 0x00000005, "5", "%x"},
+ {__LINE__, 0x00000119, " 0281", "% #2.4ld"},
+ {__LINE__, -0x0001a2a, "-6698", "%ld"},
+ {__LINE__, 0xa3633a57, "A3633A57", "%7X"},
+ {__LINE__, -0x10bd2970, "-280832368", "%-d"},
+ {__LINE__, 0xffff9c38, "ffff9c38", "%x"},
+ {__LINE__, 0xffdbe81e, "ffdbe81e", "%+6.7x"},
+ {__LINE__, 0xffffffe7, "FFFFFFE7", "%-3.0X"},
+ {__LINE__, 0x0002f6d6, "2f6d6", "%5.x"},
+ {__LINE__, 0xffffffff, "ffffffff", "% x"},
+ {__LINE__, 0xffc2c07a, "ffc2c07a", "%0.x"},
+ {__LINE__, 0xfcc0e13a, "FCC0E13A", "%X"},
+ {__LINE__, 0x0000000d, "d", "% x"},
+ {__LINE__, 0x0016cac8, "16CAC8", "%-0.3X"},
+ {__LINE__, 0x00945dc1, "9723329", "%2d"},
+ {__LINE__, 0xf19a1cd1, "F19A1CD1", "%-X"},
+ {__LINE__, 0x00000003, "+3", "%+ld"},
+ {__LINE__, 0x00000773, "1907", "%ld"},
+ {__LINE__, 0x000263e6, "263e6", "%-x"},
+ {__LINE__, -0x0238b55, "-2329429", "%d"},
+ {__LINE__, 0x00006c56, "6C56", "%X"},
+ {__LINE__, 0x0000f34b, "62283", "%#.0ld"},
+ {__LINE__, -0x1620e21, "-23203361", "%0ld"},
+ {__LINE__, 0xf9257d6a, "f9257d6a", "%2x"},
+ {__LINE__, -0x00ed463, "-971875", "%03.d"},
+ {__LINE__, 0x02bb94c6, "45847750", "%d"},
+ {__LINE__, 0xffffd20c, "0XFFFFD20C", "%#X"},
+ {__LINE__, 0x000087d8, "34776", "%.0d"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%+7.X"},
+ {__LINE__, -0x0009cd5, "-40149", "%-ld"},
+ {__LINE__, 0xfffff85e, "FFFFF85E", "% 0.7X"},
+ {__LINE__, -0x0000006, " -6", "%+#6.ld"},
+ {__LINE__, 0x007ff453, "0x7ff453", "%-#1.x"},
+ {__LINE__, 0xffffffe6, "FFFFFFE6", "%2X"},
+ {__LINE__, 0x0000001f, "0X1F", "%#4X"},
+ {__LINE__, -0x001c157, "-115031", "%.3ld"},
+ {__LINE__, 0x00096e06, "617990", "%3.1ld"},
+ {__LINE__, 0x0f77271d, "259467037", "%d"},
+ {__LINE__, -0x0001403, "-5123", "%d"},
+ {__LINE__, 0xffffff8a, "ffffff8a", "%x"},
+ {__LINE__, -0x000010f, "-271", "%1.ld"},
+ {__LINE__, 0xe573cc4a, "E573CC4A", "%0X"},
+ {__LINE__, -0x0000d88, "-3464", "%-d"},
+ {__LINE__, 0x0000000e, "14", "%#ld"},
+ {__LINE__, -0x000345b, "-13403", "%#d"},
+ {__LINE__, 0x00000602, "602", "%+x"},
+ {__LINE__, 0x00000011, "17", "%#d"},
+ {__LINE__, -0x0000002, "-2", "%+d"},
+ {__LINE__, 0x030fe6e6, "51373798", "%d"},
+ {__LINE__, 0x00000007, "007", "%.3X"},
+ {__LINE__, 0x0001abe0, "0X1ABE0", "%+#.4X"},
+ {__LINE__, 0xfffffdb7, "fffffdb7", "%-6x"},
+ {__LINE__, 0xffffff8d, "FFFFFF8D", "% 02.2X"},
+ {__LINE__, 0xfff12126, "FFF12126", "%X"},
+ {__LINE__, 0x0208e32d, "34136877", "%.2d"},
+ {__LINE__, 0x11c04b55, "297814869", "%ld"},
+ {__LINE__, 0xff1e5ca3, "0xff1e5ca3", "%#x"},
+ {__LINE__, 0xf9643f09, "f9643f09", "%x"},
+ {__LINE__, -0x003c6da, "-247514", "%4d"},
+ {__LINE__, 0xff69d0e7, "FF69D0E7", "%-X"},
+ {__LINE__, 0x00006ae9, "0x6ae9", "%#x"},
+ {__LINE__, -0x005aefe, "-372478", "%d"},
+ {__LINE__, 0x0000000d, "00013", "%3.5ld"},
+ {__LINE__, 0x00cc185c, "CC185C", "%X"},
+ {__LINE__, 0x3dd14d9f, "3DD14D9F", "%1.4X"},
+ {__LINE__, -0x4cc2ad3, "-80489171", "%1.d"},
+ {__LINE__, 0xfffff79e, "fffff79e", "%x"},
+ {__LINE__, 0xfffeeb03, "fffeeb03", "%-1x"},
+ {__LINE__, -0x0b1b15c, "-11645276", "%0ld"},
+ {__LINE__, -0x06b558d, "-7034253", "%ld"},
+ {__LINE__, 0xfffffe61, "fffffe61", "%x"},
+ {__LINE__, -0x0000002, "-2", "%d"},
+ {__LINE__, -0x0000162, "-000354", "%-5.6d"},
+ {__LINE__, 0x01a23780, "27408256", "%d"},
+ {__LINE__, 0xffff3a9b, "ffff3a9b", "% x"},
+ {__LINE__, 0xfffffdc7, "0xfffffdc7", "%#4.5x"},
+ {__LINE__, 0x00000000, "00", "%.2X"},
+ {__LINE__, -0x0000006, "-6", "%0ld"},
+ {__LINE__, -0x16072c6, "-23098054", "%#5ld"},
+ {__LINE__, -0x07152b8, "-7426744", "%01ld"},
+ {__LINE__, 0x0000d6c6, "0x0d6c6", "%#1.5x"},
+ {__LINE__, 0x00000f7c, "000f7c", "%+04.6x"},
+ {__LINE__, 0x00000bd0, "3024", "%4ld"},
+ {__LINE__, 0x0000295e, "0x295e", "%#x"},
+ {__LINE__, 0x00002e38, "11832", "%.5d"},
+ {__LINE__, -0xa2f5de4, "-170876388", "%#d"},
+ {__LINE__, -0x001aa36, "-109110", "%-#d"},
+ {__LINE__, 0x03012091, "3012091", "%+2.5X"},
+ {__LINE__, -0x00009ed, "-002541", "%-0.6ld"},
+ {__LINE__, 0x0000001d, "1d", "%x"},
+ {__LINE__, 0xffffe315, "FFFFE315", "%+4X"},
+ {__LINE__, 0x0000716b, "716B", "%X"},
+ {__LINE__, 0xfffb8315, "0xfffb8315", "%+#x"},
+ {__LINE__, 0x00000132, "132 ", "%-7.3x"},
+ {__LINE__, 0x00000000, "+0000000", "%+1.7d"},
+ {__LINE__, 0xe16d27ab, "E16D27AB", "%X"},
+ {__LINE__, 0xffffffe5, "ffffffe5", "%+x"},
+ {__LINE__, -0x000ab9d, "-43933", "%ld"},
+ {__LINE__, 0xffd042d6, "ffd042d6", "%2x"},
+ {__LINE__, 0xffffff9b, "ffffff9b", "%x"},
+ {__LINE__, 0x000000fb, "0xfb", "% #1.x"},
+ {__LINE__, 0x0000000f, " 15", "%#3ld"},
+ {__LINE__, 0xfffba2d8, "0XFFFBA2D8", "%-#0.X"},
+ {__LINE__, 0xfffffff8, "0XFFFFFFF8", "% #X"},
+ {__LINE__, 0x00000000, " ", "%4.ld"},
+ {__LINE__, 0x00000002, "2", "%+x"},
+ {__LINE__, 0xfffff314, "FFFFF314", "%-X"},
+ {__LINE__, 0x00000000, " 0", "% ld"},
+ {__LINE__, -0x0000007, "-07", "%3.2ld"},
+ {__LINE__, 0xffffdd80, "FFFFDD80", "%.6X"},
+ {__LINE__, -0x000001b, "-27", "%-ld"},
+ {__LINE__, -0x0000258, "-600", "%-0d"},
+ {__LINE__, 0x00016377, "16377", "%3X"},
+ {__LINE__, 0x00000001, "1", "%X"},
+ {__LINE__, -0xac5d314, "-180736788", "%d"},
+ {__LINE__, -0x000036e, "-878", "% ld"},
+ {__LINE__, 0xfe346af4, "fe346af4", "%.5x"},
+ {__LINE__, 0xffffffe1, "ffffffe1", "%-7.6x"},
+ {__LINE__, -0x0a1df07, "-10608391", "%#.5d"},
+ {__LINE__, 0x000000c9, " 0XC9", "%+#5.X"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%x"},
+ {__LINE__, 0xfffffff8, "fffffff8", "%+x"},
+ {__LINE__, -0x4517255, "-72446549", "%.6ld"},
+ {__LINE__, 0xfffa3670, "FFFA3670", "%-6X"},
+ {__LINE__, 0xffffffe0, "ffffffe0", "%2.x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%0x"},
+ {__LINE__, 0x0000230d, "8973", "%#.1d"},
+ {__LINE__, 0x00000238, "238", "%0X"},
+ {__LINE__, 0xfffce5ab, "FFFCE5AB", "%-X"},
+ {__LINE__, 0x0000002c, "2C", "%X"},
+ {__LINE__, 0x00000001, " 1", "%4.ld"},
+ {__LINE__, 0xffffff8d, "FFFFFF8D", "%-X"},
+ {__LINE__, 0x00069c69, "433257", "%06d"},
+ {__LINE__, 0xfffffb8d, "0xfffffb8d", "%#x"},
+ {__LINE__, 0x000d6a2d, "879149", "%5.5d"},
+ {__LINE__, -0x0001fcb, " -8139", "%7.ld"},
+ {__LINE__, 0xfff86937, "fff86937", "%-0x"},
+ {__LINE__, 0x00059cf9, "367865", "%#.0ld"},
+ {__LINE__, 0x02c5d87a, "46520442", "%3.ld"},
+ {__LINE__, 0x00000571, "1393", "%ld"},
+ {__LINE__, 0x0003c73f, "+247615", "%+4ld"},
+ {__LINE__, 0x0000004f, "4f", "% 0x"},
+ {__LINE__, 0x00000000, "0", "%-ld"},
+ {__LINE__, -0x0e5850f, "-15041807", "% ld"},
+ {__LINE__, -0x0000002, " -0002", "%7.4d"},
+ {__LINE__, 0xfffffd1b, "fffffd1b", "%05x"},
+ {__LINE__, 0x0000041c, " 1052", "% #0.ld"},
+ {__LINE__, -0x0000030, "-48", "%d"},
+ {__LINE__, -0x0013593, "-79251", "% #d"},
+ {__LINE__, 0x00000001, "1", "%+X"},
+ {__LINE__, 0x0000056b, " 56b", "%4.x"},
+ {__LINE__, -0x0000004, "-4 ", "%-3d"},
+ {__LINE__, -0x0000003, "-3", "% ld"},
+ {__LINE__, 0xffff7c14, "0XFFFF7C14", "%#X"},
+ {__LINE__, 0x02f63dd8, "49692120", "%.7ld"},
+ {__LINE__, -0x03c51c9, "-3953097", "%+d"},
+ {__LINE__, 0x00ded685, "14603909", "%5.ld"},
+ {__LINE__, 0xffffffba, "ffffffba", "%x"},
+ {__LINE__, 0x000370e8, "225512", "%#ld"},
+ {__LINE__, 0x00000003, "3", "%X"},
+ {__LINE__, -0x0024a64, "-150116", "%7.d"},
+ {__LINE__, 0xff486ca1, "ff486ca1", "%x"},
+ {__LINE__, 0x000001cf, "1CF", "% X"},
+ {__LINE__, -0x0002d7e, "-11646", "%-0d"},
+ {__LINE__, 0x0a594c65, "a594c65", "%.4x"},
+ {__LINE__, -0x0000002, "-0002", "%-5.4ld"},
+ {__LINE__, 0x00000000, "", "%00.ld"},
+ {__LINE__, 0x00058bc4, "58BC4", "%3X"},
+ {__LINE__, 0x0002cf8e, " 184206", "% 0ld"},
+ {__LINE__, 0x000009c7, "+2503", "%+4.ld"},
+ {__LINE__, 0xed0c984d, "ED0C984D", "%X"},
+ {__LINE__, -0x0000058, "-088", "%#.3ld"},
+ {__LINE__, 0x0076083d, "0X76083D", "%#6X"},
+ {__LINE__, -0x0000001, "-1", "%#d"},
+ {__LINE__, -0x6bf1777, "-113186679", "%#ld"},
+ {__LINE__, -0x000011f, "-287", "%ld"},
+ {__LINE__, 0x001b0e7d, "1B0E7D", "%-4X"},
+ {__LINE__, 0x000007ac, " 1964", "%5.ld"},
+ {__LINE__, 0x00000005, "5", "%0.d"},
+ {__LINE__, -0x00003ba, "-954", "%4.0ld"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%X"},
+ {__LINE__, 0x00000019, "19", "%x"},
+ {__LINE__, 0xffffffe0, "ffffffe0", "%-.6x"},
+ {__LINE__, 0x0000012a, " 298", "% d"},
+ {__LINE__, 0x00002c74, "2c74", "% 4.3x"},
+ {__LINE__, 0x000002d5, "725", "%d"},
+ {__LINE__, 0x0001c9a9, "1c9a9", "%-02x"},
+ {__LINE__, 0xffc928c8, "ffc928c8", "%x"},
+ {__LINE__, -0x03ae51f, "-3859743", "% #ld"},
+ {__LINE__, 0x0000526d, "526d", "%x"},
+ {__LINE__, -0x00028f0, "-10480", "%5ld"},
+ {__LINE__, -0x49b4262, "-77283938", "%+02.0d"},
+ {__LINE__, 0x028d37f0, "0x28d37f0", "%+#x"},
+ {__LINE__, 0xd66e0af9, "D66E0AF9", "%03.X"},
+ {__LINE__, -0x00c7707, "-816903", "%0d"},
+ {__LINE__, -0x00000d0, "-208", "%-.1ld"},
+ {__LINE__, 0x0000c328, "49960", "%d"},
+ {__LINE__, 0x34cb86f1, "34CB86F1", "%X"},
+ {__LINE__, 0x000000f6, "F6", "%+X"},
+ {__LINE__, 0x0a3407ec, "0xa3407ec", "%-#x"},
+ {__LINE__, 0x00007ebc, "32444", "%#3.d"},
+ {__LINE__, 0xfffd3d65, "fffd3d65", "%x"},
+ {__LINE__, 0x0007bc82, "0507010", "%0.7d"},
+ {__LINE__, 0x0005bb93, "375699", "%ld"},
+ {__LINE__, 0x0ec11cc8, "0XEC11CC8", "%+#6.2X"},
+ {__LINE__, 0xfffff9c6, "fffff9c6", "%.5x"},
+ {__LINE__, 0xff05ab70, "0XFF05AB70", "%-#.3X"},
+ {__LINE__, 0x2328b716, "589870870", "%d"},
+ {__LINE__, 0x00001a79, "6777", "%.1d"},
+ {__LINE__, 0xfffee573, "fffee573", "%0.1x"},
+ {__LINE__, -0x0000929, " -2345", "%7.d"},
+ {__LINE__, 0xffffff9a, "FFFFFF9A", "%2.X"},
+ {__LINE__, 0xfffffe60, "fffffe60", "%.5x"},
+ {__LINE__, 0xfffffcd2, "fffffcd2", "%.7x"},
+ {__LINE__, 0x00000001, " 001", "%6.3X"},
+ {__LINE__, 0x00011e9c, "+73372", "%+0ld"},
+ {__LINE__, 0x0000002a, "2a", "% x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%.7x"},
+ {__LINE__, -0x0008ee8, "-36584", "%ld"},
+ {__LINE__, 0x0000001c, "28", "%-d"},
+ {__LINE__, 0x000abeda, "704218", "%d"},
+ {__LINE__, 0x001347f7, "1347f7", "%3.0x"},
+ {__LINE__, 0x0000023e, "574", "%3.3ld"},
+ {__LINE__, 0x00000000, "0", "%-ld"},
+ {__LINE__, -0x0016de0, "-93664", "%0ld"},
+ {__LINE__, 0xffffff45, "FFFFFF45", "% X"},
+ {__LINE__, 0x02dfb08c, "48214156", "%#ld"},
+ {__LINE__, 0x003d73a2, "3d73a2", "%6.x"},
+ {__LINE__, 0x00147da7, "1342887", "%#d"},
+ {__LINE__, -0x5ff0f1e, "-100601630", "%-01ld"},
+ {__LINE__, -0x000000b, "-11", "%ld"},
+ {__LINE__, 0x00000168, " 168", "%+6.x"},
+ {__LINE__, 0xffffc28e, "ffffc28e", "%0x"},
+ {__LINE__, -0x00003a2, "-930", "%ld"},
+ {__LINE__, 0x0002e56f, " 189807", "% 1.ld"},
+ {__LINE__, 0x51abf44f, "0x51abf44f", "%#.7x"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, 0x9581268f, "9581268F", "%+X"},
+ {__LINE__, 0xffffff3b, "FFFFFF3B", "%X"},
+ {__LINE__, 0x000083d4, " 33748", "% #d"},
+ {__LINE__, 0x00000001, "1", "%x"},
+ {__LINE__, -0x000e51f, "-58655", "%.0ld"},
+ {__LINE__, 0x0003eacb, "256715", "%6ld"},
+ {__LINE__, 0x02be09db, " 46008795", "% 0.ld"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "% X"},
+ {__LINE__, 0x000084f5, " 34037", "%6ld"},
+ {__LINE__, -0x1127f99, "-17989529", "%#d"},
+ {__LINE__, 0x5f6512de, "5f6512de", "%.7x"},
+ {__LINE__, 0x00000001, "1", "%x"},
+ {__LINE__, 0xfff74ab5, "fff74ab5", "%x"},
+ {__LINE__, 0x0eebeb94, "250342292", "%4.ld"},
+ {__LINE__, 0x0001b846, "0x1b846", "%#1x"},
+ {__LINE__, 0x001e8c32, "1E8C32", "%2X"},
+ {__LINE__, -0x0dae932, "-14346546", "%5.1d"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, -0x0000042, "-66", "%ld"},
+ {__LINE__, 0xffffff51, "FFFFFF51", "%0.1X"},
+ {__LINE__, 0x00000043, "43", "%x"},
+ {__LINE__, 0x04c21f39, " 79830841", "% 0ld"},
+ {__LINE__, 0x0000061e, "1566", "%03.3d"},
+ {__LINE__, -0x0000003, "-3", "%+d"},
+ {__LINE__, 0x015b32db, " 22754011", "% .4d"},
+ {__LINE__, 0xfffff181, "FFFFF181", "%-X"},
+ {__LINE__, 0x000017ec, "0X17EC", "%#X"},
+ {__LINE__, 0x000d703e, "880702", "%#ld"},
+ {__LINE__, -0x6d7533a0, "-1836397472", "%ld"},
+ {__LINE__, 0x0000008a, " 138", "% d"},
+ {__LINE__, -0x7368794b, "-1936226635", "%+#d"},
+ {__LINE__, 0x0000000d, "0XD", "%#X"},
+ {__LINE__, 0x0000030d, "30D", "% X"},
+ {__LINE__, 0xfffff9fe, "FFFFF9FE", "%5X"},
+ {__LINE__, 0x00001bb2, "7090", "%d"},
+ {__LINE__, 0x041d2a0c, "41D2A0C", "%0X"},
+ {__LINE__, 0x00012aee, " 76526", "% d"},
+ {__LINE__, 0x0000055f, "55f", "%.1x"},
+ {__LINE__, 0xffffffff, "0XFFFFFFFF", "%#1X"},
+ {__LINE__, 0x07b0a971, "+129018225", "%+.2ld"},
+ {__LINE__, 0xfffffff8, "FFFFFFF8", "%4X"},
+ {__LINE__, 0x00000001, "1", "%d"},
+ {__LINE__, 0x00000038, "+56", "%+2ld"},
+ {__LINE__, 0xfffffc2f, "fffffc2f", "%+7.x"},
+ {__LINE__, 0x00004477, "0x4477", "% #x"},
+ {__LINE__, 0x0000000d, "0XD", "%+#3X"},
+ {__LINE__, 0xf5bf37b1, "F5BF37B1", "%1.X"},
+ {__LINE__, 0x1a96f431, "446100529", "%d"},
+ {__LINE__, 0x0037edf3, "+3665395", "%+#4.5ld"},
+ {__LINE__, 0x0007f2aa, "520874", "%0ld"},
+ {__LINE__, -0x00051a3, "-20899", "%+#1.ld"},
+ {__LINE__, 0x0000037f, "37F", "%0X"},
+ {__LINE__, 0xffffffb4, "ffffffb4", "%x"},
+ {__LINE__, -0xd984c00, "-228084736", "%+06ld"},
+ {__LINE__, 0xffffe1be, "FFFFE1BE", "%X"},
+ {__LINE__, 0xfff20d48, "FFF20D48", "%+6.0X"},
+ {__LINE__, 0x000028b7, "0x028b7", "%-#7.5x"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, 0x03f37945, "66287941", "%d"},
+ {__LINE__, 0xffffffed, "0XFFFFFFED", "%+#6.4X"},
+ {__LINE__, 0x0000f046, "f046", "%x"},
+ {__LINE__, 0xe9772b51, "E9772B51", "%-1.X"},
+ {__LINE__, 0xfffffffe, "fffffffe", "% x"},
+ {__LINE__, 0xfffffffa, "0xfffffffa", "%#x"},
+ {__LINE__, 0x00000015, "15", "%-X"},
+ {__LINE__, 0x0000003c, "60", "%#ld"},
+ {__LINE__, 0x3103952d, "822318381", "%0.ld"},
+ {__LINE__, 0x17ba68bb, "398092475", "%2d"},
+ {__LINE__, 0x000006c4, "+1732", "%+.2d"},
+ {__LINE__, 0x00000043, "67", "%#d"},
+ {__LINE__, 0x0043fb55, "4455253", "%.1ld"},
+ {__LINE__, 0x00004b76, "4b76", "% 0x"},
+ {__LINE__, 0xfff4c56b, "FFF4C56B", "%7X"},
+ {__LINE__, 0x00766055, "766055", "%+5x"},
+ {__LINE__, -0x000009f, "-159", "%+d"},
+ {__LINE__, 0xffff063f, "ffff063f", "%-2x"},
+ {__LINE__, 0x00808fc8, "808fc8", "%x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, 0x000000f1, "00000f1", "%+02.7x"},
+ {__LINE__, 0x00000002, "2", "%X"},
+ {__LINE__, 0x00000000, "000", "%03d"},
+ {__LINE__, 0xe63f73b2, "E63F73B2", "% 1X"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%5.1X"},
+ {__LINE__, 0x0d3fa38b, "222274443", "%1d"},
+ {__LINE__, 0x00000000, "0", "% X"},
+ {__LINE__, 0x00000001, " 1", "%04.ld"},
+ {__LINE__, 0x00000046, "46", "%0X"},
+ {__LINE__, 0x0000761f, " 30239", "% ld"},
+ {__LINE__, -0x0002517, "-9495", "%+d"},
+ {__LINE__, 0x00000156, "156", "% 0x"},
+ {__LINE__, 0x1c55eba2, "1c55eba2", "%.6x"},
+ {__LINE__, 0x005af80d, "5af80d", "%.6x"},
+ {__LINE__, 0x0000002e, "46", "%d"},
+ {__LINE__, -0x0007c0f, "-31759", "%ld"},
+ {__LINE__, 0xffffe924, "FFFFE924", "%7X"},
+ {__LINE__, 0x00000174, "372", "%ld"},
+ {__LINE__, 0xffffffc9, "0xffffffc9", "%-#x"},
+ {__LINE__, 0x00000020, "+000032", "%+07d"},
+ {__LINE__, 0xffffe5d9, "FFFFE5D9", "%4.5X"},
+ {__LINE__, 0xffffffa3, "FFFFFFA3", "%+.3X"},
+ {__LINE__, 0x00000a03, "+2563", "%+2d"},
+ {__LINE__, 0x001b58ca, "+1792202", "%+4d"},
+ {__LINE__, 0xffffffc9, "0xffffffc9", "%+#5x"},
+ {__LINE__, -0x0000003, "-3", "% d"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%+0x"},
+ {__LINE__, -0x0000002, "-02", "%.2d"},
+ {__LINE__, 0x000243fb, "148475", "%-ld"},
+ {__LINE__, 0x00000001, "1", "%0d"},
+ {__LINE__, -0x0000672, "-1650", "%ld"},
+ {__LINE__, -0x0005413, "-0021523", "% 7.7d"},
+ {__LINE__, 0x00000017, "0X17", "%#X"},
+ {__LINE__, 0x00000e48, "3656", "%0d"},
+ {__LINE__, 0xffe79b38, "ffe79b38", "%-x"},
+ {__LINE__, 0xffffff15, "FFFFFF15", "%+6.1X"},
+ {__LINE__, 0xfff0272c, "fff0272c", "%-.5x"},
+ {__LINE__, -0x00b706f, "-749679", "%1.ld"},
+ {__LINE__, 0x0176aeec, "176AEEC", "%.1X"},
+ {__LINE__, -0x00005a1, "-1441", "% 0ld"},
+ {__LINE__, -0x0000002, "-00002", "%.5d"},
+ {__LINE__, -0xd2e6f5d, "-221146973", "%1ld"},
+ {__LINE__, -0x0000001, " -001", "%5.3ld"},
+ {__LINE__, 0x00000001, " 1", "%05.ld"},
+ {__LINE__, 0x0000749e, "+29854", "%+#d"},
+ {__LINE__, 0x00000005, "5", "%d"},
+ {__LINE__, 0xfa7128b0, "fa7128b0", "%1.x"},
+ {__LINE__, 0xffffbbb4, "0XFFFFBBB4", "%#.1X"},
+ {__LINE__, 0x0006862f, "427567", "%d"},
+ {__LINE__, 0x00000002, "2", "%X"},
+ {__LINE__, 0x000005d4, "5d4", "% x"},
+ {__LINE__, 0x001387e1, "1279969", "%-05.0ld"},
+ {__LINE__, -0x0035a56, "-219734", "%ld"},
+ {__LINE__, -0x4064ecc6, "-1080356038", "%ld"},
+ {__LINE__, 0x0000360d, "13837", "%0ld"},
+ {__LINE__, -0xea1a85b, "-245475419", "%-.2ld"},
+ {__LINE__, 0xffffff2d, "FFFFFF2D", "%X"},
+ {__LINE__, 0x00000004, " 0004", "%7.4x"},
+ {__LINE__, 0x00f72ffd, "F72FFD", "%-X"},
+ {__LINE__, 0x00000fa2, "fa2 ", "%-5x"},
+ {__LINE__, 0x05ae1f9a, "95297434", "%#ld"},
+ {__LINE__, 0x0000bf2e, "48942", "%3.d"},
+ {__LINE__, 0x00000000, " ", "%1.X"},
+ {__LINE__, 0x01bcb097, "29143191", "%ld"},
+ {__LINE__, 0x0000009c, "156 ", "%-4.0d"},
+ {__LINE__, 0xfffffffe, "fffffffe", "% x"},
+ {__LINE__, 0x00000001, "1 ", "%-6.d"},
+ {__LINE__, 0xffffffef, "ffffffef", "%7.x"},
+ {__LINE__, 0xfffffec1, "fffffec1", "%.5x"},
+ {__LINE__, -0x000000f, "-15", "%-1d"},
+ {__LINE__, -0x0008426, "-33830", "%0ld"},
+ {__LINE__, 0x005be0ae, "5BE0AE", "% X"},
+ {__LINE__, 0x00000009, " 9", "%+7X"},
+ {__LINE__, -0x0007e18, "-32280", "%+0.d"},
+ {__LINE__, 0x01697ba1, " 23690145", "% 5.ld"},
+ {__LINE__, -0x0012042, "-073794", "%7.6d"},
+ {__LINE__, 0x04e9bd0d, "4e9bd0d", "%-2x"},
+ {__LINE__, 0xffffffd9, "FFFFFFD9", "%.2X"},
+ {__LINE__, -0x01b9632, "-1807922", "%.6ld"},
+ {__LINE__, 0x000000cd, "205", "%1.ld"},
+ {__LINE__, 0x00000000, " ", "% .0d"},
+ {__LINE__, 0xff17bbb1, "ff17bbb1", "%x"},
+ {__LINE__, -0x00146d7, "-83671", "%+1.ld"},
+ {__LINE__, 0xfffff144, "fffff144", "%x"},
+ {__LINE__, 0x000f8dbe, "F8DBE", "%3.X"},
+ {__LINE__, -0x000381c, "-14364", "%d"},
+ {__LINE__, 0x0000001e, " 30", "%4.1d"},
+ {__LINE__, 0x00000016, "22", "%-0d"},
+ {__LINE__, 0x00000002, "+02", "%+1.2ld"},
+ {__LINE__, 0x0000e803, "59395", "%d"},
+ {__LINE__, 0xb4c2448d, "b4c2448d", "%-7x"},
+ {__LINE__, 0x000e697d, "944509", "%ld"},
+ {__LINE__, 0xfffe6e32, "0XFFFE6E32", "%#X"},
+ {__LINE__, 0x00000190, " 190", "%+5.X"},
+ {__LINE__, -0x03a2219, "-3809817", "%#6.ld"},
+ {__LINE__, -0x000003c, "-60 ", "%-#4.ld"},
+ {__LINE__, 0x00000000, " ", "% 03.ld"},
+ {__LINE__, -0x074f922, "-7665954", "%ld"},
+ {__LINE__, -0x00000f0, "-240", "%-ld"},
+ {__LINE__, 0xfffe42d2, "0XFFFE42D2", "%#X"},
+ {__LINE__, 0x000000dd, "DD", "%X"},
+ {__LINE__, 0x00359abe, "359ABE", "%.1X"},
+ {__LINE__, 0xffec7bdf, "FFEC7BDF", "%0.1X"},
+ {__LINE__, 0x0ecddcba, "248372410", "%-#3.d"},
+ {__LINE__, 0x00ad0dbc, "11341244", "%ld"},
+ {__LINE__, -0x0000001, "-1", "%-d"},
+ {__LINE__, 0x00050841, "50841", "% .5x"},
+ {__LINE__, 0x01d359e7, "1d359e7", "%1.x"},
+ {__LINE__, 0xff9efaa3, "FF9EFAA3", "%X"},
+ {__LINE__, 0x0007ea10, "+518672", "%+ld"},
+ {__LINE__, -0x000671c, "-26396", "%1d"},
+ {__LINE__, 0xffffff91, "0xffffff91", "%#4.4x"},
+ {__LINE__, 0x00000000, "+", "%+0.0ld"},
+ {__LINE__, -0x002c53e, "-181566", "%3.d"},
+ {__LINE__, 0xffffff56, "ffffff56", "%x"},
+ {__LINE__, 0xfffff589, "FFFFF589", "%+X"},
+ {__LINE__, 0x00024d13, "24D13", "%-5.2X"},
+ {__LINE__, 0x00000000, " 0", "%6.1d"},
+ {__LINE__, 0x00a64f33, "A64F33", "%4.4X"},
+ {__LINE__, 0xffebb57a, "FFEBB57A", "%5.4X"},
+ {__LINE__, 0xfff3b4a0, "fff3b4a0", "%2.x"},
+ {__LINE__, 0xffffffd9, "FFFFFFD9", "%.2X"},
+ {__LINE__, 0x00d37b84, "13859716", "%d"},
+ {__LINE__, 0x00001e85, "0001E85", "%0.7X"},
+ {__LINE__, -0x756148f, "-123081871", "% 7.d"},
+ {__LINE__, -0x0319339, "-3248953", "%+#.4d"},
+ {__LINE__, -0x00798b8, "-497848", "%#5ld"},
+ {__LINE__, -0x0000039, "-57", "%0d"},
+ {__LINE__, -0x000b1d7, "-45527", "%+0.ld"},
+ {__LINE__, 0xff811fba, "FF811FBA", "%+X"},
+ {__LINE__, 0x00000042, " 66", "% ld"},
+ {__LINE__, 0xfffffe31, "0XFFFFFE31", "%#X"},
+ {__LINE__, 0x00000073, "115", "%ld"},
+ {__LINE__, 0x45091a39, "0x45091a39", "%+#3.x"},
+ {__LINE__, 0x001270f5, "1270f5", "%-5.6x"},
+ {__LINE__, 0xfffd91fd, "fffd91fd", "%x"},
+ {__LINE__, -0x0817bad, "-8485805", "%#ld"},
+ {__LINE__, -0x32ad55f, "-53138783", "%0d"},
+ {__LINE__, 0x00003e57, "15959", "%0ld"},
+ {__LINE__, -0x0048756, "-296790", "%2.6d"},
+ {__LINE__, 0xff90f45f, "FF90F45F", "% X"},
+ {__LINE__, 0x0000e454, "0e454", "% .5x"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%x"},
+ {__LINE__, 0xfffffff7, "FFFFFFF7", "%-2X"},
+ {__LINE__, 0xffdabf0e, "FFDABF0E", "%+X"},
+ {__LINE__, 0xffffffff, "0XFFFFFFFF", "%#1X"},
+ {__LINE__, 0x01516650, "1516650", "% x"},
+ {__LINE__, 0xffffff51, "FFFFFF51", "%X"},
+ {__LINE__, 0x000000ea, "234", "%00.d"},
+ {__LINE__, 0x06db60ca, "115040458", "%5.d"},
+ {__LINE__, 0x00000f01, " 3841", "% d"},
+ {__LINE__, 0x00000009, "9", "%x"},
+ {__LINE__, 0x299b3ba0, "299b3ba0", "%6.7x"},
+ {__LINE__, 0x0067f298, "67f298", "%-2.6x"},
+ {__LINE__, 0xfffffff5, "FFFFFFF5", "% 2X"},
+ {__LINE__, 0x00102ff9, "102FF9", "%-.0X"},
+ {__LINE__, 0xffc22393, "0xffc22393", "% #6x"},
+ {__LINE__, 0x00007db5, "32181", "%-2ld"},
+ {__LINE__, 0x0000b0a3, "0xb0a3", "%#0x"},
+ {__LINE__, 0x001ceebb, "1CEEBB", "%-3.4X"},
+ {__LINE__, 0x00025101, "0x25101", "%#x"},
+ {__LINE__, -0x0000001, "-1", "%0ld"},
+ {__LINE__, 0xffffd846, "FFFFD846", "%+2.3X"},
+ {__LINE__, 0x00001d79, " 7545", "% 0.1ld"},
+ {__LINE__, -0x0000002, " -2", "%5d"},
+ {__LINE__, 0xf93b9fdc, "f93b9fdc", "%5x"},
+ {__LINE__, 0xffff0021, "FFFF0021", "%6X"},
+ {__LINE__, 0x00007cf9, "7cf9", "%3.1x"},
+ {__LINE__, -0x0000002, "-2", "%d"},
+ {__LINE__, 0x00001d84, "1d84", "%0x"},
+ {__LINE__, -0x033201e, "-3350558", "%-2.0d"},
+ {__LINE__, 0xfff8a6fb, "FFF8A6FB", "%+.7X"},
+ {__LINE__, 0x00006fff, " 28671", "% ld"},
+ {__LINE__, -0x02a274a, "-2762570", "%d"},
+ {__LINE__, -0x0006628, "-26152", "%00ld"},
+ {__LINE__, 0x00000011, "11", "%-x"},
+ {__LINE__, -0x0000ed9, "-3801", "%0.ld"},
+ {__LINE__, 0xfc5b725d, "FC5B725D", "%X"},
+ {__LINE__, 0x3530bd4e, "892386638", "%7.d"},
+ {__LINE__, 0x03bb4ff7, "62607351", "%#4.7ld"},
+ {__LINE__, 0x00009f86, "9f86", "%x"},
+ {__LINE__, 0x0000e727, "59175", "%1d"},
+ {__LINE__, 0xfffffdf2, "0XFFFFFDF2", "%#X"},
+ {__LINE__, 0x00e60dbf, "0XE60DBF", "% #1.X"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%+X"},
+ {__LINE__, 0x0a16f44e, "0XA16F44E", "%#.0X"},
+ {__LINE__, 0x0001f97c, "1f97c", "% x"},
+ {__LINE__, 0x0000000d, "13", "%#0ld"},
+ {__LINE__, 0x0000002a, "42", "%0ld"},
+ {__LINE__, 0x00000007, " +7", "%+5ld"},
+ {__LINE__, 0xffffff7f, "FFFFFF7F", "%-X"},
+ {__LINE__, 0x000006a6, "1702", "%ld"},
+ {__LINE__, 0xfaff2fb1, "faff2fb1", "% x"},
+ {__LINE__, 0xffff94ab, "ffff94ab", "%x"},
+ {__LINE__, 0x011d611b, "0X11D611B", "%#2.3X"},
+ {__LINE__, 0x00000000, " +000", "%+#5.3ld"},
+ {__LINE__, -0x87fcc37, "-142593079", "%+d"},
+ {__LINE__, -0x0417424, "-4289572", "%+d"},
+ {__LINE__, 0x03fabc0c, "3fabc0c", "%x"},
+ {__LINE__, 0xfffff880, "fffff880", "%-x"},
+ {__LINE__, 0x000002d7, "2d7", "%-02.x"},
+ {__LINE__, 0x00003e82, "16002", "%#d"},
+ {__LINE__, -0x0003713, "-14099", "% 5d"},
+ {__LINE__, -0x0000027, "-39", "%ld"},
+ {__LINE__, 0x00013098, "0077976", "%01.7d"},
+ {__LINE__, -0x000000c, "-12", "%ld"},
+ {__LINE__, -0x00000c0, "-192", "% ld"},
+ {__LINE__, 0xffbe9285, "FFBE9285", "%3.X"},
+ {__LINE__, 0x00000046, "46", "%x"},
+ {__LINE__, 0x00000000, " ", "%+4.x"},
+ {__LINE__, 0x00011e72, "73330", "%2.3d"},
+ {__LINE__, -0x5276dd7, "-86470103", "%d"},
+ {__LINE__, 0x00000013, "19", "%-02.ld"},
+ {__LINE__, 0x384118a7, "0X384118A7", "%-#X"},
+ {__LINE__, 0x00000000, "0", "% #X"},
+ {__LINE__, 0x00000009, "9", "%#ld"},
+ {__LINE__, 0x00021145, "135493", "%-ld"},
+ {__LINE__, 0xff188a0c, "FF188A0C", "%1.X"},
+ {__LINE__, 0xffffffd5, "ffffffd5", "%0x"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "% 0X"},
+ {__LINE__, 0xffff74a3, "ffff74a3", "%x"},
+ {__LINE__, 0x01d5a2f8, "1d5a2f8", "%-0.x"},
+ {__LINE__, 0xfffffef6, "fffffef6", "%+06.x"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, 0x00000000, "+0", "%+ld"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%4.x"},
+ {__LINE__, -0x0000344, "-0836", "% .4d"},
+ {__LINE__, 0xfffffffd, "FFFFFFFD", "%0X"},
+ {__LINE__, 0x000a3121, "667937", "%#4.4ld"},
+ {__LINE__, 0x0001e211, "0X1E211", "%#X"},
+ {__LINE__, 0x00000c8b, "00C8B", "%05X"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%+0x"},
+ {__LINE__, 0x001a53ce, "1725390", "%d"},
+ {__LINE__, 0x0000057f, "57f ", "%-7.x"},
+ {__LINE__, -0x0073e4d, "-474701", "%#ld"},
+ {__LINE__, -0x0000002, " -2", "% 3.d"},
+ {__LINE__, 0x482dc404, "482DC404", "%X"},
+ {__LINE__, 0x0000011c, "11c", "%-.1x"},
+ {__LINE__, 0x00000c12, " 3090", "%5.3ld"},
+ {__LINE__, 0xfffe1068, "FFFE1068", "%-.4X"},
+ {__LINE__, -0x0055e88, "-351880", "%ld"},
+ {__LINE__, 0x000c9cef, "+826607", "%+d"},
+ {__LINE__, 0xffffffe3, "ffffffe3", "%0x"},
+ {__LINE__, -0x0000ee9, "-3817", "%#ld"},
+ {__LINE__, 0xff1f6daa, "FF1F6DAA", "%X"},
+ {__LINE__, 0xfffffc4e, "FFFFFC4E", "%5.2X"},
+ {__LINE__, -0x000040a, "-1034", "%d"},
+ {__LINE__, -0x0000085, "-00133", "% 01.5d"},
+ {__LINE__, -0x126c797c, "-309098876", "%5.ld"},
+ {__LINE__, 0x00000039, " 57", "% d"},
+ {__LINE__, 0xfffffff6, "0xfffffff6", "%#5.x"},
+ {__LINE__, 0xfffffff4, "fffffff4", "%7.6x"},
+ {__LINE__, 0x00000003, "3", "%ld"},
+ {__LINE__, 0x0000f8ae, "f8ae", "%.0x"},
+ {__LINE__, 0x003ca1cf, "3973583", "%#3.7d"},
+ {__LINE__, 0x14687009, "0x14687009", "%+#3x"},
+ {__LINE__, 0xfffff1f7, "0xfffff1f7", "%#4.5x"},
+ {__LINE__, 0xfffff17a, "fffff17a", "%3.x"},
+ {__LINE__, 0x0011ea18, "1174040", "%ld"},
+ {__LINE__, -0x0000019, "-25", "%03.d"},
+ {__LINE__, 0x00015d72, "0X15D72", "%-#X"},
+ {__LINE__, 0xffde4a41, "ffde4a41", "%x"},
+ {__LINE__, 0x00006f1f, "28447", "%d"},
+ {__LINE__, 0xffffffbd, "0xffffffbd", "%#.1x"},
+ {__LINE__, 0x000013b9, "13B9", "%0X"},
+ {__LINE__, -0x00001b9, "-00441", "%1.5d"},
+ {__LINE__, 0x00000001, "000001", "%-.6d"},
+ {__LINE__, 0x7b602d8f, "+2069900687", "%+0ld"},
+ {__LINE__, 0x0005e323, "+385827", "%+ld"},
+ {__LINE__, 0x00002fce, "2FCE", "%+0X"},
+ {__LINE__, 0x0000000e, "0014", "%.4d"},
+ {__LINE__, 0xffffffd6, "0XFFFFFFD6", "%#4.X"},
+ {__LINE__, 0x037bf361, "58454881", "%5.ld"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%-7.5X"},
+ {__LINE__, -0x016d4dc, "-1496284", "%6ld"},
+ {__LINE__, 0x0005be9a, "0x5be9a", "%-#.5x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%1x"},
+ {__LINE__, 0x00000055, " 85", "% 7.d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, -0x0135392, "-1266578", "% ld"},
+ {__LINE__, 0x00850f26, "8720166", "%d"},
+ {__LINE__, 0xffffee39, "ffffee39", "%0x"},
+ {__LINE__, 0x000000dd, "221", "%ld"},
+ {__LINE__, 0x00000000, " ", "%6.d"},
+ {__LINE__, 0x000000d8, "d8", "%x"},
+ {__LINE__, 0x000007ec, "002028", "%4.6ld"},
+ {__LINE__, 0x0dab4e67, "0XDAB4E67", "%#X"},
+ {__LINE__, 0xfffd7c95, "FFFD7C95", "% 4X"},
+ {__LINE__, 0x0009302d, "9302D", "%3.1X"},
+ {__LINE__, 0x00000003, " 3", "% d"},
+ {__LINE__, 0x0000082f, "82f", "%-x"},
+ {__LINE__, 0x0652517f, "652517F", "%-.2X"},
+ {__LINE__, -0x1fd8f4e3, "-534312163", "%d"},
+ {__LINE__, 0x00000176, "176", "%-x"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, 0x0000001a, "1A", "%X"},
+ {__LINE__, -0x0005740, "-22336", "% 0ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%6x"},
+ {__LINE__, 0x1b273b80, "0x1b273b80", "%#x"},
+ {__LINE__, 0x00000065, "65", "%X"},
+ {__LINE__, 0x6a62138a, "1784812426", "%2ld"},
+ {__LINE__, 0x000001a2, "1A2", "%X"},
+ {__LINE__, -0x002aafd, "-174845", "%02.ld"},
+ {__LINE__, 0x00000014, "20", "%d"},
+ {__LINE__, -0x00000c7, " -199", "%7.0ld"},
+ {__LINE__, 0xff545bfd, "ff545bfd", "%-x"},
+ {__LINE__, -0x002beb9, "-179897", "%02.2ld"},
+ {__LINE__, -0x00000df, "-223", "% 02.d"},
+ {__LINE__, -0x000d569, "-54633", "%1.ld"},
+ {__LINE__, 0x0000000e, "14", "%d"},
+ {__LINE__, -0x0077407, "-488455", "% ld"},
+ {__LINE__, 0x0001be09, "114185", "%ld"},
+ {__LINE__, -0x0000514, "-01300", "%+05.5d"},
+ {__LINE__, 0xf1fb397f, "f1fb397f", "%+x"},
+ {__LINE__, 0xfdb6707c, "FDB6707C", "%X"},
+ {__LINE__, 0x03cad111, "3cad111", "%5.x"},
+ {__LINE__, -0x022e72f, "-2287407", "%d"},
+ {__LINE__, -0xda35f48, "-228810568", "%d"},
+ {__LINE__, -0x02d1fd4, "-2957268", "%1.3d"},
+ {__LINE__, 0x0000005f, "+95", "%+2d"},
+ {__LINE__, 0xfffbf8a1, "FFFBF8A1", "%4.2X"},
+ {__LINE__, 0x0000071e, " 71e", "%6.x"},
+ {__LINE__, 0x000cc8a5, "+837797", "%+03ld"},
+ {__LINE__, 0x000eebe9, " EEBE9", "%6.X"},
+ {__LINE__, -0x2896b204, "-680964612", "%d"},
+ {__LINE__, -0x09553f8, "-9786360", "%d"},
+ {__LINE__, 0x000015d3, "5587", "%0d"},
+ {__LINE__, 0x0000056d, " 56d", "%+4.x"},
+ {__LINE__, -0x00624ad, "-402605", "% ld"},
+ {__LINE__, 0xfea64ba5, "0xfea64ba5", "%#1x"},
+ {__LINE__, 0x004f35c6, "5191110", "%-ld"},
+ {__LINE__, -0x1441fe4, "-21241828", "%d"},
+ {__LINE__, 0xffffff95, "FFFFFF95", "%X"},
+ {__LINE__, 0xfffecf81, "FFFECF81", "%-2.X"},
+ {__LINE__, -0x00002bb, "-699", "%-d"},
+ {__LINE__, -0x0000c29, "-3113", "% 02ld"},
+ {__LINE__, 0x000026a3, " 9891", "% .4d"},
+ {__LINE__, 0x00000003, "3", "%-x"},
+ {__LINE__, 0x000007db, "+02011", "%+.5ld"},
+ {__LINE__, 0xfff99558, "FFF99558", "%.1X"},
+ {__LINE__, 0x0000fce6, "64742", "%4.0d"},
+ {__LINE__, 0x000b7ea2, "753314", "%ld"},
+ {__LINE__, 0x13e5df30, "0X13E5DF30", "%#2.X"},
+ {__LINE__, 0x006761c4, "06761C4", "%6.7X"},
+ {__LINE__, 0xffffff78, "FFFFFF78", "%0.X"},
+ {__LINE__, 0xfffff1c0, "0xfffff1c0", "% #x"},
+ {__LINE__, -0x034af1c, "-3452700", "% 06.1d"},
+ {__LINE__, 0x000000de, "0000222", "%2.7ld"},
+ {__LINE__, 0x000003d8, "0x3d8", "%#4.x"},
+ {__LINE__, -0x001a1d1, "-106961", "%3.1d"},
+ {__LINE__, -0x0000002, "-2", "% d"},
+ {__LINE__, 0x00001de6, "+7654", "%+0ld"},
+ {__LINE__, 0x00000001, "001", "%#.3d"},
+ {__LINE__, -0x53dacf9f, "-1406848927", "%ld"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%3.3x"},
+ {__LINE__, -0x00950e8, "-610536", "%3.6ld"},
+ {__LINE__, 0xff14ade9, "FF14ADE9", "%6X"},
+ {__LINE__, 0x012f5284, "0X12F5284", "% #5X"},
+ {__LINE__, 0x00005a21, " 5a21", "%5x"},
+ {__LINE__, 0x00000638, "1592", "%2.4ld"},
+ {__LINE__, -0x063017b, "-6488443", "%ld"},
+ {__LINE__, 0x00000000, "0", "% X"},
+ {__LINE__, 0xfffe8ef2, "FFFE8EF2", "%+0X"},
+ {__LINE__, -0x0001c96, "-7318", "%.3d"},
+ {__LINE__, 0x0000ca7d, "51837", "%ld"},
+ {__LINE__, 0x00000001, "1", "%+1x"},
+ {__LINE__, 0xfffff7bc, "FFFFF7BC", "%X"},
+ {__LINE__, -0x03d15e2, "-4003298", "%ld"},
+ {__LINE__, 0xfffffffe, "fffffffe", "% x"},
+ {__LINE__, 0x00066183, "+418179", "%+7.1ld"},
+ {__LINE__, 0xffffef2e, "ffffef2e", "%-2.x"},
+ {__LINE__, 0x00000000, " 000", "%04.3x"},
+ {__LINE__, -0x000000f, "-15", "% d"},
+ {__LINE__, -0x00001f5, "-501", "%d"},
+ {__LINE__, 0x0c67f159, "c67f159", "%6.2x"},
+ {__LINE__, -0x0000006, "-6", "%.1d"},
+ {__LINE__, 0x00000005, "0X5", "%+#1X"},
+ {__LINE__, -0x0000002, " -2", "%6.ld"},
+ {__LINE__, 0xeb2183ec, "eb2183ec", "% x"},
+ {__LINE__, -0x5e12a322, "-1578279714", "%d"},
+ {__LINE__, 0x00000001, "0x1", "%#x"},
+ {__LINE__, -0x0001ea4, "-7844", "%0d"},
+ {__LINE__, -0x19955a3, "-26826147", "%d"},
+ {__LINE__, 0x000002a6, "2A6", "%2.X"},
+ {__LINE__, 0x00000002, "2", "%X"},
+ {__LINE__, 0xfffffeec, "fffffeec", "%0.4x"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%0x"},
+ {__LINE__, 0xffdfe740, "FFDFE740", "% X"},
+ {__LINE__, -0x0b0b3e7, "-11580391", "%.1d"},
+ {__LINE__, 0x8e01077c, "8E01077C", "%5.7X"},
+ {__LINE__, 0x3b6b6d55, "996896085", "%1.1d"},
+ {__LINE__, 0x000016af, "5807", "%ld"},
+ {__LINE__, -0x0004900, "-18688", "%d"},
+ {__LINE__, 0xfffd77bc, "FFFD77BC", "%X"},
+ {__LINE__, 0x004cbd74, "5029236", "%0d"},
+ {__LINE__, 0x00000003, " 00003", "%6.5d"},
+ {__LINE__, 0x0004720f, "4720f", "% x"},
+ {__LINE__, 0x0e44535d, "e44535d", "%4x"},
+ {__LINE__, 0xfffffff9, "FFFFFFF9", "%3.3X"},
+ {__LINE__, -0x0000005, "-5", "%-d"},
+ {__LINE__, 0x000001a6, "00001A6", "%1.7X"},
+ {__LINE__, 0x0000004a, "4A", "%-2.X"},
+ {__LINE__, 0xfffff249, "FFFFF249", "%X"},
+ {__LINE__, 0x00004345, "4345", "%x"},
+ {__LINE__, 0x0197041d, "197041d", "%+0x"},
+ {__LINE__, 0x0000019a, " 19a", "% 6.x"},
+ {__LINE__, 0xfff98376, "FFF98376", "%X"},
+ {__LINE__, 0xfc536c41, "FC536C41", "%X"},
+ {__LINE__, -0x0008d91, "-36241", "% d"},
+ {__LINE__, 0xf058d69d, "f058d69d", "%4.x"},
+ {__LINE__, -0x00013ef, "-5103", "%d"},
+ {__LINE__, -0x0000003, "-3", "%00ld"},
+ {__LINE__, -0x09e80f0, "-10387696", "%+07ld"},
+ {__LINE__, -0x0222c15, "-2239509", "%#0.4ld"},
+ {__LINE__, 0x00000004, "4", "%0ld"},
+ {__LINE__, -0x02c6b0d, "-2910989", "% 0ld"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%-4X"},
+ {__LINE__, 0xffffff3d, "FFFFFF3D", "%-.0X"},
+ {__LINE__, -0x0000015, "-21", "%0d"},
+ {__LINE__, 0x131dfc90, "+320732304", "%+d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%+x"},
+ {__LINE__, 0x000035c8, "13768", "%0ld"},
+ {__LINE__, 0x00000033, "0x0033", "%#.4x"},
+ {__LINE__, 0x0ce7e8c1, "0xce7e8c1", "%#.7x"},
+ {__LINE__, 0xfc18b5d2, "FC18B5D2", "%+.3X"},
+ {__LINE__, 0x00000015, "21", "%d"},
+ {__LINE__, 0x001a5e7c, "1a5e7c", "%05x"},
+ {__LINE__, -0x000fbf0, "-64496", "%ld"},
+ {__LINE__, -0x000a4f7, "-042231", "%+2.6d"},
+ {__LINE__, -0x0000002, "-002", "%3.3ld"},
+ {__LINE__, 0x00728878, "728878", "%0X"},
+ {__LINE__, -0x0000002, "-2", "%#.1ld"},
+ {__LINE__, -0x00002ef, "-751", "%-0ld"},
+ {__LINE__, 0xfffffff7, "fffffff7", "%.3x"},
+ {__LINE__, 0x00491867, "0491867", "%.7X"},
+ {__LINE__, 0x00000d4d, "3405", "%-ld"},
+ {__LINE__, 0x00234e86, "234E86", "%0X"},
+ {__LINE__, -0x000001b, "-27", "%ld"},
+ {__LINE__, 0x00275255, "2576981", "%.5ld"},
+ {__LINE__, 0xfeacc214, "0XFEACC214", "%-#3.X"},
+ {__LINE__, -0x0001ce5, "-7397", "%+#2.2ld"},
+ {__LINE__, 0x089ddb6a, "144563050", "%d"},
+ {__LINE__, 0x003d5a95, "3D5A95", "%1X"},
+ {__LINE__, 0x002f0b6d, "3083117", "%d"},
+ {__LINE__, 0x1e79e228, "511304232", "%ld"},
+ {__LINE__, 0xfffffe6b, "FFFFFE6B", "%+0X"},
+ {__LINE__, -0x5104ff3, "-84955123", "%.4ld"},
+ {__LINE__, 0xfffff1de, "FFFFF1DE", "%X"},
+ {__LINE__, 0x000000cf, "+207", "%+.1ld"},
+ {__LINE__, -0x16ad0164, "-380436836", "%+5.d"},
+ {__LINE__, 0x001fefa6, "2092966", "%ld"},
+ {__LINE__, 0x00000000, "00", "%-.2d"},
+ {__LINE__, 0x00195f45, "195f45", "%+0x"},
+ {__LINE__, 0x00000001, " 1", "%3.ld"},
+ {__LINE__, -0x00001c9, "-457", "% ld"},
+ {__LINE__, 0x0002479e, "149406", "%#ld"},
+ {__LINE__, 0x001ab18b, "1749387", "%04d"},
+ {__LINE__, 0x00000045, "69", "%ld"},
+ {__LINE__, 0xfbb13f7d, "fbb13f7d", "%.2x"},
+ {__LINE__, 0x03ddc208, "3ddc208", "%x"},
+ {__LINE__, 0x00000007, "000007", "%#.6d"},
+ {__LINE__, 0x00000000, "0", "%01X"},
+ {__LINE__, -0x0023110, "-143632", "%+0.3d"},
+ {__LINE__, 0x00000006, "06", "%#.2d"},
+ {__LINE__, 0xffff9ec9, "ffff9ec9", "%7x"},
+ {__LINE__, -0x08afb12, "-9108242", "% #0.ld"},
+ {__LINE__, 0x00000004, "4", "%X"},
+ {__LINE__, 0x00059684, "59684", "%x"},
+ {__LINE__, 0xfff8d8f5, "FFF8D8F5", "%X"},
+ {__LINE__, 0x00b7027d, "+11993725", "%+0.7ld"},
+ {__LINE__, 0x0000d814, "55316", "%0ld"},
+ {__LINE__, 0x03c95a08, "3c95a08", "%3x"},
+ {__LINE__, -0x0b65f9a, "-11952026", "%d"},
+ {__LINE__, 0xfd956021, "fd956021", "%0x"},
+ {__LINE__, 0x000000ed, "ed", "%0x"},
+ {__LINE__, -0x006a80c, "-436236", "%.6ld"},
+ {__LINE__, 0xfedb109d, "fedb109d", "%x"},
+ {__LINE__, 0x00000001, "1", "%X"},
+ {__LINE__, 0x00b3eb71, " 11791217", "% d"},
+ {__LINE__, 0x00000016, "16", "%0X"},
+ {__LINE__, 0x000001db, " 475", "% ld"},
+ {__LINE__, 0x00465eaf, "4611759", "%0d"},
+ {__LINE__, 0x0001b423, "1B423", "%0X"},
+ {__LINE__, 0x05df95ea, "5df95ea", "%+.5x"},
+ {__LINE__, 0x0000000e, " 14", "%7ld"},
+ {__LINE__, 0xffffb89e, "ffffb89e", "%+x"},
+ {__LINE__, 0x01259918, " 19241240", "% d"},
+ {__LINE__, -0x0000f8d, "-003981", "%+#.6d"},
+ {__LINE__, 0x00054ae0, "54AE0", "%X"},
+ {__LINE__, -0x4589ed4, "-72916692", "% ld"},
+ {__LINE__, 0x01017516, "1017516", "%6X"},
+ {__LINE__, 0xfffb9f15, "FFFB9F15", "%.2X"},
+ {__LINE__, 0x005f8394, "5F8394", "%.2X"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, -0x0000001, " -1", "%7.1ld"},
+ {__LINE__, 0x004367af, "4417455", "%4.ld"},
+ {__LINE__, 0xffffff86, "ffffff86", "%4.5x"},
+ {__LINE__, -0x0000d17, "-3351", "%2.0ld"},
+ {__LINE__, 0xffffff31, "ffffff31", "%.6x"},
+ {__LINE__, -0x0000001, "-1", "%ld"},
+ {__LINE__, -0x3d785fab, "-1031298987", "%d"},
+ {__LINE__, -0x0000002, "-2", "%-0ld"},
+ {__LINE__, 0x0000019c, "412", "%d"},
+ {__LINE__, -0x0006f54, "-28500", "%d"},
+ {__LINE__, 0xfffe3524, "FFFE3524", "% 6.2X"},
+ {__LINE__, -0x128d3c00, "-311245824", "%2d"},
+ {__LINE__, -0x3be71293, "-1004999315", "%d"},
+ {__LINE__, 0x0000659d, "26013", "%d"},
+ {__LINE__, 0x2d947538, "+764704056", "%+5d"},
+ {__LINE__, 0xffa2a420, "FFA2A420", "%0X"},
+ {__LINE__, 0x00000001, "1", "%d"},
+ {__LINE__, 0x04477c14, "4477c14", "%.6x"},
+ {__LINE__, -0x06e145b, "-7214171", "%d"},
+ {__LINE__, 0x00009c01, "39937", "%-.1d"},
+ {__LINE__, 0xffde174b, "ffde174b", "% 0x"},
+ {__LINE__, 0x0001fbae, "1FBAE", "%01.X"},
+ {__LINE__, -0x06b8406, "-7046150", "%d"},
+ {__LINE__, 0x000005b8, "005b8", "%05x"},
+ {__LINE__, -0x02d780b, "-2979851", "%1d"},
+ {__LINE__, 0x00209e26, "2137638", "%2d"},
+ {__LINE__, 0x0000041a, "41A", "%0X"},
+ {__LINE__, 0x2a77f42c, "2A77F42C", "%02X"},
+ {__LINE__, 0x13b6ee14, "+330755604", "%+0d"},
+ {__LINE__, -0x0000002, "-2 ", "%-6.d"},
+ {__LINE__, -0x0001eee, "-7918", "% #2.ld"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "% .5X"},
+ {__LINE__, 0x20d11927, "20d11927", "% 0.x"},
+ {__LINE__, -0x0018690, "-99984", "% ld"},
+ {__LINE__, 0x000002a0, "2A0", "%-0X"},
+ {__LINE__, -0x0000511, "-1297", "%+d"},
+ {__LINE__, 0x0e782f31, "242757425", "%-0.ld"},
+ {__LINE__, 0x2ce06da0, "752905632", "%#0ld"},
+ {__LINE__, 0x00000062, "62 ", "%-07x"},
+ {__LINE__, -0x015d9d8, "-1432024", "% 7d"},
+ {__LINE__, 0xc9125ea8, "c9125ea8", "%x"},
+ {__LINE__, 0x00000006, "6", "%.0ld"},
+ {__LINE__, 0x0000019c, "19c", "%x"},
+ {__LINE__, 0x00000000, " ", "%6.d"},
+ {__LINE__, 0x00043e89, "278153", "%0ld"},
+ {__LINE__, 0x3e422abd, "1044523709", "%ld"},
+ {__LINE__, 0x0220a75d, "35694429", "%#7.6d"},
+ {__LINE__, 0x0000c21c, "C21C", "% X"},
+ {__LINE__, 0x000074ab, "29867", "%d"},
+ {__LINE__, 0x056b22aa, "56B22AA", "%+0.X"},
+ {__LINE__, 0xfffffff9, "FFFFFFF9", "%X"},
+ {__LINE__, 0x00000000, "0", "%X"},
+ {__LINE__, 0xf094a4f4, "f094a4f4", "%+4.x"},
+ {__LINE__, -0x1dad0244, "-497877572", "%d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%.1X"},
+ {__LINE__, 0xfffffe2d, "fffffe2d", "%7.x"},
+ {__LINE__, 0x0000042b, "0x42b", "%#x"},
+ {__LINE__, -0x0000001, "-1", "% d"},
+ {__LINE__, 0x00e77ef5, " 15171317", "% 7.ld"},
+ {__LINE__, 0x00006210, " 25104", "% 06d"},
+ {__LINE__, 0x0011187a, "1120378", "%-ld"},
+ {__LINE__, -0x000000b, "-11", "% #ld"},
+ {__LINE__, 0x14cfaff0, "14cfaff0", "%-2.3x"},
+ {__LINE__, 0xffff74ea, "FFFF74EA", "%3.X"},
+ {__LINE__, 0x000bfb9d, "bfb9d", "%x"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%X"},
+ {__LINE__, 0x00014500, "0X14500", "%#4.X"},
+ {__LINE__, -0x0000001, "-1", "%#1d"},
+ {__LINE__, -0x0000024, "-36", "%-0d"},
+ {__LINE__, -0x6528828, "-106072104", "%d"},
+ {__LINE__, 0x00000075, " 117", "% #d"},
+ {__LINE__, 0xff027d67, "ff027d67", "%0x"},
+ {__LINE__, 0x0012b8b3, "12b8b3", "%0.1x"},
+ {__LINE__, 0x1070147b, "275780731", "%.6ld"},
+ {__LINE__, 0xffffe88e, "FFFFE88E", "%1.3X"},
+ {__LINE__, 0xfffffc0d, "fffffc0d", "%00.6x"},
+ {__LINE__, 0xffd889f5, "ffd889f5", "%x"},
+ {__LINE__, 0x00000470, "1136", "%0ld"},
+ {__LINE__, 0x000297f8, "169976", "%ld"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%+1x"},
+ {__LINE__, 0x0000064a, "64a", "%x"},
+ {__LINE__, -0x3d71e43b, "-1030874171", "%1.d"},
+ {__LINE__, -0x0000004, "-4 ", "%-3.d"},
+ {__LINE__, 0xfffff132, "FFFFF132", "%0.0X"},
+ {__LINE__, 0x37b6356f, "37b6356f", "%-x"},
+ {__LINE__, 0xffffff7a, "FFFFFF7A", "%.0X"},
+ {__LINE__, 0x00023553, "23553", "%x"},
+ {__LINE__, 0x39a4c29f, "39a4c29f", "%+5.x"},
+ {__LINE__, 0xffffffcc, "ffffffcc", "%x"},
+ {__LINE__, 0x0003a83b, "239675", "%#6ld"},
+ {__LINE__, 0x00000002, "2", "%0x"},
+ {__LINE__, -0x09b4e8c, "-10178188", "%+03.ld"},
+ {__LINE__, 0x00000002, "0000002", "%-#.7ld"},
+ {__LINE__, 0x00000b5e, "2910", "%-04ld"},
+ {__LINE__, -0x0000254, "-596", "%+0d"},
+ {__LINE__, 0x00000001, "1", "%+1.x"},
+ {__LINE__, 0xf8290d3e, "0XF8290D3E", "% #X"},
+ {__LINE__, 0x00000035, "035", "%3.3X"},
+ {__LINE__, 0x00131d7d, "131D7D ", "%-7.6X"},
+ {__LINE__, 0xffdbb36a, "0xffdbb36a", "%#.6x"},
+ {__LINE__, 0xc7275816, "c7275816", "%04.x"},
+ {__LINE__, 0x00bae994, "12249492", "%0ld"},
+ {__LINE__, 0x00000002, "+2", "%+0.0ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%0x"},
+ {__LINE__, 0xffffffe0, "ffffffe0", "%x"},
+ {__LINE__, 0x00000036, "36", "%.0X"},
+ {__LINE__, 0xfffffffd, "FFFFFFFD", "%1X"},
+ {__LINE__, 0xffffffc8, "ffffffc8", "%+x"},
+ {__LINE__, 0xe71c3689, "e71c3689", "%x"},
+ {__LINE__, 0x00000007, "7 ", "%-3.ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, 0x00030400, "030400", "%-4.6x"},
+ {__LINE__, 0xbd8c6fa7, "BD8C6FA7", "%-6X"},
+ {__LINE__, 0x00000233, "0000563", "%.7ld"},
+ {__LINE__, 0xfef92e35, "fef92e35", "%x"},
+ {__LINE__, 0xffff2172, "ffff2172", "%3x"},
+ {__LINE__, 0x00001233, "1233", "% X"},
+ {__LINE__, -0x000d2e1, "-53985", "%-0d"},
+ {__LINE__, -0x3ba8cb5b, "-1000917851", "%0d"},
+ {__LINE__, -0x4fefb9a, "-83819418", "%5.ld"},
+ {__LINE__, 0xffffe9eb, "FFFFE9EB", "%X"},
+ {__LINE__, 0x1e472dc3, "507981251", "%ld"},
+ {__LINE__, -0x0077046, "-487494", "%0d"},
+ {__LINE__, 0x0002c4c9, "+181449", "%+7.d"},
+ {__LINE__, 0xfffffe63, "fffffe63", "%x"},
+ {__LINE__, 0xfff5a6db, "FFF5A6DB", "%X"},
+ {__LINE__, 0x00174442, "174442", "%-5.0X"},
+ {__LINE__, 0x017891d9, "17891D9", "%+5.X"},
+ {__LINE__, 0x0261966b, "261966B", "%-X"},
+ {__LINE__, -0x3e58614d, "-1045979469", "%ld"},
+ {__LINE__, 0x002c4c41, "+2903105", "%+01ld"},
+ {__LINE__, 0x0000000c, "012", "%#.3d"},
+ {__LINE__, 0x0380f73a, "58783546", "%ld"},
+ {__LINE__, 0x000002c7, "0000711", "%2.7ld"},
+ {__LINE__, 0x00000002, " 002", "% 04ld"},
+ {__LINE__, 0x00687ca0, "687CA0", "%X"},
+ {__LINE__, 0x0000058a, "1418", "%0ld"},
+ {__LINE__, -0x0000642, "-1602", "% ld"},
+ {__LINE__, 0x0001f4f1, "1F4F1", "%X"},
+ {__LINE__, 0x0026d6fc, "+2545404", "%+4.ld"},
+ {__LINE__, 0x05dd423c, "+98386492", "%+#ld"},
+ {__LINE__, 0x0000782c, "0782C", "%3.5X"},
+ {__LINE__, 0xf67d91f8, "f67d91f8", "%-x"},
+ {__LINE__, 0xffffcf2d, "ffffcf2d", "%+0x"},
+ {__LINE__, -0x00af8a6, "-719014", "%0ld"},
+ {__LINE__, -0xe606ef9, "-241200889", "%ld"},
+ {__LINE__, 0xfe9d87f7, "fe9d87f7", "%+x"},
+ {__LINE__, 0x00000d44, "d44", "% 1.x"},
+ {__LINE__, 0x008716f5, "8716f5", "%2x"},
+ {__LINE__, 0x000027d4, "27D4", "% X"},
+ {__LINE__, 0xfdfd92ea, "FDFD92EA", "%-.4X"},
+ {__LINE__, 0xfffe764f, "FFFE764F", "%X"},
+ {__LINE__, 0xff699032, "ff699032", "%3.x"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%-3X"},
+ {__LINE__, -0x368ba995, "-915122581", "%+#.6ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%0x"},
+ {__LINE__, 0x0000035e, " 862", "% 1d"},
+ {__LINE__, 0xfe703e67, "fe703e67", "%07.0x"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%4.x"},
+ {__LINE__, 0x000e20cf, "e20cf", "%0x"},
+ {__LINE__, 0x000063b5, "0X63B5", "%-#X"},
+ {__LINE__, 0xfffffffa, "fffffffa", "%+2.x"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%2.X"},
+ {__LINE__, 0xfdfd69da, "FDFD69DA", "%.0X"},
+ {__LINE__, 0x00002f61, "0x2f61", "%#3.x"},
+ {__LINE__, 0x00000009, "9", "%x"},
+ {__LINE__, 0xffffff86, "ffffff86", "%6x"},
+ {__LINE__, 0xffffffe4, "ffffffe4", "%0x"},
+ {__LINE__, 0x0062e73b, "+6481723", "%+0ld"},
+ {__LINE__, -0x2b059130, "-721785136", "%+d"},
+ {__LINE__, -0x0000073, "-115", "%d"},
+ {__LINE__, 0xf596efcf, "f596efcf", "%x"},
+ {__LINE__, 0x0002f1cb, "2F1CB", "%0X"},
+ {__LINE__, -0x0000635, "-01589", "%.5ld"},
+ {__LINE__, 0xfffa011a, "FFFA011A", "%0X"},
+ {__LINE__, 0x00000047, " 47", "%4X"},
+ {__LINE__, 0xfffffbc0, "FFFFFBC0", "%5.2X"},
+ {__LINE__, 0x00000015, "15", "% X"},
+ {__LINE__, 0x002a87a6, "2a87a6", "%.1x"},
+ {__LINE__, -0x000069c, "-1692", "%+ld"},
+ {__LINE__, 0xfffffffd, "fffffffd", "%+x"},
+ {__LINE__, 0xfeda51f5, "FEDA51F5", "%0X"},
+ {__LINE__, 0x001781a4, "1781a4", "%-0x"},
+ {__LINE__, 0xe77358d4, "e77358d4", "%+0x"},
+ {__LINE__, 0x00000084, " 84", "%3.x"},
+ {__LINE__, 0xffff0cb2, "FFFF0CB2", "%+5.X"},
+ {__LINE__, 0x0009fa17, "653847", "%0.0ld"},
+ {__LINE__, -0x0000c92, "-3218", "%d"},
+ {__LINE__, 0x0004ebbb, "4ebbb", "%x"},
+ {__LINE__, 0x2e72568c, "+779245196", "%+#ld"},
+ {__LINE__, 0xffae86a7, "ffae86a7", "%.7x"},
+ {__LINE__, 0xffdf3f04, "ffdf3f04", "%x"},
+ {__LINE__, 0x000000c7, "199", "%2.d"},
+ {__LINE__, -0x0004a55, "-19029", "%ld"},
+ {__LINE__, 0x00564ef9, "5656313", "%.6ld"},
+ {__LINE__, 0xffffc205, "ffffc205", "%+.0x"},
+ {__LINE__, -0x135085d0, "-324044240", "%#.5d"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%-7x"},
+ {__LINE__, -0x0000003, "-3", "%.1ld"},
+ {__LINE__, 0xffda9e0b, "ffda9e0b", "%+0x"},
+ {__LINE__, 0x00000001, "1", "%d"},
+ {__LINE__, 0xffffffda, "ffffffda", "%.6x"},
+ {__LINE__, 0x5efdb3d1, "+1593684945", "%+0d"},
+ {__LINE__, -0x00000ca, "-202", "% 4.d"},
+ {__LINE__, -0x0014433, "-82995", "%.3d"},
+ {__LINE__, -0x0000002, "-000002", "% .6ld"},
+ {__LINE__, 0x24aac879, "615172217", "%.7d"},
+ {__LINE__, -0x1db3c1d, "-31144989", "%+#4ld"},
+ {__LINE__, 0x000945ad, "0x945ad", "%#1x"},
+ {__LINE__, 0x0000000a, "10", "%#.1ld"},
+ {__LINE__, -0x002a2e5, "-172773", "%d"},
+ {__LINE__, 0xfffffff3, "FFFFFFF3", "%5X"},
+ {__LINE__, 0x0000000e, "e", "%+x"},
+ {__LINE__, 0x335333dc, "861090780", "%6.d"},
+ {__LINE__, 0xfffa16f4, "FFFA16F4", "%6X"},
+ {__LINE__, 0xffffc727, "ffffc727", "%+2.x"},
+ {__LINE__, 0x00000273, "273", "%x"},
+ {__LINE__, -0x000000f, "-15", "%-0d"},
+ {__LINE__, 0x00065fbd, "417725", "%5.1d"},
+ {__LINE__, 0x00000ed5, "3797", "%d"},
+ {__LINE__, 0x30a40024, "30A40024", "%3.7X"},
+ {__LINE__, 0x00000054, "84", "%ld"},
+ {__LINE__, 0x00000515, "01301", "%.5ld"},
+ {__LINE__, 0x00000897, "+02199", "%+.5d"},
+ {__LINE__, -0x0001bcc, "-7116", "% ld"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%7X"},
+ {__LINE__, 0x00000013, "0X13", "%#X"},
+ {__LINE__, 0xffffffff, "0xffffffff", "% #x"},
+ {__LINE__, 0x00000006, "6", "%ld"},
+ {__LINE__, -0x00000c3, "-195", "%1.ld"},
+ {__LINE__, -0x005291e, "-338206", "%+d"},
+ {__LINE__, 0xffb437a7, "FFB437A7", "%-0X"},
+ {__LINE__, 0xff8335cb, "ff8335cb", "%x"},
+ {__LINE__, 0x0000006a, "6A", "%2X"},
+ {__LINE__, -0x004f629, "-325161", "% .4d"},
+ {__LINE__, 0x003698ef, "3578095", "%0ld"},
+ {__LINE__, 0x6b5cdf3a, "6b5cdf3a", "%-x"},
+ {__LINE__, 0xe9bc5c21, "e9bc5c21", "%+x"},
+ {__LINE__, -0x0000001, " -1", "%+6.ld"},
+ {__LINE__, 0xfffeffc8, "FFFEFFC8", "%6.X"},
+ {__LINE__, 0xff070a73, "ff070a73", "%+.7x"},
+ {__LINE__, 0x0023f8ae, "2357422", "%07.4ld"},
+ {__LINE__, 0x00000000, "0", "%X"},
+ {__LINE__, 0x00000016, "16", "%0X"},
+ {__LINE__, -0x000005a, " -90", "%4d"},
+ {__LINE__, 0x00000116, "116", "% .3x"},
+ {__LINE__, 0xfffed024, "fffed024", "%-x"},
+ {__LINE__, 0xfb907950, "fb907950", "%.0x"},
+ {__LINE__, 0x0101a1e5, "101a1e5", "%x"},
+ {__LINE__, -0x09e7684, "-10385028", "%-#ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%1x"},
+ {__LINE__, 0xfffffff6, "fffffff6", "%x"},
+ {__LINE__, 0x00000078, "78", "%x"},
+ {__LINE__, 0xe6bca9c9, "0XE6BCA9C9", "%#.5X"},
+ {__LINE__, -0x0000010, "-16", "%d"},
+ {__LINE__, -0x1348f685, "-323548805", "%d"},
+ {__LINE__, 0x4dd85797, "1306023831", "%ld"},
+ {__LINE__, -0x0000080, "-128", "%.2d"},
+ {__LINE__, -0xaed13a7, "-183309223", "%+ld"},
+ {__LINE__, -0x000002f, "-47", "% d"},
+ {__LINE__, -0x679911f, "-108630303", "%ld"},
+ {__LINE__, 0xfffff221, "FFFFF221", "% .7X"},
+ {__LINE__, 0x0007476c, "7476c", "%x"},
+ {__LINE__, 0xffffe02a, "0xffffe02a", "%#7x"},
+ {__LINE__, 0x00000ebb, "0XEBB", "%#X"},
+ {__LINE__, 0xffffffff, "0XFFFFFFFF", "%-#X"},
+ {__LINE__, 0x00281896, "281896", "%+1.x"},
+ {__LINE__, 0x0000085d, " 0X85D", "%#6.3X"},
+ {__LINE__, 0x000112bf, "112BF", "%X"},
+ {__LINE__, 0xf5518fbf, "F5518FBF", "% X"},
+ {__LINE__, -0x00c945b, "-824411", "%ld"},
+ {__LINE__, 0x00001b43, "0x1b43", "%-#x"},
+ {__LINE__, -0x5872a246, "-1483907654", "%#7.7ld"},
+ {__LINE__, 0x00001f96, "8086", "%#d"},
+ {__LINE__, 0xfffffff9, "FFFFFFF9", "%X"},
+ {__LINE__, -0x006e244, "-451140", "% .3d"},
+ {__LINE__, -0x0382188, "-3678600", "%0.2ld"},
+ {__LINE__, 0x00000006, "6", "%-x"},
+ {__LINE__, 0x00000036, "54 ", "%-5.d"},
+ {__LINE__, -0x0000439, " -1081", "%#6.3ld"},
+ {__LINE__, 0xfff911c6, "FFF911C6", "%X"},
+ {__LINE__, -0x03454dc, "-3429596", "%d"},
+ {__LINE__, -0x0363e8d, "-3554957", "%-.2ld"},
+ {__LINE__, 0x00000000, "000", "%.3X"},
+ {__LINE__, -0x59bb030f, "-1505428239", "%0ld"},
+ {__LINE__, 0x073c94d8, "121410776", "%-d"},
+ {__LINE__, -0x001ef94, "-126868", "%5.1ld"},
+ {__LINE__, 0xfff65fc5, "FFF65FC5", "%0X"},
+ {__LINE__, 0xfffffff4, "fffffff4", "%-x"},
+ {__LINE__, 0x00001d83, "07555", "%5.5d"},
+ {__LINE__, 0x0012b40a, "1225738", "%ld"},
+ {__LINE__, -0x0000006, "-6", "%0ld"},
+ {__LINE__, 0xfffffffc, "fffffffc", "%06.0x"},
+ {__LINE__, -0x0000002, "-00002", "%#.5ld"},
+ {__LINE__, 0xf9932c1d, "f9932c1d", "%-x"},
+ {__LINE__, -0x46a31d9, "-74068441", "%.3ld"},
+ {__LINE__, 0x000987e9, "987E9", "%1X"},
+ {__LINE__, 0x0000000f, "15", "%-ld"},
+ {__LINE__, -0x0001c4d, "-7245", "%ld"},
+ {__LINE__, -0x007deee, "-515822", "%2.6d"},
+ {__LINE__, 0xffffffa2, "FFFFFFA2", "%.6X"},
+ {__LINE__, 0x00000001, "1", "%-ld"},
+ {__LINE__, 0xfc106bde, "fc106bde", "%.4x"},
+ {__LINE__, 0x0002f1f8, "0x2f1f8", "%#7.x"},
+ {__LINE__, -0x06a290b, "-6957323", "%-ld"},
+ {__LINE__, -0x0000037, " -55", "%4ld"},
+ {__LINE__, 0x0000152e, "5422", "%2.d"},
+ {__LINE__, 0xfffffcb2, "0XFFFFFCB2", "%#3.X"},
+ {__LINE__, 0x1b7ca086, "1b7ca086", "%+x"},
+ {__LINE__, 0x00000001, "1", "%ld"},
+ {__LINE__, 0x006775fc, "6775fc", "%3.2x"},
+ {__LINE__, 0x0000000e, "0XE", "%#3.X"},
+ {__LINE__, 0xffffffff, "0xffffffff", "%+#4.x"},
+ {__LINE__, 0x00001246, "1246", "%X"},
+ {__LINE__, 0xffffaed6, "ffffaed6", "%2x"},
+ {__LINE__, -0x3a2dec78, "-976088184", "% 0ld"},
+ {__LINE__, 0x0001423b, "1423b", "%01x"},
+ {__LINE__, 0x00000007, " 0X7", "%#4.X"},
+ {__LINE__, 0x01a7ff5a, "27787098", "%.4ld"},
+ {__LINE__, -0x0020d05, "-134405", "%-d"},
+ {__LINE__, 0xffffff9a, "ffffff9a", "%-.1x"},
+ {__LINE__, 0xffff3557, "ffff3557", "%x"},
+ {__LINE__, 0x08828e35, "8828e35", "%+.1x"},
+ {__LINE__, 0x000006b2, "001714", "%04.6ld"},
+ {__LINE__, 0x00000013, "19", "%.0ld"},
+ {__LINE__, -0x00341a5, "-213413", "%#d"},
+ {__LINE__, -0x0000043, "-67", "%d"},
+ {__LINE__, -0x074dce3, "-7658723", "%.1d"},
+ {__LINE__, -0x16de2df3, "-383659507", "% ld"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0x00000ce7, "ce7", "% 2.1x"},
+ {__LINE__, 0xffecd377, "ffecd377", "% 0x"},
+ {__LINE__, 0xa4e8465c, "a4e8465c", "% x"},
+ {__LINE__, 0x000005e8, "1512", "%d"},
+ {__LINE__, 0x00000513, "1299", "%d"},
+ {__LINE__, 0xffffffb8, "FFFFFFB8", "%X"},
+ {__LINE__, 0x00000003, "00003", "%3.5x"},
+ {__LINE__, -0x0000003, "-3 ", "%-3.ld"},
+ {__LINE__, 0xad53f01d, "ad53f01d", "%0x"},
+ {__LINE__, 0x0f1c1dae, "253500846", "%-#.0d"},
+ {__LINE__, 0xff1753c0, "0xff1753c0", "%#3.x"},
+ {__LINE__, -0x00389c5, "-231877", "%d"},
+ {__LINE__, 0x0000016e, "00016E", "%.6X"},
+ {__LINE__, -0x54d3310f, "-1423126799", "%-d"},
+ {__LINE__, 0x00000005, "0X5", "%#.1X"},
+ {__LINE__, 0xfffffffd, "0XFFFFFFFD", "%#5.3X"},
+ {__LINE__, 0xfffffe0e, "fffffe0e", "%-x"},
+ {__LINE__, 0xa3c02157, "a3c02157", "%.5x"},
+ {__LINE__, 0x00005765, "22373", "%d"},
+ {__LINE__, -0x12668cd, "-19294413", "%+ld"},
+ {__LINE__, -0x66544da, "-107300058", "%2d"},
+ {__LINE__, 0x8646c605, "0X8646C605", "% #X"},
+ {__LINE__, 0x000001f5, "1F5", "%X"},
+ {__LINE__, 0x01b33ae4, "28523236", "%5ld"},
+ {__LINE__, 0x000007ce, "7ce", "%3.x"},
+ {__LINE__, 0x00000355, "355", "%X"},
+ {__LINE__, 0x000001ce, "1CE", "% X"},
+ {__LINE__, 0xfffffccd, "fffffccd", "%7.0x"},
+ {__LINE__, -0x0000001, "-1", "%0ld"},
+ {__LINE__, 0x000640b6, "640b6", "%5.x"},
+ {__LINE__, 0x0038c4ec, "3720428", "%5.4d"},
+ {__LINE__, -0x0f10b5e, "-15797086", "%2ld"},
+ {__LINE__, 0x256c815f, "256c815f", "%4.x"},
+ {__LINE__, 0x00000682, " 1666", "%6ld"},
+ {__LINE__, -0x00000ab, "-171", "%2ld"},
+ {__LINE__, 0x00000003, "3", "%0d"},
+ {__LINE__, 0x063f5075, "63F5075", "%X"},
+ {__LINE__, 0xff83b5d0, "FF83B5D0", "%7.X"},
+ {__LINE__, 0xffffffec, "ffffffec", "%x"},
+ {__LINE__, 0xffb551c4, "0XFFB551C4", "% #4.X"},
+ {__LINE__, -0x071f057, "-7467095", "%3.7d"},
+ {__LINE__, 0x00634879, "6506617", "%#ld"},
+ {__LINE__, 0x000001d7, "471", "%d"},
+ {__LINE__, 0x00a7da92, "A7DA92", "% .4X"},
+ {__LINE__, 0x00000003, "3 ", "%-2.ld"},
+ {__LINE__, -0x0000004, "-0004", "%.4d"},
+ {__LINE__, -0x01dea32, "-1960498", "% #7.d"},
+ {__LINE__, 0x53c4159f, "53C4159F", "%1.7X"},
+ {__LINE__, -0x1ad7904, "-28145924", "%#d"},
+ {__LINE__, -0x0000a85, "-2693", "%ld"},
+ {__LINE__, -0x0000c7d, "-3197", "%d"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%+0X"},
+ {__LINE__, 0x00000004, "00004", "%1.5d"},
+ {__LINE__, 0x0000b761, "46945", "%5ld"},
+ {__LINE__, -0x0ee3b2c, "-15612716", "%.6d"},
+ {__LINE__, 0x0677a73d, "677a73d", "% x"},
+ {__LINE__, -0x5f96020, "-100229152", "% d"},
+ {__LINE__, 0x00000000, " 0", "%#7X"},
+ {__LINE__, -0x5d1cb5b, "-97635163", "% ld"},
+ {__LINE__, -0x00a8d8b, "-691595", "%-0ld"},
+ {__LINE__, 0xffffffa2, "FFFFFFA2", "%X"},
+ {__LINE__, 0xffffffc9, "FFFFFFC9", "%X"},
+ {__LINE__, 0x0b180d35, "B180D35", "%X"},
+ {__LINE__, 0xfc0b94ce, "fc0b94ce", "%.1x"},
+ {__LINE__, 0x0012cd7b, "12CD7B", "% X"},
+ {__LINE__, -0x02f1da8, "-3087784", "%ld"},
+ {__LINE__, -0x000a6f9, "-42745", "%-ld"},
+ {__LINE__, -0x000006d, "-109 ", "%-6d"},
+ {__LINE__, 0x00000001, "+1", "%+0d"},
+ {__LINE__, 0x00000001, "1", "%1d"},
+ {__LINE__, 0xfffffff8, "fffffff8", "%5.x"},
+ {__LINE__, -0x00fc4d7, "-1033431", "%+0.5ld"},
+ {__LINE__, 0xffff41b4, "0xffff41b4", "%#x"},
+ {__LINE__, -0x0000d37, "-3383", "%ld"},
+ {__LINE__, 0xffc4e405, "ffc4e405", "%7x"},
+ {__LINE__, 0xffffffb0, "FFFFFFB0", "%04X"},
+ {__LINE__, -0x0054477, "-345207", "%01.ld"},
+ {__LINE__, 0x00512778, "0x512778", "%#3.0x"},
+ {__LINE__, 0x00000007, " 7", "%7.d"},
+ {__LINE__, 0x00000008, " 00008", "% .5ld"},
+ {__LINE__, 0x000053fd, "21501", "%.4ld"},
+ {__LINE__, 0x0000370c, "370c", "%2x"},
+ {__LINE__, -0x44670a7, "-71725223", "%3d"},
+ {__LINE__, 0x00000064, " 64", "%+5x"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%X"},
+ {__LINE__, 0xf7bbf094, "f7bbf094", "%3x"},
+ {__LINE__, 0xfffeb268, "FFFEB268", "%X"},
+ {__LINE__, 0x00001ef0, "1ef0", "%4.x"},
+ {__LINE__, 0x05ad9aa4, " 95263396", "% 0.ld"},
+ {__LINE__, 0xf294dca7, "F294DCA7", "% 4.X"},
+ {__LINE__, -0x0000003, "-000003", "%.6d"},
+ {__LINE__, 0xfff57471, "fff57471", "% x"},
+ {__LINE__, 0x0a848cfd, "176459005", "%d"},
+ {__LINE__, -0x000002e, "-46", "%.0d"},
+ {__LINE__, 0x00000051, " +81", "%+5d"},
+ {__LINE__, -0x000072b, "-0001835", "%06.7d"},
+ {__LINE__, -0x0000002, " -2", "%+#6ld"},
+ {__LINE__, 0x00000003, "3", "%x"},
+ {__LINE__, 0xfffd1799, "FFFD1799", "%6.X"},
+ {__LINE__, 0x00000005, "5", "%ld"},
+ {__LINE__, 0x0052138b, "5378955", "%#7.7ld"},
+ {__LINE__, 0x000000c0, " 192", "% 7ld"},
+ {__LINE__, 0x005b26cd, "5B26CD", "%X"},
+ {__LINE__, -0x008df17, "-581399", "%.4ld"},
+ {__LINE__, 0xfffffad8, "fffffad8", "%-x"},
+ {__LINE__, 0x000006a9, "6a9", "%.0x"},
+ {__LINE__, -0x003b7f9, "-243705", "%+0ld"},
+ {__LINE__, 0x005d7ea4, "6127268", "%ld"},
+ {__LINE__, -0x003ccea, "-249066", "%+.0ld"},
+ {__LINE__, 0x0000846f, "846F", "%X"},
+ {__LINE__, 0x00004f79, "4F79", "%4.X"},
+ {__LINE__, 0xe3e1409c, "E3E1409C", "%-X"},
+ {__LINE__, 0x07cce2f4, "7CCE2F4", "%2.X"},
+ {__LINE__, 0x004bcc8b, "4967563", "%-.5ld"},
+ {__LINE__, 0x7d49665e, "2101962334", "%ld"},
+ {__LINE__, 0xfffffffc, "FFFFFFFC", "%.5X"},
+ {__LINE__, 0x0000019e, "+000414", "%+.6d"},
+ {__LINE__, 0x000027ef, "10223", "%d"},
+ {__LINE__, -0x0000261, "-609", "%3ld"},
+ {__LINE__, -0x000000e, "-14", "% 2.ld"},
+ {__LINE__, 0xff3ba3c7, "ff3ba3c7", "%+5.7x"},
+ {__LINE__, 0xffffffc4, "FFFFFFC4", "%-1.X"},
+ {__LINE__, 0xfffc5a70, "0xfffc5a70", "%#4.4x"},
+ {__LINE__, 0x0000d156, " 53590", "% d"},
+ {__LINE__, -0x0486258, "-4743768", "%0ld"},
+ {__LINE__, 0x00000000, " ", "% 2.d"},
+ {__LINE__, 0x04a0ef9f, "77655967", "%0.6ld"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%X"},
+ {__LINE__, 0x00000019, "0000019", "%.7x"},
+ {__LINE__, -0x0058d3a, "-363834", "%ld"},
+ {__LINE__, 0xfffff6b3, "fffff6b3", "%x"},
+ {__LINE__, 0xfffffff5, "FFFFFFF5", "%.0X"},
+ {__LINE__, 0x005e1fcb, "5E1FCB", "%+6X"},
+ {__LINE__, 0xffc3c866, "0xffc3c866", "%-#.4x"},
+ {__LINE__, 0x00000003, "3", "%X"},
+ {__LINE__, 0xffa2e961, "FFA2E961", "%7.4X"},
+ {__LINE__, 0x00000029, "41", "%d"},
+ {__LINE__, -0x0000035, "-53", "%d"},
+ {__LINE__, 0x0001b033, "110643", "%ld"},
+ {__LINE__, 0x004dd51b, "5100827", "%-2ld"},
+ {__LINE__, -0x000252d, "-9517", "% d"},
+ {__LINE__, 0xffffdeb2, "ffffdeb2", "%4.x"},
+ {__LINE__, 0xffe94eab, "0xffe94eab", "%#x"},
+ {__LINE__, 0xf921edf6, "f921edf6", "%4.2x"},
+ {__LINE__, 0x0007df97, "515991", "%4.ld"},
+ {__LINE__, 0x00709bc5, "709BC5", "%0X"},
+ {__LINE__, -0x0000001, "-1", "%d"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "%7.3X"},
+ {__LINE__, -0x0063f74, "-409460", "%+05.0d"},
+ {__LINE__, 0xfffffe9a, "FFFFFE9A", "%.2X"},
+ {__LINE__, -0x0001ce2, "-7394", "%.4d"},
+ {__LINE__, 0x000038c5, "14533", "%ld"},
+ {__LINE__, 0x000000ad, "000ad", "% 5.5x"},
+ {__LINE__, 0xffffbcc4, "ffffbcc4", "%-5x"},
+ {__LINE__, 0x00000000, "0", "% X"},
+ {__LINE__, 0x00372877, "372877", "%.6X"},
+ {__LINE__, 0xffffffd7, "FFFFFFD7", "%1.X"},
+ {__LINE__, 0xfa58b14b, "fa58b14b", "%x"},
+ {__LINE__, 0xfffffd9f, "FFFFFD9F", "%0.7X"},
+ {__LINE__, 0x00000710, "+1808", "%+#.2ld"},
+ {__LINE__, 0x00000006, " 6", "%5.0ld"},
+ {__LINE__, 0x0fba9706, "263886598", "%-6.3d"},
+ {__LINE__, 0xffff420a, "ffff420a", "%-2x"},
+ {__LINE__, 0x14b9a825, "14b9a825", "%x"},
+ {__LINE__, 0x0077ffe4, "77FFE4", "%+.2X"},
+ {__LINE__, 0x00067108, "422152 ", "%-7.ld"},
+ {__LINE__, 0x00000001, " 00001", "%6.5X"},
+ {__LINE__, 0x00000000, "0", "%ld"},
+ {__LINE__, -0x0000001, " -1", "% 7ld"},
+ {__LINE__, 0x01ddc7a3, "31311779", "%d"},
+ {__LINE__, -0x2a92f9b, "-44642203", "% 3ld"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%4.6x"},
+ {__LINE__, 0x0279a274, "279a274", "%x"},
+ {__LINE__, 0x2e37ed8e, "775417230", "%d"},
+ {__LINE__, 0x5ba59f58, "1537580888", "%-ld"},
+ {__LINE__, 0xffffffe0, "ffffffe0", "%x"},
+ {__LINE__, 0x3110ae47, "0X3110AE47", "%+#X"},
+ {__LINE__, 0x000e00b9, "917689", "%d"},
+ {__LINE__, 0x0000002e, " 0046", "% 7.4d"},
+ {__LINE__, 0x00000363, " 867", "%7.d"},
+ {__LINE__, -0x000000b, "-0011", "% 0.4d"},
+ {__LINE__, 0x000349c8, " 349C8", "% 7.X"},
+ {__LINE__, -0x01358f1, "-1267953", "%d"},
+ {__LINE__, -0x0039d3c, "-236860", "%-.3d"},
+ {__LINE__, 0xffd6de19, "ffd6de19", "%04.0x"},
+ {__LINE__, -0x0003c54, "-0015444", "%1.7d"},
+ {__LINE__, -0x0000e17, "-3607", "%d"},
+ {__LINE__, 0xff0fa3a9, "ff0fa3a9", "%+3x"},
+ {__LINE__, 0x00000009, "0000009", "%1.7x"},
+ {__LINE__, 0xfffffc81, "FFFFFC81", "% X"},
+ {__LINE__, -0x4ef2df5, "-82783733", "%ld"},
+ {__LINE__, 0x00000013, "19", "%-ld"},
+ {__LINE__, 0x00000000, " 0", "%#7x"},
+ {__LINE__, -0x3b9485fd, "-999589373", "%1.d"},
+ {__LINE__, -0x0000006, "-00006", "%6.5d"},
+ {__LINE__, 0x0000003f, "+63", "%+ld"},
+ {__LINE__, 0x000004c5, "1221", "%1.d"},
+ {__LINE__, 0x003f8a8c, "4164236", "%d"},
+ {__LINE__, -0x000001e, "-30", "%-#3d"},
+ {__LINE__, 0xfff9d230, "FFF9D230", "%+07.3X"},
+ {__LINE__, 0x0147cf17, "147cf17", "% x"},
+ {__LINE__, 0xffffffeb, "ffffffeb", "%x"},
+ {__LINE__, 0x0000007d, "00125", "%.5ld"},
+ {__LINE__, 0x000fff56, "1048406", "%#3d"},
+ {__LINE__, 0x064307a0, " 105056160", "% 0.3ld"},
+ {__LINE__, 0x007d2860, "8202336", "%-.2d"},
+ {__LINE__, 0x00a05711, "a05711", "%x"},
+ {__LINE__, 0x179a7f9e, "0x179a7f9e", "%+#.3x"},
+ {__LINE__, 0x00000003, "3", "%X"},
+ {__LINE__, -0x0001d7d, "-7549", "%#5d"},
+ {__LINE__, 0x0025d3f2, "+2479090", "%+2.d"},
+ {__LINE__, -0x0000001, "-1", "%#ld"},
+ {__LINE__, 0xfffffdd5, "fffffdd5", "%.7x"},
+ {__LINE__, 0x003462b9, "3433145", "%d"},
+ {__LINE__, 0x00005a81, "23169", "%d"},
+ {__LINE__, 0xfffffcdb, "fffffcdb", "%-x"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, 0xfff22085, "fff22085", "%x"},
+ {__LINE__, 0x00016d72, " 93554", "% d"},
+ {__LINE__, -0x0000002, "-2", "%0ld"},
+ {__LINE__, 0xfffffd21, "fffffd21", "% 0x"},
+ {__LINE__, 0x00000931, "2353", "%ld"},
+ {__LINE__, 0x00010021, "10021", "%5.1X"},
+ {__LINE__, -0x000007e, "-126", "%1.0ld"},
+ {__LINE__, 0xfffffff8, "fffffff8", "%01.x"},
+ {__LINE__, -0x001d148, "-119112", "%d"},
+ {__LINE__, -0x0000008, "-8", "%ld"},
+ {__LINE__, -0x000038e, "-910", "% ld"},
+ {__LINE__, 0x0039e3e5, "3793893", "%0.1d"},
+ {__LINE__, 0x0038fb8e, "38FB8E", "%.2X"},
+ {__LINE__, -0x002dafa, "-187130", "%ld"},
+ {__LINE__, -0xbec275b, "-200025947", "%ld"},
+ {__LINE__, 0x1a32f999, "1A32F999", "%05.4X"},
+ {__LINE__, 0x0000002f, "2f", "%x"},
+ {__LINE__, -0x0001a5b, "-6747", "%+3.ld"},
+ {__LINE__, 0x00000762, " 1890", "%7.ld"},
+ {__LINE__, 0x000000c2, "000194", "%0.6ld"},
+ {__LINE__, 0xffff002b, "FFFF002B", "%.4X"},
+ {__LINE__, -0x0019dae, "-105902", "% .2d"},
+ {__LINE__, 0x0000125f, "125f", "%+1x"},
+ {__LINE__, -0x000b688, " -46728", "%#7.d"},
+ {__LINE__, 0x000401ca, "401ca", "%0x"},
+ {__LINE__, 0x00000192, "402", "%#ld"},
+ {__LINE__, 0xffffffff, "ffffffff", "%x"},
+ {__LINE__, 0x1e505a0c, "0X1E505A0C", "%#1.3X"},
+ {__LINE__, 0x000f8f6c, "1019756", "%d"},
+ {__LINE__, 0x0004a296, "4a296", "%5.2x"},
+ {__LINE__, 0x00000003, "3", "% x"},
+ {__LINE__, -0x000d44c, "-54348", "%#ld"},
+ {__LINE__, 0x00009ae2, "39650", "%-d"},
+ {__LINE__, 0xffffff3a, "FFFFFF3A", "% .7X"},
+ {__LINE__, 0x0042350b, "4338955", "%d"},
+ {__LINE__, 0x000071af, "71af", "%+.4x"},
+ {__LINE__, 0x00000001, "0x1", "%#0x"},
+ {__LINE__, 0x00000033, "00051", "%3.5d"},
+ {__LINE__, 0x00000001, "1", "%X"},
+ {__LINE__, -0xebfb0e7, "-247443687", "%+3ld"},
+ {__LINE__, 0x00000027, "27 ", "%-07.X"},
+ {__LINE__, -0x0004837, "-18487", "%01d"},
+ {__LINE__, 0x1a8c53da, "1A8C53DA", "%X"},
+ {__LINE__, -0x0bdb8a9, "-12433577", "%d"},
+ {__LINE__, -0x0000098, "-152", "%#ld"},
+ {__LINE__, -0x003b554, "-243028", "%d"},
+ {__LINE__, 0x000000cb, "00000CB", "%+.7X"},
+ {__LINE__, 0xfffffeda, "FFFFFEDA", "%X"},
+ {__LINE__, -0x0000010, "-16", "%-#d"},
+ {__LINE__, 0x00000006, "+6", "%+d"},
+ {__LINE__, 0x003c294a, "+3942730", "%+4.ld"},
+ {__LINE__, 0x00000009, "9", "%ld"},
+ {__LINE__, 0xfbbdd2bc, "FBBDD2BC", "% X"},
+ {__LINE__, 0x71c86678, "+1908958840", "%+0.6ld"},
+ {__LINE__, -0x0b49bff, "-11836415", "% 6.ld"},
+ {__LINE__, 0xfff416be, "fff416be", "%3.x"},
+ {__LINE__, 0x00000077, "+119", "%+d"},
+ {__LINE__, 0xfff1cfaa, "FFF1CFAA", "% 0.2X"},
+ {__LINE__, 0xfffffffb, "fffffffb", "% x"},
+ {__LINE__, 0x0000127e, "4734", "%d"},
+ {__LINE__, 0x00107ad2, "107ad2", "%+2.6x"},
+ {__LINE__, 0x0006b8e9, "440553", "%-#d"},
+ {__LINE__, 0x0000eb6f, "eb6f", "% x"},
+ {__LINE__, 0x00001f18, "7960", "%0d"},
+ {__LINE__, 0xfffff225, "fffff225", "%1.5x"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%+6.x"},
+ {__LINE__, 0x000005b9, "01465", "%.5ld"},
+ {__LINE__, 0xfffc26b8, "FFFC26B8", "% X"},
+ {__LINE__, 0x540d580d, "0X540D580D", "%+#X"},
+ {__LINE__, 0x05ad7094, "5AD7094", "% 4.7X"},
+ {__LINE__, -0x000019b, "-411", "% d"},
+ {__LINE__, 0x00000006, "000006", "%6.6ld"},
+ {__LINE__, 0x0000026a, "+618", "%+ld"},
+ {__LINE__, 0x0000000b, "11", "%ld"},
+ {__LINE__, -0x26985d5, "-40469973", "%#.0ld"},
+ {__LINE__, 0x0000007d, "7D", "%+02.0X"},
+ {__LINE__, -0x0079ddf, "-0499167", "%+.7ld"},
+ {__LINE__, 0x0000375f, "14175", "%0d"},
+ {__LINE__, -0x18de7f99, "-417234841", "%ld"},
+ {__LINE__, -0x00507cc, "-329676", "%.0d"},
+ {__LINE__, 0x000029d5, "29D5", "%-2.1X"},
+ {__LINE__, 0x0000328c, "328C", "%-3.X"},
+ {__LINE__, 0x016f6234, "24076852", "%3.ld"},
+ {__LINE__, 0xfffffffc, "0XFFFFFFFC", "%#.5X"},
+ {__LINE__, 0xfe6163ca, "FE6163CA", "%5.X"},
+ {__LINE__, 0xffffffc2, "FFFFFFC2", "%X"},
+ {__LINE__, 0x00000087, "+135", "%+ld"},
+ {__LINE__, 0x00310166, "310166", "% x"},
+ {__LINE__, 0x00e8c871, "15255665", "%d"},
+ {__LINE__, 0x000005ee, "1518", "%ld"},
+ {__LINE__, 0xfcb24306, "FCB24306", "%X"},
+ {__LINE__, 0x0000000b, " 11", "%5ld"},
+ {__LINE__, 0x006d11d0, "0x6d11d0", "%#.0x"},
+ {__LINE__, 0x0010d416, "1102870", "%#6.5d"},
+ {__LINE__, -0x0047cb3, "-294067", "%.3d"},
+ {__LINE__, 0x000000c0, "c0", "%x"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%+X"},
+ {__LINE__, -0x000000a, "-10", "%d"},
+ {__LINE__, -0x0000007, "-7", "% ld"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "%-X"},
+ {__LINE__, 0x00000014, "0x14", "%-#3.1x"},
+ {__LINE__, 0x00003319, "3319", "% x"},
+ {__LINE__, 0x00000000, "00", "%+#.2X"},
+ {__LINE__, -0x0000009, "-9", "% ld"},
+ {__LINE__, -0x0000001, "-1 ", "%-3ld"},
+ {__LINE__, 0x00262909, "2500873", "%.5ld"},
+ {__LINE__, 0x33e76560, "33e76560", "%7.0x"},
+ {__LINE__, -0x0000002, "-2", "%ld"},
+ {__LINE__, 0x00035ee9, "35EE9", "%-3.X"},
+ {__LINE__, -0x0000235, "-565", "%+4.ld"},
+ {__LINE__, -0x3ea63c5, "-65692613", "%d"},
+ {__LINE__, 0x00000003, "3", "%ld"},
+ {__LINE__, -0x003362f, "-210479", "% d"},
+ {__LINE__, -0x1a819f8a, "-444702602", "%.7d"},
+ {__LINE__, 0x027a4668, "41567848", "%d"},
+ {__LINE__, 0x0002b025, "2b025", "%x"},
+ {__LINE__, -0x0000001, "-001", "%.3ld"},
+ {__LINE__, 0xfffffff0, "fffffff0", "%-0x"},
+ {__LINE__, -0x0000d4f, "-3407", "%-ld"},
+ {__LINE__, 0x00000146, " 326", "% 1.d"},
+ {__LINE__, -0x0000006, "-6", "%d"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%06.4X"},
+ {__LINE__, 0x376fddae, "+930078126", "%+#0ld"},
+ {__LINE__, 0x006d9da3, "6d9da3", "%1.x"},
+ {__LINE__, -0x0000f28, "-3880", "%3.2ld"},
+ {__LINE__, 0x0006962c, " 431660", "% 5d"},
+ {__LINE__, 0x000011db, " 4571", "%6.ld"},
+ {__LINE__, 0xffffffa8, "ffffffa8", "%+x"},
+ {__LINE__, 0x0d886db3, "D886DB3", "%.7X"},
+ {__LINE__, 0x00000000, "000000", "%2.6ld"},
+ {__LINE__, 0xfffff6b6, "FFFFF6B6", "% X"},
+ {__LINE__, -0x0739068, "-7573608", "%+6.ld"},
+ {__LINE__, 0xfba62553, "0XFBA62553", "%#X"},
+ {__LINE__, -0x4474bc5, "-71781317", "%-2ld"},
+ {__LINE__, 0xffffff95, "FFFFFF95", "% 2.X"},
+ {__LINE__, -0x1d0e1ca, "-30466506", "%+.0d"},
+ {__LINE__, -0x000f3aa, "-62378", "%ld"},
+ {__LINE__, 0x00000026, "26", "%1x"},
+ {__LINE__, 0x001c5400, "1856512", "%-#d"},
+ {__LINE__, 0x03808442, "3808442", "%X"},
+ {__LINE__, -0x0000081, "-129", "%+#ld"},
+ {__LINE__, 0x000004ae, " 1198", "% 3.4d"},
+ {__LINE__, -0x7f4ed54, "-133492052", "%d"},
+ {__LINE__, 0x00000000, "+0", "%+ld"},
+ {__LINE__, 0x00000000, "0", "%+x"},
+ {__LINE__, 0x004c7e46, "5013062", "%.0d"},
+ {__LINE__, -0x647d7a65, "-1685944933", "%0.2d"},
+ {__LINE__, 0x00003b59, "15193", "%-#1d"},
+ {__LINE__, 0xfff3e64d, "FFF3E64D", "%-X"},
+ {__LINE__, 0x00007022, "28706", "%-d"},
+ {__LINE__, 0xc28d0ad8, "c28d0ad8", "%+x"},
+ {__LINE__, -0x005c208, "-377352", "% ld"},
+ {__LINE__, 0x00cfbadc, "13613788", "%d"},
+ {__LINE__, 0x000016ea, "5866", "%0d"},
+ {__LINE__, 0x00000029, "29", "%X"},
+ {__LINE__, 0xffe16813, "0XFFE16813", "%+#X"},
+ {__LINE__, 0x00000004, "4", "%0X"},
+ {__LINE__, -0x0000096, " -150", "%5d"},
+ {__LINE__, 0x00027ac7, "162503", "%ld"},
+ {__LINE__, -0x0075de0, "-482784", "%d"},
+ {__LINE__, 0x005fcff6, "6279158", "%d"},
+ {__LINE__, 0xffffffef, "FFFFFFEF", "%3X"},
+ {__LINE__, 0x267b05ec, "645596652", "%4ld"},
+ {__LINE__, 0xa487b724, "a487b724", "%x"},
+ {__LINE__, 0x01da2a11, "31074833", "%-.0ld"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%X"},
+ {__LINE__, 0x0000037a, "37a", "%x"},
+ {__LINE__, 0x003d0314, "+3998484", "%+#1d"},
+ {__LINE__, 0x0000011b, " 283", "%5.2d"},
+ {__LINE__, 0x094f6066, "94f6066", "%x"},
+ {__LINE__, 0x00000004, "4", "%X"},
+ {__LINE__, -0x102e14bd, "-271455421", "% 7.ld"},
+ {__LINE__, 0x000048da, "0018650", "%07ld"},
+ {__LINE__, -0x24ae0390, "-615383952", "%0.6d"},
+ {__LINE__, 0xffff5159, "0XFFFF5159", "%#0X"},
+ {__LINE__, 0xfffd38c3, "fffd38c3", "%x"},
+ {__LINE__, 0xfffff9ea, "FFFFF9EA", "%-X"},
+ {__LINE__, -0x000fd28, "-64808", "% ld"},
+ {__LINE__, 0x002c1bf4, "2890740", "%-.1d"},
+ {__LINE__, 0x00d00ee7, "D00EE7", "%0.4X"},
+ {__LINE__, 0x00000cf9, "3321", "%0d"},
+ {__LINE__, -0x0000001, "-1", "%-#ld"},
+ {__LINE__, 0xfffffd75, "FFFFFD75", "%.2X"},
+ {__LINE__, 0x00000012, "18", "%-d"},
+ {__LINE__, 0xfd44b4b2, "fd44b4b2", "%+5.x"},
+ {__LINE__, -0x001c53f, "-116031", "%-#6.d"},
+ {__LINE__, 0x000ff6fd, "ff6fd", "%2x"},
+ {__LINE__, 0x00000001, "1", "%0d"},
+ {__LINE__, 0x0120b478, "120B478", "%.7X"},
+ {__LINE__, 0x0145591e, "145591E", "%1.4X"},
+ {__LINE__, 0x001f99b9, "1F99B9", "%.1X"},
+ {__LINE__, 0xffffd078, "ffffd078", "%-1.5x"},
+ {__LINE__, 0xffffff1a, "FFFFFF1A", "%-4.6X"},
+ {__LINE__, 0xfffffffa, "fffffffa", "%x"},
+ {__LINE__, -0x00000b9, "-185", "%3ld"},
+ {__LINE__, 0x00001cf0, "7408", "%-ld"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "%X"},
+ {__LINE__, 0x00151f30, "151F30", "%X"},
+ {__LINE__, -0x0000103, "-259", "%d"},
+ {__LINE__, -0x000303f, "-12351", "%d"},
+ {__LINE__, 0x000002ca, "714", "%ld"},
+ {__LINE__, -0x0000c55, "-3157", "%1d"},
+ {__LINE__, 0x00000691, "01681", "%#.5ld"},
+ {__LINE__, 0x00230537, "2295095", "%#d"},
+ {__LINE__, 0x032a1faa, "53092266", "%.4d"},
+ {__LINE__, 0x000050d7, "20695", "%d"},
+ {__LINE__, -0x0c7ad4c, "-13086028", "%#.4ld"},
+ {__LINE__, -0x00009d9, "-2521", "%+d"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%0x"},
+ {__LINE__, 0xffdec2d9, "FFDEC2D9", "%5.1X"},
+ {__LINE__, -0x000563c, "-22076", "%-.2ld"},
+ {__LINE__, 0x0073b36a, "0x73b36a", "%-#x"},
+ {__LINE__, 0xfffffffd, "fffffffd", "%x"},
+ {__LINE__, 0x0193ba5a, "193ba5a", "%1.x"},
+ {__LINE__, 0x00d147b5, "13715381", "%2.d"},
+ {__LINE__, 0xffffff10, "ffffff10", "%4x"},
+ {__LINE__, 0x000648d5, "648d5", "%1.3x"},
+ {__LINE__, 0x00000011, "11", "%X"},
+ {__LINE__, 0xff259f5b, "0xff259f5b", "% #.1x"},
+ {__LINE__, 0x00000175, "175", "%x"},
+ {__LINE__, 0x00000000, "0", "%ld"},
+ {__LINE__, 0x00000015, "21", "%#ld"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%-x"},
+ {__LINE__, 0x00000013, " 19", "% 0ld"},
+ {__LINE__, -0x0000001, "-0000001", "% 5.7ld"},
+ {__LINE__, 0x0000139d, "139D", "%X"},
+ {__LINE__, 0x0041ad18, "41ad18", "%-.6x"},
+ {__LINE__, -0x00000f9, "-249", "% 3.d"},
+ {__LINE__, 0x00000076, "118", "%ld"},
+ {__LINE__, 0x000006f8, "1784", "%d"},
+ {__LINE__, -0x0000005, "-5", "%ld"},
+ {__LINE__, -0x00008e7, "-2279", "%+ld"},
+ {__LINE__, 0x00003f77, "3F77", "%+0X"},
+ {__LINE__, 0x000ca3f8, "0XCA3F8", "%+#X"},
+ {__LINE__, -0x00004bf, "-001215", "%#5.6ld"},
+ {__LINE__, 0x319129ab, "0x319129ab", "%+#x"},
+ {__LINE__, -0x0000002, "-2", "%ld"},
+ {__LINE__, -0x0f6686e, "-16148590", "%.6ld"},
+ {__LINE__, 0x0329576b, "53041003", "%2.d"},
+ {__LINE__, -0x000179e, "-6046", "%d"},
+ {__LINE__, 0x000002cc, "+716", "%+1.3ld"},
+ {__LINE__, 0xfffffff7, "0xfffffff7", "% #x"},
+ {__LINE__, 0x0016eb40, "1502016", "%ld"},
+ {__LINE__, 0x00000003, "3", "%-0ld"},
+ {__LINE__, 0x0023e0d6, "23E0D6", "%-05.X"},
+ {__LINE__, 0xffffa6a4, "0XFFFFA6A4", "%#X"},
+ {__LINE__, 0x00087664, "87664", "% .2x"},
+ {__LINE__, -0x0000002, " -2", "%3.ld"},
+ {__LINE__, 0x003ad85d, "3AD85D", "%X"},
+ {__LINE__, 0x00002f20, "12064", "%ld"},
+ {__LINE__, 0x02030bfc, "2030BFC", "%02.3X"},
+ {__LINE__, 0xfffff36a, "FFFFF36A", "%X"},
+ {__LINE__, 0xfe0729ff, "0xfe0729ff", "% #.0x"},
+ {__LINE__, 0xfec15164, "FEC15164", "%0.2X"},
+ {__LINE__, -0x00169ec, "-92652", "%+d"},
+ {__LINE__, 0x006d7990, "0x6d7990", "%#x"},
+ {__LINE__, 0xffcc89e6, "ffcc89e6", "%x"},
+ {__LINE__, 0x002d7cca, "2981066", "%7.7ld"},
+ {__LINE__, -0x1649692b, "-373909803", "%#ld"},
+ {__LINE__, 0x00664f47, "664f47", "%+6.x"},
+ {__LINE__, 0x00000000, "0", "% X"},
+ {__LINE__, 0x00000047, "000047", "%.6X"},
+ {__LINE__, 0x00000007, "0000007", "%.7ld"},
+ {__LINE__, 0x00000030, "30", "%-x"},
+ {__LINE__, -0x25bcbabb, "-633125563", "% ld"},
+ {__LINE__, 0xfe11c031, "FE11C031", "%4.6X"},
+ {__LINE__, -0x0000001, "-0000001", "%.7d"},
+ {__LINE__, 0x00b56d84, "11890052", "%ld"},
+ {__LINE__, -0x0000b01, "-0002817", "%+07.7ld"},
+ {__LINE__, 0xffffe4ad, "ffffe4ad", "% 0.0x"},
+ {__LINE__, 0x007760fc, "7760fc", "%+x"},
+ {__LINE__, 0xffef44d8, "FFEF44D8", "%X"},
+ {__LINE__, 0xfcb6862e, "fcb6862e", "%+x"},
+ {__LINE__, -0x0000001, "-1", "%0d"},
+ {__LINE__, 0xffffffe6, "FFFFFFE6", "%3.1X"},
+ {__LINE__, 0xff816e27, "FF816E27", "% 6.X"},
+ {__LINE__, 0x00006415, "25621", "%ld"},
+ {__LINE__, -0xfae5449, "-263083081", "%0ld"},
+ {__LINE__, 0x00000001, " 1", "% 0d"},
+ {__LINE__, 0x00000009, " 9", "%2.X"},
+ {__LINE__, 0x002d7e18, "2981400", "%7d"},
+ {__LINE__, -0x00000fc, "-0000252", "%-#.7d"},
+ {__LINE__, 0x00000003, "3", "%0x"},
+ {__LINE__, 0x0d46e47f, "222749823", "%ld"},
+ {__LINE__, 0xfffcbc52, "FFFCBC52", "%+X"},
+ {__LINE__, 0x00000000, "0", "%-X"},
+ {__LINE__, 0xfffff0e5, "fffff0e5", "%x"},
+ {__LINE__, 0xffffffd9, "FFFFFFD9", "%07X"},
+ {__LINE__, 0x000004ee, "4ee", "%0x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%0x"},
+ {__LINE__, -0x0008cb4, "-036020", "%+3.6ld"},
+ {__LINE__, 0x0000dada, "0xdada", "%#0.x"},
+ {__LINE__, 0x0000001a, "26 ", "%-4d"},
+ {__LINE__, -0x000000c, " -12", "%04.d"},
+ {__LINE__, 0x0000025c, " 25c", "%7.x"},
+ {__LINE__, 0xfe9b091e, "FE9B091E", "%X"},
+ {__LINE__, 0x00000002, " 2", "%07.ld"},
+ {__LINE__, -0x0004930, "-18736", "% 6.d"},
+ {__LINE__, 0xffffffe9, "FFFFFFE9", "%X"},
+ {__LINE__, 0x00000003, " 3", "%2.ld"},
+ {__LINE__, 0x00000e00, "3584", "%.4d"},
+ {__LINE__, 0xffff38c2, "ffff38c2", "%0.x"},
+ {__LINE__, 0xffffffff, "FFFFFFFF", "% .3X"},
+ {__LINE__, 0xff7c1b2f, "FF7C1B2F", "%-3.2X"},
+ {__LINE__, -0x0000005, "-5", "%2d"},
+ {__LINE__, 0x00098775, "98775", "%x"},
+ {__LINE__, 0x000015ff, " 15FF", "%6.X"},
+ {__LINE__, 0xfffbe3ef, "FFFBE3EF", "%0.3X"},
+ {__LINE__, -0x0000048, "-72", "%ld"},
+ {__LINE__, 0x0001488a, "84106", "%d"},
+ {__LINE__, 0x00000001, "1", "%x"},
+ {__LINE__, -0x0000002, "-2", "%-0.0ld"},
+ {__LINE__, -0x0000001, "-1", "%-d"},
+ {__LINE__, 0x0006616f, "6616f", "%x"},
+ {__LINE__, 0x3657856d, "911705453", "%6.d"},
+ {__LINE__, -0x0007222, "-0029218", "%.7d"},
+ {__LINE__, 0x00041606, "267782", "%04.5d"},
+ {__LINE__, 0x00000001, " 1", "%2.ld"},
+ {__LINE__, 0x00000219, "219", "%0x"},
+ {__LINE__, 0x0ae0184c, "ae0184c", "%x"},
+ {__LINE__, 0x00003a7d, " 14973", "%7.ld"},
+ {__LINE__, 0xffffffff, "0XFFFFFFFF", "%#X"},
+ {__LINE__, -0x0000002, "-2", "%0ld"},
+ {__LINE__, 0x00002cdf, "11487", "%0ld"},
+ {__LINE__, -0x000000c, "-12", "%d"},
+ {__LINE__, -0x000000e, "-14", "%-#2d"},
+ {__LINE__, 0x00000371, "881", "%#ld"},
+ {__LINE__, 0x000015be, " 5566", "%5.ld"},
+ {__LINE__, 0x01525b91, "22174609", "%#0.0ld"},
+ {__LINE__, 0xff8fc22f, "FF8FC22F", "% X"},
+ {__LINE__, -0x0007f7b, "-32635", "%4.ld"},
+ {__LINE__, 0x00007bca, "7bca", "%x"},
+ {__LINE__, -0x0000582, "-1410", "%ld"},
+ {__LINE__, 0x00000047, " +71", "%+04.2d"},
+ {__LINE__, 0xf8a8dce2, "f8a8dce2", "%+.6x"},
+ {__LINE__, -0x000de2e, "-56878", "%.0d"},
+ {__LINE__, 0x019c03c1, "0X19C03C1", "%#X"},
+ {__LINE__, -0x0f3a43e, "-15967294", "%ld"},
+ {__LINE__, 0x00009e87, "40583", "%#5.1d"},
+ {__LINE__, 0x000000b8, "184", "%0ld"},
+ {__LINE__, -0x000befe, "-48894", "%2ld"},
+ {__LINE__, -0x002ee1a, "-192026", "%.2d"},
+ {__LINE__, 0x00004fd8, "4fd8", "%x"},
+ {__LINE__, 0x0006d57b, "447867", "%2d"},
+ {__LINE__, 0xfffffa9c, "FFFFFA9C", "%-X"},
+ {__LINE__, 0x0000000f, "15", "%ld"},
+ {__LINE__, 0x0005deb2, "5DEB2", "% X"},
+ {__LINE__, 0x00000007, "7", "%X"},
+ {__LINE__, 0xffffffc8, "0XFFFFFFC8", "% #.1X"},
+ {__LINE__, 0xfffff62f, "FFFFF62F", "%X"},
+ {__LINE__, -0x1a935bba, "-445864890", "% 3.5d"},
+ {__LINE__, 0x000b34b4, "0x0b34b4", "%-#3.6x"},
+ {__LINE__, 0xfffff430, "FFFFF430", "%X"},
+ {__LINE__, 0x00000b5f, "+0002911", "%+#.7d"},
+ {__LINE__, 0x00000007, " 7", "%3ld"},
+ {__LINE__, 0xffffffd8, "FFFFFFD8", "% .7X"},
+ {__LINE__, 0xfffff544, "FFFFF544", "%0X"},
+ {__LINE__, -0x353667b9, "-892757945", "%d"},
+ {__LINE__, 0x00000058, "0x00058", "%+#.5x"},
+ {__LINE__, 0x39dbcc4a, "+970705994", "%+0.6ld"},
+ {__LINE__, 0xfffffffd, "fffffffd", "% 01x"},
+ {__LINE__, 0x00b1c28e, "+11649678", "%+0ld"},
+ {__LINE__, 0x000066c2, "0X66C2", "%-#4X"},
+ {__LINE__, 0x007171a2, "+7434658", "%+07.ld"},
+ {__LINE__, -0x0000001, "-1", "%-d"},
+ {__LINE__, 0x00000ae0, "+2784", "%+0d"},
+ {__LINE__, 0x13786a57, "326658647", "%#5d"},
+ {__LINE__, -0x0000001, "-1", "%2.ld"},
+ {__LINE__, -0x0168a16, "-1477142", "%d"},
+ {__LINE__, 0x12df7dd6, "316636630", "%ld"},
+ {__LINE__, 0x00000000, "000000", "%1.6d"},
+ {__LINE__, 0x266da2a9, "644719273", "%ld"},
+ {__LINE__, 0x0000004a, "74", "%d"},
+ {__LINE__, 0x000102ff, "00102FF", "%+06.7X"},
+ {__LINE__, 0x17916237, "0x17916237", "%#5x"},
+ {__LINE__, -0x0003cbb, "-0015547", "%-.7d"},
+ {__LINE__, 0xe7da2010, "e7da2010", "%2.4x"},
+ {__LINE__, 0xfffffff3, "fffffff3", "% .7x"},
+ {__LINE__, 0xfc9b64f8, "FC9B64F8", "% 7.X"},
+ {__LINE__, 0x000001af, "431", "%0d"},
+ {__LINE__, 0xffc81796, "0xffc81796", "%#.5x"},
+ {__LINE__, 0x057a1fbc, "+91889596", "%+04d"},
+ {__LINE__, 0x00001ae1, "6881", "%ld"},
+ {__LINE__, 0xfffffff6, "fffffff6", "%3.0x"},
+ {__LINE__, -0x6b7d5db, "-112711131", "%-06.1d"},
+ {__LINE__, 0x008e8a5c, " 8e8a5c", "%7.0x"},
+ {__LINE__, 0xfe07a9bd, "fe07a9bd", "%.1x"},
+ {__LINE__, -0x00278e6, "-162022", "%0ld"},
+ {__LINE__, 0xf98709f5, "F98709F5", "%X"},
+ {__LINE__, -0x00000c9, "-201", "% 1.d"},
+ {__LINE__, -0x000001d, "-00029", "%+2.5ld"},
+ {__LINE__, 0x00000030, " 48", "% d"},
+ {__LINE__, 0xffd753f4, "FFD753F4", "%0X"},
+ {__LINE__, 0xfffffffd, "FFFFFFFD", "%X"},
+ {__LINE__, 0x0000a765, "a765", "%x"},
+ {__LINE__, 0x0026e2c8, "26E2C8", "%-0X"},
+ {__LINE__, -0x00003eb, "-1003", "%3.1ld"},
+ {__LINE__, 0x015d53ca, "22893514", "%0ld"},
+ {__LINE__, -0x0000020, "-32", "%ld"},
+ {__LINE__, -0x03558dd, "-3496157", "%1.0ld"},
+ {__LINE__, -0x000007f, "-127", "%1.d"},
+ {__LINE__, 0xffffc737, "0xffffc737", "%+#x"},
+ {__LINE__, 0x0000a70d, " a70d", "%6.x"},
+ {__LINE__, 0x01ea0e31, "0X1EA0E31", "% #1.X"},
+ {__LINE__, 0x00b5f406, "0X0B5F406", "%-#.7X"},
+ {__LINE__, 0x0e58fa9a, "240712346", "%.2d"},
+ {__LINE__, 0xf43ff8a9, "f43ff8a9", "%+0.6x"},
+ {__LINE__, -0x5d0d3d3, "-97571795", "%.3ld"},
+ {__LINE__, -0x000027a, "-634", "%0d"},
+ {__LINE__, 0xffcef248, "FFCEF248", "%07.X"},
+ {__LINE__, 0x000002dc, "2dc", "%0x"},
+ {__LINE__, -0x31fa6c1, "-52405953", "%.2d"},
+ {__LINE__, 0x00000014, "14", "%X"},
+ {__LINE__, -0x0282f98, "-2633624", "%ld"},
+ {__LINE__, 0x00005f55, "24405", "%#d"},
+ {__LINE__, -0x0000004, "-4", "%d"},
+ {__LINE__, 0x00000001, "1", "%+x"},
+ {__LINE__, 0x013f47ce, "13f47ce", "%0.x"},
+ {__LINE__, 0x00143fce, "1327054", "%.3d"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, 0x00001f9a, "1F9A", "% X"},
+ {__LINE__, 0x00000cf5, "cf5", "%x"},
+ {__LINE__, 0xffea9c24, "ffea9c24", "%x"},
+ {__LINE__, 0xf09f85a7, "F09F85A7", "%X"},
+ {__LINE__, 0x00001e04, "7684", "%ld"},
+ {__LINE__, 0xffffc82a, "ffffc82a", "%7x"},
+ {__LINE__, -0x0000a77, "-2679", "% d"},
+ {__LINE__, 0x0019a859, "+1681497", "%+2.6ld"},
+ {__LINE__, -0x00002d7, "-727", "%ld"},
+ {__LINE__, 0x00011b82, "72578", "%-#ld"},
+ {__LINE__, 0x00000c32, "3122", "%ld"},
+ {__LINE__, -0x0000337, "-823", "%1.d"},
+ {__LINE__, 0x00000004, "4", "%1ld"},
+ {__LINE__, 0x0000062c, "1580", "%.1ld"},
+ {__LINE__, 0xffffffd3, "FFFFFFD3", "% X"},
+ {__LINE__, -0x07b1bf8, "-8068088", "%#d"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%x"},
+ {__LINE__, 0x159e6cfb, "159e6cfb", "%0.x"},
+ {__LINE__, 0x0001148d, "1148d", "%-.1x"},
+ {__LINE__, 0x003373b7, "3371959", "%#.0d"},
+ {__LINE__, 0x00001af2, "1af2", "%.4x"},
+ {__LINE__, -0x0000001, "-000001", "%+.6ld"},
+ {__LINE__, -0x00001a3, "-419", "%d"},
+ {__LINE__, 0xfdb232e7, "fdb232e7", "%5.4x"},
+ {__LINE__, -0x000000d, "-13", "%d"},
+ {__LINE__, 0x98ec1c74, "98ec1c74", "% 3x"},
+ {__LINE__, 0xfffffff8, "fffffff8", "%+1.4x"},
+ {__LINE__, -0x0000d58, "-3416", "%+#0ld"},
+ {__LINE__, -0x65d1973, "-106764659", "%.6d"},
+ {__LINE__, -0x0737641, "-7566913", "%-d"},
+ {__LINE__, 0x0000037c, "37c", "%+0x"},
+ {__LINE__, 0x0000012c, "0000300", "%#3.7d"},
+ {__LINE__, 0x00c12d9b, "12660123", "%1.5ld"},
+ {__LINE__, 0xe7e5e77d, "e7e5e77d", "%6x"},
+ {__LINE__, 0x1fe0e820, "1FE0E820", "%-4X"},
+ {__LINE__, 0xc85a793a, "C85A793A", "%X"},
+ {__LINE__, 0x05f9fe2c, "100269612", "%#ld"},
+ {__LINE__, 0x00000032, "0X32", "%+#4.1X"},
+ {__LINE__, 0xfab4ce81, "fab4ce81", "%3.x"},
+ {__LINE__, -0x0000009, "-9", "%2.d"},
+ {__LINE__, 0xffff8d2e, "ffff8d2e", "% 6x"},
+ {__LINE__, 0xfffffffe, "0xfffffffe", "%#x"},
+ {__LINE__, 0x02960f60, "2960f60", "%1.x"},
+ {__LINE__, 0x34cf3cbc, " 885996732", "% 5ld"},
+ {__LINE__, -0x000006e, "-110", "% d"},
+ {__LINE__, -0x0000001, "-1", "%-.0d"},
+ {__LINE__, 0x000000b1, " B1", "%+7X"},
+ {__LINE__, 0xfffff5b4, "FFFFF5B4", "%01.7X"},
+ {__LINE__, 0x00000086, "86", "%0X"},
+ {__LINE__, 0x00074367, " 74367", "% 6x"},
+ {__LINE__, 0x001000d7, "+1048791", "%+ld"},
+ {__LINE__, 0x00000f35, " 3893", "% d"},
+ {__LINE__, -0x00000e1, "-225", "%d"},
+ {__LINE__, 0xffff6694, "FFFF6694", "%6.X"},
+ {__LINE__, 0x00019cf7, "19cf7", "%0.x"},
+ {__LINE__, 0x00000046, "0046", "%+.4X"},
+ {__LINE__, -0x000001f, "-31", "%ld"},
+ {__LINE__, 0xfff25859, "fff25859", "%6x"},
+ {__LINE__, 0x21884061, "562577505", "%#ld"},
+ {__LINE__, 0x01448b7a, "1448B7A", "%0.1X"},
+ {__LINE__, 0xffffffc0, "ffffffc0", "%x"},
+ {__LINE__, 0xfffffed5, "fffffed5", "% 1.0x"},
+ {__LINE__, 0x0e349767, "E349767", "%.5X"},
+ {__LINE__, 0x00000330, "816", "%0d"},
+ {__LINE__, -0x0000016, "-22", "%d"},
+ {__LINE__, 0xffff9bab, "FFFF9BAB", "%X"},
+ {__LINE__, 0xffffee4e, "ffffee4e", "%x"},
+ {__LINE__, 0x0026beeb, "2539243", "%6.d"},
+ {__LINE__, 0x00002c6c, "11372", "%.2d"},
+ {__LINE__, -0x000002c, "-44", "%ld"},
+ {__LINE__, -0x001dcfa, "-122106", "% d"},
+ {__LINE__, 0x0001683c, "92220", "%#4.ld"},
+ {__LINE__, 0x09b51fc9, "9b51fc9", "%+.7x"},
+ {__LINE__, 0x0000001d, "29", "%0ld"},
+ {__LINE__, -0x83f17e5, "-138352613", "%ld"},
+ {__LINE__, 0xfa4e2c1b, "fa4e2c1b", "%x"},
+ {__LINE__, 0x000001f3, "499", "%0ld"},
+ {__LINE__, 0xffff03e4, "ffff03e4", "%x"},
+ {__LINE__, 0x000000ac, "+0172", "%+.4ld"},
+ {__LINE__, 0x03c3903b, "63148091", "%00d"},
+ {__LINE__, 0x0000000d, "13", "%#d"},
+ {__LINE__, 0x0000002e, "0X2E", "%#X"},
+ {__LINE__, 0x00006b2d, "6B2D", "%X"},
+ {__LINE__, 0x0000010b, " 0010b", "%7.5x"},
+ {__LINE__, 0x0000017a, " 17a", "%4x"},
+ {__LINE__, 0xfffffffb, "fffffffb", "%+x"},
+ {__LINE__, 0xffffac6a, "ffffac6a", "%-.3x"},
+ {__LINE__, -0x0005870, "-22640", "%0d"},
+ {__LINE__, 0x189c17bc, "189c17bc", "%x"},
+ {__LINE__, -0x01bbc38, "-1817656", "%#6.ld"},
+ {__LINE__, -0x3382b55, "-54012757", "%d"},
+ {__LINE__, -0x0000007, "-7", "%-ld"},
+ {__LINE__, -0x000c74b, "-51019", "%ld"},
+ {__LINE__, 0x0001a6f2, "+108274", "%+#1.ld"},
+ {__LINE__, 0x00077448, "77448", "%x"},
+ {__LINE__, 0x00000000, "0", "%x"},
+ {__LINE__, 0xfffff056, "FFFFF056", "%.3X"},
+ {__LINE__, -0x6f3f9451, "-1866437713", "%-#3.0ld"},
+ {__LINE__, 0x000000ac, "AC", "%X"},
+ {__LINE__, 0xffc8752f, "ffc8752f", "%-x"},
+ {__LINE__, 0xfffffe6d, "FFFFFE6D", "%2.X"},
+ {__LINE__, -0x377f1a5, "-58192293", "% .2d"},
+ {__LINE__, -0x0000294, "-660", "%d"},
+ {__LINE__, 0xfffffffe, "fffffffe", "%-x"},
+ {__LINE__, 0xfffcbbe8, "0xfffcbbe8", "%-#4.x"},
+ {__LINE__, 0x0022e510, "+2286864", "%+ld"},
+ {__LINE__, 0xfffffe2a, "FFFFFE2A", "%0.3X"},
+ {__LINE__, 0xfe29f7c0, "fe29f7c0", "%x"},
+ {__LINE__, 0xfffe957e, "FFFE957E", "%X"},
+ {__LINE__, 0x000080f8, "33016", "%ld"},
+ {__LINE__, 0x0003ee2c, " 257580", "%7d"},
+ {__LINE__, 0x000003a1, "929", "%d"},
+ {__LINE__, 0x0000021f, "21f", "%+x"},
+ {__LINE__, 0xffffffff, "ffffffff", "%.5x"},
+ {__LINE__, -0x040a988, "-4237704", "%-d"},
+ {__LINE__, 0x027c8b69, "41716585", "%ld"},
+ {__LINE__, 0x00000003, "3", "%-X"},
+ {__LINE__, -0x0000368, " -872", "%7.d"},
+ {__LINE__, 0x00000d3c, "3388", "%0.2d"},
+ {__LINE__, -0x33734cc, "-53949644", "%2ld"},
+ {__LINE__, 0x000003db, "3DB", "%X"},
+ {__LINE__, -0x00f154d, "-988493", "%5d"},
+ {__LINE__, 0x0000000b, " 11", "%4.ld"},
+ {__LINE__, 0x00000067, "103", "%-ld"},
+ {__LINE__, -0x0199fce, "-1679310", "%4d"},
+ {__LINE__, 0x02b6266b, "2b6266b", "% x"},
+ {__LINE__, -0x006b39d, "-439197", "%+d"},
+ {__LINE__, 0x00000007, "7", "%ld"},
+ {__LINE__, 0x0141fc98, "21101720", "%0ld"},
+ {__LINE__, -0x0008420, "-33824", "%d"},
+ {__LINE__, 0x0011622b, "1139243", "%6ld"},
+ {__LINE__, 0x0000001b, "27", "%-d"},
+ {__LINE__, -0x0030935, "-198965", "%3d"},
+ {__LINE__, 0x0000001f, " 1f", "%4.x"},
+ {__LINE__, -0x10782a19, "-276310553", "%#ld"},
+ {__LINE__, -0x007eac4, "-518852", "%06.ld"},
+ {__LINE__, 0x0bc4c681, "197445249", "%6ld"},
+ {__LINE__, 0x000000f5, "245", "%.3ld"},
+ {__LINE__, 0x00000197, "197", "%X"},
+ {__LINE__, 0xfffffeab, "FFFFFEAB", "% X"},
+ {__LINE__, 0x00000f05, "F05", "%+X"},
+ {__LINE__, 0xffe1b785, "0xffe1b785", "%#x"},
+ {__LINE__, -0x02d3581, "-2962817", "%05d"},
+ {__LINE__, 0xffffb994, "FFFFB994", "%X"},
+ {__LINE__, 0x03d139a3, "64043427", "%ld"},
+ {__LINE__, -0x0000002, " -2", "%+4.d"},
+ {__LINE__, -0x043da83, "-4446851", "%#ld"},
+ {__LINE__, -0x6aad891, "-111859857", "%7.ld"},
+ {__LINE__, 0x00003e68, "15976", "%-4.5ld"},
+ {__LINE__, 0xffe4d3ee, "FFE4D3EE", "%X"},
+ {__LINE__, 0x00000002, "000002", "%4.6ld"},
+ {__LINE__, 0xffffee32, "ffffee32", "%4x"},
+ {__LINE__, 0x0cb7dd25, "cb7dd25", "%3x"},
+ {__LINE__, 0xf773d422, "F773D422", "%X"},
+ {__LINE__, -0x0b590f7, "-11899127", "%#d"},
+ {__LINE__, -0x0002c45, "-11333", "%-#5ld"},
+ {__LINE__, -0x1efc9e4, "-32492004", "%ld"},
+ {__LINE__, -0x0003b9c, "-15260", "%d"},
+ {__LINE__, 0x000001b6, "0X1B6", "%#4X"},
+ {__LINE__, 0x3ce93ec3, "1021918915", "%.6d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%-x"},
+ {__LINE__, 0xfffaf0e4, "fffaf0e4", "%2.x"},
+ {__LINE__, 0x00000002, "0x2", "%#x"},
+ {__LINE__, 0x0000e806, "e806", "%4x"},
+ {__LINE__, 0xfffffff0, "fffffff0", "% 2.x"},
+ {__LINE__, 0xfffffc0e, "fffffc0e", "%+.4x"},
+ {__LINE__, 0xfd45716e, "FD45716E", "%.4X"},
+ {__LINE__, 0xfff96fda, "FFF96FDA", "%-X"},
+ {__LINE__, 0xff99d08a, "FF99D08A", "%.5X"},
+ {__LINE__, 0x00000002, "2", "%-00.d"},
+ {__LINE__, -0x000000f, " -15", "%6.ld"},
+ {__LINE__, -0x00d321c, "-864796", "%#1ld"},
+ {__LINE__, 0xff19ff8d, "ff19ff8d", "%1.5x"},
+ {__LINE__, 0x00000000, "0000000", "%-.7x"},
+ {__LINE__, 0x0000f50d, " F50D", "%5X"},
+ {__LINE__, 0x00001688, " 5768", "%7.ld"},
+ {__LINE__, 0x00000157, "343", "%2ld"},
+ {__LINE__, 0xfffffffd, "0xfffffffd", "%+#3x"},
+ {__LINE__, 0x00000d52, "3410", "%ld"},
+ {__LINE__, 0x00000003, "3", "%d"},
+ {__LINE__, 0x0001c6d2, "01c6d2", "%.6x"},
+ {__LINE__, 0x242d65d2, "606954962", "%#7.ld"},
+ {__LINE__, 0x00000e9f, "0000E9F", "%5.7X"},
+ {__LINE__, 0x0002d785, "2D785", "%0X"},
+ {__LINE__, 0x00000167, "167", "%0X"},
+ {__LINE__, 0xfffff5e5, "fffff5e5", "% x"},
+ {__LINE__, 0xffb69a04, "0xffb69a04", "%#0.x"},
+ {__LINE__, 0xfffa012e, "FFFA012E", "%X"},
+ {__LINE__, 0x0000001a, "0x1a", "% #x"},
+ {__LINE__, 0xfffb26d3, "fffb26d3", "%+x"},
+ {__LINE__, -0x00003e6, " -998", "%7ld"},
+ {__LINE__, 0x00000004, "4", "%-d"},
+ {__LINE__, 0xfffffd76, "0XFFFFFD76", "%#7X"},
+ {__LINE__, 0x00000035, "53", "%ld"},
+ {__LINE__, 0xffc6c190, "0XFFC6C190", "%#X"},
+ {__LINE__, 0xffffffe2, "ffffffe2", "%7.0x"},
+ {__LINE__, 0x03ff1b87, "67050375", "%2.d"},
+ {__LINE__, 0x00020c47, "0X20C47", "%#X"},
+ {__LINE__, 0x00000000, "0", "%d"},
+ {__LINE__, 0x0000000e, "0X000E", "% #.4X"},
+ {__LINE__, -0x00035cd, "-13773", "%+2.d"},
+ {__LINE__, 0x00005eec, "5eec", "%1x"},
+ {__LINE__, 0x001da0ff, "1941759", "%0d"},
+ {__LINE__, 0xf8a9e96a, "f8a9e96a", "%+x"},
+ {__LINE__, -0x0000120, "-288 ", "%-#6.d"},
+ {__LINE__, 0x00000000, "0", "%-X"},
+ {__LINE__, 0x0000152e, "152E", "%+X"},
+ {__LINE__, -0x0001077, "-4215", "% 0d"},
+ {__LINE__, 0xffffffd7, "FFFFFFD7", "%0X"},
+ {__LINE__, 0xfffe097d, "FFFE097D", "%2X"},
+ {__LINE__, 0xcb982712, "cb982712", "%x"},
+ {__LINE__, 0xfff39f2e, "FFF39F2E", "%.5X"},
+ {__LINE__, -0x0058cae, "-363694", "%+.1d"},
+ {__LINE__, -0x000002b, "-043", "%#1.3d"},
+ {__LINE__, -0x001e989, "-125321", "%1d"},
+ {__LINE__, 0x00959ecd, "9805517", "%d"},
+ {__LINE__, 0xf49df846, "F49DF846", "%+3X"},
+ {__LINE__, 0xfffffffd, "fffffffd", "%+.5x"},
+ {__LINE__, -0x000ac76, "-44150", "%3.ld"},
+ {__LINE__, 0x00000028, " 0028", "%06.4x"},
+ {__LINE__, 0x000003e8, "3E8", "%-02X"},
+ {__LINE__, 0x00000012, "012", "%.3X"},
+ {__LINE__, 0x00000006, "0X6", "%#X"},
+ {__LINE__, 0x00ef8479, "+15697017", "%+0.6d"},
+ {__LINE__, 0xffffffe8, "FFFFFFE8", "%-X"},
+ {__LINE__, 0x773a90f7, "773a90f7", "%3.5x"},
+ {__LINE__, 0x00096d44, "96D44", "%-X"},
+ {__LINE__, -0x08a3d96, "-9059734", "%ld"},
+ {__LINE__, -0x000001a, "-26", "%00.ld"},
+ {__LINE__, 0x32f57585, "32f57585", "% x"},
+ {__LINE__, 0x2825f175, "2825F175", "%X"},
+ {__LINE__, 0x000054ff, "21759", "%-2d"},
+ {__LINE__, -0x0266cdc, "-2518236", "%ld"},
+ {__LINE__, 0x0000031d, "0X31D", "%+#4X"},
+ {__LINE__, 0x0003fc99, "3fc99", "%x"},
+ {__LINE__, -0x0064624, "-411172", "%-#d"},
+ {__LINE__, 0x0001b2d9, "111321", "%-ld"},
+ {__LINE__, -0x000007c, "-124", "%#d"},
+ {__LINE__, 0xfffffffa, "FFFFFFFA", "%+X"},
+ {__LINE__, -0x007a5b8, "-501176", "%+ld"},
+ {__LINE__, 0x0213b583, "213B583", "%2.X"},
+ {__LINE__, 0xfff12e51, "FFF12E51", "%+X"},
+ {__LINE__, 0x00052403, "0336899", "%-0.7d"},
+ {__LINE__, 0xffffffff, "ffffffff", "%-04.4x"},
+ {__LINE__, 0x00000010, "0010", "%0.4X"},
+ {__LINE__, 0xffffffb5, "FFFFFFB5", "%-1.3X"},
+ {__LINE__, -0x0000001, "-1", "%d"},
+ {__LINE__, 0x0003a2d1, "3a2d1", "% x"},
+ {__LINE__, 0x00000424, "1060", "%0ld"},
+ {__LINE__, -0x0000078, "-120", "%1d"},
+ {__LINE__, 0x00000000, "0", "%ld"},
+ {__LINE__, 0x00000414, "1044", "%ld"},
+ {__LINE__, 0x00000072, "0x072", "%#5.3x"},
+ {__LINE__, 0x0000007a, "7A", "% X"},
+ {__LINE__, 0x081542a3, "135611043", "%0d"},
+ {__LINE__, 0xfffb4ce6, "fffb4ce6", "%4.6x"},
+ {__LINE__, 0x00002ab2, "2ab2", "%-1x"},
+ {__LINE__, 0x00000000, " 0", "% 2x"},
+ {__LINE__, 0xfffffa59, "FFFFFA59", "%2.X"},
+ {__LINE__, 0xffffe22b, "ffffe22b", "%-x"},
+ {__LINE__, 0xfffffd52, "FFFFFD52", "%+.2X"},
+ {__LINE__, 0x0000039f, "927", "%-d"},
+ {__LINE__, 0x0002dea6, "2dea6", "%0x"},
+ {__LINE__, 0x000216db, "136923", "%ld"},
+ {__LINE__, 0x00000013, "19", "%0d"},
+ {__LINE__, 0x000047cc, "18380", "%2.2ld"},
+ {__LINE__, -0x0007d10, "-32016", "%d"},
+ {__LINE__, 0xff9af906, "FF9AF906", "%0X"},
+ {__LINE__, 0x02cfa224, "+47161892", "%+0.7d"},
+ {__LINE__, -0x0000022, "-34", "%1.d"},
+ {__LINE__, 0xfffffff0, "FFFFFFF0", "%-4X"},
+ {__LINE__, 0x00000029, " 41", "%6.ld"},
+ {__LINE__, 0xffffff76, "ffffff76", "%x"},
+ {__LINE__, 0x00000000, "0", "%+X"},
+ {__LINE__, 0x00000001, "1", "%d"},
+ {__LINE__, 0xfff6de5a, "FFF6DE5A", "%X"},
+ {__LINE__, 0x00000002, "2", "%ld"},
+ {__LINE__, 0x00000025, "25", "%+x"},
+ {__LINE__, 0xfffffffb, "FFFFFFFB", "%5.0X"},
+ {__LINE__, 0x0011bbb5, "1162165", "%0.0ld"},
+ {__LINE__, 0xfffcdc96, "0XFFFCDC96", "%#X"},
+ {__LINE__, 0x00008f5f, "8f5f", "%3.1x"},
+ {__LINE__, 0xffa0fa5d, "0XFFA0FA5D", "%#X"},
+ {__LINE__, 0x00004534, "4534", "% 0X"},
+ {__LINE__, 0xfffffff9, "fffffff9", "%.2x"},
+ {__LINE__, 0xffeeae50, "ffeeae50", "%-x"},
+ {__LINE__, 0x00002964, " 0010596", "% 0.7d"},
+ {__LINE__, 0x000021c9, " 21c9", "%6x"},
+ {__LINE__, 0x00000001, " 1", "% d"},
+ {__LINE__, 0x0002abd8, "+175064", "%+d"},
+ {__LINE__, 0xffffffad, "FFFFFFAD", "%+0X"},
+ {__LINE__, 0x00000003, "3", "%ld"},
+ {__LINE__, 0x0c036da3, " 201551267", "% .3d"},
+ {__LINE__, -0x004343c, "-275516", "%+ld"},
+ {__LINE__, 0x00000003, "003", "% .3x"},
+ {__LINE__, 0xffffe34e, "ffffe34e", "%x"},
+ {__LINE__, 0x0000e118, "e118", "%x"},
+ {__LINE__, -0x007d945, "-514373", "%+#0ld"},
+ {__LINE__, 0x277f1cc5, "277f1cc5", "% x"},
+ {__LINE__, 0x00003bef, "03bef", "% 0.5x"},
+ {__LINE__, 0xfffffcb9, "fffffcb9", "%x"},
+ {__LINE__, 0x0003311a, "209178", "%ld"},
+ {__LINE__, 0x00000000, " ", "%3.ld"},
+ {__LINE__, 0x05942225, "5942225", "%x"},
+ {__LINE__, 0xfffceb4c, "FFFCEB4C", "%-X"},
+ {__LINE__, 0xffd08633, "ffd08633", "%2.x"},
+ {__LINE__, -0x0000001, " -1", "%6d"},
+ {__LINE__, 0x000fdb12, "1039122", "%d"},
+ {__LINE__, 0x00000003, "3", "% 0X"},
+ {__LINE__, -0x2fd5bf1, "-50158577", "% 5.ld"},
+ {__LINE__, -0x0089a03, "-563715", "%-d"},
+ {__LINE__, 0xfffffffe, "FFFFFFFE", "% X"},
+ {__LINE__, 0x29fdb2ba, "29fdb2ba", "% 0x"},
+ {__LINE__, 0x0000008f, "8F", "% X"},
+ {__LINE__, 0x00000003, "3", "%ld"},
+ {__LINE__, 0xffc58445, "FFC58445", "%.2X"},
+ {__LINE__, -0x00023f6, "-9206", "%+d"},
+ {__LINE__, 0x00000011, "11", "%X"},
+ {__LINE__, -0x0000003, "-0000003", "%-.7d"},
+ {__LINE__, -0x0000003, "-3", "%#ld"},
+ {__LINE__, 0x001242d9, "1242D9", "%X"},
+ {__LINE__, -0x48d0c81, "-76352641", "%7.d"},
+ {__LINE__, -0x001b675, "-112245", "%#ld"},
+ {__LINE__, 0x00000003, "3", "%-d"},
+ {__LINE__, 0xfff93fdf, "0XFFF93FDF", "% #X"},
+ {__LINE__, 0x001a9414, "1741844", "%#ld"},
+ {__LINE__, 0x0001fd86, "130438", "%ld"},
+ {__LINE__, 0x010f37a8, "17774504", "%4.7d"},
+ {__LINE__, 0x00382838, "0382838", "%3.7X"},
+ {__LINE__, -0x47fd56c2, "-1207785154", "%ld"},
+ {__LINE__, 0x001981dd, "1981dd", "%x"},
+ {__LINE__, 0xffffefba, "ffffefba", "% 06.x"},
+ {__LINE__, -0x3f402b29, "-1061169961", "%+#ld"},
+ {__LINE__, -0x395aae44, "-962244164", "%-1d"},
+ {__LINE__, 0x1fa39f42, "530816834", "%#d"},
+ {__LINE__, -0x000358d, "-13709", "%d"},
+ {__LINE__, -0xdc17b8f, "-230783887", "%ld"},
+ {__LINE__, -0x23c41583, "-600053123", "%+3.d"},
+ {__LINE__, 0xfffffc16, "fffffc16", "%x"},
+ {__LINE__, 0x003f1364, "4133732", "%7.ld"},
+ {__LINE__, 0xffffe691, "FFFFE691", "%07X"},
+ {__LINE__, 0x07b31d71, "129178993", "%.7d"},
+ {__LINE__, -0x0019732, "-104242", "% ld"},
+ {__LINE__, 0x02428167, "0x2428167", "%#x"},
+ {__LINE__, -0x06c1ecd, "-7085773", "%.7ld"},
+ {__LINE__, 0xfb01cb4e, "fb01cb4e", "%x"},
+ {__LINE__, 0x00005a41, "+23105", "%+ld"},
+ {__LINE__, 0xfffffff4, "FFFFFFF4", "%-5.X"},
+ {__LINE__, 0x00000005, " 5", "%4.ld"},
+ {__LINE__, 0xf4ab4b2d, "F4AB4B2D", "%0.X"},
+ {__LINE__, -0x000fce3, "-64739", "%+#3.ld"},
+ {__LINE__, 0x000076ea, " 30442", "%6.2ld"},
+ {__LINE__, 0x00000cb9, " cb9", "%4.x"},
+ {__LINE__, 0x002f43ef, "3097583", "%1.1ld"},
+ {__LINE__, 0xf5bd0105, "F5BD0105", "%+X"},
+ {__LINE__, 0x0037954a, "3642698", "%d"},
+ {__LINE__, 0xfffffff7, "0XFFFFFFF7", "%-#X"},
+ {__LINE__, 0xffffcedf, "0xffffcedf", "%#6.7x"},
+ {__LINE__, 0xfffffde4, "FFFFFDE4", "%2.4X"},
+ {__LINE__, 0x01a6f103, "1a6f103", "%5.x"},
+ {__LINE__, 0x00000191, " 191", "%7.0X"},
+ {__LINE__, 0x00000003, "03", "% .2X"},
+ {__LINE__, -0xd4e3219, "-223228441", "%6.ld"},
+ {__LINE__, 0x00b0efbd, "11595709", "%d"},
+ {__LINE__, -0x00000ea, "-234", "%#3d"},
+ {__LINE__, 0x00000be8, "BE8 ", "%-5X"},
+ {__LINE__, 0xffffffff, "ffffffff", "%5.3x"},
+ {__LINE__, -0x267f8c6, "-40368326", "%d"},
+ {__LINE__, 0x000006ed, "6ED", "%X"},
+ {__LINE__, 0xfdd6c9b6, "FDD6C9B6", "%X"},
+ {__LINE__, 0x0007ac29, "7ac29", "%-x"},
+ {__LINE__, 0x00000014, "14", "%2x"},
+ {__LINE__, 0x123ca563, "+305964387", "%+ld"},
+ {__LINE__, 0x00000004, " 4", "%5.d"},
+ {__LINE__, 0xffff877a, "ffff877a", "%x"},
+ {__LINE__, -0x00003e7, "-999", "%+0.3d"},
+ {__LINE__, 0x0a68ba6e, "a68ba6e", "%3.1x"},
+ {__LINE__, 0xfe29c810, "FE29C810", "%+X"},
+#endif
+
+ {__LINE__, 0x00000000, "0", "%o"},
+ {__LINE__, 0000000123, "123", "%o"},
+ {__LINE__, 0000123456, "0123456", "%#o"},
+ {__LINE__, 0000123456, "00123456", "%#.8o"},
+ {__LINE__, 0000123456, " 00123456", "%#10.8o"},
+ {__LINE__, 0x00000123, "0x00123", "%#07x"},
+ {__LINE__, 0x00000000, "", "%#.0d"},
+ {__LINE__, 0x00000000, "", "%#.0x"},
+ {__LINE__, 0x00000000, "0", "%#.0o"},
+
+ {__LINE__, 0x00000000, "0", "%Id"},
+ {__LINE__, 0x0000000a, "10", "%Id"},
+ {__LINE__, 0x000000d2, "210", "%Id"},
+ {__LINE__, 0x00000c8a, "3210", "%Id"},
+ {__LINE__, 0x0000a8ca, "43210", "%Id"},
+ {__LINE__, 0x000849ea, "543210", "%Id"},
+ {__LINE__, 0x0063d76a, "6543210", "%Id"},
+ {__LINE__, 0x048ff4ea, "76543210", "%Id"},
+ {__LINE__, 0x343efcea, "876543210", "%Id"},
+
+ {0},
+};
+
+int
+main(int argc, char *argv[])
+{
+ int errcount = 0;
+ int testcount = 0;
+#define BSIZE 1024
+ char buffer[BSIZE];
+ sprint_int_type *iptr;
+ for (iptr = sprint_ints; iptr->line; iptr++) {
+ snprintf(buffer, sizeof(buffer), iptr->format_string, iptr->value);
+ if (strcmp(buffer, iptr->result) != 0) {
+ errcount++;
+ printf(
+ "Error in line %d using \"%s\". Result is \"%s\"; should be: \"%s\".\n",
+ iptr->line, iptr->format_string, buffer, iptr->result);
+ }
+ testcount++;
+ }
+
+ if (errcount == 0) {
+ printf ("Encountered no errors in %d tests.\n", testcount);
+ return 0;
+ }
+ else {
+ printf ("Encountered %d errors in %d tests.\n",
+ errcount, testcount);
+ return 1;
+ }
+}
diff --git a/mozglue/tests/glibc_printf_tests/tllformat.c b/mozglue/tests/glibc_printf_tests/tllformat.c
new file mode 100644
index 0000000000..88b2132093
--- /dev/null
+++ b/mozglue/tests/glibc_printf_tests/tllformat.c
@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <string.h>
+
+/* The original file was tiformat.c and it has been changed for long long tests\
+. */
+typedef struct
+{
+ int line;
+ long long int value;
+ const char *result;
+ const char *format_string;
+} sprint_int_type;
+
+sprint_int_type sprint_ints[] =
+{
+ {__LINE__, 0x00000000ULL, "0", "%llx"},
+ {__LINE__, 0xffff00000000208bULL, "ffff00000000208b", "%llx"},
+ {__LINE__, 0xffff00000000208bULL, "18446462598732849291", "%llu"},
+ {__LINE__, 18446462598732849291ULL, "ffff00000000208b", "%llx"},
+ {__LINE__, 18446462598732849291ULL, "18446462598732849291", "%llu"},
+ {__LINE__, 18359476226655002763ULL, "fec9f65b0000208b", "%llx"},
+ {__LINE__, 18359476226655002763ULL, "18359476226655002763", "%llu"},
+
+ {0},
+};
+
+int
+main (void)
+{
+ int errcount = 0;
+ int testcount = 0;
+#define BSIZE 1024
+ char buffer[BSIZE];
+ sprint_int_type *iptr;
+ for (iptr = sprint_ints; iptr->line; iptr++)
+ {
+ snprintf (buffer, sizeof(buffer), iptr->format_string, iptr->value);
+ if (strcmp (buffer, iptr->result) != 0)
+ {
+ ++errcount;
+ printf ("\
+Error in line %d using \"%s\". Result is \"%s\"; should be: \"%s\".\n",
+ iptr->line, iptr->format_string, buffer, iptr->result);
+ }
+ ++testcount;
+ }
+
+ if (errcount == 0)
+ {
+ printf ("Encountered no errors in %d tests.\n", testcount);
+ return 0;
+ }
+ else
+ {
+ printf ("Encountered %d errors in %d tests.\n",
+ errcount, testcount);
+ return 1;
+ }
+}
diff --git a/mozglue/tests/gtest/TestNativeNtGTest.cpp b/mozglue/tests/gtest/TestNativeNtGTest.cpp
new file mode 100644
index 0000000000..cc48f16fdd
--- /dev/null
+++ b/mozglue/tests/gtest/TestNativeNtGTest.cpp
@@ -0,0 +1,63 @@
+/* -*- 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/. */
+
+#include <windows.h>
+
+#include "gtest/gtest.h"
+
+#include "mozilla/NativeNt.h"
+#include "nsHashKeys.h"
+#include "nsTHashSet.h"
+
+TEST(TestNativeNtGTest, GenerateDependentModuleSet)
+{
+ mozilla::nt::PEHeaders executable(::GetModuleHandleW(nullptr));
+ nsTHashSet<nsStringCaseInsensitiveHashKey> dependentModules;
+ executable.EnumImportChunks([&](const char* aModule) {
+ dependentModules.Insert(
+ mozilla::nt::GetLeafName(NS_ConvertASCIItoUTF16(aModule)));
+ });
+
+ EXPECT_TRUE(dependentModules.Contains(u"mozglue.dll"_ns));
+ EXPECT_TRUE(dependentModules.Contains(u"MOZGLUE.dll"_ns));
+ EXPECT_FALSE(dependentModules.Contains(u"xxx.dll"_ns));
+}
+
+TEST(TestNativeNtGTest, GetLeafName)
+{
+ nsAutoString str;
+ str = mozilla::nt::GetLeafName(u""_ns);
+ EXPECT_STREQ(str.get(), L"");
+ str = mozilla::nt::GetLeafName(u"\\"_ns);
+ EXPECT_STREQ(str.get(), L"");
+ str = mozilla::nt::GetLeafName(u"\\\\"_ns);
+ EXPECT_STREQ(str.get(), L"");
+ str = mozilla::nt::GetLeafName(u"abc\\def\\ghi"_ns);
+ EXPECT_STREQ(str.get(), L"ghi");
+ str = mozilla::nt::GetLeafName(u"abcdef"_ns);
+ EXPECT_STREQ(str.get(), L"abcdef");
+ str = mozilla::nt::GetLeafName(u"\\abcdef"_ns);
+ EXPECT_STREQ(str.get(), L"abcdef");
+
+ const auto kEntireText =
+ u"\\"_ns
+ u"\\\\abc"_ns
+ u"\\x\\y\\z"_ns
+ u"123\\456\\"_ns
+ u"789"_ns;
+ str = mozilla::nt::GetLeafName(Substring(kEntireText, 0, 0));
+ EXPECT_STREQ(str.get(), L"");
+ str = mozilla::nt::GetLeafName(Substring(kEntireText, 0, 1));
+ EXPECT_STREQ(str.get(), L"");
+ str = mozilla::nt::GetLeafName(Substring(kEntireText, 1, 5));
+ EXPECT_STREQ(str.get(), L"abc");
+ str = mozilla::nt::GetLeafName(Substring(kEntireText, 6, 6));
+ EXPECT_STREQ(str.get(), L"z");
+ str = mozilla::nt::GetLeafName(Substring(kEntireText, 12, 8));
+ EXPECT_STREQ(str.get(), L"");
+ str = mozilla::nt::GetLeafName(Substring(kEntireText, 20));
+ EXPECT_STREQ(str.get(), L"789");
+}
diff --git a/mozglue/tests/gtest/TestStackWalk.cpp b/mozglue/tests/gtest/TestStackWalk.cpp
new file mode 100644
index 0000000000..cec21ffc5e
--- /dev/null
+++ b/mozglue/tests/gtest/TestStackWalk.cpp
@@ -0,0 +1,279 @@
+/* -*- 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/. */
+
+// The header under test.
+#include "mozilla/StackWalk.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+
+#include <algorithm>
+
+#include "gtest/gtest.h"
+
+MOZ_EXPORT bool gStackWalkTesterDummy = true;
+
+struct StackWalkTester;
+
+// Descriptor of the recursive function calls wanted, and for each of them
+// whether to perform tail call optimization or not.
+struct CallInfo {
+ int (*mFunc)(int aDepth, int aLastSkipped, int aIgnored,
+ StackWalkTester& aTester);
+ bool mTailCall;
+
+ bool TailCall() {
+#if defined(__i386__) || defined(MOZ_CODE_COVERAGE)
+ // We can't make tail calls happen on i386 because all arguments to
+ // functions are on the stack, so the stack pointer needs to be updated
+ // before the call and restored after the call, so tail call optimization
+ // never happens.
+ // Similarly, code-coverage flags don't guarantee that tail call
+ // optimization will happen.
+ return false;
+#else
+ return mTailCall;
+#endif
+ }
+};
+
+struct PCRange {
+ void* mStart;
+ void* mEnd;
+};
+
+// PCRange pretty printer for gtest assertions.
+std::ostream& operator<<(std::ostream& aStream, const PCRange& aRange) {
+ aStream << aRange.mStart;
+ aStream << "-";
+ aStream << aRange.mEnd;
+ return aStream;
+}
+
+// Allow to use EXPECT_EQ with a vector of PCRanges and a vector of plain
+// addresses, allowing a more useful output when the test fails, showing
+// both lists.
+bool operator==(const std::vector<PCRange>& aRanges,
+ const std::vector<void*>& aPtrs) {
+ if (aRanges.size() != aPtrs.size()) {
+ return false;
+ }
+ for (size_t i = 0; i < aRanges.size(); i++) {
+ auto range = aRanges[i];
+ auto ptr = reinterpret_cast<uintptr_t>(aPtrs[i]);
+ if (ptr <= reinterpret_cast<uintptr_t>(range.mStart) ||
+ ptr >= reinterpret_cast<uintptr_t>(range.mEnd)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+struct StackWalkTester {
+ // Description of the recursion of functions to perform for the testcase.
+ std::vector<CallInfo> mFuncCalls;
+ // Collection of PCs reported by MozStackWalk.
+ std::vector<void*> mFramePCs;
+ // Collection of PCs expected per what was observed while recursing.
+ std::vector<PCRange> mExpectedFramePCs;
+ // The aFirstFramePC value that will be passed to MozStackWalk.
+ void* mFirstFramePC = nullptr;
+
+ // Callback to be given to the stack walker.
+ // aClosure should point at an instance of this class.
+ static void StackWalkCallback(uint32_t aFrameNumber, void* aPC, void* aSP,
+ void* aClosure) {
+ ASSERT_NE(aClosure, nullptr);
+ StackWalkTester& tester = *reinterpret_cast<StackWalkTester*>(aClosure);
+ tester.mFramePCs.push_back(aPC);
+ EXPECT_EQ(tester.mFramePCs.size(), size_t(aFrameNumber))
+ << "Frame number doesn't match";
+ }
+
+ // Callers of this function get a range of addresses with:
+ // ```
+ // label:
+ // recursion();
+ // AddExpectedPC(&&label);
+ // ```
+ // This intends to record the range from label to the return of AddExpectedPC.
+ // The ideal code would be:
+ // ```
+ // recursion();
+ // label:
+ // AddExpectedPC(&&label);
+ // ```
+ // and we wouldn't need to keep ranges. But while this works fine with Clang,
+ // GCC actually sometimes reorders code such the address received by
+ // AddExpectedPC is the address *before* the recursion.
+ // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99784 Using a label before the
+ // recursion and CallerPC() from a function call after the recursion makes it
+ // less likely for things to go wrong.
+ MOZ_NEVER_INLINE void AddExpectedPC(void* aPC) {
+ mExpectedFramePCs.push_back({aPC, CallerPC()});
+ }
+
+ // Function intended to be called in sequence for recursion.
+ // CallInfo lists are meant to contain a sequence of IntermediateCallback<1>,
+ // IntermediateCallback<2>, etc.
+ // aDepth is a counter of how deep the recursion has gone so far;
+ // aLastSkipped is the depth of the last frame we want skipped in the
+ // testcase; aIgnored is there to avoid the compiler merging both recursive
+ // function calls, which would prevent tail call optimization happening on one
+ // of them. aTester is the instance of this class for the testcase.
+ template <int Id>
+ MOZ_NEVER_INLINE MOZ_EXPORT static int IntermediateCallback(
+ int aDepth, int aLastSkipped, int aIgnored, StackWalkTester& aTester) {
+ auto& callInfo = aTester.mFuncCalls.at(aDepth + 1);
+ if (aDepth == aLastSkipped) {
+ aTester.mFirstFramePC = CallerPC();
+ }
+ if (aTester.mFuncCalls.at(aDepth).TailCall()) {
+ return callInfo.mFunc(aDepth + 1, aLastSkipped, Id, aTester);
+ // Since we're doing a tail call, we're not expecting this frame appearing
+ // in the trace.
+ }
+ here:
+ callInfo.mFunc(aDepth + 1, aLastSkipped, Id + 1, aTester);
+ aTester.AddExpectedPC(&&here);
+ return 0;
+ }
+
+#if defined(__clang__)
+ __attribute__((no_sanitize("function")))
+#endif
+ MOZ_NEVER_INLINE MOZ_EXPORT static void
+ LeafCallback(int aDepth, int aLastSkipped, int aIgnored,
+ StackWalkTester& aTester) {
+ if (aDepth == aLastSkipped) {
+ aTester.mFirstFramePC = CallerPC();
+ }
+ if (aTester.mFuncCalls.at(aDepth).TailCall()) {
+ // For the same reason that we have the aIgnored argument on these
+ // callbacks, we need to avoid both MozStackWalk calls to be merged by the
+ // compiler, so we use different values of aMaxFrames for that.
+ return MozStackWalk(StackWalkTester::StackWalkCallback,
+ aTester.mFirstFramePC,
+ /*aMaxFrames*/ 19, &aTester);
+ // Since we're doing a tail call, we're not expecting this frame appearing
+ // in the trace.
+ }
+ here:
+ MozStackWalk(StackWalkTester::StackWalkCallback, aTester.mFirstFramePC,
+ /*aMaxFrames*/ 20, &aTester);
+ aTester.AddExpectedPC(&&here);
+ // Because we return nothing from this function, simply returning here would
+ // produce a tail-call optimization, which we explicitly don't want to
+ // happen. So we add a branch that depends on an extern value to prevent
+ // that from happening.
+ MOZ_RELEASE_ASSERT(gStackWalkTesterDummy);
+ }
+
+ explicit StackWalkTester(std::initializer_list<CallInfo> aFuncCalls)
+ : mFuncCalls(aFuncCalls) {}
+
+ // Dump a vector of PCRanges as WalkTheStack would, for test failure output.
+ // Only the end of the range is shown. Not ideal, but
+ // MozFormatCodeAddressDetails only knows to deal with one address at a time.
+ // The full ranges would be printed by EXPECT_EQ anyways.
+ static std::string DumpFrames(std::vector<PCRange>& aFramePCRanges) {
+ std::vector<void*> framePCs;
+ framePCs.reserve(aFramePCRanges.size());
+ for (auto range : aFramePCRanges) {
+ framePCs.push_back(range.mEnd);
+ }
+ return DumpFrames(framePCs);
+ }
+
+ // Dump a vector of addresses as WalkTheStack would, for test failure output.
+ static std::string DumpFrames(std::vector<void*>& aFramePCs) {
+ size_t n = 0;
+ std::string result;
+ for (auto* framePC : aFramePCs) {
+ char buf[1024];
+ MozCodeAddressDetails details;
+ result.append(" ");
+ n++;
+ if (MozDescribeCodeAddress(framePC, &details)) {
+ int length =
+ MozFormatCodeAddressDetails(buf, sizeof(buf), n, framePC, &details);
+ result.append(buf, std::min(length, (int)sizeof(buf) - 1));
+ } else {
+ result.append("MozDescribeCodeAddress failed");
+ }
+ result.append("\n");
+ }
+ return result;
+ }
+
+ // Dump a description of the given test case.
+ static std::string DumpFuncCalls(std::vector<CallInfo>& aFuncCalls) {
+ std::string result;
+ for (auto funcCall : aFuncCalls) {
+ MozCodeAddressDetails details;
+ result.append(" ");
+ if (MozDescribeCodeAddress(reinterpret_cast<void*>(funcCall.mFunc),
+ &details)) {
+ result.append(details.function);
+ if (funcCall.TailCall()) {
+ result.append(" tail call");
+ }
+ } else {
+ result.append("MozDescribeCodeAddress failed");
+ }
+ result.append("\n");
+ }
+ return result;
+ }
+
+ MOZ_EXPORT MOZ_NEVER_INLINE void RunTest(int aLastSkipped) {
+ ASSERT_TRUE(aLastSkipped < (int)mFuncCalls.size());
+ mFramePCs.clear();
+ mExpectedFramePCs.clear();
+ mFirstFramePC = nullptr;
+ auto& callInfo = mFuncCalls.at(0);
+ here:
+ callInfo.mFunc(0, aLastSkipped, 0, *this);
+ AddExpectedPC(&&here);
+ if (aLastSkipped < 0) {
+ aLastSkipped = mFuncCalls.size();
+ }
+ for (int i = (int)mFuncCalls.size() - 1; i >= aLastSkipped; i--) {
+ if (!mFuncCalls.at(i).TailCall()) {
+ mExpectedFramePCs.erase(mExpectedFramePCs.begin());
+ }
+ }
+ mFramePCs.resize(std::min(mExpectedFramePCs.size(), mFramePCs.size()));
+ EXPECT_EQ(mExpectedFramePCs, mFramePCs)
+ << "Expected frames:\n"
+ << DumpFrames(mExpectedFramePCs) << "Found frames:\n"
+ << DumpFrames(mFramePCs)
+ << "Function calls data (last skipped: " << aLastSkipped << "):\n"
+ << DumpFuncCalls(mFuncCalls);
+ }
+};
+
+TEST(TestStackWalk, StackWalk)
+{
+ const auto foo = StackWalkTester::IntermediateCallback<1>;
+ const auto bar = StackWalkTester::IntermediateCallback<2>;
+ const auto qux = StackWalkTester::IntermediateCallback<3>;
+ const auto leaf = reinterpret_cast<int (*)(int, int, int, StackWalkTester&)>(
+ StackWalkTester::LeafCallback);
+
+ const std::initializer_list<CallInfo> tests[] = {
+ {{foo, false}, {bar, false}, {qux, false}, {leaf, false}},
+ {{foo, false}, {bar, true}, {qux, false}, {leaf, false}},
+ {{foo, false}, {bar, false}, {qux, false}, {leaf, true}},
+ {{foo, true}, {bar, false}, {qux, true}, {leaf, true}},
+ };
+ for (auto test : tests) {
+ StackWalkTester tester(test);
+ for (int i = -1; i < (int)test.size(); i++) {
+ tester.RunTest(i);
+ }
+ }
+}
diff --git a/mozglue/tests/gtest/moz.build b/mozglue/tests/gtest/moz.build
new file mode 100644
index 0000000000..8f6ba9ad7b
--- /dev/null
+++ b/mozglue/tests/gtest/moz.build
@@ -0,0 +1,20 @@
+# 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["OS_ARCH"] == "WINNT":
+ SOURCES += [
+ "TestNativeNtGTest.cpp",
+ ]
+
+
+if not CONFIG["MOZ_TSAN"]:
+ SOURCES += [
+ "TestStackWalk.cpp",
+ ]
+
+ # The test relies on optimizations being on, so we can't let --disable-optimize
+ # getting in the way. See details in the source file.
+ SOURCES["TestStackWalk.cpp"].flags += ["-O2"]
+
+FINAL_LIBRARY = "xul-gtest"
diff --git a/mozglue/tests/moz.build b/mozglue/tests/moz.build
new file mode 100644
index 0000000000..ac68508ebd
--- /dev/null
+++ b/mozglue/tests/moz.build
@@ -0,0 +1,53 @@
+# -*- Mode: python; 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/.
+
+DisableStlWrapping()
+
+# Important: for CppUnitTests to be run, they also need to be added
+# to testing/cppunittest.ini.
+
+GeckoCppUnitTests(
+ [
+ "ShowSSEConfig",
+ ],
+ linkage=None,
+)
+
+CppUnitTests(
+ [
+ "TestBaseProfiler",
+ "TestIntegerPrintfMacros",
+ "TestPrintf",
+ ]
+)
+
+with Files("TestBaseProfiler.cpp"):
+ BUG_COMPONENT = ("Core", "Gecko Profiler")
+
+if CONFIG["OS_ARCH"] == "WINNT":
+ GeckoCppUnitTests(
+ [
+ "TestNativeNt",
+ "TestPEExportSection",
+ "TestStackCookie",
+ "TestTimeStampWin",
+ ],
+ linkage=None,
+ )
+ OS_LIBS += [
+ "ntdll",
+ "version",
+ ]
+
+if CONFIG["OS_TARGET"] == "WINNT" and CONFIG["CC_TYPE"] in ("gcc", "clang"):
+ # This allows us to use wmain as the entry point on mingw
+ LDFLAGS += [
+ "-municode",
+ ]
+
+TEST_DIRS += [
+ "gtest",
+]