WebAssemblyUtilities.h

Go to the documentation of this file.

//===-- WebAssemblyUtilities - WebAssembly Utility Functions ---*- C++ -*-====//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the declaration of the WebAssembly-specific
/// utility functions.
///
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_UTILS_WEBASSEMBLYUTILITIES_H
#define LLVM_LIB_TARGET_WEBASSEMBLY_UTILS_WEBASSEMBLYUTILITIES_H
 
#include "llvm/ADT/StringRef.h"
#include "llvm/CodeGen/SelectionDAGNodes.h"
#include "llvm/Support/CommandLine.h"
#include <algorithm>
 
namespace llvm {
 
class MachineBasicBlock;
class MachineFunction;
class MachineInstr;
class MachineOperand;
class MCContext;
class MCSymbolWasm;
class MCRegisterClass;
using TargetRegisterClass = MCRegisterClass;
class WebAssemblyFunctionInfo;
class WebAssemblySubtarget;
class MachineSDNode;
class SDLoc;
class SelectionDAG;
 
namespace WebAssembly {
 
enum class WebAssemblyABI {
  MVP,
  ExperimentalMV,
};
 
/// Parse an ABI name into the corresponding enum.
inline WebAssemblyABI getABI(StringRef Name) {
  return Name == "experimental-mv" ? WebAssemblyABI::ExperimentalMV
                                   : WebAssemblyABI::MVP;
}
 
bool isChild(const MachineInstr &MI, const WebAssemblyFunctionInfo &MFI);
bool mayThrow(const MachineInstr &MI);
 
// Exception-related function names
extern const char *const ClangCallTerminateFn;
extern const char *const CxaBeginCatchFn;
extern const char *const CxaRethrowFn;
extern const char *const StdTerminateFn;
extern const char *const PersonalityWrapperFn;
 
/// Returns the operand number of a callee, assuming the argument is a call
/// instruction.
const MachineOperand &getCalleeOp(const MachineInstr &MI);
 
/// Returns the __indirect_function_table, for use in call_indirect and in
/// function bitcasts.
MCSymbolWasm *
getOrCreateFunctionTableSymbol(MCContext &Ctx,
                               const WebAssemblySubtarget *Subtarget);
 
/// Returns the __funcref_call_table, for use in funcref calls when lowered to
/// table.set + call_indirect.
MCSymbolWasm *
getOrCreateFuncrefCallTableSymbol(MCContext &Ctx,
                                  const WebAssemblySubtarget *Subtarget);
 
/// Find a catch instruction from an EH pad. Returns null if no catch
/// instruction found or the catch is in an invalid location.
MachineInstr *findCatch(MachineBasicBlock *EHPad);
 
/// Returns the appropriate copy opcode for the given register class.
unsigned getCopyOpcodeForRegClass(const TargetRegisterClass *RC);
 
/// Returns true if multivalue returns of a function can be lowered directly,
/// i.e., not indirectly via a pointer parameter that points to the value in
/// memory.
bool canLowerMultivalueReturn(const WebAssemblySubtarget *Subtarget);
 
/// Returns true if the function's return value(s) can be lowered directly,
/// i.e., not indirectly via a pointer parameter that points to the value in
/// memory.
bool canLowerReturn(size_t ResultSize, const WebAssemblySubtarget *Subtarget);
 
// Get the TLS base value for the current target
// If using libcall thread context, calls
// __wasm_get_tls_base, otherwise, global.get __tls_base
MachineSDNode *getTLSBase(SelectionDAG &DAG, const SDLoc &DL,
                          const WebAssemblySubtarget *Subtarget,
                          const SDValue Chain = SDValue());
 
/// Moves the element at \p Idx of \p Range to the front, keeping the order of
/// the other elements.
template <typename RangeT> void moveToFront(RangeT &Range, size_t Idx) {
  std::rotate(Range.begin(), Range.begin() + Idx, Range.begin() + Idx + 1);
}
 
/// Returns the virtual register defined by the ARGUMENT instruction of the
/// swiftasync argument, or an invalid register if there is none. The argument
/// arrives in local 0, which must hold the async context for the whole
/// function.
Register getSwiftAsyncArgReg(const MachineFunction &MF);
 
} // end namespace WebAssembly
 
} // end namespace llvm
 
#endif