asmjit 0.2.0 → 0.2.1

data/ext/asmjit/asmjit/test/asmjit_test_unit.cpp

@@ -0,0 +1,172 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#include <asmjit/core.h>
+
+#if !defined(ASMJIT_NO_X86)
+#include <asmjit/x86.h>
+#endif
+
+#include "asmjitutils.h"
+#include "broken.h"
+
+using namespace asmjit;
+
+static void dumpCpu(void) noexcept {
+  const CpuInfo& cpu = CpuInfo::host();
+
+  // CPU Information
+  // ---------------
+
+  INFO("CPU Info:");
+  INFO("  Vendor                  : %s", cpu.vendor());
+  INFO("  Brand                   : %s", cpu.brand());
+  INFO("  Model ID                : %u", cpu.modelId());
+  INFO("  Brand ID                : %u", cpu.brandId());
+  INFO("  Family ID               : %u", cpu.familyId());
+  INFO("  Stepping                : %u", cpu.stepping());
+  INFO("  Processor Type          : %u", cpu.processorType());
+  INFO("  Max logical Processors  : %u", cpu.maxLogicalProcessors());
+  INFO("  Cache-Line Size         : %u", cpu.cacheLineSize());
+  INFO("  HW-Thread Count         : %u", cpu.hwThreadCount());
+  INFO("");
+
+  // CPU Features
+  // ------------
+
+#ifndef ASMJIT_NO_LOGGING
+  INFO("CPU Features:");
+  CpuFeatures::Iterator it(cpu.features().iterator());
+  while (it.hasNext()) {
+    uint32_t featureId = uint32_t(it.next());
+    StringTmp<64> featureString;
+    Formatter::formatFeature(featureString, cpu.arch(), featureId);
+    INFO("  %s\n", featureString.data());
+  };
+  INFO("");
+#endif // !ASMJIT_NO_LOGGING
+}
+
+#define DUMP_TYPE(...) \
+  INFO("  %-26s: %u", #__VA_ARGS__, uint32_t(sizeof(__VA_ARGS__)))
+
+static void dumpSizeOf(void) noexcept {
+  INFO("Size of C++ types:");
+    DUMP_TYPE(int8_t);
+    DUMP_TYPE(int16_t);
+    DUMP_TYPE(int32_t);
+    DUMP_TYPE(int64_t);
+    DUMP_TYPE(int);
+    DUMP_TYPE(long);
+    DUMP_TYPE(size_t);
+    DUMP_TYPE(intptr_t);
+    DUMP_TYPE(float);
+    DUMP_TYPE(double);
+    DUMP_TYPE(void*);
+  INFO("");
+
+  INFO("Size of base classes:");
+    DUMP_TYPE(BaseAssembler);
+    DUMP_TYPE(BaseEmitter);
+    DUMP_TYPE(CodeBuffer);
+    DUMP_TYPE(CodeHolder);
+    DUMP_TYPE(ConstPool);
+    DUMP_TYPE(LabelEntry);
+    DUMP_TYPE(RelocEntry);
+    DUMP_TYPE(Section);
+    DUMP_TYPE(String);
+    DUMP_TYPE(Target);
+    DUMP_TYPE(Zone);
+    DUMP_TYPE(ZoneAllocator);
+    DUMP_TYPE(ZoneBitVector);
+    DUMP_TYPE(ZoneHashNode);
+    DUMP_TYPE(ZoneHash<ZoneHashNode>);
+    DUMP_TYPE(ZoneList<int>);
+    DUMP_TYPE(ZoneVector<int>);
+  INFO("");
+
+  INFO("Size of operand classes:");
+    DUMP_TYPE(Operand);
+    DUMP_TYPE(BaseReg);
+    DUMP_TYPE(BaseMem);
+    DUMP_TYPE(Imm);
+    DUMP_TYPE(Label);
+  INFO("");
+
+  INFO("Size of function classes:");
+    DUMP_TYPE(CallConv);
+    DUMP_TYPE(FuncFrame);
+    DUMP_TYPE(FuncValue);
+    DUMP_TYPE(FuncDetail);
+    DUMP_TYPE(FuncSignature);
+    DUMP_TYPE(FuncArgsAssignment);
+  INFO("");
+
+#if !defined(ASMJIT_NO_BUILDER)
+  INFO("Size of builder classes:");
+    DUMP_TYPE(BaseBuilder);
+    DUMP_TYPE(BaseNode);
+    DUMP_TYPE(InstNode);
+    DUMP_TYPE(InstExNode);
+    DUMP_TYPE(AlignNode);
+    DUMP_TYPE(LabelNode);
+    DUMP_TYPE(EmbedDataNode);
+    DUMP_TYPE(EmbedLabelNode);
+    DUMP_TYPE(ConstPoolNode);
+    DUMP_TYPE(CommentNode);
+    DUMP_TYPE(SentinelNode);
+  INFO("");
+#endif
+
+#if !defined(ASMJIT_NO_COMPILER)
+  INFO("Size of compiler classes:");
+    DUMP_TYPE(BaseCompiler);
+    DUMP_TYPE(FuncNode);
+    DUMP_TYPE(FuncRetNode);
+    DUMP_TYPE(InvokeNode);
+  INFO("");
+#endif
+
+#if !defined(ASMJIT_NO_X86)
+  INFO("Size of x86-specific classes:");
+    DUMP_TYPE(x86::Assembler);
+    #if !defined(ASMJIT_NO_BUILDER)
+    DUMP_TYPE(x86::Builder);
+    #endif
+    #if !defined(ASMJIT_NO_COMPILER)
+    DUMP_TYPE(x86::Compiler);
+    #endif
+    DUMP_TYPE(x86::InstDB::InstInfo);
+    DUMP_TYPE(x86::InstDB::CommonInfo);
+    DUMP_TYPE(x86::InstDB::OpSignature);
+    DUMP_TYPE(x86::InstDB::InstSignature);
+  INFO("");
+#endif
+}
+
+#undef DUMP_TYPE
+
+static void onBeforeRun(void) noexcept {
+  dumpCpu();
+  dumpSizeOf();
+}
+
+int main(int argc, const char* argv[]) {
+#if defined(ASMJIT_BUILD_DEBUG)
+  const char buildType[] = "Debug";
+#else
+  const char buildType[] = "Release";
+#endif
+
+  INFO("AsmJit Unit-Test v%u.%u.%u [Arch=%s] [Mode=%s]\n\n",
+    unsigned((ASMJIT_LIBRARY_VERSION >> 16)       ),
+    unsigned((ASMJIT_LIBRARY_VERSION >>  8) & 0xFF),
+    unsigned((ASMJIT_LIBRARY_VERSION      ) & 0xFF),
+    asmjitArchAsString(Arch::kHost),
+    buildType
+  );
+
+  return BrokenAPI::run(argc, argv, onBeforeRun);
+}

data/ext/asmjit/asmjit/test/asmjit_test_x86_sections.cpp

@@ -0,0 +1,172 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+// ----------------------------------------------------------------------------
+// This is a working example that demonstrates how multiple sections can be
+// used in a JIT-based code generator. It shows also the necessary tooling
+// that is expected to be done by the user when the feature is used. It's
+// important to handle the following cases:
+//
+//   - Assign offsets to sections when the code generation is finished.
+//   - Tell the CodeHolder to resolve unresolved links and check whether
+//     all links were resolved.
+//   - Relocate the code
+//   - Copy the code to the destination address.
+// ----------------------------------------------------------------------------
+
+#include <asmjit/core.h>
+#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86
+
+#include <asmjit/x86.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+using namespace asmjit;
+
+// The generated function is very simple, it only accesses the built-in data
+// (from .data section) at the index as provided by its first argument. This
+// data is inlined into the resulting function so we can use it this array
+// for verification that the function returns correct values.
+static const uint8_t dataArray[] = { 2, 9, 4, 7, 1, 3, 8, 5, 6, 0 };
+
+static void fail(const char* message, Error err) {
+  printf("** FAILURE: %s (%s) **\n", message, DebugUtils::errorAsString(err));
+  exit(1);
+}
+
+int main() {
+  printf("AsmJit X86 Sections Test\n\n");
+
+  Environment env = Environment::host();
+  JitAllocator allocator;
+
+#ifndef ASMJIT_NO_LOGGING
+  FileLogger logger(stdout);
+  logger.setIndentation(FormatIndentationGroup::kCode, 2);
+#endif
+
+  CodeHolder code;
+  code.init(env);
+
+#ifndef ASMJIT_NO_LOGGING
+  code.setLogger(&logger);
+#endif
+
+  Section* dataSection;
+  Error err = code.newSection(&dataSection, ".data", SIZE_MAX, SectionFlags::kNone, 8);
+
+  if (err) {
+    fail("Failed to create a .data section", err);
+  }
+  else {
+    printf("Generating code:\n");
+    x86::Assembler a(&code);
+    x86::Gp idx = a.zax();
+    x86::Gp addr = a.zcx();
+
+    Label data = a.newLabel();
+
+    FuncDetail func;
+    func.init(FuncSignatureT<size_t, size_t>(CallConvId::kHost), code.environment());
+
+    FuncFrame frame;
+    frame.init(func);
+    frame.addDirtyRegs(idx, addr);
+
+    FuncArgsAssignment args(&func);
+    args.assignAll(idx);
+    args.updateFuncFrame(frame);
+    frame.finalize();
+
+    a.emitProlog(frame);
+    a.emitArgsAssignment(frame, args);
+
+    a.lea(addr, x86::ptr(data));
+    a.movzx(idx, x86::byte_ptr(addr, idx));
+
+    a.emitEpilog(frame);
+
+    a.section(dataSection);
+    a.bind(data);
+
+    a.embed(dataArray, sizeof(dataArray));
+  }
+
+  // Manually change he offsets of each section, start at 0. This code is very
+  // similar to what `CodeHolder::flatten()` does, however, it's shown here
+  // how to do it explicitly.
+  printf("\nCalculating section offsets:\n");
+  uint64_t offset = 0;
+  for (Section* section : code.sectionsByOrder()) {
+    offset = Support::alignUp(offset, section->alignment());
+    section->setOffset(offset);
+    offset += section->realSize();
+
+    printf("  [0x%08X %s] {Id=%u Size=%u}\n",
+           uint32_t(section->offset()),
+           section->name(),
+           section->id(),
+           uint32_t(section->realSize()));
+  }
+  size_t codeSize = size_t(offset);
+  printf("  Final code size: %zu\n", codeSize);
+
+  // Resolve cross-section links (if any). On 32-bit X86 this is not necessary
+  // as this is handled through relocations as the addressing is different.
+  if (code.hasUnresolvedLinks()) {
+    printf("\nResolving cross-section links:\n");
+    printf("  Before 'resolveUnresolvedLinks()': %zu\n", code.unresolvedLinkCount());
+
+    err = code.resolveUnresolvedLinks();
+    if (err)
+      fail("Failed to resolve cross-section links", err);
+    printf("  After 'resolveUnresolvedLinks()': %zu\n", code.unresolvedLinkCount());
+  }
+
+  // Allocate memory for the function and relocate it there.
+  void* rxPtr;
+  void* rwPtr;
+  err = allocator.alloc(&rxPtr, &rwPtr, codeSize);
+  if (err)
+    fail("Failed to allocate executable memory", err);
+
+  // Relocate to the base-address of the allocated memory.
+  code.relocateToBase(uint64_t(uintptr_t(rxPtr)));
+
+  VirtMem::protectJitMemory(VirtMem::ProtectJitAccess::kReadWrite);
+
+  // Copy the flattened code into `mem.rw`. There are two ways. You can either copy
+  // everything manually by iterating over all sections or use `copyFlattenedData`.
+  // This code is similar to what `copyFlattenedData(p, codeSize, 0)` would do:
+  for (Section* section : code.sectionsByOrder())
+    memcpy(static_cast<uint8_t*>(rwPtr) + size_t(section->offset()), section->data(), section->bufferSize());
+
+  VirtMem::protectJitMemory(VirtMem::ProtectJitAccess::kReadExecute);
+  VirtMem::flushInstructionCache(rwPtr, code.codeSize());
+
+  // Execute the function and test whether it works.
+  typedef size_t (*Func)(size_t idx);
+  Func fn = (Func)rxPtr;
+
+  printf("\n");
+  if (fn(0) != dataArray[0] ||
+      fn(3) != dataArray[3] ||
+      fn(6) != dataArray[6] ||
+      fn(9) != dataArray[9] ) {
+    printf("** FAILURE: The generated function returned incorrect result(s) **\n");
+    return 1;
+  }
+
+  printf("** SUCCESS **\n");
+  return 0;
+}
+
+#else
+int main() {
+  printf("AsmJit X86 Sections Test is disabled on non-x86 host\n\n");
+  return 0;
+}
+#endif // !ASMJIT_NO_X86 && ASMJIT_ARCH_X86

data/ext/asmjit/asmjit/test/asmjitutils.h

@@ -0,0 +1,38 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#ifndef ASMJITUTILS_H_INCLUDED
+#define ASMJITUTILS_H_INCLUDED
+
+#include <asmjit/core.h>
+
+static const char* asmjitArchAsString(asmjit::Arch arch) noexcept {
+  switch (arch) {
+    case asmjit::Arch::kX86       : return "X86";
+    case asmjit::Arch::kX64       : return "X64";
+
+    case asmjit::Arch::kRISCV32   : return "RISCV32";
+    case asmjit::Arch::kRISCV64   : return "RISCV64";
+
+    case asmjit::Arch::kARM       : return "ARM";
+    case asmjit::Arch::kAArch64   : return "AArch64";
+    case asmjit::Arch::kThumb     : return "Thumb";
+
+    case asmjit::Arch::kMIPS32_LE : return "MIPS_LE";
+    case asmjit::Arch::kMIPS64_LE : return "MIPS64_LE";
+
+    case asmjit::Arch::kARM_BE    : return "ARM_BE";
+    case asmjit::Arch::kThumb_BE  : return "Thumb_BE";
+    case asmjit::Arch::kAArch64_BE: return "AArch64_BE";
+
+    case asmjit::Arch::kMIPS32_BE : return "MIPS_BE";
+    case asmjit::Arch::kMIPS64_BE : return "MIPS64_BE";
+
+    default:
+      return "<Unknown>";
+  }
+}
+
+#endif // ASMJITUTILS_H_INCLUDED

data/ext/asmjit/asmjit/test/broken.cpp

@@ -0,0 +1,312 @@
+// Broken - Lightweight unit testing for C++
+//
+// This is free and unencumbered software released into the public domain.
+//
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+//
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+// For more information, please refer to <http://unlicense.org>
+
+#include "./broken.h"
+#include <stdarg.h>
+
+// ============================================================================
+// [Broken - Global]
+// ============================================================================
+
+// Zero initialized globals.
+struct BrokenGlobal {
+  // Application arguments.
+  int _argc;
+  const char** _argv;
+
+  // Output file.
+  FILE* _file;
+
+  // Unit tests.
+  BrokenAPI::Unit* _unitList;
+  BrokenAPI::Unit* _unitRunning;
+
+  bool hasArg(const char* a) const noexcept {
+    for (int i = 1; i < _argc; i++)
+      if (strcmp(_argv[i], a) == 0)
+        return true;
+    return false;
+  }
+
+  inline FILE* file() const noexcept { return _file ? _file : stdout; }
+};
+static BrokenGlobal _brokenGlobal;
+
+// ============================================================================
+// [Broken - API]
+// ============================================================================
+
+// Get whether the string `a` starts with string `b`.
+static bool BrokenAPI_startsWith(const char* a, const char* b) noexcept {
+  for (size_t i = 0; ; i++) {
+    if (b[i] == '\0') return true;
+    if (a[i] != b[i]) return false;
+  }
+}
+
+//! Compares names and priority of two unit tests.
+static int BrokenAPI_compareUnits(const BrokenAPI::Unit* a, const BrokenAPI::Unit* b) noexcept {
+  if (a->priority == b->priority)
+    return strcmp(a->name, b->name);
+  else
+    return a->priority > b->priority ? 1 : -1;
+}
+
+// Get whether the strings `a` and `b` are equal, ignoring case and treating
+// `-` as `_`.
+static bool BrokenAPI_matchesFilter(const char* a, const char* b) noexcept {
+  for (size_t i = 0; ; i++) {
+    int ca = (unsigned char)a[i];
+    int cb = (unsigned char)b[i];
+
+    // If filter is defined as wildcard the rest automatically matches.
+    if (cb == '*')
+      return true;
+
+    if (ca == '-') ca = '_';
+    if (cb == '-') cb = '_';
+
+    if (ca >= 'A' && ca <= 'Z') ca += 'a' - 'A';
+    if (cb >= 'A' && cb <= 'Z') cb += 'a' - 'A';
+
+    if (ca != cb)
+      return false;
+
+    if (ca == '\0')
+      return true;
+  }
+}
+
+static bool BrokenAPI_canRun(BrokenAPI::Unit* unit) noexcept {
+  BrokenGlobal& global = _brokenGlobal;
+
+  int i, argc = global._argc;
+  const char** argv = global._argv;
+
+  const char* unitName = unit->name;
+  bool hasFilter = false;
+
+  for (i = 1; i < argc; i++) {
+    const char* arg = argv[i];
+
+    if (BrokenAPI_startsWith(arg, "--run-") && strcmp(arg, "--run-all") != 0) {
+      hasFilter = true;
+
+      if (BrokenAPI_matchesFilter(unitName, arg + 6))
+        return true;
+    }
+  }
+
+  // If no filter has been specified the default is to run.
+  return !hasFilter;
+}
+
+static void BrokenAPI_runUnit(BrokenAPI::Unit* unit) noexcept {
+  BrokenAPI::info("Running %s", unit->name);
+
+  _brokenGlobal._unitRunning = unit;
+  unit->entry();
+  _brokenGlobal._unitRunning = NULL;
+}
+
+static void BrokenAPI_runAll() noexcept {
+  BrokenAPI::Unit* unit = _brokenGlobal._unitList;
+
+  bool hasUnits = unit != NULL;
+  size_t count = 0;
+  int currentPriority = 0;
+
+  while (unit != NULL) {
+    if (BrokenAPI_canRun(unit)) {
+      if (currentPriority != unit->priority) {
+        if (count)
+          INFO("");
+        INFO("[[Priority=%d]]", unit->priority);
+      }
+
+      currentPriority = unit->priority;
+      BrokenAPI_runUnit(unit);
+      count++;
+    }
+    unit = unit->next;
+  }
+
+  if (count) {
+    INFO("\nSuccess:");
+    INFO("  All tests passed!");
+  }
+  else {
+    INFO("\nWarning:");
+    INFO("  No units %s!", hasUnits ? "matched the filter" : "defined");
+  }
+}
+
+static void BrokenAPI_listAll() noexcept {
+  BrokenAPI::Unit* unit = _brokenGlobal._unitList;
+
+  if (unit != NULL) {
+    INFO("Units:");
+    do {
+      INFO("  %s [priority=%d]", unit->name, unit->priority);
+      unit = unit->next;
+    } while (unit != NULL);
+  }
+  else {
+    INFO("Warning:");
+    INFO("  No units defined!");
+  }
+}
+
+bool BrokenAPI::hasArg(const char* name) noexcept {
+  return _brokenGlobal.hasArg(name);
+}
+
+void BrokenAPI::add(Unit* unit) noexcept {
+  Unit** pPrev = &_brokenGlobal._unitList;
+  Unit* current = *pPrev;
+
+  // C++ static initialization doesn't guarantee anything. We sort all units by
+  // name so the execution will always happen in deterministic order.
+  while (current != NULL) {
+    if (BrokenAPI_compareUnits(current, unit) >= 0)
+      break;
+
+    pPrev = &current->next;
+    current = *pPrev;
+  }
+
+  *pPrev = unit;
+  unit->next = current;
+}
+
+void BrokenAPI::setOutputFile(FILE* file) noexcept {
+  BrokenGlobal& global = _brokenGlobal;
+
+  global._file = file;
+}
+
+int BrokenAPI::run(int argc, const char* argv[], Entry onBeforeRun, Entry onAfterRun) {
+  BrokenGlobal& global = _brokenGlobal;
+
+  global._argc = argc;
+  global._argv = argv;
+
+  if (global.hasArg("--help")) {
+    INFO("Options:");
+    INFO("  --help    - print this usage");
+    INFO("  --list    - list all tests");
+    INFO("  --run-... - run a test(s), trailing wildcards supported");
+    INFO("  --run-all - run all tests (default)");
+    return 0;
+  }
+
+  if (global.hasArg("--list")) {
+    BrokenAPI_listAll();
+    return 0;
+  }
+
+  if (onBeforeRun)
+    onBeforeRun();
+
+  // We don't care about filters here, it's implemented by `runAll`.
+  BrokenAPI_runAll();
+
+  if (onAfterRun)
+    onAfterRun();
+
+  return 0;
+}
+
+static void BrokenAPI_printMessage(const char* prefix, const char* fmt, va_list ap) noexcept {
+  BrokenGlobal& global = _brokenGlobal;
+  FILE* dst = global.file();
+
+  if (!fmt || fmt[0] == '\0') {
+    fprintf(dst, "\n");
+  }
+  else {
+    // This looks scary, but we really want to use only a single call to vfprintf()
+    // in multithreaded code. So we change the format a bit if necessary.
+    enum : unsigned { kBufferSize = 512 };
+    char staticBuffer[512];
+
+    size_t fmtSize = strlen(fmt);
+    size_t prefixSize = strlen(prefix);
+
+    char* fmtBuf = staticBuffer;
+    if (fmtSize > kBufferSize - 2 - prefixSize)
+      fmtBuf = static_cast<char*>(malloc(fmtSize + prefixSize + 2));
+
+    if (!fmtBuf) {
+      fprintf(dst, "%sCannot allocate buffer for vfprintf()\n", prefix);
+    }
+    else {
+      memcpy(fmtBuf, prefix, prefixSize);
+      memcpy(fmtBuf + prefixSize, fmt, fmtSize);
+
+      fmtSize += prefixSize;
+      if (fmtBuf[fmtSize - 1] != '\n')
+        fmtBuf[fmtSize++] = '\n';
+      fmtBuf[fmtSize] = '\0';
+
+      vfprintf(dst, fmtBuf, ap);
+
+      if (fmtBuf != staticBuffer)
+        free(fmtBuf);
+    }
+  }
+
+  fflush(dst);
+}
+
+void BrokenAPI::info(const char* fmt, ...) noexcept {
+  BrokenGlobal& global = _brokenGlobal;
+
+  va_list ap;
+  va_start(ap, fmt);
+  BrokenAPI_printMessage(global._unitRunning ? "  " : "", fmt, ap);
+  va_end(ap);
+}
+
+void BrokenAPI::fail(const char* file, int line, const char* expression, const char* fmt, ...) noexcept {
+  BrokenGlobal& global = _brokenGlobal;
+  FILE* dst = global.file();
+
+  fprintf(dst, "  FAILED: %s\n", expression);
+
+  if (fmt) {
+    va_list ap;
+    va_start(ap, fmt);
+    BrokenAPI_printMessage("  REASON: ", fmt, ap);
+    va_end(ap);
+  }
+
+  fprintf(dst, "  SOURCE: %s (Line: %d)\n", file, line);
+  fflush(dst);
+
+  exit(1);
+}