Line data Source code
1 : // Copyright 2011 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #ifndef V8_V8MEMORY_H_
6 : #define V8_V8MEMORY_H_
7 :
8 : #include "src/globals.h"
9 :
10 : namespace v8 {
11 : namespace internal {
12 :
13 : // Memory provides an interface to 'raw' memory. It encapsulates the casts
14 : // that typically are needed when incompatible pointer types are used.
15 : // Note that this class currently relies on undefined behaviour. There is a
16 : // proposal (http://wg21.link/p0593r2) to make it defined behaviour though.
17 : template <class T>
18 27536275 : T& Memory(Address addr) {
19 419935295 : return *reinterpret_cast<T*>(addr);
20 : }
21 : template <class T>
22 : T& Memory(byte* addr) {
23 : return Memory<T>(reinterpret_cast<Address>(addr));
24 : }
25 :
26 : template <typename V>
27 : static inline V ReadUnalignedValue(Address p) {
28 : ASSERT_TRIVIALLY_COPYABLE(V);
29 : #if !(V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM)
30 196478472 : return *reinterpret_cast<const V*>(p);
31 : #else // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
32 : V r;
33 : memmove(&r, reinterpret_cast<void*>(p), sizeof(V));
34 : return r;
35 : #endif // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
36 : }
37 :
38 : template <typename V>
39 : static inline void WriteUnalignedValue(Address p, V value) {
40 : ASSERT_TRIVIALLY_COPYABLE(V);
41 : #if !(V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM)
42 49756812 : *(reinterpret_cast<V*>(p)) = value;
43 : #else // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
44 : memmove(reinterpret_cast<void*>(p), &value, sizeof(V));
45 : #endif // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
46 : }
47 :
48 : static inline double ReadFloatValue(Address p) {
49 : return ReadUnalignedValue<float>(p);
50 : }
51 :
52 : static inline double ReadDoubleValue(Address p) {
53 : return ReadUnalignedValue<double>(p);
54 : }
55 :
56 : static inline void WriteDoubleValue(Address p, double value) {
57 : WriteUnalignedValue(p, value);
58 : }
59 :
60 : static inline uint16_t ReadUnalignedUInt16(Address p) {
61 : return ReadUnalignedValue<uint16_t>(p);
62 : }
63 :
64 : static inline void WriteUnalignedUInt16(Address p, uint16_t value) {
65 : WriteUnalignedValue(p, value);
66 : }
67 :
68 : static inline uint32_t ReadUnalignedUInt32(Address p) {
69 : return ReadUnalignedValue<uint32_t>(p);
70 : }
71 :
72 : static inline void WriteUnalignedUInt32(Address p, uint32_t value) {
73 : WriteUnalignedValue(p, value);
74 : }
75 :
76 : template <typename V>
77 : static inline V ReadLittleEndianValue(Address p) {
78 : #if defined(V8_TARGET_LITTLE_ENDIAN)
79 : return ReadUnalignedValue<V>(p);
80 : #elif defined(V8_TARGET_BIG_ENDIAN)
81 : V ret{};
82 : const byte* src = reinterpret_cast<const byte*>(p);
83 : byte* dst = reinterpret_cast<byte*>(&ret);
84 : for (size_t i = 0; i < sizeof(V); i++) {
85 : dst[i] = src[sizeof(V) - i - 1];
86 : }
87 : return ret;
88 : #endif // V8_TARGET_LITTLE_ENDIAN
89 : }
90 :
91 : template <typename V>
92 : static inline void WriteLittleEndianValue(Address p, V value) {
93 : #if defined(V8_TARGET_LITTLE_ENDIAN)
94 : WriteUnalignedValue<V>(p, value);
95 : #elif defined(V8_TARGET_BIG_ENDIAN)
96 : byte* src = reinterpret_cast<byte*>(&value);
97 : byte* dst = reinterpret_cast<byte*>(p);
98 : for (size_t i = 0; i < sizeof(V); i++) {
99 : dst[i] = src[sizeof(V) - i - 1];
100 : }
101 : #endif // V8_TARGET_LITTLE_ENDIAN
102 : }
103 :
104 : template <typename V>
105 : static inline V ReadLittleEndianValue(V* p) {
106 : return ReadLittleEndianValue<V>(reinterpret_cast<Address>(p));
107 : }
108 :
109 : template <typename V>
110 : static inline void WriteLittleEndianValue(V* p, V value) {
111 : WriteLittleEndianValue<V>(reinterpret_cast<Address>(p), value);
112 : }
113 :
114 : } // namespace internal
115 : } // namespace v8
116 :
117 : #endif // V8_V8MEMORY_H_
|