• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Copyright 2019 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
5intrinsic %FromConstexpr<To: type, From: type>(b: From): To;
6macro FromConstexpr<To: type, From: type>(o: From): To;
7// Conversions for IntegerLiteral
8FromConstexpr<intptr, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
9    intptr {
10  return ConstexprIntegerLiteralToIntptr(i);
11}
12FromConstexpr<uintptr, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
13    uintptr {
14  return ConstexprIntegerLiteralToUintptr(i);
15}
16FromConstexpr<int32, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
17    int32 {
18  return ConstexprIntegerLiteralToInt32(i);
19}
20FromConstexpr<uint32, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
21    uint32 {
22  return ConstexprIntegerLiteralToUint32(i);
23}
24FromConstexpr<int31, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
25    int31 {
26  return ConstexprIntegerLiteralToInt31(i);
27}
28FromConstexpr<int8, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
29    int8 {
30  return ConstexprIntegerLiteralToInt8(i);
31}
32FromConstexpr<uint8, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
33    uint8 {
34  return ConstexprIntegerLiteralToUint8(i);
35}
36FromConstexpr<uint64, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
37    uint64 {
38  return ConstexprIntegerLiteralToUint64(i);
39}
40FromConstexpr<constexpr int31, constexpr IntegerLiteral>(
41    i: constexpr IntegerLiteral): constexpr int31 {
42  return ConstexprIntegerLiteralToInt31(i);
43}
44FromConstexpr<constexpr int32, constexpr IntegerLiteral>(
45    i: constexpr IntegerLiteral): constexpr int32 {
46  return ConstexprIntegerLiteralToInt32(i);
47}
48FromConstexpr<Number, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
49    Number {
50  return NumberConstant(ConstexprIntegerLiteralToFloat64(i));
51}
52FromConstexpr<Smi, constexpr IntegerLiteral>(i: constexpr IntegerLiteral): Smi {
53  return Convert<Smi>(ConstexprIntegerLiteralToInt31(i));
54}
55FromConstexpr<char8, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
56    char8 {
57  return %RawDownCast<char8>(FromConstexpr<uint8>(i));
58}
59
60FromConstexpr<int31, constexpr int31>(i: constexpr int31): int31 {
61  return %FromConstexpr<int31>(i);
62}
63FromConstexpr<int32, constexpr int31>(i: constexpr int31): int32 {
64  return %FromConstexpr<int32>(i);
65}
66FromConstexpr<int32, constexpr int32>(i: constexpr int32): int32 {
67  return %FromConstexpr<int32>(i);
68}
69FromConstexpr<intptr, constexpr int31>(i: constexpr int31): intptr {
70  return %FromConstexpr<intptr>(i);
71}
72FromConstexpr<intptr, constexpr int32>(i: constexpr int32): intptr {
73  return %FromConstexpr<intptr>(i);
74}
75FromConstexpr<intptr, constexpr intptr>(i: constexpr intptr): intptr {
76  return %FromConstexpr<intptr>(i);
77}
78FromConstexpr<uintptr, constexpr uintptr>(i: constexpr uintptr): uintptr {
79  return %FromConstexpr<uintptr>(i);
80}
81FromConstexpr<Smi, constexpr int31>(i: constexpr int31): Smi {
82  return %FromConstexpr<Smi>(i);
83}
84FromConstexpr<PositiveSmi, constexpr int31>(i: constexpr int31): PositiveSmi {
85  dcheck(i >= 0);
86  return %FromConstexpr<PositiveSmi>(i);
87}
88FromConstexpr<String, constexpr string>(s: constexpr string): String {
89  return %FromConstexpr<String>(s);
90}
91FromConstexpr<Number, constexpr uint32>(i: constexpr uint32): Number {
92  return %FromConstexpr<Number>(i);
93}
94FromConstexpr<Number, constexpr int32>(i: constexpr int32): Number {
95  return %FromConstexpr<Number>(i);
96}
97FromConstexpr<Number, constexpr float64>(f: constexpr float64): Number {
98  return %FromConstexpr<Number>(f);
99}
100FromConstexpr<Number, constexpr int31>(i: constexpr int31): Number {
101  return %FromConstexpr<Number>(i);
102}
103FromConstexpr<uint8, constexpr int31>(i: constexpr int31): uint8 {
104  const i: uint32 = i;
105  static_assert(i <= 255);
106  return %RawDownCast<uint8>(i);
107}
108FromConstexpr<int8, constexpr int31>(i: constexpr int31): int8 {
109  const i: int32 = i;
110  static_assert(-128 <= i && i <= 127);
111  return %RawDownCast<int8>(i);
112}
113FromConstexpr<char8, constexpr int31>(i: constexpr int31): char8 {
114  return %RawDownCast<char8>(FromConstexpr<uint8>(i));
115}
116FromConstexpr<Number, constexpr Smi>(s: constexpr Smi): Number {
117  return SmiConstant(s);
118}
119FromConstexpr<Smi, constexpr Smi>(s: constexpr Smi): Smi {
120  return SmiConstant(s);
121}
122FromConstexpr<uint32, constexpr int31>(i: constexpr int31): uint32 {
123  return Unsigned(Int32Constant(i));
124}
125FromConstexpr<uint8, constexpr uint8>(i: constexpr uint8): uint8 {
126  const i: uint32 = i;
127  return %RawDownCast<uint8>(i);
128}
129FromConstexpr<uint32, constexpr uint32>(i: constexpr uint32): uint32 {
130  return Unsigned(%FromConstexpr<int32>(i));
131}
132FromConstexpr<uint64, constexpr uint64>(i: constexpr uint64): uint64 {
133  return Uint64Constant(i);
134}
135FromConstexpr<uint64, constexpr int31>(i: constexpr int31): uint64 {
136  return Convert<uint64>(Unsigned(Int32Constant(i)));
137}
138FromConstexpr<uintptr, constexpr int31>(i: constexpr int31): uintptr {
139  return ChangeUint32ToWord(i);
140}
141FromConstexpr<float64, constexpr int31>(i: constexpr int31): float64 {
142  return Float64Constant(i);
143}
144FromConstexpr<float64, constexpr int32>(i: constexpr int32): float64 {
145  return Float64Constant(i);
146}
147FromConstexpr<float64, constexpr float64>(i: constexpr float64): float64 {
148  return Float64Constant(i);
149}
150FromConstexpr<bool, constexpr bool>(b: constexpr bool): bool {
151  return BoolConstant(b);
152}
153FromConstexpr<Object, constexpr string>(s: constexpr string): Object {
154  return StringConstant(s);
155}
156FromConstexpr<JSAny, constexpr string>(s: constexpr string): JSAny {
157  return StringConstant(s);
158}
159FromConstexpr<ContextSlot, constexpr ContextSlot>(c: constexpr ContextSlot):
160    ContextSlot {
161  return IntPtrConstant(c);
162}
163FromConstexpr<LanguageModeSmi, constexpr LanguageMode>(
164    c: constexpr LanguageMode): LanguageModeSmi {
165  return %RawDownCast<LanguageModeSmi>(SmiConstant(c));
166}
167FromConstexpr<PromiseState, constexpr PromiseState>(c: constexpr PromiseState):
168    PromiseState {
169  return %RawDownCast<PromiseState>(Int32Constant(c));
170}
171FromConstexpr<InstanceType, constexpr InstanceType>(c: constexpr InstanceType):
172    InstanceType {
173  return %RawDownCast<InstanceType>(Uint16Constant(c));
174}
175
176FromConstexpr<IterationKind, constexpr IterationKind>(
177    c: constexpr IterationKind): IterationKind {
178  return %RawDownCast<IterationKind>(Unsigned(%FromConstexpr<int32>(c)));
179}
180
181FromConstexpr<string::TrimMode, string::constexpr TrimMode>(
182    c: string::constexpr TrimMode): string::TrimMode {
183  return %RawDownCast<string::TrimMode>(Unsigned(%FromConstexpr<int32>(c)));
184}
185
186macro Convert<To: type, From: type>(i: From): To {
187  return i;
188}
189
190macro Convert<To: type, From: type>(i: From): To labels Overflow {
191  return i;
192}
193
194Convert<Boolean, bool>(b: bool): Boolean {
195  return b ? True : False;
196}
197Convert<int32, bool>(b: bool): int32 {
198  return ChangeBoolToInt32(b);
199}
200Convert<Number, int32>(i: int32): Number {
201  return ChangeInt32ToTagged(i);
202}
203Convert<intptr, int32>(i: int32): intptr {
204  return ChangeInt32ToIntPtr(i);
205}
206Convert<intptr, int31>(i: int31): intptr {
207  return ChangeInt32ToIntPtr(i);
208}
209Convert<intptr, uint32>(i: uint32): intptr {
210  return Signed(ChangeUint32ToWord(i));
211}
212Convert<Smi, int32>(i: int32): Smi {
213  return SmiFromInt32(i);
214}
215Convert<Number, uint32>(ui: uint32): Number {
216  return ChangeUint32ToTagged(ui);
217}
218Convert<Smi, uint32>(ui: uint32): Smi {
219  return SmiFromUint32(ui);
220}
221Convert<uintptr, uint32>(ui: uint32): uintptr {
222  return ChangeUint32ToWord(ui);
223}
224Convert<uint64, uint32>(ui: uint32): uint64 {
225  return ChangeUint32ToUint64(ui);
226}
227Convert<intptr, uint16>(ui: uint16): intptr {
228  return Signed(ChangeUint32ToWord(ui));
229}
230Convert<intptr, uint8>(ui: uint8): intptr {
231  return Signed(ChangeUint32ToWord(ui));
232}
233Convert<uint8, intptr>(i: intptr): uint8 {
234  return %RawDownCast<uint8>(Unsigned(TruncateIntPtrToInt32(i)) & 0xFF);
235}
236Convert<int8, intptr>(i: intptr): int8 {
237  return %RawDownCast<int8>(TruncateIntPtrToInt32(i) << 24 >> 24);
238}
239Convert<uint16, uint32>(i: uint32): uint16 {
240  return %RawDownCast<uint16>(i & 0xFFFF);
241}
242Convert<int32, uint8>(i: uint8): int32 {
243  return Signed(Convert<uint32>(i));
244}
245Convert<int32, uint16>(i: uint16): int32 {
246  return Signed(Convert<uint32>(i));
247}
248Convert<int32, char16|char8>(i: char16|char8): int32 {
249  return Signed(Convert<uint32>(i));
250}
251Convert<intptr, char16>(i: char16): intptr {
252  return Convert<intptr, uint32>(i);
253}
254Convert<intptr, char8>(i: char8): intptr {
255  return Convert<intptr, uint32>(i);
256}
257Convert<int32, uint31>(i: uint31): int32 {
258  return Signed(Convert<uint32>(i));
259}
260Convert<int32, intptr>(i: intptr): int32 {
261  return TruncateIntPtrToInt32(i);
262}
263Convert<int32, int64>(i: int64): int32 {
264  return TruncateInt64ToInt32(i);
265}
266Convert<int32, Number>(n: Number): int32 {
267  typeswitch (n) {
268    case (s: Smi): {
269      return Convert<int32>(s);
270    }
271    case (h: HeapNumber): {
272      return TruncateHeapNumberValueToWord32(h);
273    }
274  }
275}
276
277Convert<Smi, intptr>(i: intptr): Smi {
278  return SmiTag(i);
279}
280Convert<uint32, uintptr>(ui: uintptr): uint32 {
281  return Unsigned(TruncateIntPtrToInt32(Signed(ui)));
282}
283Convert<intptr, Smi>(s: Smi): intptr {
284  return SmiUntag(s);
285}
286Convert<uintptr, PositiveSmi>(ps: PositiveSmi): uintptr {
287  return Unsigned(SmiUntag(ps));
288}
289Convert<intptr, TaggedIndex>(ti: TaggedIndex): intptr {
290  return TaggedIndexToIntPtr(ti);
291}
292Convert<TaggedIndex, intptr>(i: intptr): TaggedIndex {
293  return IntPtrToTaggedIndex(i);
294}
295Convert<intptr, uintptr>(ui: uintptr): intptr {
296  const i = Signed(ui);
297  dcheck(i >= 0);
298  return i;
299}
300Convert<PositiveSmi, intptr>(i: intptr): PositiveSmi {
301  dcheck(IsValidPositiveSmi(i));
302  return %RawDownCast<PositiveSmi>(SmiTag(i));
303}
304Convert<PositiveSmi, uintptr>(ui: uintptr): PositiveSmi labels IfOverflow {
305  if (ui > kSmiMaxValue) deferred {
306      goto IfOverflow;
307    }
308  return %RawDownCast<PositiveSmi>(SmiTag(Signed(ui)));
309}
310Convert<PositiveSmi, intptr>(i: intptr): PositiveSmi labels IfOverflow {
311  if (IsValidPositiveSmi(i)) {
312    return %RawDownCast<PositiveSmi>(SmiTag(i));
313  } else
314    deferred {
315      goto IfOverflow;
316    }
317}
318Convert<PositiveSmi, uint32>(ui: uint32): PositiveSmi labels IfOverflow {
319  return Convert<PositiveSmi>(Convert<uintptr>(ui)) otherwise IfOverflow;
320}
321Convert<int32, Smi>(s: Smi): int32 {
322  return SmiToInt32(s);
323}
324Convert<float64, HeapNumber>(h: HeapNumber): float64 {
325  return LoadHeapNumberValue(h);
326}
327Convert<float64, Number>(n: Number): float64 {
328  return ChangeNumberToFloat64(n);
329}
330Convert<uintptr, Number>(n: Number): uintptr {
331  return ChangeUintPtrNumberToUintPtr(n);
332}
333Convert<float64, int32>(f: int32): float64 {
334  return ChangeInt32ToFloat64(f);
335}
336Convert<float64, float32>(f: float32): float64 {
337  return ChangeFloat32ToFloat64(f);
338}
339Convert<float64_or_hole, float64>(f: float64): float64_or_hole {
340  return float64_or_hole{is_hole: false, value: f};
341}
342Convert<float64_or_hole, Number>(n: Number): float64_or_hole {
343  return Convert<float64_or_hole>(Convert<float64>(n));
344}
345Convert<float32, float64>(f: float64): float32 {
346  return TruncateFloat64ToFloat32(f);
347}
348Convert<float32, Number>(n: Number): float32 {
349  return Convert<float32>(ChangeNumberToFloat64(n));
350}
351Convert<Number, float64>(d: float64): Number {
352  return ChangeFloat64ToTagged(d);
353}
354Convert<float64, uintptr>(ui: uintptr): float64 {
355  return ChangeUintPtrToFloat64(ui);
356}
357Convert<Number, uintptr>(ui: uintptr): Number {
358  return ChangeUintPtrToTagged(ui);
359}
360Convert<Number, intptr>(i: intptr): Number {
361  return ChangeUintPtrToTagged(Unsigned(i));
362}
363Convert<uintptr, float64>(d: float64): uintptr {
364  return ChangeFloat64ToUintPtr(d);
365}
366Convert<uintptr, intptr>(i: intptr): uintptr {
367  return Unsigned(i);
368}
369Convert<uintptr, RawPtr>(r: RawPtr): uintptr {
370  return Unsigned(r);
371}
372Convert<intptr, RawPtr>(r: RawPtr): intptr {
373  return Signed(r);
374}
375Convert<intptr, Number>(n: Number): intptr {
376  return ChangeFloat64ToIntPtr(ChangeNumberToFloat64(n));
377}
378Convert<bint, int32>(v: int32): bint {
379  return IntPtrToBInt(Convert<intptr>(v));
380}
381FromConstexpr<float64, constexpr IntegerLiteral>(v: constexpr IntegerLiteral):
382    float64 {
383  return ConstexprIntegerLiteralToFloat64(v);
384}
385extern macro IntPtrToBInt(intptr): bint;
386Convert<bint, intptr>(v: intptr): bint {
387  return IntPtrToBInt(v);
388}
389extern macro BIntToIntPtr(bint): intptr;
390Convert<intptr, bint>(v: bint): intptr {
391  return BIntToIntPtr(v);
392}
393extern macro SmiToBInt(Smi): bint;
394Convert<bint, Smi>(v: Smi): bint {
395  return SmiToBInt(v);
396}
397extern macro BIntToSmi(bint): Smi;
398Convert<Smi, bint>(v: bint): Smi {
399  return BIntToSmi(v);
400}
401Convert<PromiseState, int32>(s: int32): PromiseState {
402  return %RawDownCast<PromiseState>(s);
403}
404Convert<ScopeFlags, Smi>(s: Smi): ScopeFlags {
405  return %RawDownCast<ScopeFlags>(Unsigned(SmiToInt32(s)));
406}
407Convert<I8X16, Simd128>(s: Simd128): I8X16 {
408  return %RawDownCast<I8X16>(s);
409}
410