summaryrefslogtreecommitdiffstats
path: root/js/src/jit-test/tests/wasm/gc/casting.js
blob: 7c07bfcf69f5ee1ae888344e5ceb80f8a76cd5c0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
// |jit-test| skip-if: !wasmGcEnabled()

// Test the maximum depth limit
{
  const MaxDepth = 31;
  let types = `(type (struct))\n`;
  for (let depth = 1; depth <= MaxDepth + 1; depth++) {
    types += `(type (sub ${depth - 1} (struct)))\n`;
  }
  wasmFailValidateText(`(module
    ${types}
  )`, /too deep/);
}

// Test all possible casting combinations of the following graph:
//
//  A1       A2
//  |        |
//  B1       B2
//  | \      |
//  C1  C2   C3
//  | \      |
//  D1  D2   D3
//  | \      |
//  E1  E2   E3
//  | \      |
//  F1  F2   F3
//  | \      |
//  G1  G2   G3
//  | \      |
//  H1  H2   H3
//  | \      |
//  I1  I2   I3
//  | \      |
//  J1  J2   J3
//
// NOTE: this object will be mutated and needs to be ordered such that parent
// definitions come before children.  Note also, to be properly effective,
// these trees need to have a depth of at least MinSuperTypeVectorLength as
// defined in wasm/WasmCodegenConstants.h; keep it in sync with that.
const TYPES = {
  'A1': { super: null },
  'A2': { super: null },
  'B1': { super: 'A1' },
  'B2': { super: 'A2' },
  'C1': { super: 'B1' },
  'C2': { super: 'B1' },
  'C3': { super: 'B2' },
  'D1': { super: 'C1' },
  'D2': { super: 'C1' },
  'D3': { super: 'C3' },
  'E1': { super: 'D1' },
  'E2': { super: 'D1' },
  'E3': { super: 'D3' },
  'F1': { super: 'E1' },
  'F2': { super: 'E1' },
  'F3': { super: 'E3' },
  'G1': { super: 'F1' },
  'G2': { super: 'F1' },
  'G3': { super: 'F3' },
  'H1': { super: 'G1' },
  'H2': { super: 'G1' },
  'H3': { super: 'G3' },
  'I1': { super: 'H1' },
  'I2': { super: 'H1' },
  'I3': { super: 'H3' },
  'J1': { super: 'I1' },
  'J2': { super: 'I1' },
  'J3': { super: 'I3' },
};

// The oracle method for testing the declared subtype relationship.
function manualIsSubtype(types, subType, superType) {
  while (subType !== superType && subType.super !== null) {
    subType = types[subType.super];
  }
  return subType === superType;
}

function testAllCasts(types) {
  let typeSection = ``;
  let funcSection = ``;
  for (let name in types) {
    let type = types[name];
    if (type.super === null) {
      typeSection += `(type \$${name} (struct))\n`;
    } else {
      typeSection += `(type \$${name} (sub \$${type.super} (struct)))\n`;
    }
    funcSection += `
      (func (export "new${name}") (result externref)
        struct.new_default \$${name}
        extern.externalize
      )
      (func (export "is${name}") (param externref) (result i32)
        local.get 0
        extern.internalize
        ref.test (ref \$${name})
      )`;
  }
  // NOTE: we place all types in a single recursion group to prevent
  // canonicalization from 
  let moduleText = `(module
    (rec ${typeSection})
    ${funcSection}
  )`;

  // Instantiate the module and acquire the testing methods
  let exports = wasmEvalText(moduleText).exports;
  for (let name in types) {
    let type = types[name];
    type['new'] = exports[`new${name}`];
    type['is'] = exports[`is${name}`];
  }

  // Test every combination of types, comparing the oracle method against the
  // JIT'ed method.
  for (let subTypeName in types) {
    let subType = types[subTypeName];
    for (let superTypeName in types) {
      let superType = types[subTypeName];
      assertEq(
        manualIsSubtype(types, subType, superType) ? 1 : 0,
        superType['is'](subType['new']()));
    }
  }
}
testAllCasts(TYPES);