OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, 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/bootstrap_natives.h" | 5 #include "vm/bootstrap_natives.h" |
6 | 6 |
7 #include "vm/bigint_operations.h" | 7 #include "vm/bigint_operations.h" |
8 #include "vm/dart_entry.h" | 8 #include "vm/dart_entry.h" |
9 #include "vm/exceptions.h" | 9 #include "vm/exceptions.h" |
10 #include "vm/native_entry.h" | 10 #include "vm/native_entry.h" |
(...skipping 20 matching lines...) Expand all Loading... |
31 Mint& mint = Mint::Handle(); | 31 Mint& mint = Mint::Handle(); |
32 mint ^= i.raw(); | 32 mint ^= i.raw(); |
33 return !Smi::IsValid64(mint.value()); | 33 return !Smi::IsValid64(mint.value()); |
34 } | 34 } |
35 return true; | 35 return true; |
36 } | 36 } |
37 | 37 |
38 | 38 |
39 DEFINE_NATIVE_ENTRY(Integer_bitAndFromInteger, 2) { | 39 DEFINE_NATIVE_ENTRY(Integer_bitAndFromInteger, 2) { |
40 const Integer& right = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 40 const Integer& right = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
41 GET_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); | 41 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); |
42 ASSERT(CheckInteger(right)); | 42 ASSERT(CheckInteger(right)); |
43 ASSERT(CheckInteger(left)); | 43 ASSERT(CheckInteger(left)); |
44 if (FLAG_trace_intrinsified_natives) { | 44 if (FLAG_trace_intrinsified_natives) { |
45 OS::Print("Integer_bitAndFromInteger %s & %s\n", | 45 OS::Print("Integer_bitAndFromInteger %s & %s\n", |
46 right.ToCString(), left.ToCString()); | 46 right.ToCString(), left.ToCString()); |
47 } | 47 } |
48 const Integer& result = | 48 const Integer& result = |
49 Integer::Handle(left.BitOp(Token::kBIT_AND, right)); | 49 Integer::Handle(left.BitOp(Token::kBIT_AND, right)); |
50 return result.AsValidInteger(); | 50 return result.AsValidInteger(); |
51 } | 51 } |
52 | 52 |
53 | 53 |
54 DEFINE_NATIVE_ENTRY(Integer_bitOrFromInteger, 2) { | 54 DEFINE_NATIVE_ENTRY(Integer_bitOrFromInteger, 2) { |
55 const Integer& right = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 55 const Integer& right = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
56 GET_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); | 56 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); |
57 ASSERT(CheckInteger(right)); | 57 ASSERT(CheckInteger(right)); |
58 ASSERT(CheckInteger(left)); | 58 ASSERT(CheckInteger(left)); |
59 if (FLAG_trace_intrinsified_natives) { | 59 if (FLAG_trace_intrinsified_natives) { |
60 OS::Print("Integer_bitOrFromInteger %s | %s\n", | 60 OS::Print("Integer_bitOrFromInteger %s | %s\n", |
61 left.ToCString(), right.ToCString()); | 61 left.ToCString(), right.ToCString()); |
62 } | 62 } |
63 const Integer& result = | 63 const Integer& result = |
64 Integer::Handle(left.BitOp(Token::kBIT_OR, right)); | 64 Integer::Handle(left.BitOp(Token::kBIT_OR, right)); |
65 return result.AsValidInteger(); | 65 return result.AsValidInteger(); |
66 } | 66 } |
67 | 67 |
68 | 68 |
69 DEFINE_NATIVE_ENTRY(Integer_bitXorFromInteger, 2) { | 69 DEFINE_NATIVE_ENTRY(Integer_bitXorFromInteger, 2) { |
70 const Integer& right = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 70 const Integer& right = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
71 GET_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); | 71 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); |
72 ASSERT(CheckInteger(right)); | 72 ASSERT(CheckInteger(right)); |
73 ASSERT(CheckInteger(left)); | 73 ASSERT(CheckInteger(left)); |
74 if (FLAG_trace_intrinsified_natives) { | 74 if (FLAG_trace_intrinsified_natives) { |
75 OS::Print("Integer_bitXorFromInteger %s ^ %s\n", | 75 OS::Print("Integer_bitXorFromInteger %s ^ %s\n", |
76 left.ToCString(), right.ToCString()); | 76 left.ToCString(), right.ToCString()); |
77 } | 77 } |
78 const Integer& result = | 78 const Integer& result = |
79 Integer::Handle(left.BitOp(Token::kBIT_XOR, right)); | 79 Integer::Handle(left.BitOp(Token::kBIT_XOR, right)); |
80 return result.AsValidInteger(); | 80 return result.AsValidInteger(); |
81 } | 81 } |
82 | 82 |
83 | 83 |
84 DEFINE_NATIVE_ENTRY(Integer_addFromInteger, 2) { | 84 DEFINE_NATIVE_ENTRY(Integer_addFromInteger, 2) { |
85 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 85 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
86 GET_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); | 86 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); |
87 ASSERT(CheckInteger(right_int)); | 87 ASSERT(CheckInteger(right_int)); |
88 ASSERT(CheckInteger(left_int)); | 88 ASSERT(CheckInteger(left_int)); |
89 if (FLAG_trace_intrinsified_natives) { | 89 if (FLAG_trace_intrinsified_natives) { |
90 OS::Print("Integer_addFromInteger %s + %s\n", | 90 OS::Print("Integer_addFromInteger %s + %s\n", |
91 left_int.ToCString(), right_int.ToCString()); | 91 left_int.ToCString(), right_int.ToCString()); |
92 } | 92 } |
93 const Integer& result = | 93 const Integer& result = |
94 Integer::Handle(left_int.ArithmeticOp(Token::kADD, right_int)); | 94 Integer::Handle(left_int.ArithmeticOp(Token::kADD, right_int)); |
95 return result.AsValidInteger(); | 95 return result.AsValidInteger(); |
96 } | 96 } |
97 | 97 |
98 | 98 |
99 DEFINE_NATIVE_ENTRY(Integer_subFromInteger, 2) { | 99 DEFINE_NATIVE_ENTRY(Integer_subFromInteger, 2) { |
100 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 100 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
101 GET_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); | 101 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); |
102 ASSERT(CheckInteger(right_int)); | 102 ASSERT(CheckInteger(right_int)); |
103 ASSERT(CheckInteger(left_int)); | 103 ASSERT(CheckInteger(left_int)); |
104 if (FLAG_trace_intrinsified_natives) { | 104 if (FLAG_trace_intrinsified_natives) { |
105 OS::Print("Integer_subFromInteger %s - %s\n", | 105 OS::Print("Integer_subFromInteger %s - %s\n", |
106 left_int.ToCString(), right_int.ToCString()); | 106 left_int.ToCString(), right_int.ToCString()); |
107 } | 107 } |
108 const Integer& result = | 108 const Integer& result = |
109 Integer::Handle(left_int.ArithmeticOp(Token::kSUB, right_int)); | 109 Integer::Handle(left_int.ArithmeticOp(Token::kSUB, right_int)); |
110 return result.AsValidInteger(); | 110 return result.AsValidInteger(); |
111 } | 111 } |
112 | 112 |
113 | 113 |
114 DEFINE_NATIVE_ENTRY(Integer_mulFromInteger, 2) { | 114 DEFINE_NATIVE_ENTRY(Integer_mulFromInteger, 2) { |
115 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 115 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
116 GET_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); | 116 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); |
117 ASSERT(CheckInteger(right_int)); | 117 ASSERT(CheckInteger(right_int)); |
118 ASSERT(CheckInteger(left_int)); | 118 ASSERT(CheckInteger(left_int)); |
119 if (FLAG_trace_intrinsified_natives) { | 119 if (FLAG_trace_intrinsified_natives) { |
120 OS::Print("Integer_mulFromInteger %s * %s\n", | 120 OS::Print("Integer_mulFromInteger %s * %s\n", |
121 left_int.ToCString(), right_int.ToCString()); | 121 left_int.ToCString(), right_int.ToCString()); |
122 } | 122 } |
123 const Integer& result = | 123 const Integer& result = |
124 Integer::Handle(left_int.ArithmeticOp(Token::kMUL, right_int)); | 124 Integer::Handle(left_int.ArithmeticOp(Token::kMUL, right_int)); |
125 return result.AsValidInteger(); | 125 return result.AsValidInteger(); |
126 } | 126 } |
127 | 127 |
128 | 128 |
129 DEFINE_NATIVE_ENTRY(Integer_truncDivFromInteger, 2) { | 129 DEFINE_NATIVE_ENTRY(Integer_truncDivFromInteger, 2) { |
130 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 130 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
131 GET_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); | 131 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); |
132 ASSERT(CheckInteger(right_int)); | 132 ASSERT(CheckInteger(right_int)); |
133 ASSERT(CheckInteger(left_int)); | 133 ASSERT(CheckInteger(left_int)); |
134 ASSERT(!right_int.IsZero()); | 134 ASSERT(!right_int.IsZero()); |
135 const Integer& result = | 135 const Integer& result = |
136 Integer::Handle(left_int.ArithmeticOp(Token::kTRUNCDIV, right_int)); | 136 Integer::Handle(left_int.ArithmeticOp(Token::kTRUNCDIV, right_int)); |
137 return result.AsValidInteger(); | 137 return result.AsValidInteger(); |
138 } | 138 } |
139 | 139 |
140 | 140 |
141 DEFINE_NATIVE_ENTRY(Integer_moduloFromInteger, 2) { | 141 DEFINE_NATIVE_ENTRY(Integer_moduloFromInteger, 2) { |
142 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 142 const Integer& right_int = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
143 GET_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); | 143 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1)); |
144 ASSERT(CheckInteger(right_int)); | 144 ASSERT(CheckInteger(right_int)); |
145 ASSERT(CheckInteger(right_int)); | 145 ASSERT(CheckInteger(right_int)); |
146 if (FLAG_trace_intrinsified_natives) { | 146 if (FLAG_trace_intrinsified_natives) { |
147 OS::Print("Integer_moduloFromInteger %s mod %s\n", | 147 OS::Print("Integer_moduloFromInteger %s mod %s\n", |
148 left_int.ToCString(), right_int.ToCString()); | 148 left_int.ToCString(), right_int.ToCString()); |
149 } | 149 } |
150 if (right_int.IsZero()) { | 150 if (right_int.IsZero()) { |
151 // Should have been caught before calling into runtime. | 151 // Should have been caught before calling into runtime. |
152 UNIMPLEMENTED(); | 152 UNIMPLEMENTED(); |
153 } | 153 } |
154 const Integer& result = | 154 const Integer& result = |
155 Integer::Handle(left_int.ArithmeticOp(Token::kMOD, right_int)); | 155 Integer::Handle(left_int.ArithmeticOp(Token::kMOD, right_int)); |
156 return result.AsValidInteger(); | 156 return result.AsValidInteger(); |
157 } | 157 } |
158 | 158 |
159 | 159 |
160 DEFINE_NATIVE_ENTRY(Integer_greaterThanFromInteger, 2) { | 160 DEFINE_NATIVE_ENTRY(Integer_greaterThanFromInteger, 2) { |
161 const Integer& right = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 161 const Integer& right = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
162 GET_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); | 162 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); |
163 ASSERT(CheckInteger(right)); | 163 ASSERT(CheckInteger(right)); |
164 ASSERT(CheckInteger(left)); | 164 ASSERT(CheckInteger(left)); |
165 if (FLAG_trace_intrinsified_natives) { | 165 if (FLAG_trace_intrinsified_natives) { |
166 OS::Print("Integer_greaterThanFromInteger %s > %s\n", | 166 OS::Print("Integer_greaterThanFromInteger %s > %s\n", |
167 left.ToCString(), right.ToCString()); | 167 left.ToCString(), right.ToCString()); |
168 } | 168 } |
169 return Bool::Get(left.CompareWith(right) == 1); | 169 return Bool::Get(left.CompareWith(right) == 1); |
170 } | 170 } |
171 | 171 |
172 | 172 |
173 DEFINE_NATIVE_ENTRY(Integer_equalToInteger, 2) { | 173 DEFINE_NATIVE_ENTRY(Integer_equalToInteger, 2) { |
174 const Integer& left = Integer::CheckedHandle(arguments->NativeArgAt(0)); | 174 const Integer& left = Integer::CheckedHandle(arguments->NativeArgAt(0)); |
175 GET_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1)); | 175 GET_NON_NULL_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1)); |
176 ASSERT(CheckInteger(left)); | 176 ASSERT(CheckInteger(left)); |
177 ASSERT(CheckInteger(right)); | 177 ASSERT(CheckInteger(right)); |
178 if (FLAG_trace_intrinsified_natives) { | 178 if (FLAG_trace_intrinsified_natives) { |
179 OS::Print("Integer_equalToInteger %s == %s\n", | 179 OS::Print("Integer_equalToInteger %s == %s\n", |
180 left.ToCString(), right.ToCString()); | 180 left.ToCString(), right.ToCString()); |
181 } | 181 } |
182 return Bool::Get(left.CompareWith(right) == 0); | 182 return Bool::Get(left.CompareWith(right) == 0); |
183 } | 183 } |
184 | 184 |
185 | 185 |
186 DEFINE_NATIVE_ENTRY(Integer_parse, 1) { | 186 DEFINE_NATIVE_ENTRY(Integer_parse, 1) { |
187 GET_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0)); | 187 GET_NON_NULL_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0)); |
188 const String& dummy_key = String::Handle(Symbols::Empty()); | 188 const String& dummy_key = String::Handle(Symbols::Empty()); |
189 Scanner scanner(value, dummy_key); | 189 Scanner scanner(value, dummy_key); |
190 const Scanner::GrowableTokenStream& tokens = scanner.GetStream(); | 190 const Scanner::GrowableTokenStream& tokens = scanner.GetStream(); |
191 String* int_string; | 191 String* int_string; |
192 bool is_positive; | 192 bool is_positive; |
193 if (Scanner::IsValidLiteral(tokens, | 193 if (Scanner::IsValidLiteral(tokens, |
194 Token::kINTEGER, | 194 Token::kINTEGER, |
195 &is_positive, | 195 &is_positive, |
196 &int_string)) { | 196 &int_string)) { |
197 if (is_positive) { | 197 if (is_positive) { |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
250 return BigintOperations::ShiftRight(big_value, amount.Value()); | 250 return BigintOperations::ShiftRight(big_value, amount.Value()); |
251 default: | 251 default: |
252 UNIMPLEMENTED(); | 252 UNIMPLEMENTED(); |
253 } | 253 } |
254 return Integer::null(); | 254 return Integer::null(); |
255 } | 255 } |
256 | 256 |
257 | 257 |
258 DEFINE_NATIVE_ENTRY(Smi_shrFromInt, 2) { | 258 DEFINE_NATIVE_ENTRY(Smi_shrFromInt, 2) { |
259 const Smi& amount = Smi::CheckedHandle(arguments->NativeArgAt(0)); | 259 const Smi& amount = Smi::CheckedHandle(arguments->NativeArgAt(0)); |
260 GET_NATIVE_ARGUMENT(Integer, value, arguments->NativeArgAt(1)); | 260 GET_NON_NULL_NATIVE_ARGUMENT(Integer, value, arguments->NativeArgAt(1)); |
261 ASSERT(CheckInteger(amount)); | 261 ASSERT(CheckInteger(amount)); |
262 ASSERT(CheckInteger(value)); | 262 ASSERT(CheckInteger(value)); |
263 const Integer& result = Integer::Handle( | 263 const Integer& result = Integer::Handle( |
264 ShiftOperationHelper(Token::kSHR, value, amount)); | 264 ShiftOperationHelper(Token::kSHR, value, amount)); |
265 return result.AsValidInteger(); | 265 return result.AsValidInteger(); |
266 } | 266 } |
267 | 267 |
268 | 268 |
269 | 269 |
270 DEFINE_NATIVE_ENTRY(Smi_shlFromInt, 2) { | 270 DEFINE_NATIVE_ENTRY(Smi_shlFromInt, 2) { |
271 const Smi& amount = Smi::CheckedHandle(arguments->NativeArgAt(0)); | 271 const Smi& amount = Smi::CheckedHandle(arguments->NativeArgAt(0)); |
272 GET_NATIVE_ARGUMENT(Integer, value, arguments->NativeArgAt(1)); | 272 GET_NON_NULL_NATIVE_ARGUMENT(Integer, value, arguments->NativeArgAt(1)); |
273 ASSERT(CheckInteger(amount)); | 273 ASSERT(CheckInteger(amount)); |
274 ASSERT(CheckInteger(value)); | 274 ASSERT(CheckInteger(value)); |
275 if (FLAG_trace_intrinsified_natives) { | 275 if (FLAG_trace_intrinsified_natives) { |
276 OS::Print("Smi_shlFromInt: %s << %s\n", | 276 OS::Print("Smi_shlFromInt: %s << %s\n", |
277 value.ToCString(), amount.ToCString()); | 277 value.ToCString(), amount.ToCString()); |
278 } | 278 } |
279 const Integer& result = Integer::Handle( | 279 const Integer& result = Integer::Handle( |
280 ShiftOperationHelper(Token::kSHL, value, amount)); | 280 ShiftOperationHelper(Token::kSHL, value, amount)); |
281 return result.AsValidInteger(); | 281 return result.AsValidInteger(); |
282 } | 282 } |
(...skipping 25 matching lines...) Expand all Loading... |
308 | 308 |
309 DEFINE_NATIVE_ENTRY(Bigint_bitNegate, 1) { | 309 DEFINE_NATIVE_ENTRY(Bigint_bitNegate, 1) { |
310 const Bigint& value = Bigint::CheckedHandle(arguments->NativeArgAt(0)); | 310 const Bigint& value = Bigint::CheckedHandle(arguments->NativeArgAt(0)); |
311 const Bigint& result = Bigint::Handle(BigintOperations::BitNot(value)); | 311 const Bigint& result = Bigint::Handle(BigintOperations::BitNot(value)); |
312 ASSERT(CheckInteger(value)); | 312 ASSERT(CheckInteger(value)); |
313 ASSERT(CheckInteger(result)); | 313 ASSERT(CheckInteger(result)); |
314 return result.AsValidInteger(); | 314 return result.AsValidInteger(); |
315 } | 315 } |
316 | 316 |
317 } // namespace dart | 317 } // namespace dart |
OLD | NEW |