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