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
|
// -*- c -*-
//
// %CopyrightBegin%
//
// Copyright Ericsson AB 2020-2023. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// %CopyrightEnd%
//
pred.is_offset(X, Y, Offset) {
return X.type == Y.type && X.val + Offset == Y.val;
}
pred.succ(X, Y) {
return X.type == Y.type && X.val + 1 == Y.val;
}
pred.succ3(X, Y) {
return X.type == Y.type && X.val + 3 == Y.val;
}
pred.succ4(X, Y) {
return X.type == Y.type && X.val + 4 == Y.val;
}
// Test whether the following two moves are independent:
//
// move Src1 Dst1
// move Src2 Dst2
//
pred.independent_moves(Src1, Dst1, Src2, Dst2) {
return (Src1.type != Dst2.type || Src1.val != Dst2.val) &&
(Src2.type != Dst1.type || Src2.val != Dst1.val) &&
(Dst1.type != Dst2.type ||Dst1.val != Dst2.val);
}
pred.needs_nif_padding() {
Export *e = erts_active_export_entry(S->module, S->function, S->arity);
if (e != NULL && e->bif_number != -1) {
return 1;
}
/* If the module may load a NIF lib, all functions or functions declared as
* -nifs() must be able to hold a NIF stub. So we'll pad to that size at the
* end of every potential NIF function.
*/
return S->may_load_nif &&
(S->code_hdr->are_nifs == NULL ||
S->code_hdr->are_nifs[S->function_number-1]);
}
// Test whether the given literal is a map.
pred.literal_is_map(Lit) {
Eterm term;
ASSERT(Lit.type == TAG_q);
term = beamfile_get_literal(&S->beam, Lit.val);
return is_map(term);
}
// Test whether the negation of the given number is small.
pred.negation_is_small(Int) {
/*
* Check for the rare case of overflow in BeamInstr (UWord) -> Sint.
* Cast to the correct type before using IS_SSMALL (Sint).
*/
return Int.type == TAG_i &&
!(Int.val & ~((((BeamInstr)1) << ((sizeof(Sint)*8)-1))-1)) &&
IS_SSMALL(-((Sint)Int.val));
}
|
