Prototype CL for faster DOM accessors.

src/runtime/runtime-ptr.cc

Index: src/runtime/runtime-ptr.cc
diff --git a/src/runtime/runtime-ptr.cc b/src/runtime/runtime-ptr.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c1d24cea0e647e7bd9129ca7ebeb90c1f17d8b81
--- /dev/null
+++ b/src/runtime/runtime-ptr.cc
@@ -0,0 +1,111 @@
+// Copyright 2015 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"
+
+#include "src/arguments.h"
+#include "src/runtime/runtime-utils.h"
+
+// Implmement runtime functions for direct DOM element access.
+
+namespace v8 {
+namespace internal {
+
+namespace {
+
+// Helper functions & definitions to handle our 'external pointer' pseudo
+// type. Essentially, we're using the "aligned pointer in Smi" hack to
+// transport a C++ pointer between our intrinsics below.
+
+#define CONVERT_PTR_ARG_CHECKED(name, index) \
+  RUNTIME_ASSERT(args[index]->IsSmi());      \
+  intptr_t name = fromObject(args.arguments()[index]);
+
+typedef intptr_t aligned_ptr_t;
+
+
+static aligned_ptr_t fromObject(Object* value) {
+  DCHECK(value->IsSmi());
+  return *reinterpret_cast<aligned_ptr_t*>(&value);

[epertoso, 2015/09/25 08:22:53]

just return reinterpret_cast<aligned_ptr>(value).

[vogelheim, 2015/09/29 11:15:17]

Done.

For some reason, I was dead sure that you could only reinterpret_cast<> between
pointer types. Apparently not. :)

+}
+
+
+static Object* fromAlignedPtr(aligned_ptr_t value) {
+  Object* object = *reinterpret_cast<Object**>(&value);

[epertoso, 2015/09/25 08:22:53]

As above, just reinterpret_cast<Object*>(value) is enough.

[vogelheim, 2015/09/29 11:15:17]

Done.

+  DCHECK(object->IsSmi());
+  return object;
+}
+
+
+static aligned_ptr_t loadAsPtr(aligned_ptr_t value) {
+  return *reinterpret_cast<aligned_ptr_t*>(value);
+}
+
+
+static int32_t loadAsInt32(aligned_ptr_t value) {
+  return *reinterpret_cast<int32_t*>(value);
+}
+
+
+static void checkAlignedOffset(int offset) { DCHECK((offset % 4) == 0); }
+
+
+static Object* objectFromAlignedPtr(aligned_ptr_t value) {
+  Object* object = *reinterpret_cast<Object**>(&value);

[epertoso, 2015/09/25 08:22:53]

And here too :).

[vogelheim, 2015/09/29 11:15:17]

Done.

+  DCHECK(!object->IsSmi());
+  return object;
+}
+
+}  // anonymous namespace
+
+
+RUNTIME_FUNCTION(Runtime_PtrGetFromInternalField) {
+  HandleScope scope(isolate);

[epertoso, 2015/09/25 08:22:53]

I think is that these functions should be UNREACHABLE, i.e. they are defined so
that turbofan can lower them.

OTOH, their implementation can be helpful to verify the correctness of the
function that's calling them. Should we have an #ifdef here?

[vogelheim, 2015/09/29 11:15:17]

Disagree. The reason why I want them (#ifdef-ed) in the code now - despite the
other parts not being in place - is that we can develop + experiment properly,
without having to patch the local client every time.

Long term you are probably right; but for the time being UNREACHABLE() strikes
me as the wrong thing to to.
Well... #ifdef V8_JS_ACCESSORS kinda does that. I think you mean to only #ifdef
the implementation of these runtime implementations; but there I disagree, as
above.

+  DCHECK(args.length() == 2);
+  CONVERT_ARG_HANDLE_CHECKED(JSObject, wrapper, 0);
+  CONVERT_SMI_ARG_CHECKED(field_number, 1);
+  Object* object = wrapper->GetInternalField(field_number);
+  DCHECK(object->IsSmi());
+  return object;
+}
+
+
+RUNTIME_FUNCTION(Runtime_PtrLoadOffset) {
+  HandleScope scope(isolate);
+  DCHECK(args.length() == 2);
+  CONVERT_PTR_ARG_CHECKED(ptr, 0);
+  CONVERT_SMI_ARG_CHECKED(offset, 1);
+  checkAlignedOffset(offset);
+  return fromAlignedPtr(loadAsPtr(ptr + offset));
+}
+
+
+RUNTIME_FUNCTION(Runtime_PtrLoadOffsetInt) {

[jochen (gone - plz use gerrit), 2015/09/25 11:20:12]

why not PtrTestIntAtOffset() or something?

[vogelheim, 2015/09/29 11:15:17]

Meanwhile, Enrico has done a good bit of work with this and he'll almost
certainly modify and extend these, once this CL is in. I'd prefer to let him
decide, depending on whether we really only need to mask bits, or possibly do
other things.

(An alternative would be for me to just drop this CL entirely, and let him check
in his version right away.)

+  HandleScope scope(isolate);
+  DCHECK(args.length() == 2);
+  CONVERT_PTR_ARG_CHECKED(ptr, 0);
+  CONVERT_SMI_ARG_CHECKED(offset, 1);
+  checkAlignedOffset(offset);
+  return Smi::FromInt(loadAsInt32(ptr + offset));
+}
+
+
+RUNTIME_FUNCTION(Runtime_PtrLoadOffsetObj) {
+  HandleScope scope(isolate);
+  DCHECK(args.length() == 1);
+  CONVERT_PTR_ARG_CHECKED(ptr, 0);
+  return objectFromAlignedPtr(loadAsPtr(ptr));
+}
+
+
+RUNTIME_FUNCTION(Runtime_PtrIsNull) {
+  HandleScope scope(isolate);
+  DCHECK(args.length() == 1);
+  CONVERT_PTR_ARG_CHECKED(ptr, 0);
+  return (ptr == 0) ? isolate->heap()->true_value()
+                    : isolate->heap()->false_value();
+}
+
+}  // namespace internal
+}  // namespace v8