runtime-utils.h 6.31 KB
Newer Older
1 2 3 4
// Copyright 2014 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.

5 6
#ifndef V8_RUNTIME_RUNTIME_UTILS_H_
#define V8_RUNTIME_RUNTIME_UTILS_H_
7

8
#include "src/base/logging.h"
9
#include "src/globals.h"
10
#include "src/runtime/runtime.h"
11 12 13 14 15 16

namespace v8 {
namespace internal {

// Cast the given object to a value of the specified type and store
// it in a variable with the given name.  If the object is not of the
17
// expected type we crash safely.
18
#define CONVERT_ARG_CHECKED(Type, name, index) \
19
  CHECK(args[index]->Is##Type());              \
20 21 22
  Type* name = Type::cast(args[index]);

#define CONVERT_ARG_HANDLE_CHECKED(Type, name, index) \
23
  CHECK(args[index]->Is##Type());                     \
24 25 26
  Handle<Type> name = args.at<Type>(index);

#define CONVERT_NUMBER_ARG_HANDLE_CHECKED(name, index) \
27
  CHECK(args[index]->IsNumber());                      \
28
  Handle<Object> name = args.at(index);
29 30

// Cast the given object to a boolean and store it in a variable with
31
// the given name.  If the object is not a boolean we crash safely.
32
#define CONVERT_BOOLEAN_ARG_CHECKED(name, index) \
33
  CHECK(args[index]->IsBoolean());               \
34
  bool name = args[index]->IsTrue(isolate);
35 36

// Cast the given argument to a Smi and store its value in an int variable
37
// with the given name.  If the argument is not a Smi we crash safely.
38
#define CONVERT_SMI_ARG_CHECKED(name, index) \
39
  CHECK(args[index]->IsSmi());               \
40 41 42 43
  int name = args.smi_at(index);

// Cast the given argument to a double and store it in a variable with
// the given name.  If the argument is not a number (as opposed to
44
// the number not-a-number) we crash safely.
45
#define CONVERT_DOUBLE_ARG_CHECKED(name, index) \
46
  CHECK(args[index]->IsNumber());               \
47 48
  double name = args.number_at(index);

binji's avatar
binji committed
49
// Cast the given argument to a size_t and store its value in a variable with
50
// the given name.  If the argument is not a size_t we crash safely.
51 52 53 54
#define CONVERT_SIZE_ARG_CHECKED(name, index)    \
  CHECK(args[index]->IsNumber());                \
  Handle<Object> name##_object = args.at(index); \
  size_t name = 0;                               \
55
  CHECK(TryNumberToSize(*name##_object, &name));
binji's avatar
binji committed
56

57 58
// Call the specified converter on the object *comand store the result in
// a variable of the specified type with the given name.  If the
59
// object is not a Number we crash safely.
60
#define CONVERT_NUMBER_CHECKED(type, name, Type, obj) \
61
  CHECK(obj->IsNumber());                             \
62 63 64
  type name = NumberTo##Type(obj);

// Cast the given argument to PropertyDetails and store its value in a
65
// variable with the given name.  If the argument is not a Smi we crash safely.
66
#define CONVERT_PROPERTY_DETAILS_CHECKED(name, index) \
67
  CHECK(args[index]->IsSmi());                        \
68 69
  PropertyDetails name = PropertyDetails(Smi::cast(args[index]));

70 71
// Assert that the given argument has a valid value for a LanguageMode
// and store it in a LanguageMode variable with the given name.
72
#define CONVERT_LANGUAGE_MODE_ARG_CHECKED(name, index) \
73 74 75 76 77
  CHECK(args[index]->IsNumber());                      \
  int32_t __tmp_##name = 0;                            \
  CHECK(args[index]->ToInt32(&__tmp_##name));          \
  CHECK(is_valid_language_mode(__tmp_##name));         \
  LanguageMode name = static_cast<LanguageMode>(__tmp_##name);
78 79

// Assert that the given argument is a number within the Int32 range
80
// and convert it to int32_t.  If the argument is not an Int32 we crash safely.
81
#define CONVERT_INT32_ARG_CHECKED(name, index) \
82
  CHECK(args[index]->IsNumber());              \
83
  int32_t name = 0;                            \
84
  CHECK(args[index]->ToInt32(&name));
85

86 87 88 89 90 91 92 93
// Assert that the given argument is a number within the Uint32 range
// and convert it to uint32_t.  If the argument is not an Uint32 call
// IllegalOperation and return.
#define CONVERT_UINT32_ARG_CHECKED(name, index) \
  CHECK(args[index]->IsNumber());               \
  uint32_t name = 0;                            \
  CHECK(args[index]->ToUint32(&name));

94
// Cast the given argument to PropertyAttributes and store its value in a
95 96
// variable with the given name.  If the argument is not a Smi or the
// enum value is out of range, we crash safely.
97 98 99
#define CONVERT_PROPERTY_ATTRIBUTES_CHECKED(name, index)                    \
  CHECK(args[index]->IsSmi());                                              \
  CHECK_EQ(args.smi_at(index) & ~(READ_ONLY | DONT_ENUM | DONT_DELETE), 0); \
100 101
  PropertyAttributes name = static_cast<PropertyAttributes>(args.smi_at(index));

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
// A mechanism to return a pair of Object pointers in registers (if possible).
// How this is achieved is calling convention-dependent.
// All currently supported x86 compiles uses calling conventions that are cdecl
// variants where a 64-bit value is returned in two 32-bit registers
// (edx:eax on ia32, r1:r0 on ARM).
// In AMD-64 calling convention a struct of two pointers is returned in rdx:rax.
// In Win64 calling convention, a struct of two pointers is returned in memory,
// allocated by the caller, and passed as a pointer in a hidden first parameter.
#ifdef V8_HOST_ARCH_64_BIT
struct ObjectPair {
  Object* x;
  Object* y;
};


static inline ObjectPair MakePair(Object* x, Object* y) {
  ObjectPair result = {x, y};
  // Pointers x and y returned in rax and rdx, in AMD-x64-abi.
  // In Win64 they are assigned to a hidden first argument.
  return result;
}
#elif V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_32_BIT
// For x32 a 128-bit struct return is done as rax and rdx from the ObjectPair
125 126
// are used in generated code. An alternative is using uint64_t and modifying
// generated code.
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
struct ObjectPair {
  Object* x;
  uint32_t x_upper;
  Object* y;
  uint32_t y_upper;
};


static inline ObjectPair MakePair(Object* x, Object* y) {
  ObjectPair result = {x, 0, y, 0};
  // Pointers x and y returned in rax and rdx, in x32-abi.
  return result;
}
#else
typedef uint64_t ObjectPair;
static inline ObjectPair MakePair(Object* x, Object* y) {
#if defined(V8_TARGET_LITTLE_ENDIAN)
  return reinterpret_cast<uint32_t>(x) |
         (reinterpret_cast<ObjectPair>(y) << 32);
#elif defined(V8_TARGET_BIG_ENDIAN)
  return reinterpret_cast<uint32_t>(y) |
         (reinterpret_cast<ObjectPair>(x) << 32);
#else
#error Unknown endianness
#endif
}
#endif
154

155 156
}  // namespace internal
}  // namespace v8
157

158
#endif  // V8_RUNTIME_RUNTIME_UTILS_H_