OLD | NEW |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
| 5 #include "vm/verified_memory.h" |
5 #include "platform/assert.h" | 6 #include "platform/assert.h" |
6 #include "vm/unit_test.h" | 7 #include "vm/unit_test.h" |
7 #include "vm/verified_memory.h" | |
8 | 8 |
9 namespace dart { | 9 namespace dart { |
10 | 10 |
11 void Init() { | 11 void Init() { |
12 #if defined(DEBUG) | 12 #if defined(DEBUG) |
13 FLAG_verified_mem = true; | 13 FLAG_verified_mem = true; |
14 #endif | 14 #endif |
15 } | 15 } |
16 | 16 |
17 | |
18 void Shutdown() { | 17 void Shutdown() { |
19 #if defined(DEBUG) | 18 #if defined(DEBUG) |
20 // We must reset this to false to avoid checking some assumptions in | 19 // We must reset this to false to avoid checking some assumptions in |
21 // VM shutdown that are left violated by these tests. | 20 // VM shutdown that are left violated by these tests. |
22 FLAG_verified_mem = false; | 21 FLAG_verified_mem = false; |
23 #endif | 22 #endif |
24 } | 23 } |
25 | 24 |
26 | |
27 VM_UNIT_TEST_CASE(VerifiedMemoryReserve) { | 25 VM_UNIT_TEST_CASE(VerifiedMemoryReserve) { |
28 Init(); | 26 Init(); |
29 const intptr_t kReservationSize = 64 * KB; | 27 const intptr_t kReservationSize = 64 * KB; |
30 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); | 28 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); |
31 EXPECT_EQ(kReservationSize, vm->size()); | 29 EXPECT_EQ(kReservationSize, vm->size()); |
32 delete vm; | 30 delete vm; |
33 Shutdown(); | 31 Shutdown(); |
34 } | 32 } |
35 | 33 |
36 | |
37 VM_UNIT_TEST_CASE(VerifiedMemoryCommit) { | 34 VM_UNIT_TEST_CASE(VerifiedMemoryCommit) { |
38 Init(); | 35 Init(); |
39 const intptr_t kReservationSize = 64 * KB; | 36 const intptr_t kReservationSize = 64 * KB; |
40 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); | 37 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); |
41 EXPECT_EQ(kReservationSize, vm->size()); | 38 EXPECT_EQ(kReservationSize, vm->size()); |
42 vm->Commit(false); | 39 vm->Commit(false); |
43 delete vm; | 40 delete vm; |
44 Shutdown(); | 41 Shutdown(); |
45 } | 42 } |
46 | 43 |
47 | |
48 VM_UNIT_TEST_CASE(VerifiedMemoryBasic) { | 44 VM_UNIT_TEST_CASE(VerifiedMemoryBasic) { |
49 Init(); | 45 Init(); |
50 const intptr_t kReservationSize = 64 * KB; | 46 const intptr_t kReservationSize = 64 * KB; |
51 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); | 47 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); |
52 EXPECT_EQ(kReservationSize, vm->size()); | 48 EXPECT_EQ(kReservationSize, vm->size()); |
53 vm->Commit(false); | 49 vm->Commit(false); |
54 double* addr = reinterpret_cast<double*>(vm->address()); | 50 double* addr = reinterpret_cast<double*>(vm->address()); |
55 VerifiedMemory::Write(&addr[0], 0.5); | 51 VerifiedMemory::Write(&addr[0], 0.5); |
56 EXPECT_EQ(0.5, addr[0]); | 52 EXPECT_EQ(0.5, addr[0]); |
57 VerifiedMemory::Write(&addr[1], 1.5); | 53 VerifiedMemory::Write(&addr[1], 1.5); |
58 VerifiedMemory::Write(&addr[2], 2.5); | 54 VerifiedMemory::Write(&addr[2], 2.5); |
59 VerifiedMemory::Write(&addr[0], 0.25); | 55 VerifiedMemory::Write(&addr[0], 0.25); |
60 static const double kNaN = NAN; | 56 static const double kNaN = NAN; |
61 VerifiedMemory::Write(&addr[0], kNaN); // Bitwise comparison should be used. | 57 VerifiedMemory::Write(&addr[0], kNaN); // Bitwise comparison should be used. |
62 VerifiedMemory::Write(&addr[0], 0.5); | 58 VerifiedMemory::Write(&addr[0], 0.5); |
63 int64_t* unverified = reinterpret_cast<int64_t*>(&addr[3]); | 59 int64_t* unverified = reinterpret_cast<int64_t*>(&addr[3]); |
64 *unverified = 123; | 60 *unverified = 123; |
65 VerifiedMemory::Verify(reinterpret_cast<uword>(addr), 3 * sizeof(double)); | 61 VerifiedMemory::Verify(reinterpret_cast<uword>(addr), 3 * sizeof(double)); |
66 delete vm; | 62 delete vm; |
67 Shutdown(); | 63 Shutdown(); |
68 } | 64 } |
69 | 65 |
70 | |
71 VM_UNIT_TEST_CASE(VerifiedMemoryAccept) { | 66 VM_UNIT_TEST_CASE(VerifiedMemoryAccept) { |
72 Init(); | 67 Init(); |
73 const intptr_t kReservationSize = 64 * KB; | 68 const intptr_t kReservationSize = 64 * KB; |
74 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); | 69 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); |
75 EXPECT_EQ(kReservationSize, vm->size()); | 70 EXPECT_EQ(kReservationSize, vm->size()); |
76 vm->Commit(false); | 71 vm->Commit(false); |
77 double* addr = reinterpret_cast<double*>(vm->address()); | 72 double* addr = reinterpret_cast<double*>(vm->address()); |
78 VerifiedMemory::Write(&addr[0], 0.5); | 73 VerifiedMemory::Write(&addr[0], 0.5); |
79 VerifiedMemory::Write(&addr[1], 1.5); | 74 VerifiedMemory::Write(&addr[1], 1.5); |
80 VerifiedMemory::Write(&addr[2], 2.5); | 75 VerifiedMemory::Write(&addr[2], 2.5); |
81 VerifiedMemory::Write(&addr[0], 0.25); | 76 VerifiedMemory::Write(&addr[0], 0.25); |
82 // Unverified write followed by Accept ("I know what I'm doing"). | 77 // Unverified write followed by Accept ("I know what I'm doing"). |
83 memset(addr, 0xf3, 2 * sizeof(double)); | 78 memset(addr, 0xf3, 2 * sizeof(double)); |
84 VerifiedMemory::Accept(reinterpret_cast<uword>(addr), 2 * sizeof(double)); | 79 VerifiedMemory::Accept(reinterpret_cast<uword>(addr), 2 * sizeof(double)); |
85 VerifiedMemory::Verify(reinterpret_cast<uword>(addr), 3 * sizeof(double)); | 80 VerifiedMemory::Verify(reinterpret_cast<uword>(addr), 3 * sizeof(double)); |
86 delete vm; | 81 delete vm; |
87 Shutdown(); | 82 Shutdown(); |
88 } | 83 } |
89 | 84 |
90 | |
91 // Negative tests below. | 85 // Negative tests below. |
92 | 86 |
93 VM_UNIT_TEST_CASE(VerifyImplicit_Crash) { | 87 VM_UNIT_TEST_CASE(VerifyImplicit_Crash) { |
94 Init(); | 88 Init(); |
95 const intptr_t kReservationSize = 64 * KB; | 89 const intptr_t kReservationSize = 64 * KB; |
96 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); | 90 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); |
97 EXPECT_EQ(kReservationSize, vm->size()); | 91 EXPECT_EQ(kReservationSize, vm->size()); |
98 vm->Commit(false); | 92 vm->Commit(false); |
99 double* addr = reinterpret_cast<double*>(vm->address()); | 93 double* addr = reinterpret_cast<double*>(vm->address()); |
100 addr[0] = 0.5; // Forget to use Write. | 94 addr[0] = 0.5; // Forget to use Write. |
101 VerifiedMemory::Write(&addr[0], 1.5); | 95 VerifiedMemory::Write(&addr[0], 1.5); |
102 Shutdown(); | 96 Shutdown(); |
103 } | 97 } |
104 | 98 |
105 | |
106 VM_UNIT_TEST_CASE(VerifyExplicit_Crash) { | 99 VM_UNIT_TEST_CASE(VerifyExplicit_Crash) { |
107 Init(); | 100 Init(); |
108 const intptr_t kReservationSize = 64 * KB; | 101 const intptr_t kReservationSize = 64 * KB; |
109 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); | 102 VirtualMemory* vm = VerifiedMemory::Reserve(kReservationSize); |
110 EXPECT_EQ(kReservationSize, vm->size()); | 103 EXPECT_EQ(kReservationSize, vm->size()); |
111 vm->Commit(false); | 104 vm->Commit(false); |
112 double* addr = reinterpret_cast<double*>(vm->address()); | 105 double* addr = reinterpret_cast<double*>(vm->address()); |
113 VerifiedMemory::Write(&addr[0], 0.5); | 106 VerifiedMemory::Write(&addr[0], 0.5); |
114 VerifiedMemory::Write(&addr[1], 1.5); | 107 VerifiedMemory::Write(&addr[1], 1.5); |
115 addr[1] = 3.5; // Forget to use Write. | 108 addr[1] = 3.5; // Forget to use Write. |
116 VerifiedMemory::Write(&addr[2], 2.5); | 109 VerifiedMemory::Write(&addr[2], 2.5); |
117 VerifiedMemory::Verify(reinterpret_cast<uword>(addr), 3 * sizeof(double)); | 110 VerifiedMemory::Verify(reinterpret_cast<uword>(addr), 3 * sizeof(double)); |
118 Shutdown(); | 111 Shutdown(); |
119 } | 112 } |
120 | 113 |
121 } // namespace dart | 114 } // namespace dart |
OLD | NEW |