electron/patches/v8/chore_add_v8_apple_silicon_patches.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Samuel Attard <marshallofsound@electronjs.org>
Date: Mon, 6 Jul 2020 20:47:43 -0700
Subject: chore: add v8 apple silicon patches

Once these are available upstream we can remove this patch.

diff --git a/src/codegen/arm64/macro-assembler-arm64.cc b/src/codegen/arm64/macro-assembler-arm64.cc
index fef1758aaa81a85009461839ec9aa816e7d196a6..c0f7a1cf5fd4787896b06bce911aabf17b290e88 100644
--- a/src/codegen/arm64/macro-assembler-arm64.cc
+++ b/src/codegen/arm64/macro-assembler-arm64.cc
@@ -2975,6 +2975,35 @@ void TurboAssembler::PrintfNoPreserve(const char* format,
 
   int arg_count = kPrintfMaxArgCount;
 
+#if V8_OS_MACOSX && !USE_SIMULATOR
+  CPURegList tmp_list = kCallerSaved;
+  tmp_list.Remove(x0);      // Used to pass the format string.
+  tmp_list.Remove(arg0, arg1, arg2, arg3);
+
+  // Override the MacroAssembler's scratch register list. The lists will be
+  // reset automatically at the end of the UseScratchRegisterScope.
+  UseScratchRegisterScope temps(this);
+  TmpList()->set_list(tmp_list.list());
+
+  VRegister temp_D = temps.AcquireD();
+
+  // https://developer.apple.com/library/archive/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARM64FunctionCallingConventions.html#//apple_ref/doc/uid/TP40013702-SW1
+  Claim(kPrintfMaxArgCount, 8);
+  int64_t offset = 0;
+  for (unsigned i = 0; i < kPrintfMaxArgCount; i++) {
+    CPURegister arg = args[i];
+    if (arg.IsNone()) {
+      break;
+    }
+    if (arg.IsS()) {
+      fcvt(temp_D, arg.S());
+      arg = temp_D;
+    }
+    // FIXME: Use stp.
+    str(arg, MemOperand(sp, offset, Offset));
+    offset += 8;
+  }
+#else
   // The PCS varargs registers for printf. Note that x0 is used for the printf
   // format string.
   static const CPURegList kPCSVarargs =
@@ -3085,7 +3114,7 @@ void TurboAssembler::PrintfNoPreserve(const char* format,
     }
 #endif
   }
-
+#endif
   // Load the format string into x0, as per the procedure-call standard.
   //
   // To make the code as portable as possible, the format string is encoded
@@ -3107,6 +3136,10 @@ void TurboAssembler::PrintfNoPreserve(const char* format,
   }
 
   CallPrintf(arg_count, pcs);
+
+#if V8_OS_MACOSX && !USE_SIMULATOR
+  Drop(kPrintfMaxArgCount, 8);
+#endif
 }
 
 void TurboAssembler::CallPrintf(int arg_count, const CPURegister* args) {
diff --git a/src/compiler/backend/arm64/instruction-selector-arm64.cc b/src/compiler/backend/arm64/instruction-selector-arm64.cc
index 78ae11f0d17c156b3debd1d501a22edc42c9fff5..564e6a1a71073727fe6daa847093c556c532620b 100644
--- a/src/compiler/backend/arm64/instruction-selector-arm64.cc
+++ b/src/compiler/backend/arm64/instruction-selector-arm64.cc
@@ -1905,6 +1905,7 @@ void InstructionSelector::EmitPrepareArguments(
 
   // Poke the arguments into the stack.
   while (slot >= 0) {
+    // FIXME: In the Apple ARM64 ABI parameters should be packed on the stack.
     PushParameter input0 = (*arguments)[slot];
     PushParameter input1 = slot > 0 ? (*arguments)[slot - 1] : PushParameter();
     // Emit a poke-pair if consecutive parameters have the same type.
diff --git a/src/flags/flag-definitions.h b/src/flags/flag-definitions.h
index 3137eb2ad31847efb9a0c526a2e0f84209d71cfe..723845eee8439f6dc8b5d1de3cc578ecdd1d3e99 100644
--- a/src/flags/flag-definitions.h
+++ b/src/flags/flag-definitions.h
@@ -776,7 +776,12 @@ DEFINE_INT(wasm_num_compilation_tasks, 128,
            "maximum number of parallel compilation tasks for wasm")
 DEFINE_DEBUG_BOOL(trace_wasm_native_heap, false,
                   "trace wasm native heap events")
-DEFINE_BOOL(wasm_write_protect_code_memory, false,
+#if V8_OS_MACOSX && V8_TARGET_ARCH_ARM64
+#define V8_DEFAULT_WASM_WRITE_PROTECT_CODE_MEMORY true
+#else
+#define V8_DEFAULT_WASM_WRITE_PROTECT_CODE_MEMORY false
+#endif
+DEFINE_BOOL(wasm_write_protect_code_memory, V8_DEFAULT_WASM_WRITE_PROTECT_CODE_MEMORY,
             "write protect code memory on the wasm native heap")
 DEFINE_DEBUG_BOOL(trace_wasm_serialization, false,
                   "trace serialization/deserialization")
diff --git a/src/wasm/function-compiler.cc b/src/wasm/function-compiler.cc
index 5c35f69f2af2199025dddfa577564996dbb6145f..a4e6b0128e909d371d0ede3627494002e281d547 100644
--- a/src/wasm/function-compiler.cc
+++ b/src/wasm/function-compiler.cc
@@ -258,6 +258,7 @@ void WasmCompilationUnit::CompileWasmFunction(Isolate* isolate,
       isolate->counters(), detected);
   if (result.succeeded()) {
     WasmCodeRefScope code_ref_scope;
+    NativeModuleModificationScope native_module_modification_scope(native_module);
     native_module->PublishCode(
         native_module->AddCompiledCode(std::move(result)));
   } else {
diff --git a/src/wasm/wasm-code-manager.h b/src/wasm/wasm-code-manager.h
index 5e8ed5475bb064cb657069242ce7517de7f5f8e2..5652bb407da3646e55c42492b3e9facec4556367 100644
--- a/src/wasm/wasm-code-manager.h
+++ b/src/wasm/wasm-code-manager.h
@@ -886,7 +886,7 @@ class V8_EXPORT_PRIVATE WasmCodeManager final {
 //    and even if we did, the resulting set of pages may be fragmented.
 //    Currently, we try and keep the number of syscalls low.
 // -  similar argument for debug time.
-class NativeModuleModificationScope final {
+class V8_EXPORT_PRIVATE NativeModuleModificationScope final {
  public:
   explicit NativeModuleModificationScope(NativeModule* native_module);
   ~NativeModuleModificationScope();
diff --git a/src/wasm/wasm-objects.cc b/src/wasm/wasm-objects.cc
index 0666f88619b9e724fe79d8fad817b8acf99a01b7..5274cad0d0aed50bbdea66ff1666af556d994879 100644
--- a/src/wasm/wasm-objects.cc
+++ b/src/wasm/wasm-objects.cc
@@ -1512,6 +1512,7 @@ void WasmInstanceObject::ImportWasmJSFunctionIntoTable(
     wasm::WasmCompilationResult result = compiler::CompileWasmImportCallWrapper(
         isolate->wasm_engine(), &env, kind, sig, false,
         shared.internal_formal_parameter_count());
+    wasm::NativeModuleModificationScope native_module_modification_scope(native_module);
     std::unique_ptr<wasm::WasmCode> wasm_code = native_module->AddCode(
         result.func_index, result.code_desc, result.frame_slot_count,
         result.tagged_parameter_slots,