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
|
#ifndef __optimizer_h__
#define __optimizer_h__
#include "simple_ast.h"
extern bool preciseF32,
receiveJSON,
emitJSON,
minifyWhitespace,
last;
extern cashew::Ref extraInfo;
void eliminateDeadFuncs(cashew::Ref ast);
void eliminate(cashew::Ref ast, bool memSafe=false);
void eliminateMemSafe(cashew::Ref ast);
void simplifyExpressions(cashew::Ref ast);
void optimizeFrounds(cashew::Ref ast);
void simplifyIfs(cashew::Ref ast);
void registerize(cashew::Ref ast);
void registerizeHarder(cashew::Ref ast);
void minifyLocals(cashew::Ref ast);
void asmLastOpts(cashew::Ref ast);
//
enum AsmType {
ASM_INT = 0,
ASM_DOUBLE,
ASM_FLOAT,
ASM_FLOAT32X4,
ASM_FLOAT64X2,
ASM_INT8X16,
ASM_INT16X8,
ASM_INT32X4,
ASM_NONE // number of types
};
struct AsmData;
AsmType detectType(cashew::Ref node, AsmData *asmData=nullptr, bool inVarDef=false);
struct AsmData {
struct Local {
Local() {}
Local(AsmType type, bool param) : type(type), param(param) {}
AsmType type;
bool param; // false if a var
};
typedef std::unordered_map<cashew::IString, Local> Locals;
Locals locals;
std::vector<cashew::IString> params; // in order
std::vector<cashew::IString> vars; // in order
AsmType ret;
cashew::Ref func;
AsmType getType(const cashew::IString& name) {
auto ret = locals.find(name);
if (ret != locals.end()) return ret->second.type;
return ASM_NONE;
}
void setType(const cashew::IString& name, AsmType type) {
locals[name].type = type;
}
bool isLocal(const cashew::IString& name) {
return locals.count(name) > 0;
}
bool isParam(const cashew::IString& name) {
return isLocal(name) && locals[name].param;
}
bool isVar(const cashew::IString& name) {
return isLocal(name) && !locals[name].param;
}
AsmData() {} // if you want to fill in the data yourself
AsmData(cashew::Ref f); // if you want to read data from f, and modify it as you go (parallel to denormalize)
void denormalize();
void addParam(cashew::IString name, AsmType type) {
locals[name] = Local(type, true);
params.push_back(name);
}
void addVar(cashew::IString name, AsmType type) {
locals[name] = Local(type, false);
vars.push_back(name);
}
void deleteVar(cashew::IString name) {
locals.erase(name);
for (size_t i = 0; i < vars.size(); i++) {
if (vars[i] == name) {
vars.erase(vars.begin() + i);
break;
}
}
}
};
bool isInteger(double x);
bool isInteger32(double x);
extern cashew::IString ASM_FLOAT_ZERO;
extern cashew::IString SIMD_INT8X16_CHECK,
SIMD_INT16X8_CHECK,
SIMD_INT32X4_CHECK,
SIMD_FLOAT32X4_CHECK,
SIMD_FLOAT64X2_CHECK;
int parseInt(const char *str);
struct HeapInfo {
bool valid, unsign, floaty;
int bits;
AsmType type;
};
HeapInfo parseHeap(const char *name);
#endif // __optimizer_h__
|
