Install function tables for the code range on Win64

src/x64/codegen-x64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_X64
 
 #include "src/codegen.h"
 #include "src/macro-assembler.h"
@@ skipping 13 matching lines @@
 
 void StubRuntimeCallHelper::AfterCall(MacroAssembler* masm) const {
   masm->LeaveFrame(StackFrame::INTERNAL);
   DCHECK(masm->has_frame());
   masm->set_has_frame(false);
 }
 
 
 #define __ masm.
 
+#ifdef _WIN64
+

[cpu_(ooo_6.6-7.5), 2014/09/26 20:35:31]

can you copy the definition of UndwinIfo from

Microsoft Visual Studio 12.0\VC\crt\src\ehdata.h

So when it becomes public we can just remove the local definition?

+struct UnwindInfo {
+  unsigned char version : 3;
+  unsigned char flags : 5;
+  unsigned char size_of_prolog;
+  unsigned char count_of_codes;
+  unsigned frame_register : 4;
+  unsigned frame_offset   : 4;
+  Address exception_handler;
+  Address exception_data;
+};
+
+struct ExceptionTableEntry {
+  char trampoline[16];
+  ::RUNTIME_FUNCTION runtime_function;
+  UnwindInfo unwind_info;
+};
+
+void InstallExceptionFilter(Isolate* isolate,
+                            WinExceptionFilter exception_filter) {
+  CHECK(exception_filter);
+  MemoryChunk* chunk = isolate->memory_allocator()->AllocateChunk(
+      sizeof(ExceptionTableEntry), sizeof(ExceptionTableEntry),
+      EXECUTABLE, NULL);
+  CHECK(chunk && chunk->address());
+  byte* buffer = chunk->area_start();
+  MacroAssembler masm(NULL, buffer, chunk->area_size());
+
+  __ Jump(reinterpret_cast<Address>(exception_filter),
+          RelocInfo::EXTERNAL_REFERENCE);

[cpu_(ooo_6.6-7.5), 2014/09/26 17:03:51]

what is ^^ that?

[jochen (gone - plz use gerrit), 2014/09/26 17:25:31]

this emits a jump to the breakpad exception filter into the buffer and marks the
address as a non-relocatable reference to an external address

[cpu_(ooo_6.6-7.5), 2014/09/26 20:35:31]

Acknowledged.

+
+  CodeDesc desc;
+  masm.GetCode(&desc);
+  DCHECK(!RelocInfo::RequiresRelocation(desc));
+
+  ExceptionTableEntry* table_entry =
+      reinterpret_cast<ExceptionTableEntry*>(buffer);
+  table_entry->runtime_function.BeginAddress = 0;

[cpu_(ooo_6.6-7.5), 2014/09/26 17:03:51]

is that begin address absolute?

[jochen (gone - plz use gerrit), 2014/09/26 17:25:31]

no, all addresses are 32bit offsets to the start of the region. that's the
reason why the stuff has to be inside v8's code range

[cpu_(ooo_6.6-7.5), 2014/09/26 20:35:31]

Acknowledged.

+  table_entry->runtime_function.EndAddress =
+      static_cast<DWORD>(isolate->code_range()->size());
+  table_entry->runtime_function.UnwindData =
+      reinterpret_cast<Address>(&table_entry->unwind_info) -
+      isolate->code_range()->start();
+
+  table_entry->unwind_info.version = 1;
+  table_entry->unwind_info.flags = UNW_FLAG_EHANDLER;
+  table_entry->unwind_info.size_of_prolog = 0;
+  table_entry->unwind_info.count_of_codes = 0;
+  table_entry->unwind_info.frame_register = 0;
+  table_entry->unwind_info.frame_offset = 0;
+  table_entry->unwind_info.exception_handler = reinterpret_cast<Address>(
+      reinterpret_cast<Address>(&table_entry->trampoline) -
+      isolate->code_range()->start());
+  table_entry->unwind_info.exception_data = 0;
+
+  CpuFeatures::FlushICache(buffer, chunk->area_size());
+  base::OS::ProtectCode(buffer, chunk->area_size());
+
+  CHECK(RtlAddFunctionTable(
+      &table_entry->runtime_function, 1,
+      reinterpret_cast<DWORD64>(isolate->code_range()->start())));
+}
+#endif
 
 UnaryMathFunction CreateExpFunction() {
   if (!FLAG_fast_math) return &std::exp;
   size_t actual_size;
   byte* buffer =
       static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
   if (buffer == NULL) return &std::exp;
   ExternalReference::InitializeMathExpData();
 
   MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
@@ skipping 662 matching lines @@
     // argument_count_reg_ * times_pointer_size + (receiver - 1) * kPointerSize.
     return Operand(base_reg_, argument_count_reg_, times_pointer_size,
         displacement_to_last_argument + (receiver - 1 - index) * kPointerSize);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64