Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 657 insertions, 0 deletions

diff --git a/js/src/util/DumpFunctions.cpp b/js/src/util/DumpFunctions.cpp
new file mode 100644
index 0000000000..0de9beea89
--- /dev/null
+++ b/js/src/util/DumpFunctions.cpp
@@ -0,0 +1,657 @@
+/* -*- 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 "js/friend/DumpFunctions.h"
+
+#include "mozilla/Maybe.h"  // mozilla::Maybe
+
+#include <inttypes.h>  // PRIu64
+#include <stddef.h>    // size_t
+#include <stdio.h>     // fprintf, fflush
+
+#include "jsfriendapi.h"  // js::WeakMapTracer
+#include "jstypes.h"      // JS_PUBLIC_API
+
+#include "gc/Allocator.h"         // js::CanGC
+#include "gc/Cell.h"              // js::gc::Cell, js::gc::TenuredCell
+#include "gc/GC.h"                // js::TraceRuntimeWithoutEviction
+#include "gc/Heap.h"              // js::gc::Arena
+#include "gc/Tracer.h"            // js::TraceChildren
+#include "gc/WeakMap.h"           // js::IterateHeapUnbarriered, js::WeakMapBase
+#include "js/CallAndConstruct.h"  // JS::IsCallable
+#include "js/GCAPI.h"             // JS::GCReason
+#include "js/GCVector.h"          // JS::RootedVector
+#include "js/HeapAPI.h"           // JS::GCCellPtr, js::gc::IsInsideNursery
+#include "js/Id.h"                // JS::PropertyKey
+#include "js/Printer.h"     // js::GenericPrinter, js::QuoteString, js::Sprinter
+#include "js/RootingAPI.h"  // JS::Handle, JS::Rooted
+#include "js/TracingAPI.h"  // JS::CallbackTracer, JS_GetTraceThingInfo
+#include "js/UbiNode.h"     // JS::ubi::Node
+#include "js/Value.h"       // JS::Value
+#include "js/Wrapper.h"     // js::UncheckedUnwrapWithoutExpose
+#include "vm/BigIntType.h"  // JS::BigInt::dump
+#include "vm/FrameIter.h"   // js::AllFramesIter, js::FrameIter
+#include "vm/Interpreter.h"  // GetFunctionThis
+#include "vm/JSContext.h"    // JSContext
+#include "vm/JSFunction.h"   // JSFunction
+#include "vm/JSObject.h"     // JSObject
+#include "vm/JSScript.h"     // JSScript
+#include "vm/Realm.h"        // JS::Realm
+#include "vm/Runtime.h"      // JSRuntime
+#include "vm/Scope.h"        // js::PositionalFormalParameterIter
+#include "vm/Stack.h"        // js::DONT_CHECK_ALIASING
+#include "vm/StringType.h"   // JSAtom, JSString, js::ToString
+
+#include "vm/JSObject-inl.h"  // js::IsCallable
+#include "vm/Realm-inl.h"     // js::AutoRealm
+
+namespace JS {
+
+class JS_PUBLIC_API AutoRequireNoGC;
+class JS_PUBLIC_API Zone;
+
+}  // namespace JS
+
+using JS::Handle;
+using JS::MagicValue;
+using JS::PropertyKey;
+using JS::Realm;
+using JS::Rooted;
+using JS::RootedVector;
+using JS::UniqueChars;
+using JS::Value;
+using JS::Zone;
+
+using js::AllFramesIter;
+using js::AutoRealm;
+using js::CanGC;
+using js::DONT_CHECK_ALIASING;
+using js::FrameIter;
+using js::PositionalFormalParameterIter;
+using js::Sprinter;
+using js::ToString;
+using js::UncheckedUnwrapWithoutExpose;
+using js::WeakMapTracer;
+
+// We don't want jsfriendapi.h to depend on GenericPrinter,
+// so these functions are declared directly in the cpp.
+
+namespace js {
+
+class InterpreterFrame;
+
+extern JS_PUBLIC_API void DumpString(JSString* str, GenericPrinter& out);
+
+extern JS_PUBLIC_API void DumpAtom(JSAtom* atom, GenericPrinter& out);
+
+extern JS_PUBLIC_API void DumpObject(JSObject* obj, GenericPrinter& out);
+
+extern JS_PUBLIC_API void DumpChars(const char16_t* s, size_t n,
+                                    GenericPrinter& out);
+
+extern JS_PUBLIC_API void DumpValue(const JS::Value& val, GenericPrinter& out);
+
+extern JS_PUBLIC_API void DumpId(PropertyKey id, GenericPrinter& out);
+
+extern JS_PUBLIC_API void DumpInterpreterFrame(
+    JSContext* cx, GenericPrinter& out, InterpreterFrame* start = nullptr);
+
+extern JS_PUBLIC_API void DumpBigInt(JS::BigInt* bi, GenericPrinter& out);
+
+}  // namespace js
+
+void js::DumpString(JSString* str, GenericPrinter& out) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  str->dump(out);
+#endif
+}
+
+void js::DumpAtom(JSAtom* atom, GenericPrinter& out) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  atom->dump(out);
+#endif
+}
+
+void js::DumpChars(const char16_t* s, size_t n, GenericPrinter& out) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  out.printf("char16_t * (%p) = ", (void*)s);
+  JSString::dumpChars(s, n, out);
+  out.putChar('\n');
+#endif
+}
+
+void js::DumpObject(JSObject* obj, GenericPrinter& out) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  if (!obj) {
+    out.printf("NULL\n");
+    return;
+  }
+  obj->dump(out);
+#endif
+}
+
+void js::DumpBigInt(JS::BigInt* bi, GenericPrinter& out) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  bi->dump(out);
+#endif
+}
+
+void js::DumpString(JSString* str, FILE* fp) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  Fprinter out(fp);
+  js::DumpString(str, out);
+#endif
+}
+
+void js::DumpAtom(JSAtom* atom, FILE* fp) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  Fprinter out(fp);
+  js::DumpAtom(atom, out);
+#endif
+}
+
+void js::DumpChars(const char16_t* s, size_t n, FILE* fp) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  Fprinter out(fp);
+  js::DumpChars(s, n, out);
+#endif
+}
+
+void js::DumpObject(JSObject* obj, FILE* fp) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  Fprinter out(fp);
+  js::DumpObject(obj, out);
+#endif
+}
+
+void js::DumpBigInt(JS::BigInt* bi, FILE* fp) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  Fprinter out(fp);
+  js::DumpBigInt(bi, out);
+#endif
+}
+
+void js::DumpId(PropertyKey id, FILE* fp) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  Fprinter out(fp);
+  js::DumpId(id, out);
+#endif
+}
+
+void js::DumpValue(const JS::Value& val, FILE* fp) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  Fprinter out(fp);
+  js::DumpValue(val, out);
+#endif
+}
+
+void js::DumpString(JSString* str) { DumpString(str, stderr); }
+void js::DumpAtom(JSAtom* atom) { DumpAtom(atom, stderr); }
+void js::DumpObject(JSObject* obj) { DumpObject(obj, stderr); }
+void js::DumpChars(const char16_t* s, size_t n) { DumpChars(s, n, stderr); }
+void js::DumpBigInt(JS::BigInt* bi) { DumpBigInt(bi, stderr); }
+void js::DumpValue(const JS::Value& val) { DumpValue(val, stderr); }
+void js::DumpId(PropertyKey id) { DumpId(id, stderr); }
+void js::DumpInterpreterFrame(JSContext* cx, InterpreterFrame* start) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  Fprinter out(stderr);
+  DumpInterpreterFrame(cx, out, start);
+#endif
+}
+
+bool js::DumpPC(JSContext* cx) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  return DumpPC(cx, stdout);
+#else
+  return true;
+#endif
+}
+
+bool js::DumpScript(JSContext* cx, JSScript* scriptArg) {
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  return DumpScript(cx, scriptArg, stdout);
+#else
+  return true;
+#endif
+}
+
+static const char* FormatValue(JSContext* cx, Handle<Value> v,
+                               UniqueChars& bytes) {
+  if (v.isMagic()) {
+    MOZ_ASSERT(v.whyMagic() == JS_OPTIMIZED_OUT ||
+               v.whyMagic() == JS_UNINITIALIZED_LEXICAL);
+    return "[unavailable]";
+  }
+
+  if (js::IsCallable(v)) {
+    return "[function]";
+  }
+
+  if (v.isObject() && js::IsCrossCompartmentWrapper(&v.toObject())) {
+    return "[cross-compartment wrapper]";
+  }
+
+  JSString* str;
+  {
+    mozilla::Maybe<AutoRealm> ar;
+    if (v.isObject()) {
+      ar.emplace(cx, &v.toObject());
+    }
+
+    str = ToString<CanGC>(cx, v);
+    if (!str) {
+      return nullptr;
+    }
+  }
+
+  bytes = js::QuoteString(cx, str, '"');
+  return bytes.get();
+}
+
+static bool FormatFrame(JSContext* cx, const FrameIter& iter, Sprinter& sp,
+                        int num, bool showArgs, bool showLocals,
+                        bool showThisProps) {
+  MOZ_ASSERT(!cx->isExceptionPending());
+  Rooted<JSScript*> script(cx, iter.script());
+  jsbytecode* pc = iter.pc();
+
+  Rooted<JSObject*> envChain(cx, iter.environmentChain(cx));
+  JSAutoRealm ar(cx, envChain);
+
+  const char* filename = script->filename();
+  unsigned column = 0;
+  unsigned lineno = PCToLineNumber(script, pc, &column);
+  Rooted<JSFunction*> fun(cx, iter.maybeCallee(cx));
+  Rooted<JSString*> funname(cx);
+  if (fun) {
+    funname = fun->displayAtom();
+  }
+
+  Rooted<Value> thisVal(cx);
+  if (iter.hasUsableAbstractFramePtr() && iter.isFunctionFrame() && fun &&
+      !fun->isArrow() && !fun->isDerivedClassConstructor()) {
+    if (!GetFunctionThis(cx, iter.abstractFramePtr(), &thisVal)) {
+      return false;
+    }
+  }
+
+  // print the frame number and function name
+  if (funname) {
+    UniqueChars funbytes = js::QuoteString(cx, funname);
+    if (!funbytes) {
+      return false;
+    }
+    if (!sp.printf("%d %s(", num, funbytes.get())) {
+      return false;
+    }
+  } else if (fun) {
+    if (!sp.printf("%d anonymous(", num)) {
+      return false;
+    }
+  } else {
+    if (!sp.printf("%d <TOP LEVEL>", num)) {
+      return false;
+    }
+  }
+
+  if (showArgs && iter.hasArgs()) {
+    PositionalFormalParameterIter fi(script);
+    bool first = true;
+    for (unsigned i = 0; i < iter.numActualArgs(); i++) {
+      Rooted<Value> arg(cx);
+      if (i < iter.numFormalArgs() && fi.closedOver()) {
+        if (iter.hasInitialEnvironment(cx)) {
+          arg = iter.callObj(cx).aliasedBinding(fi);
+        } else {
+          arg = MagicValue(JS_OPTIMIZED_OUT);
+        }
+      } else if (iter.hasUsableAbstractFramePtr()) {
+        if (script->argsObjAliasesFormals() && iter.hasArgsObj()) {
+          arg = iter.argsObj().arg(i);
+        } else {
+          arg = iter.unaliasedActual(i, DONT_CHECK_ALIASING);
+        }
+      } else {
+        arg = MagicValue(JS_OPTIMIZED_OUT);
+      }
+
+      UniqueChars valueBytes;
+      const char* value = FormatValue(cx, arg, valueBytes);
+      if (!value) {
+        if (cx->isThrowingOutOfMemory()) {
+          return false;
+        }
+        cx->clearPendingException();
+      }
+
+      UniqueChars nameBytes;
+      const char* name = nullptr;
+
+      if (i < iter.numFormalArgs()) {
+        MOZ_ASSERT(fi.argumentSlot() == i);
+        if (!fi.isDestructured()) {
+          nameBytes = StringToNewUTF8CharsZ(cx, *fi.name());
+          name = nameBytes.get();
+          if (!name) {
+            return false;
+          }
+        } else {
+          name = "(destructured parameter)";
+        }
+        fi++;
+      }
+
+      if (value) {
+        if (!sp.printf("%s%s%s%s%s%s", !first ? ", " : "", name ? name : "",
+                       name ? " = " : "", arg.isString() ? "\"" : "", value,
+                       arg.isString() ? "\"" : "")) {
+          return false;
+        }
+
+        first = false;
+      } else {
+        if (!sp.put("    <Failed to get argument while inspecting stack "
+                    "frame>\n")) {
+          return false;
+        }
+      }
+    }
+  }
+
+  // print filename, line number and column
+  if (!sp.printf("%s [\"%s\":%u:%u]\n", fun ? ")" : "",
+                 filename ? filename : "<unknown>", lineno, column)) {
+    return false;
+  }
+
+  // Note: Right now we don't dump the local variables anymore, because
+  // that is hard to support across all the JITs etc.
+
+  // print the value of 'this'
+  if (showLocals) {
+    if (!thisVal.isUndefined()) {
+      Rooted<JSString*> thisValStr(cx, ToString<CanGC>(cx, thisVal));
+      if (!thisValStr) {
+        if (cx->isThrowingOutOfMemory()) {
+          return false;
+        }
+        cx->clearPendingException();
+      }
+      if (thisValStr) {
+        UniqueChars thisValBytes = QuoteString(cx, thisValStr);
+        if (!thisValBytes) {
+          return false;
+        }
+        if (!sp.printf("    this = %s\n", thisValBytes.get())) {
+          return false;
+        }
+      } else {
+        if (!sp.put("    <failed to get 'this' value>\n")) {
+          return false;
+        }
+      }
+    }
+  }
+
+  if (showThisProps && thisVal.isObject()) {
+    Rooted<JSObject*> obj(cx, &thisVal.toObject());
+
+    RootedVector<PropertyKey> keys(cx);
+    if (!GetPropertyKeys(cx, obj, JSITER_OWNONLY, &keys)) {
+      if (cx->isThrowingOutOfMemory()) {
+        return false;
+      }
+      cx->clearPendingException();
+    }
+
+    for (size_t i = 0; i < keys.length(); i++) {
+      Rooted<jsid> id(cx, keys[i]);
+      Rooted<Value> key(cx, IdToValue(id));
+      Rooted<Value> v(cx);
+
+      if (!GetProperty(cx, obj, obj, id, &v)) {
+        if (cx->isThrowingOutOfMemory()) {
+          return false;
+        }
+        cx->clearPendingException();
+        if (!sp.put("    <Failed to fetch property while inspecting stack "
+                    "frame>\n")) {
+          return false;
+        }
+        continue;
+      }
+
+      UniqueChars nameBytes;
+      const char* name = FormatValue(cx, key, nameBytes);
+      if (!name) {
+        if (cx->isThrowingOutOfMemory()) {
+          return false;
+        }
+        cx->clearPendingException();
+      }
+
+      UniqueChars valueBytes;
+      const char* value = FormatValue(cx, v, valueBytes);
+      if (!value) {
+        if (cx->isThrowingOutOfMemory()) {
+          return false;
+        }
+        cx->clearPendingException();
+      }
+
+      if (name && value) {
+        if (!sp.printf("    this.%s = %s%s%s\n", name, v.isString() ? "\"" : "",
+                       value, v.isString() ? "\"" : "")) {
+          return false;
+        }
+      } else {
+        if (!sp.put("    <Failed to format values while inspecting stack "
+                    "frame>\n")) {
+          return false;
+        }
+      }
+    }
+  }
+
+  MOZ_ASSERT(!cx->isExceptionPending());
+  return true;
+}
+
+static bool FormatWasmFrame(JSContext* cx, const FrameIter& iter, Sprinter& sp,
+                            int num) {
+  UniqueChars nameStr;
+  if (JSAtom* functionDisplayAtom = iter.maybeFunctionDisplayAtom()) {
+    nameStr = StringToNewUTF8CharsZ(cx, *functionDisplayAtom);
+    if (!nameStr) {
+      return false;
+    }
+  }
+
+  if (!sp.printf("%d %s()", num, nameStr ? nameStr.get() : "<wasm-function>")) {
+    return false;
+  }
+
+  if (!sp.printf(" [\"%s\":wasm-function[%u]:0x%x]\n",
+                 iter.filename() ? iter.filename() : "<unknown>",
+                 iter.wasmFuncIndex(), iter.wasmBytecodeOffset())) {
+    return false;
+  }
+
+  MOZ_ASSERT(!cx->isExceptionPending());
+  return true;
+}
+
+JS::UniqueChars JS::FormatStackDump(JSContext* cx, bool showArgs,
+                                    bool showLocals, bool showThisProps) {
+  int num = 0;
+
+  Sprinter sp(cx);
+  if (!sp.init()) {
+    return nullptr;
+  }
+
+  for (AllFramesIter i(cx); !i.done(); ++i) {
+    bool ok = i.hasScript() ? FormatFrame(cx, i, sp, num, showArgs, showLocals,
+                                          showThisProps)
+                            : FormatWasmFrame(cx, i, sp, num);
+    if (!ok) {
+      return nullptr;
+    }
+    num++;
+  }
+
+  if (num == 0) {
+    if (!sp.put("JavaScript stack is empty\n")) {
+      return nullptr;
+    }
+  }
+
+  return sp.release();
+}
+
+struct DumpHeapTracer final : public JS::CallbackTracer, public WeakMapTracer {
+  const char* prefix;
+  FILE* output;
+  mozilla::MallocSizeOf mallocSizeOf;
+
+  DumpHeapTracer(FILE* fp, JSContext* cx, mozilla::MallocSizeOf mallocSizeOf)
+      : JS::CallbackTracer(cx, JS::TracerKind::Callback,
+                           JS::WeakMapTraceAction::Skip),
+        WeakMapTracer(cx->runtime()),
+        prefix(""),
+        output(fp),
+        mallocSizeOf(mallocSizeOf) {}
+
+ private:
+  void trace(JSObject* map, JS::GCCellPtr key, JS::GCCellPtr value) override {
+    JSObject* kdelegate = nullptr;
+    if (key.is<JSObject>()) {
+      kdelegate = UncheckedUnwrapWithoutExpose(&key.as<JSObject>());
+    }
+
+    fprintf(output, "WeakMapEntry map=%p key=%p keyDelegate=%p value=%p\n", map,
+            key.asCell(), kdelegate, value.asCell());
+  }
+
+  void onChild(JS::GCCellPtr thing, const char* name) override;
+};
+
+static char MarkDescriptor(js::gc::Cell* thing) {
+  js::gc::TenuredCell* cell = &thing->asTenured();
+  if (cell->isMarkedBlack()) {
+    return 'B';
+  }
+  if (cell->isMarkedGray()) {
+    return 'G';
+  }
+  if (cell->isMarkedAny()) {
+    return 'X';
+  }
+  return 'W';
+}
+
+static void DumpHeapVisitZone(JSRuntime* rt, void* data, Zone* zone,
+                              const JS::AutoRequireNoGC& nogc) {
+  DumpHeapTracer* dtrc = static_cast<DumpHeapTracer*>(data);
+  fprintf(dtrc->output, "# zone %p\n", static_cast<void*>(zone));
+}
+
+static void DumpHeapVisitRealm(JSContext* cx, void* data, Realm* realm,
+                               const JS::AutoRequireNoGC& nogc) {
+  char name[1024];
+  if (auto nameCallback = cx->runtime()->realmNameCallback) {
+    nameCallback(cx, realm, name, sizeof(name), nogc);
+  } else {
+    strcpy(name, "<unknown>");
+  }
+
+  DumpHeapTracer* dtrc = static_cast<DumpHeapTracer*>(data);
+  fprintf(dtrc->output, "# realm %s [in compartment %p, zone %p]\n", name,
+          static_cast<void*>(realm->compartment()),
+          static_cast<void*>(realm->zone()));
+}
+
+static void DumpHeapVisitArena(JSRuntime* rt, void* data, js::gc::Arena* arena,
+                               JS::TraceKind traceKind, size_t thingSize,
+                               const JS::AutoRequireNoGC& nogc) {
+  DumpHeapTracer* dtrc = static_cast<DumpHeapTracer*>(data);
+  fprintf(dtrc->output, "# arena allockind=%u size=%u\n",
+          unsigned(arena->getAllocKind()), unsigned(thingSize));
+}
+
+static void DumpHeapVisitCell(JSRuntime* rt, void* data, JS::GCCellPtr cellptr,
+                              size_t thingSize,
+                              const JS::AutoRequireNoGC& nogc) {
+  DumpHeapTracer* dtrc = static_cast<DumpHeapTracer*>(data);
+  char cellDesc[1024 * 32];
+  js::gc::GetTraceThingInfo(cellDesc, sizeof(cellDesc), cellptr.asCell(),
+                            cellptr.kind(), true);
+
+  fprintf(dtrc->output, "%p %c %s", cellptr.asCell(),
+          MarkDescriptor(cellptr.asCell()), cellDesc);
+  if (dtrc->mallocSizeOf) {
+    auto size = JS::ubi::Node(cellptr).size(dtrc->mallocSizeOf);
+    fprintf(dtrc->output, " SIZE:: %" PRIu64 "\n", size);
+  } else {
+    fprintf(dtrc->output, "\n");
+  }
+
+  JS::TraceChildren(dtrc, cellptr);
+}
+
+void DumpHeapTracer::onChild(JS::GCCellPtr thing, const char* name) {
+  if (js::gc::IsInsideNursery(thing.asCell())) {
+    return;
+  }
+
+  char buffer[1024];
+  context().getEdgeName(name, buffer, sizeof(buffer));
+  fprintf(output, "%s%p %c %s\n", prefix, thing.asCell(),
+          MarkDescriptor(thing.asCell()), buffer);
+}
+
+void js::DumpHeap(JSContext* cx, FILE* fp,
+                  DumpHeapNurseryBehaviour nurseryBehaviour,
+                  mozilla::MallocSizeOf mallocSizeOf) {
+  if (nurseryBehaviour == CollectNurseryBeforeDump) {
+    cx->runtime()->gc.evictNursery(JS::GCReason::API);
+  }
+
+  DumpHeapTracer dtrc(fp, cx, mallocSizeOf);
+
+  fprintf(dtrc.output, "# Roots.\n");
+  TraceRuntimeWithoutEviction(&dtrc);
+
+  fprintf(dtrc.output, "# Weak maps.\n");
+  WeakMapBase::traceAllMappings(&dtrc);
+
+  fprintf(dtrc.output, "==========\n");
+
+  dtrc.prefix = "> ";
+  IterateHeapUnbarriered(cx, &dtrc, DumpHeapVisitZone, DumpHeapVisitRealm,
+                         DumpHeapVisitArena, DumpHeapVisitCell);
+
+  fflush(dtrc.output);
+}
+
+void DumpFmtV(FILE* fp, const char* fmt, va_list args) {
+  js::Fprinter out(fp);
+  out.vprintf(fmt, args);
+}
+
+void js::DumpFmt(FILE* fp, const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  DumpFmtV(fp, fmt, args);
+  va_end(args);
+}
+
+void js::DumpFmt(const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  DumpFmtV(stderr, fmt, args);
+  va_end(args);
+}