1//===-- WebAssembly.h - Top-level interface for WebAssembly ----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file contains the entry points for global functions defined in
11/// the LLVM WebAssembly back-end.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLY_H
16#define LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLY_H
17
18#include "GISel/WebAssemblyRegisterBankInfo.h"
19#include "WebAssemblySubtarget.h"
20#include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
21#include "llvm/CodeGen/MachineFunction.h"
22#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
23#include "llvm/CodeGen/SelectionDAGISel.h"
24#include "llvm/IR/Analysis.h"
25#include "llvm/IR/PassManager.h"
26#include "llvm/PassRegistry.h"
27#include "llvm/Support/CodeGen.h"
28
29namespace llvm {
30
31class WebAssemblyTargetMachine;
32class ModulePass;
33class FunctionPass;
34
35// LLVM IR passes.
36class WebAssemblyLowerEmscriptenEHSjLjPass
37 : public RequiredPassInfoMixin<WebAssemblyLowerEmscriptenEHSjLjPass> {
38 bool EnableEmEH;
39
40public:
41 WebAssemblyLowerEmscriptenEHSjLjPass(bool EnableEmEH = false)
42 : EnableEmEH(EnableEmEH) {}
43 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
44};
45
46ModulePass *createWebAssemblyLowerEmscriptenEHSjLjLegacyPass(bool EnableEmEH);
47
48class WebAssemblyAddMissingPrototypesPass
49 : public RequiredPassInfoMixin<WebAssemblyAddMissingPrototypesPass> {
50public:
51 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
52};
53
54ModulePass *createWebAssemblyAddMissingPrototypesLegacyPass();
55
56class WebAssemblyFixFunctionBitcastsPass
57 : public RequiredPassInfoMixin<WebAssemblyFixFunctionBitcastsPass> {
58public:
59 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
60};
61
62ModulePass *createWebAssemblyFixFunctionBitcastsLegacyPass();
63
64class WebAssemblyOptimizeReturnedPass
65 : public OptionalPassInfoMixin<WebAssemblyOptimizeReturnedPass> {
66public:
67 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
68};
69
70FunctionPass *createWebAssemblyOptimizeReturnedLegacyPass();
71
72class WebAssemblyRefTypeMem2LocalPass
73 : public RequiredPassInfoMixin<WebAssemblyRefTypeMem2LocalPass> {
74public:
75 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
76};
77
78FunctionPass *createWebAssemblyRefTypeMem2LocalLegacyPass();
79
80class WebAssemblyReduceToAnyAllTruePass
81 : public RequiredPassInfoMixin<WebAssemblyReduceToAnyAllTruePass> {
82private:
83 Module *CachedModule = nullptr;
84 bool ModuleHasInterestingIntrinsics = false;
85 WebAssemblyTargetMachine &TM;
86
87public:
88 WebAssemblyReduceToAnyAllTruePass(WebAssemblyTargetMachine &TM) : TM(TM) {}
89 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
90};
91
92FunctionPass *
93createWebAssemblyReduceToAnyAllTrueLegacyPass(WebAssemblyTargetMachine &TM);
94
95class WebAssemblyCoalesceFeaturesAndStripAtomicsPass
96 : public RequiredPassInfoMixin<
97 WebAssemblyCoalesceFeaturesAndStripAtomicsPass> {
98 WebAssemblyTargetMachine &TM;
99
100public:
101 WebAssemblyCoalesceFeaturesAndStripAtomicsPass(WebAssemblyTargetMachine &TM)
102 : TM(TM) {}
103 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
104};
105
106ModulePass *createWebAssemblyCoalesceFeaturesAndStripAtomicsLegacyPass(
107 WebAssemblyTargetMachine &TM);
108
109// GlobalISel
110InstructionSelector *
111createWebAssemblyInstructionSelector(const WebAssemblyTargetMachine &,
112 const WebAssemblySubtarget &,
113 const WebAssemblyRegisterBankInfo &);
114
115class WebAssemblyPostLegalizerCombinerPass
116 : public RequiredPassInfoMixin<WebAssemblyPostLegalizerCombinerPass> {
117public:
118 PreservedAnalyses run(MachineFunction &MF,
119 MachineFunctionAnalysisManager &MFAM);
120};
121
122FunctionPass *createWebAssemblyPostLegalizerCombinerLegacyPass();
123
124class WebAssemblyPreLegalizerCombinerPass
125 : public RequiredPassInfoMixin<WebAssemblyPreLegalizerCombinerPass> {
126public:
127 PreservedAnalyses run(MachineFunction &MF,
128 MachineFunctionAnalysisManager &MFAM);
129};
130
131FunctionPass *createWebAssemblyPreLegalizerCombinerLegacyPass();
132
133// ISel and immediate followup passes.
134class WebAssemblyISelDAGToDAGPass : public SelectionDAGISelPass {
135public:
136 WebAssemblyISelDAGToDAGPass(WebAssemblyTargetMachine &TM,
137 CodeGenOptLevel OptLevel);
138};
139
140FunctionPass *createWebAssemblyISelDagLegacyPass(WebAssemblyTargetMachine &TM,
141 CodeGenOptLevel OptLevel);
142
143class WebAssemblyArgumentMovePass
144 : public RequiredPassInfoMixin<WebAssemblyArgumentMovePass> {
145public:
146 PreservedAnalyses run(MachineFunction &MF,
147 MachineFunctionAnalysisManager &MFAM);
148};
149
150FunctionPass *createWebAssemblyArgumentMoveLegacyPass();
151
152class WebAssemblySetP2AlignOperandsPass
153 : public RequiredPassInfoMixin<WebAssemblySetP2AlignOperandsPass> {
154public:
155 PreservedAnalyses run(MachineFunction &MF,
156 MachineFunctionAnalysisManager &MFAM);
157};
158
159FunctionPass *createWebAssemblySetP2AlignOperandsLegacyPass();
160
161class WebAssemblyCleanCodeAfterTrapPass
162 : public RequiredPassInfoMixin<WebAssemblyCleanCodeAfterTrapPass> {
163public:
164 PreservedAnalyses run(MachineFunction &MF,
165 MachineFunctionAnalysisManager &MFAM);
166};
167
168FunctionPass *createWebAssemblyCleanCodeAfterTrapLegacyPass();
169
170// Late passes.
171class WebAssemblyReplacePhysRegsPass
172 : public RequiredPassInfoMixin<WebAssemblyReplacePhysRegsPass> {
173public:
174 PreservedAnalyses run(MachineFunction &MF,
175 MachineFunctionAnalysisManager &MFAM);
176};
177
178FunctionPass *createWebAssemblyReplacePhysRegsLegacyPass();
179
180class WebAssemblyNullifyDebugValueListsPass
181 : public RequiredPassInfoMixin<WebAssemblyNullifyDebugValueListsPass> {
182public:
183 PreservedAnalyses run(MachineFunction &MF,
184 MachineFunctionAnalysisManager &MFAM);
185};
186
187FunctionPass *createWebAssemblyNullifyDebugValueListsLegacyPass();
188
189class WebAssemblyOptimizeLiveIntervalsPass
190 : public RequiredPassInfoMixin<WebAssemblyOptimizeLiveIntervalsPass> {
191public:
192 PreservedAnalyses run(MachineFunction &MF,
193 MachineFunctionAnalysisManager &MFAM);
194};
195
196FunctionPass *createWebAssemblyOptimizeLiveIntervalsLegacyPass();
197
198class WebAssemblyMemIntrinsicResultsPass
199 : public RequiredPassInfoMixin<WebAssemblyMemIntrinsicResultsPass> {
200public:
201 PreservedAnalyses run(MachineFunction &MF,
202 MachineFunctionAnalysisManager &MFAM);
203};
204
205FunctionPass *createWebAssemblyMemIntrinsicResultsLegacyPass();
206
207class WebAssemblyRegStackifyPass
208 : public RequiredPassInfoMixin<WebAssemblyRegStackifyPass> {
209private:
210 bool Optimize = false;
211
212public:
213 WebAssemblyRegStackifyPass(CodeGenOptLevel OptLevel)
214 : Optimize(OptLevel != CodeGenOptLevel::None) {}
215 PreservedAnalyses run(MachineFunction &MF,
216 MachineFunctionAnalysisManager &MFAM);
217};
218
219FunctionPass *createWebAssemblyRegStackifyLegacyPass(CodeGenOptLevel OptLevel);
220
221class WebAssemblyRegColoringPass
222 : public RequiredPassInfoMixin<WebAssemblyRegColoringPass> {
223public:
224 PreservedAnalyses run(MachineFunction &MF,
225 MachineFunctionAnalysisManager &MFAM);
226};
227
228FunctionPass *createWebAssemblyRegColoringLegacyPass();
229
230class WebAssemblyFixBrTableDefaultsPass
231 : public RequiredPassInfoMixin<WebAssemblyFixBrTableDefaultsPass> {
232public:
233 PreservedAnalyses run(MachineFunction &MF,
234 MachineFunctionAnalysisManager &MFAM);
235};
236
237FunctionPass *createWebAssemblyFixBrTableDefaultsLegacyPass();
238
239class WebAssemblyFixIrreducibleControlFlowPass
240 : public RequiredPassInfoMixin<WebAssemblyFixIrreducibleControlFlowPass> {
241public:
242 PreservedAnalyses run(MachineFunction &MF,
243 MachineFunctionAnalysisManager &MFAM);
244};
245
246FunctionPass *createWebAssemblyFixIrreducibleControlFlowLegacyPass();
247
248class WebAssemblyLateEHPreparePass
249 : public RequiredPassInfoMixin<WebAssemblyLateEHPreparePass> {
250public:
251 PreservedAnalyses run(MachineFunction &MF,
252 MachineFunctionAnalysisManager &MFAM);
253};
254
255FunctionPass *createWebAssemblyLateEHPrepareLegacyPass();
256
257class WebAssemblyCFGSortPass
258 : public RequiredPassInfoMixin<WebAssemblyCFGSortPass> {
259public:
260 PreservedAnalyses run(MachineFunction &MF,
261 MachineFunctionAnalysisManager &MFAM);
262};
263
264FunctionPass *createWebAssemblyCFGSortLegacyPass();
265
266class WebAssemblyCFGStackifyPass
267 : public RequiredPassInfoMixin<WebAssemblyCFGStackifyPass> {
268public:
269 PreservedAnalyses run(MachineFunction &MF,
270 MachineFunctionAnalysisManager &MFAM);
271};
272
273FunctionPass *createWebAssemblyCFGStackifyLegacyPass();
274
275class WebAssemblyExplicitLocalsPass
276 : public RequiredPassInfoMixin<WebAssemblyExplicitLocalsPass> {
277public:
278 PreservedAnalyses run(MachineFunction &MF,
279 MachineFunctionAnalysisManager &MFAM);
280};
281
282FunctionPass *createWebAssemblyExplicitLocalsLegacyPass();
283
284class WebAssemblyLowerBrUnlessPass
285 : public RequiredPassInfoMixin<WebAssemblyLowerBrUnlessPass> {
286public:
287 PreservedAnalyses run(MachineFunction &MF,
288 MachineFunctionAnalysisManager &MFAM);
289};
290
291FunctionPass *createWebAssemblyLowerBrUnlessLegacyPass();
292
293class WebAssemblyRegNumberingPass
294 : public RequiredPassInfoMixin<WebAssemblyRegNumberingPass> {
295public:
296 PreservedAnalyses run(MachineFunction &MF,
297 MachineFunctionAnalysisManager &MFAM);
298};
299
300FunctionPass *createWebAssemblyRegNumberingLegacyPass();
301
302class WebAssemblyDebugFixupPass
303 : public RequiredPassInfoMixin<WebAssemblyDebugFixupPass> {
304public:
305 PreservedAnalyses run(MachineFunction &MF,
306 MachineFunctionAnalysisManager &MFAM);
307};
308
309FunctionPass *createWebAssemblyDebugFixupLegacyPass();
310
311class WebAssemblyPeepholePass
312 : public RequiredPassInfoMixin<WebAssemblyPeepholePass> {
313public:
314 PreservedAnalyses run(MachineFunction &MF,
315 MachineFunctionAnalysisManager &MFAM);
316};
317
318FunctionPass *createWebAssemblyPeepholeLegacyPass();
319
320class WebAssemblyMCLowerPrePass
321 : public RequiredPassInfoMixin<WebAssemblyMCLowerPrePass> {
322public:
323 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
324};
325
326ModulePass *createWebAssemblyMCLowerPreLegacyPass();
327
328// PassRegistry initialization declarations.
329void initializeWebAssemblyOptimizeReturnedLegacyPass(PassRegistry &);
330void initializeWebAssemblyRefTypeMem2LocalLegacyPass(PassRegistry &);
331void initializeWebAssemblyAddMissingPrototypesLegacyPass(PassRegistry &);
332void initializeWebAssemblyArgumentMoveLegacyPass(PassRegistry &);
333void initializeWebAssemblyAsmPrinterPass(PassRegistry &);
334void initializeWebAssemblyCleanCodeAfterTrapLegacyPass(PassRegistry &);
335void initializeWebAssemblyCFGSortLegacyPass(PassRegistry &);
336void initializeWebAssemblyCFGStackifyLegacyPass(PassRegistry &);
337void initializeWebAssemblyDAGToDAGISelLegacyPass(PassRegistry &);
338void initializeWebAssemblyDebugFixupLegacyPass(PassRegistry &);
339void initializeWebAssemblyExceptionInfoWrapperPassPass(PassRegistry &);
340void initializeWebAssemblyExplicitLocalsLegacyPass(PassRegistry &);
341void initializeWebAssemblyFixBrTableDefaultsLegacyPass(PassRegistry &);
342void initializeWebAssemblyFixFunctionBitcastsLegacyPass(PassRegistry &);
343void initializeWebAssemblyFixIrreducibleControlFlowLegacyPass(PassRegistry &);
344void initializeWebAssemblyLateEHPrepareLegacyPass(PassRegistry &);
345void initializeWebAssemblyLowerBrUnlessLegacyPass(PassRegistry &);
346void initializeWebAssemblyLowerEmscriptenEHSjLjLegacyPass(PassRegistry &);
347void initializeWebAssemblyMCLowerPreLegacyPass(PassRegistry &);
348void initializeWebAssemblyMemIntrinsicResultsLegacyPass(PassRegistry &);
349void initializeWebAssemblyNullifyDebugValueListsLegacyPass(PassRegistry &);
350void initializeWebAssemblyOptimizeLiveIntervalsLegacyPass(PassRegistry &);
351void initializeWebAssemblyPeepholeLegacyPass(PassRegistry &);
352void initializeWebAssemblyPostLegalizerCombinerLegacyPass(PassRegistry &);
353void initializeWebAssemblyPreLegalizerCombinerLegacyPass(PassRegistry &);
354void initializeWebAssemblyRegColoringLegacyPass(PassRegistry &);
355void initializeWebAssemblyRegNumberingLegacyPass(PassRegistry &);
356void initializeWebAssemblyRegStackifyLegacyPass(PassRegistry &);
357void initializeWebAssemblyReplacePhysRegsLegacyPass(PassRegistry &);
358void initializeWebAssemblySetP2AlignOperandsLegacyPass(PassRegistry &);
359void initializeWebAssemblyCoalesceFeaturesAndStripAtomicsLegacyPass(
360 PassRegistry &);
361
362namespace WebAssembly {
363enum TargetIndex {
364 // Followed by a local index (ULEB).
365 TI_LOCAL,
366 // Followed by an absolute global index (ULEB). DEPRECATED.
367 TI_GLOBAL_FIXED,
368 // Followed by the index from the bottom of the Wasm stack.
369 TI_OPERAND_STACK,
370 // Followed by a compilation unit relative global index (uint32_t)
371 // that will have an associated relocation.
372 TI_GLOBAL_RELOC,
373 // Like TI_LOCAL, but indicates an indirect value (e.g. byval arg
374 // passed by pointer).
375 TI_LOCAL_INDIRECT
376};
377} // end namespace WebAssembly
378
379} // end namespace llvm
380
381#endif
382